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:05.995] plan(): Setting new future strategy stack:
[15:32:05.996] List of future strategies:
[15:32:05.996] 1. sequential:
[15:32:05.996]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:05.996]    - tweaked: FALSE
[15:32:05.996]    - call: future::plan("sequential")
[15:32:06.023] plan(): nbrOfWorkers() = 1
> 
> message("*** future_mapply() ...")
*** future_mapply() ...
> 
> message("- Parallel RNG truth (for later)...")
- Parallel RNG truth (for later)...
> plan(sequential)
[15:32:06.031] plan(): Setting new future strategy stack:
[15:32:06.031] List of future strategies:
[15:32:06.031] 1. sequential:
[15:32:06.031]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.031]    - tweaked: FALSE
[15:32:06.031]    - call: plan(sequential)
[15:32:06.057] plan(): nbrOfWorkers() = 1
> y_rng_0 <- future_mapply(stats::runif, n = 1:4, max = 2:5,
+                          MoreArgs = list(min = 1), future.seed = 0xBEEF)
[15:32:06.058] future_mapply() ...
[15:32:06.059] Generating random seeds ...
[15:32:06.059] Generating random seed streams for 4 elements ...
[15:32:06.060] Generating random seed streams for 4 elements ... DONE
[15:32:06.061] Generating random seeds ... DONE
[15:32:06.061] Will set RNG state on exit: 10407, 949485115, -138203693, 511393082, -128431090, 758578777, -253660479
[15:32:06.061] Number of chunks: 1
[15:32:06.062] getGlobalsAndPackagesXApply() ...
[15:32:06.062]  - future.globals: TRUE
[15:32:06.064] getGlobalsAndPackages() ...
[15:32:06.064] Searching for globals...
[15:32:06.073] - globals found: [3] 'FUN', '.Call', 'C_runif'
[15:32:06.073] Searching for globals ... DONE
[15:32:06.073] Resolving globals: FALSE
[15:32:06.075] The total size of the 1 globals is 2.04 KiB (2088 bytes)
[15:32:06.076] The total size of the 1 globals exported for future expression ('FUN(min = 1)') is 2.04 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (2.04 KiB of class 'function')
[15:32:06.077] - globals: [1] 'FUN'
[15:32:06.077] - packages: [1] 'stats'
[15:32:06.077] getGlobalsAndPackages() ... DONE
[15:32:06.077]  - globals found/used: [n=1] 'FUN'
[15:32:06.078]  - needed namespaces: [n=1] 'stats'
[15:32:06.078] Finding globals ... DONE
[15:32:06.079] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.079] List of 2
[15:32:06.079]  $ ...future.FUN:function (n, min = 0, max = 1)  
[15:32:06.079]  $ MoreArgs     :List of 1
[15:32:06.079]   ..$ min: num 1
[15:32:06.079]  - attr(*, "where")=List of 2
[15:32:06.079]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.079]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.079]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.079]  - attr(*, "resolved")= logi FALSE
[15:32:06.079]  - attr(*, "total_size")= num NA
[15:32:06.088] Packages to be attached in all futures: [n=1] 'stats'
[15:32:06.089] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.089] Number of futures (= number of chunks): 1
[15:32:06.090] Launching 1 futures (chunks) ...
[15:32:06.090] Chunk #1 of 1 ...
[15:32:06.091]  - Finding globals in '...' for chunk #1 ...
[15:32:06.091] getGlobalsAndPackages() ...
[15:32:06.091] Searching for globals...
[15:32:06.092] 
[15:32:06.092] Searching for globals ... DONE
[15:32:06.093] - globals: [0] <none>
[15:32:06.093] getGlobalsAndPackages() ... DONE
[15:32:06.093]    + additional globals found: [n=0] 
[15:32:06.093]    + additional namespaces needed: [n=0] 
[15:32:06.094]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.094]  - seeds: [4] <seeds>
[15:32:06.094]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.095] getGlobalsAndPackages() ...
[15:32:06.095] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.095] Resolving globals: FALSE
[15:32:06.097] The total size of the 5 globals is 2.84 KiB (2912 bytes)
[15:32:06.098] 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 2.84 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (2.04 KiB of class 'function'), '...future.elements_ii' (448 bytes of class 'list') and '...future.seeds_ii' (320 bytes of class 'list')
[15:32:06.098] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.098] - packages: [1] 'stats'
[15:32:06.099] getGlobalsAndPackages() ... DONE
[15:32:06.100] run() for 'Future' ...
[15:32:06.100] - state: 'created'
[15:32:06.101] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:06.102] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.102] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:06.102]   - Field: 'label'
[15:32:06.103]   - Field: 'local'
[15:32:06.103]   - Field: 'owner'
[15:32:06.103]   - Field: 'envir'
[15:32:06.104]   - Field: 'packages'
[15:32:06.104]   - Field: 'gc'
[15:32:06.104]   - Field: 'conditions'
[15:32:06.104]   - Field: 'expr'
[15:32:06.105]   - Field: 'uuid'
[15:32:06.105]   - Field: 'seed'
[15:32:06.105]   - Field: 'version'
[15:32:06.106]   - Field: 'result'
[15:32:06.106]   - Field: 'asynchronous'
[15:32:06.106]   - Field: 'calls'
[15:32:06.107]   - Field: 'globals'
[15:32:06.107]   - Field: 'stdout'
[15:32:06.107]   - Field: 'earlySignal'
[15:32:06.108]   - Field: 'lazy'
[15:32:06.108]   - Field: 'state'
[15:32:06.108] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:06.108] - Launch lazy future ...
[15:32:06.110] Packages needed by the future expression (n = 1): 'stats'
[15:32:06.110] Packages needed by future strategies (n = 0): <none>
[15:32:06.112] {
[15:32:06.112]     {
[15:32:06.112]         {
[15:32:06.112]             ...future.startTime <- base::Sys.time()
[15:32:06.112]             {
[15:32:06.112]                 {
[15:32:06.112]                   {
[15:32:06.112]                     {
[15:32:06.112]                       base::local({
[15:32:06.112]                         has_future <- base::requireNamespace("future", 
[15:32:06.112]                           quietly = TRUE)
[15:32:06.112]                         if (has_future) {
[15:32:06.112]                           ns <- base::getNamespace("future")
[15:32:06.112]                           version <- ns[[".package"]][["version"]]
[15:32:06.112]                           if (is.null(version)) 
[15:32:06.112]                             version <- utils::packageVersion("future")
[15:32:06.112]                         }
[15:32:06.112]                         else {
[15:32:06.112]                           version <- NULL
[15:32:06.112]                         }
[15:32:06.112]                         if (!has_future || version < "1.8.0") {
[15:32:06.112]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:06.112]                             "", base::R.version$version.string), 
[15:32:06.112]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:06.112]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:06.112]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:06.112]                               "release", "version")], collapse = " "), 
[15:32:06.112]                             hostname = base::Sys.info()[["nodename"]])
[15:32:06.112]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:06.112]                             info)
[15:32:06.112]                           info <- base::paste(info, collapse = "; ")
[15:32:06.112]                           if (!has_future) {
[15:32:06.112]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:06.112]                               info)
[15:32:06.112]                           }
[15:32:06.112]                           else {
[15:32:06.112]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:06.112]                               info, version)
[15:32:06.112]                           }
[15:32:06.112]                           base::stop(msg)
[15:32:06.112]                         }
[15:32:06.112]                       })
[15:32:06.112]                     }
[15:32:06.112]                     base::local({
[15:32:06.112]                       for (pkg in "stats") {
[15:32:06.112]                         base::loadNamespace(pkg)
[15:32:06.112]                         base::library(pkg, character.only = TRUE)
[15:32:06.112]                       }
[15:32:06.112]                     })
[15:32:06.112]                   }
[15:32:06.112]                   ...future.strategy.old <- future::plan("list")
[15:32:06.112]                   options(future.plan = NULL)
[15:32:06.112]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.112]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:06.112]                 }
[15:32:06.112]                 ...future.workdir <- getwd()
[15:32:06.112]             }
[15:32:06.112]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:06.112]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:06.112]         }
[15:32:06.112]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:06.112]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:06.112]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:06.112]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:06.112]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:06.112]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:06.112]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:06.112]             base::names(...future.oldOptions))
[15:32:06.112]     }
[15:32:06.112]     if (FALSE) {
[15:32:06.112]     }
[15:32:06.112]     else {
[15:32:06.112]         if (TRUE) {
[15:32:06.112]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:06.112]                 open = "w")
[15:32:06.112]         }
[15:32:06.112]         else {
[15:32:06.112]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:06.112]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:06.112]         }
[15:32:06.112]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:06.112]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:06.112]             base::sink(type = "output", split = FALSE)
[15:32:06.112]             base::close(...future.stdout)
[15:32:06.112]         }, add = TRUE)
[15:32:06.112]     }
[15:32:06.112]     ...future.frame <- base::sys.nframe()
[15:32:06.112]     ...future.conditions <- base::list()
[15:32:06.112]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:06.112]     if (FALSE) {
[15:32:06.112]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:06.112]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:06.112]     }
[15:32:06.112]     ...future.result <- base::tryCatch({
[15:32:06.112]         base::withCallingHandlers({
[15:32:06.112]             ...future.value <- base::withVisible(base::local({
[15:32:06.112]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.112]                 if (!identical(...future.globals.maxSize.org, 
[15:32:06.112]                   ...future.globals.maxSize)) {
[15:32:06.112]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.112]                   on.exit(options(oopts), add = TRUE)
[15:32:06.112]                 }
[15:32:06.112]                 {
[15:32:06.112]                   ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:06.112]                     assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:06.112]                       envir = globalenv(), inherits = FALSE)
[15:32:06.112]                     ...future.FUN(...)
[15:32:06.112]                   }
[15:32:06.112]                   args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:06.112]                     list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:06.112]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:06.112]                     USE.NAMES = FALSE)
[15:32:06.112]                   do.call(mapply, args = args)
[15:32:06.112]                 }
[15:32:06.112]             }))
[15:32:06.112]             future::FutureResult(value = ...future.value$value, 
[15:32:06.112]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.112]                   ...future.rng), globalenv = if (FALSE) 
[15:32:06.112]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:06.112]                     ...future.globalenv.names))
[15:32:06.112]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:06.112]         }, condition = base::local({
[15:32:06.112]             c <- base::c
[15:32:06.112]             inherits <- base::inherits
[15:32:06.112]             invokeRestart <- base::invokeRestart
[15:32:06.112]             length <- base::length
[15:32:06.112]             list <- base::list
[15:32:06.112]             seq.int <- base::seq.int
[15:32:06.112]             signalCondition <- base::signalCondition
[15:32:06.112]             sys.calls <- base::sys.calls
[15:32:06.112]             `[[` <- base::`[[`
[15:32:06.112]             `+` <- base::`+`
[15:32:06.112]             `<<-` <- base::`<<-`
[15:32:06.112]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:06.112]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:06.112]                   3L)]
[15:32:06.112]             }
[15:32:06.112]             function(cond) {
[15:32:06.112]                 is_error <- inherits(cond, "error")
[15:32:06.112]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:06.112]                   NULL)
[15:32:06.112]                 if (is_error) {
[15:32:06.112]                   sessionInformation <- function() {
[15:32:06.112]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:06.112]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:06.112]                       search = base::search(), system = base::Sys.info())
[15:32:06.112]                   }
[15:32:06.112]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.112]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:06.112]                     cond$call), session = sessionInformation(), 
[15:32:06.112]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:06.112]                   signalCondition(cond)
[15:32:06.112]                 }
[15:32:06.112]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:06.112]                 "immediateCondition"))) {
[15:32:06.112]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:06.112]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.112]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:06.112]                   if (TRUE && !signal) {
[15:32:06.112]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.112]                     {
[15:32:06.112]                       inherits <- base::inherits
[15:32:06.112]                       invokeRestart <- base::invokeRestart
[15:32:06.112]                       is.null <- base::is.null
[15:32:06.112]                       muffled <- FALSE
[15:32:06.112]                       if (inherits(cond, "message")) {
[15:32:06.112]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.112]                         if (muffled) 
[15:32:06.112]                           invokeRestart("muffleMessage")
[15:32:06.112]                       }
[15:32:06.112]                       else if (inherits(cond, "warning")) {
[15:32:06.112]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.112]                         if (muffled) 
[15:32:06.112]                           invokeRestart("muffleWarning")
[15:32:06.112]                       }
[15:32:06.112]                       else if (inherits(cond, "condition")) {
[15:32:06.112]                         if (!is.null(pattern)) {
[15:32:06.112]                           computeRestarts <- base::computeRestarts
[15:32:06.112]                           grepl <- base::grepl
[15:32:06.112]                           restarts <- computeRestarts(cond)
[15:32:06.112]                           for (restart in restarts) {
[15:32:06.112]                             name <- restart$name
[15:32:06.112]                             if (is.null(name)) 
[15:32:06.112]                               next
[15:32:06.112]                             if (!grepl(pattern, name)) 
[15:32:06.112]                               next
[15:32:06.112]                             invokeRestart(restart)
[15:32:06.112]                             muffled <- TRUE
[15:32:06.112]                             break
[15:32:06.112]                           }
[15:32:06.112]                         }
[15:32:06.112]                       }
[15:32:06.112]                       invisible(muffled)
[15:32:06.112]                     }
[15:32:06.112]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.112]                   }
[15:32:06.112]                 }
[15:32:06.112]                 else {
[15:32:06.112]                   if (TRUE) {
[15:32:06.112]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.112]                     {
[15:32:06.112]                       inherits <- base::inherits
[15:32:06.112]                       invokeRestart <- base::invokeRestart
[15:32:06.112]                       is.null <- base::is.null
[15:32:06.112]                       muffled <- FALSE
[15:32:06.112]                       if (inherits(cond, "message")) {
[15:32:06.112]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.112]                         if (muffled) 
[15:32:06.112]                           invokeRestart("muffleMessage")
[15:32:06.112]                       }
[15:32:06.112]                       else if (inherits(cond, "warning")) {
[15:32:06.112]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.112]                         if (muffled) 
[15:32:06.112]                           invokeRestart("muffleWarning")
[15:32:06.112]                       }
[15:32:06.112]                       else if (inherits(cond, "condition")) {
[15:32:06.112]                         if (!is.null(pattern)) {
[15:32:06.112]                           computeRestarts <- base::computeRestarts
[15:32:06.112]                           grepl <- base::grepl
[15:32:06.112]                           restarts <- computeRestarts(cond)
[15:32:06.112]                           for (restart in restarts) {
[15:32:06.112]                             name <- restart$name
[15:32:06.112]                             if (is.null(name)) 
[15:32:06.112]                               next
[15:32:06.112]                             if (!grepl(pattern, name)) 
[15:32:06.112]                               next
[15:32:06.112]                             invokeRestart(restart)
[15:32:06.112]                             muffled <- TRUE
[15:32:06.112]                             break
[15:32:06.112]                           }
[15:32:06.112]                         }
[15:32:06.112]                       }
[15:32:06.112]                       invisible(muffled)
[15:32:06.112]                     }
[15:32:06.112]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.112]                   }
[15:32:06.112]                 }
[15:32:06.112]             }
[15:32:06.112]         }))
[15:32:06.112]     }, error = function(ex) {
[15:32:06.112]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:06.112]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.112]                 ...future.rng), started = ...future.startTime, 
[15:32:06.112]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:06.112]             version = "1.8"), class = "FutureResult")
[15:32:06.112]     }, finally = {
[15:32:06.112]         if (!identical(...future.workdir, getwd())) 
[15:32:06.112]             setwd(...future.workdir)
[15:32:06.112]         {
[15:32:06.112]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:06.112]                 ...future.oldOptions$nwarnings <- NULL
[15:32:06.112]             }
[15:32:06.112]             base::options(...future.oldOptions)
[15:32:06.112]             if (.Platform$OS.type == "windows") {
[15:32:06.112]                 old_names <- names(...future.oldEnvVars)
[15:32:06.112]                 envs <- base::Sys.getenv()
[15:32:06.112]                 names <- names(envs)
[15:32:06.112]                 common <- intersect(names, old_names)
[15:32:06.112]                 added <- setdiff(names, old_names)
[15:32:06.112]                 removed <- setdiff(old_names, names)
[15:32:06.112]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:06.112]                   envs[common]]
[15:32:06.112]                 NAMES <- toupper(changed)
[15:32:06.112]                 args <- list()
[15:32:06.112]                 for (kk in seq_along(NAMES)) {
[15:32:06.112]                   name <- changed[[kk]]
[15:32:06.112]                   NAME <- NAMES[[kk]]
[15:32:06.112]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.112]                     next
[15:32:06.112]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.112]                 }
[15:32:06.112]                 NAMES <- toupper(added)
[15:32:06.112]                 for (kk in seq_along(NAMES)) {
[15:32:06.112]                   name <- added[[kk]]
[15:32:06.112]                   NAME <- NAMES[[kk]]
[15:32:06.112]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.112]                     next
[15:32:06.112]                   args[[name]] <- ""
[15:32:06.112]                 }
[15:32:06.112]                 NAMES <- toupper(removed)
[15:32:06.112]                 for (kk in seq_along(NAMES)) {
[15:32:06.112]                   name <- removed[[kk]]
[15:32:06.112]                   NAME <- NAMES[[kk]]
[15:32:06.112]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.112]                     next
[15:32:06.112]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.112]                 }
[15:32:06.112]                 if (length(args) > 0) 
[15:32:06.112]                   base::do.call(base::Sys.setenv, args = args)
[15:32:06.112]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:06.112]             }
[15:32:06.112]             else {
[15:32:06.112]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:06.112]             }
[15:32:06.112]             {
[15:32:06.112]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:06.112]                   0L) {
[15:32:06.112]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:06.112]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:06.112]                   base::options(opts)
[15:32:06.112]                 }
[15:32:06.112]                 {
[15:32:06.112]                   {
[15:32:06.112]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:06.112]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:06.112]                     -253660479L), envir = base::globalenv(), 
[15:32:06.112]                       inherits = FALSE)
[15:32:06.112]                     NULL
[15:32:06.112]                   }
[15:32:06.112]                   options(future.plan = NULL)
[15:32:06.112]                   if (is.na(NA_character_)) 
[15:32:06.112]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.112]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:06.112]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:06.112]                     .init = FALSE)
[15:32:06.112]                 }
[15:32:06.112]             }
[15:32:06.112]         }
[15:32:06.112]     })
[15:32:06.112]     if (TRUE) {
[15:32:06.112]         base::sink(type = "output", split = FALSE)
[15:32:06.112]         if (TRUE) {
[15:32:06.112]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:06.112]         }
[15:32:06.112]         else {
[15:32:06.112]             ...future.result["stdout"] <- base::list(NULL)
[15:32:06.112]         }
[15:32:06.112]         base::close(...future.stdout)
[15:32:06.112]         ...future.stdout <- NULL
[15:32:06.112]     }
[15:32:06.112]     ...future.result$conditions <- ...future.conditions
[15:32:06.112]     ...future.result$finished <- base::Sys.time()
[15:32:06.112]     ...future.result
[15:32:06.112] }
[15:32:06.120] assign_globals() ...
[15:32:06.120] List of 5
[15:32:06.120]  $ ...future.FUN            :function (n, min = 0, max = 1)  
[15:32:06.120]  $ MoreArgs                 :List of 1
[15:32:06.120]   ..$ min: num 1
[15:32:06.120]  $ ...future.elements_ii    :List of 2
[15:32:06.120]   ..$ n  :List of 4
[15:32:06.120]   .. ..$ : int 1
[15:32:06.120]   .. ..$ : int 2
[15:32:06.120]   .. ..$ : int 3
[15:32:06.120]   .. ..$ : int 4
[15:32:06.120]   ..$ max:List of 4
[15:32:06.120]   .. ..$ : int 2
[15:32:06.120]   .. ..$ : int 3
[15:32:06.120]   .. ..$ : int 4
[15:32:06.120]   .. ..$ : int 5
[15:32:06.120]  $ ...future.seeds_ii       :List of 4
[15:32:06.120]   ..$ : int [1:7] 10407 1242173061 -1150840343 -834448425 701050094 -1369558043 -650964284
[15:32:06.120]   ..$ : int [1:7] 10407 859061261 1088872332 -1371790091 -942478768 -889560561 1393381402
[15:32:06.120]   ..$ : int [1:7] 10407 -1977952646 362645338 -1927542548 -742448269 -2030870718 1472975712
[15:32:06.120]   ..$ : int [1:7] 10407 -781199300 -1470244364 -1435938985 -1154922760 795337516 2089908040
[15:32:06.120]  $ ...future.globals.maxSize: NULL
[15:32:06.120]  - attr(*, "where")=List of 5
[15:32:06.120]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:06.120]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:06.120]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:06.120]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:06.120]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:06.120]  - attr(*, "resolved")= logi FALSE
[15:32:06.120]  - attr(*, "total_size")= num 2912
[15:32:06.120]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.120]  - attr(*, "already-done")= logi TRUE
[15:32:06.142] - copied '...future.FUN' to environment
[15:32:06.142] - copied 'MoreArgs' to environment
[15:32:06.143] - copied '...future.elements_ii' to environment
[15:32:06.143] - copied '...future.seeds_ii' to environment
[15:32:06.143] - copied '...future.globals.maxSize' to environment
[15:32:06.144] assign_globals() ... done
[15:32:06.145] plan(): Setting new future strategy stack:
[15:32:06.145] List of future strategies:
[15:32:06.145] 1. sequential:
[15:32:06.145]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.145]    - tweaked: FALSE
[15:32:06.145]    - call: NULL
[15:32:06.146] plan(): nbrOfWorkers() = 1
[15:32:06.149] plan(): Setting new future strategy stack:
[15:32:06.149] List of future strategies:
[15:32:06.149] 1. sequential:
[15:32:06.149]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.149]    - tweaked: FALSE
[15:32:06.149]    - call: plan(sequential)
[15:32:06.150] plan(): nbrOfWorkers() = 1
[15:32:06.151] SequentialFuture started (and completed)
[15:32:06.152] - Launch lazy future ... done
[15:32:06.152] run() for 'SequentialFuture' ... done
[15:32:06.152] Created future:
[15:32:06.153] SequentialFuture:
[15:32:06.153] Label: 'future_mapply-1'
[15:32:06.153] Expression:
[15:32:06.153] {
[15:32:06.153]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.153]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:06.153]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.153]         on.exit(options(oopts), add = TRUE)
[15:32:06.153]     }
[15:32:06.153]     {
[15:32:06.153]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:06.153]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:06.153]                 inherits = FALSE)
[15:32:06.153]             ...future.FUN(...)
[15:32:06.153]         }
[15:32:06.153]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:06.153]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:06.153]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:06.153]         do.call(mapply, args = args)
[15:32:06.153]     }
[15:32:06.153] }
[15:32:06.153] Lazy evaluation: FALSE
[15:32:06.153] Asynchronous evaluation: FALSE
[15:32:06.153] Local evaluation: TRUE
[15:32:06.153] Environment: R_GlobalEnv
[15:32:06.153] Capture standard output: TRUE
[15:32:06.153] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:06.153] Globals: 5 objects totaling 2.84 KiB (function '...future.FUN' of 2.04 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 448 bytes, list '...future.seeds_ii' of 320 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:06.153] Packages: 1 packages ('stats')
[15:32:06.153] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:06.153] Resolved: TRUE
[15:32:06.153] Value: 280 bytes of class 'list'
[15:32:06.153] Early signaling: FALSE
[15:32:06.153] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:06.153] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.155] Chunk #1 of 1 ... DONE
[15:32:06.156] Launching 1 futures (chunks) ... DONE
[15:32:06.156] Resolving 1 futures (chunks) ...
[15:32:06.157] resolve() on list ...
[15:32:06.157]  recursive: 0
[15:32:06.158]  length: 1
[15:32:06.158] 
[15:32:06.158] resolved() for 'SequentialFuture' ...
[15:32:06.159] - state: 'finished'
[15:32:06.159] - run: TRUE
[15:32:06.159] - result: 'FutureResult'
[15:32:06.160] resolved() for 'SequentialFuture' ... done
[15:32:06.160] Future #1
[15:32:06.161] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:06.161] - nx: 1
[15:32:06.161] - relay: TRUE
[15:32:06.162] - stdout: TRUE
[15:32:06.162] - signal: TRUE
[15:32:06.162] - resignal: FALSE
[15:32:06.162] - force: TRUE
[15:32:06.163] - relayed: [n=1] FALSE
[15:32:06.163] - queued futures: [n=1] FALSE
[15:32:06.163]  - until=1
[15:32:06.164]  - relaying element #1
[15:32:06.164] - relayed: [n=1] TRUE
[15:32:06.164] - queued futures: [n=1] TRUE
[15:32:06.165] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:06.165]  length: 0 (resolved future 1)
[15:32:06.165] Relaying remaining futures
[15:32:06.166] signalConditionsASAP(NULL, pos=0) ...
[15:32:06.166] - nx: 1
[15:32:06.166] - relay: TRUE
[15:32:06.166] - stdout: TRUE
[15:32:06.167] - signal: TRUE
[15:32:06.167] - resignal: FALSE
[15:32:06.167] - force: TRUE
[15:32:06.167] - relayed: [n=1] TRUE
[15:32:06.168] - queued futures: [n=1] TRUE
 - flush all
[15:32:06.168] - relayed: [n=1] TRUE
[15:32:06.168] - queued futures: [n=1] TRUE
[15:32:06.169] signalConditionsASAP(NULL, pos=0) ... done
[15:32:06.169] resolve() on list ... DONE
[15:32:06.169]  - Number of value chunks collected: 1
[15:32:06.170] Resolving 1 futures (chunks) ... DONE
[15:32:06.170] Reducing values from 1 chunks ...
[15:32:06.170]  - Number of values collected after concatenation: 4
[15:32:06.170]  - Number of values expected: 4
[15:32:06.171] Reducing values from 1 chunks ... DONE
[15:32:06.171] future_mapply() ... DONE
> print(y_rng_0)
[[1]]
[1] 1.752502

[[2]]
[1] 2.765950 2.044156

[[3]]
[1] 1.419503 3.529684 1.023802

[[4]]
[1] 4.494280 3.546145 1.402837 4.295444

> 
> for (strategy in supportedStrategies()) {
+   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
+   plan(strategy)
+ 
+   message("- From example(mapply) ...")
+   y0 <- mapply(rep, 1:4, 4:1)
+   y1 <- future_mapply(rep, 1:4, 4:1)
+   stopifnot(identical(y1, y0))
+   y2 <- future_mapply("rep", 1:4, 4:1)
+   stopifnot(identical(y2, y0))
+   
+   y0 <- mapply(rep, times = 1:4, x = 4:1)
+   y1 <- future_mapply(rep, times = 1:4, x = 4:1)
+   stopifnot(identical(y1, y0))
+   
+   y0 <- mapply(rep, times = 1:4, MoreArgs = list(x = 42))
+   y1 <- future_mapply(rep, times = 1:4, MoreArgs = list(x = 42))
+   stopifnot(identical(y1, y0))
+   
+   y0 <- mapply(function(x, y) seq_len(x) + y,
+                c(a =  1, b = 2, c = 3),  # names from first
+                c(A = 10, B = 0, C = -10))
+   y1 <- future_mapply(function(x, y) seq_len(x) + y,
+                       c(a =  1, b = 2, c = 3),  # names from first
+                       c(A = 10, B = 0, C = -10))
+   stopifnot(identical(y1, y0))
+ 
+   message("- future_.mapply()")
+   dots <- list(c(a =  1, b = 2, c = 3),  # names from first
+                c(A = 10, B = 0, C = -10))
+   y2 <- .mapply(function(x, y) seq_len(x) + y, dots = dots, MoreArgs = list())
+   names(y0) <- NULL  ## .mapply() don't set names
+   stopifnot(all.equal(y2, y0))
+   y3 <- future_.mapply(function(x, y) seq_len(x) + y, dots = dots, MoreArgs = list())
+   stopifnot(all.equal(y3, y2))
+ 
+   word <- function(C, k) paste(rep.int(C, k), collapse = "")
+   for (chunk.size in list(1L, structure(2L, ordering = "random"), structure(3L, ordering = 5:1))) {
+     y0 <- mapply(word, LETTERS[1:5], 5:1, SIMPLIFY = FALSE)
+     y1 <- future_mapply(word, LETTERS[1:5], 5:1, SIMPLIFY = FALSE, future.chunk.size = chunk.size)
+     stopifnot(identical(y1, y0))
+ 
+     dots <- list(LETTERS[1:5], 5:1)
+     MoreArgs <- list()
+     y2 <- .mapply(word, dots = dots, MoreArgs = list())
+     names(y0) <- NULL  ## .mapply() don't set names
+     stopifnot(all.equal(y2, y0))
+     y3 <- future_.mapply(word, dots = dots, MoreArgs = list())
+     stopifnot(all.equal(y3, y2))
+   }
+ 
+   message("- Subsetting (Issue #17) ...")
+   X <- as.Date("2018-06-01")
+   y0 <- mapply(FUN = identity, X, SIMPLIFY = FALSE)
+   y1 <- future_mapply(FUN = identity, X, SIMPLIFY = FALSE)
+   stopifnot(identical(y1, y0))
+ 
+   dots <- list(X)
+   y2 <- .mapply(FUN = identity, dots = dots, MoreArgs = MoreArgs)
+   stopifnot(identical(y2, y0))
+   y3 <- future_.mapply(FUN = identity, dots = dots, MoreArgs = MoreArgs)
+   stopifnot(identical(y3, y2))
+ 
+   message("- Non-recycling of MoreArgs (Issue #51) ...")
+   y0 <- base::mapply(
+     function(x, y) y,
+     x = 1:2, MoreArgs = list(y = 3:4)
+   )
+   y1 <- future.apply::future_mapply(
+     function(x, y) y,
+     x = 1:2, MoreArgs = list(y = 3:4),
+     future.seed = FALSE
+   )
+   stopifnot(identical(y1, y0))
+   y2 <- future.apply::future_mapply(
+     function(x, y) y,
+     x = 1:2, MoreArgs = list(y = 3:4),
+     future.seed = TRUE
+   )
+   stopifnot(identical(y2, y0))
+ 
+   dots <- list(x = 1:2)
+   MoreArgs <- list(y = 3:4)
+   y3 <- .mapply(function(x, y) y, dots = dots, MoreArgs = MoreArgs)
+   y4 <- future_.mapply(function(x, y) y, dots = dots, MoreArgs = MoreArgs)
+   stopifnot(identical(y4, y3))
+ 
+   message("- Recycle arguments to same length ...")
+   y0 <- mapply(rep, 1:4, 2:1)
+   y1 <- future_mapply(rep, 1:4, 2:1)
+   stopifnot(identical(y1, y0))
+ 
+   
+   message("- Parallel RNG ...")
+   y_rng_1 <- future_mapply(stats::runif, n = 1:4, max = 2:5,
+                            MoreArgs = list(min = 1), future.seed = 0xBEEF)
+   print(y_rng_1)
+   stopifnot(all.equal(y_rng_1, y_rng_0))
+ 
+   message("- future_Map() ...")
+   xs <- replicate(5, stats::runif(10), simplify = FALSE)
+   ws <- replicate(5, stats::rpois(10, 5) + 1, simplify = FALSE)
+   y0 <- Map(weighted.mean, xs, ws)
+   y1 <- future_Map(stats::weighted.mean, xs, ws)
+   stopifnot(all.equal(y1, y0))
+ 
+   message("- future_mapply() - 'max-or-0-if' recycling rule ...")
+   ## R (>= 4.2.0): mapply() & Map() follow usual "max-or-0-if" recycling rule
+   ## and keeps returning a named list in the "empty" case.
+   
+   truth <- list()
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(`+`, 1:3, NULL)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(`+`, 1:3, NULL)
+   stopifnot(identical(y, truth))
+   
+   truth <- setNames(list(), character())
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, character(), NULL)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, character(), NULL)
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, character(), letters)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, character(), letters)
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, "A", character())
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, "A", character())
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, character(), letters) 
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, character(), letters) 
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, character(), NULL)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, character(), NULL)
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, character(), letters)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, character(), letters)
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, "A", character()) 
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, "A", character()) 
+   stopifnot(identical(y, truth))
+   
+   if (getRversion() >= "4.2.0") {
+     y0 <- mapply(paste, character(), letters) 
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, character(), letters) 
+   stopifnot(identical(y, truth))
+ 
+   ## Gives an error in R-devel (2021-11-26 r81252)
+   if (getRversion() >= "4.2.0" && FALSE) {
+     y0 <- mapply(paste, c(a = "A"), character())
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_mapply(paste, c(a = "A"), character())
+   stopifnot(identical(y, truth))
+ 
+   ## R (>= 4.2.0): Map() now recycles similar to basic Ops:
+   truth <- as.list(1 + 1:3)
+   if (getRversion() >= "4.2.0") {
+     y0 <- Map(`+`, 1, 1:3)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_Map(`+`, 1, 1:3)
+   stopifnot(identical(y, truth))
+   
+   truth <- as.list(numeric() + 1:3)
+   if (getRversion() >= "4.2.0") {
+     y0 <- Map(`+`, numeric(), 1:3)
+     stopifnot(identical(y0, truth))
+   }
+   y <- future_Map(`+`, numeric(), 1:3)
+   stopifnot(identical(y, truth))
+ 
+   message("- future_mapply(x, ...) where x[[i]] subsets via S3 method ...")
+   x <- structure(list(a = 1, b = 2), class = "Foo")
+   `[[.Foo` <- function(x, ...) 0
+   y0 <- mapply(x, FUN = identity)
+   stopifnot(identical(y0, c(a = 0, b = 0)))
+   y1 <- future_mapply(x, FUN = identity)
+   if (getOption("future.apply.chunkWith", "[[") == "[") {
+     stopifnot(identical(y1, unlist(x)))
+   } else {
+     stopifnot(identical(y1, y0))
+   }
+ 
+   plan(sequential)
+   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
+ } ## for (strategy in ...) 
*** strategy = 'sequential' ...
[15:32:06.569] plan(): Setting new future strategy stack:
[15:32:06.569] List of future strategies:
[15:32:06.569] 1. sequential:
[15:32:06.569]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.569]    - tweaked: FALSE
[15:32:06.569]    - call: plan(strategy)
[15:32:06.570] plan(): nbrOfWorkers() = 1
- From example(mapply) ...
[15:32:06.571] future_mapply() ...
[15:32:06.571] Number of chunks: 1
[15:32:06.574] getGlobalsAndPackagesXApply() ...
[15:32:06.574]  - future.globals: TRUE
[15:32:06.574] getGlobalsAndPackages() ...
[15:32:06.575] Searching for globals...
[15:32:06.576] - globals found: [1] 'FUN'
[15:32:06.576] Searching for globals ... DONE
[15:32:06.576] Resolving globals: FALSE
[15:32:06.577] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:06.578] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:06.578] - globals: [1] 'FUN'
[15:32:06.578] 
[15:32:06.578] getGlobalsAndPackages() ... DONE
[15:32:06.579]  - globals found/used: [n=1] 'FUN'
[15:32:06.579]  - needed namespaces: [n=0] 
[15:32:06.579] Finding globals ... DONE
[15:32:06.580] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.580] List of 2
[15:32:06.580]  $ ...future.FUN:function (x, ...)  
[15:32:06.580]  $ MoreArgs     : NULL
[15:32:06.580]  - attr(*, "where")=List of 2
[15:32:06.580]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.580]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.580]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.580]  - attr(*, "resolved")= logi FALSE
[15:32:06.580]  - attr(*, "total_size")= num NA
[15:32:06.584] Packages to be attached in all futures: [n=0] 
[15:32:06.585] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.585] Number of futures (= number of chunks): 1
[15:32:06.585] Launching 1 futures (chunks) ...
[15:32:06.586] Chunk #1 of 1 ...
[15:32:06.586]  - Finding globals in '...' for chunk #1 ...
[15:32:06.586] getGlobalsAndPackages() ...
[15:32:06.586] Searching for globals...
[15:32:06.587] 
[15:32:06.587] Searching for globals ... DONE
[15:32:06.587] - globals: [0] <none>
[15:32:06.588] getGlobalsAndPackages() ... DONE
[15:32:06.588]    + additional globals found: [n=0] 
[15:32:06.588]    + additional namespaces needed: [n=0] 
[15:32:06.588]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.589]  - seeds: <none>
[15:32:06.589]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.589] getGlobalsAndPackages() ...
[15:32:06.590] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.590] Resolving globals: FALSE
[15:32:06.591] The total size of the 5 globals is 504 bytes (504 bytes)
[15:32:06.592] 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 504 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (448 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:06.592] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.592] 
[15:32:06.593] getGlobalsAndPackages() ... DONE
[15:32:06.593] run() for 'Future' ...
[15:32:06.593] - state: 'created'
[15:32:06.594] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:06.594] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.595] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:06.595]   - Field: 'label'
[15:32:06.595]   - Field: 'local'
[15:32:06.596]   - Field: 'owner'
[15:32:06.596]   - Field: 'envir'
[15:32:06.596]   - Field: 'packages'
[15:32:06.596]   - Field: 'gc'
[15:32:06.597]   - Field: 'conditions'
[15:32:06.597]   - Field: 'expr'
[15:32:06.597]   - Field: 'uuid'
[15:32:06.598]   - Field: 'seed'
[15:32:06.598]   - Field: 'version'
[15:32:06.598]   - Field: 'result'
[15:32:06.598]   - Field: 'asynchronous'
[15:32:06.599]   - Field: 'calls'
[15:32:06.599]   - Field: 'globals'
[15:32:06.599]   - Field: 'stdout'
[15:32:06.600]   - Field: 'earlySignal'
[15:32:06.600]   - Field: 'lazy'
[15:32:06.600]   - Field: 'state'
[15:32:06.600] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:06.601] - Launch lazy future ...
[15:32:06.601] Packages needed by the future expression (n = 0): <none>
[15:32:06.602] Packages needed by future strategies (n = 0): <none>
[15:32:06.602] {
[15:32:06.602]     {
[15:32:06.602]         {
[15:32:06.602]             ...future.startTime <- base::Sys.time()
[15:32:06.602]             {
[15:32:06.602]                 {
[15:32:06.602]                   {
[15:32:06.602]                     base::local({
[15:32:06.602]                       has_future <- base::requireNamespace("future", 
[15:32:06.602]                         quietly = TRUE)
[15:32:06.602]                       if (has_future) {
[15:32:06.602]                         ns <- base::getNamespace("future")
[15:32:06.602]                         version <- ns[[".package"]][["version"]]
[15:32:06.602]                         if (is.null(version)) 
[15:32:06.602]                           version <- utils::packageVersion("future")
[15:32:06.602]                       }
[15:32:06.602]                       else {
[15:32:06.602]                         version <- NULL
[15:32:06.602]                       }
[15:32:06.602]                       if (!has_future || version < "1.8.0") {
[15:32:06.602]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:06.602]                           "", base::R.version$version.string), 
[15:32:06.602]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:06.602]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:06.602]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:06.602]                             "release", "version")], collapse = " "), 
[15:32:06.602]                           hostname = base::Sys.info()[["nodename"]])
[15:32:06.602]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:06.602]                           info)
[15:32:06.602]                         info <- base::paste(info, collapse = "; ")
[15:32:06.602]                         if (!has_future) {
[15:32:06.602]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:06.602]                             info)
[15:32:06.602]                         }
[15:32:06.602]                         else {
[15:32:06.602]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:06.602]                             info, version)
[15:32:06.602]                         }
[15:32:06.602]                         base::stop(msg)
[15:32:06.602]                       }
[15:32:06.602]                     })
[15:32:06.602]                   }
[15:32:06.602]                   ...future.strategy.old <- future::plan("list")
[15:32:06.602]                   options(future.plan = NULL)
[15:32:06.602]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.602]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:06.602]                 }
[15:32:06.602]                 ...future.workdir <- getwd()
[15:32:06.602]             }
[15:32:06.602]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:06.602]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:06.602]         }
[15:32:06.602]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:06.602]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:06.602]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:06.602]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:06.602]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:06.602]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:06.602]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:06.602]             base::names(...future.oldOptions))
[15:32:06.602]     }
[15:32:06.602]     if (FALSE) {
[15:32:06.602]     }
[15:32:06.602]     else {
[15:32:06.602]         if (TRUE) {
[15:32:06.602]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:06.602]                 open = "w")
[15:32:06.602]         }
[15:32:06.602]         else {
[15:32:06.602]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:06.602]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:06.602]         }
[15:32:06.602]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:06.602]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:06.602]             base::sink(type = "output", split = FALSE)
[15:32:06.602]             base::close(...future.stdout)
[15:32:06.602]         }, add = TRUE)
[15:32:06.602]     }
[15:32:06.602]     ...future.frame <- base::sys.nframe()
[15:32:06.602]     ...future.conditions <- base::list()
[15:32:06.602]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:06.602]     if (FALSE) {
[15:32:06.602]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:06.602]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:06.602]     }
[15:32:06.602]     ...future.result <- base::tryCatch({
[15:32:06.602]         base::withCallingHandlers({
[15:32:06.602]             ...future.value <- base::withVisible(base::local({
[15:32:06.602]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.602]                 if (!identical(...future.globals.maxSize.org, 
[15:32:06.602]                   ...future.globals.maxSize)) {
[15:32:06.602]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.602]                   on.exit(options(oopts), add = TRUE)
[15:32:06.602]                 }
[15:32:06.602]                 {
[15:32:06.602]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.602]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:06.602]                     USE.NAMES = FALSE)
[15:32:06.602]                   do.call(mapply, args = args)
[15:32:06.602]                 }
[15:32:06.602]             }))
[15:32:06.602]             future::FutureResult(value = ...future.value$value, 
[15:32:06.602]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.602]                   ...future.rng), globalenv = if (FALSE) 
[15:32:06.602]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:06.602]                     ...future.globalenv.names))
[15:32:06.602]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:06.602]         }, condition = base::local({
[15:32:06.602]             c <- base::c
[15:32:06.602]             inherits <- base::inherits
[15:32:06.602]             invokeRestart <- base::invokeRestart
[15:32:06.602]             length <- base::length
[15:32:06.602]             list <- base::list
[15:32:06.602]             seq.int <- base::seq.int
[15:32:06.602]             signalCondition <- base::signalCondition
[15:32:06.602]             sys.calls <- base::sys.calls
[15:32:06.602]             `[[` <- base::`[[`
[15:32:06.602]             `+` <- base::`+`
[15:32:06.602]             `<<-` <- base::`<<-`
[15:32:06.602]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:06.602]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:06.602]                   3L)]
[15:32:06.602]             }
[15:32:06.602]             function(cond) {
[15:32:06.602]                 is_error <- inherits(cond, "error")
[15:32:06.602]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:06.602]                   NULL)
[15:32:06.602]                 if (is_error) {
[15:32:06.602]                   sessionInformation <- function() {
[15:32:06.602]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:06.602]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:06.602]                       search = base::search(), system = base::Sys.info())
[15:32:06.602]                   }
[15:32:06.602]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.602]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:06.602]                     cond$call), session = sessionInformation(), 
[15:32:06.602]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:06.602]                   signalCondition(cond)
[15:32:06.602]                 }
[15:32:06.602]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:06.602]                 "immediateCondition"))) {
[15:32:06.602]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:06.602]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.602]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:06.602]                   if (TRUE && !signal) {
[15:32:06.602]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.602]                     {
[15:32:06.602]                       inherits <- base::inherits
[15:32:06.602]                       invokeRestart <- base::invokeRestart
[15:32:06.602]                       is.null <- base::is.null
[15:32:06.602]                       muffled <- FALSE
[15:32:06.602]                       if (inherits(cond, "message")) {
[15:32:06.602]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.602]                         if (muffled) 
[15:32:06.602]                           invokeRestart("muffleMessage")
[15:32:06.602]                       }
[15:32:06.602]                       else if (inherits(cond, "warning")) {
[15:32:06.602]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.602]                         if (muffled) 
[15:32:06.602]                           invokeRestart("muffleWarning")
[15:32:06.602]                       }
[15:32:06.602]                       else if (inherits(cond, "condition")) {
[15:32:06.602]                         if (!is.null(pattern)) {
[15:32:06.602]                           computeRestarts <- base::computeRestarts
[15:32:06.602]                           grepl <- base::grepl
[15:32:06.602]                           restarts <- computeRestarts(cond)
[15:32:06.602]                           for (restart in restarts) {
[15:32:06.602]                             name <- restart$name
[15:32:06.602]                             if (is.null(name)) 
[15:32:06.602]                               next
[15:32:06.602]                             if (!grepl(pattern, name)) 
[15:32:06.602]                               next
[15:32:06.602]                             invokeRestart(restart)
[15:32:06.602]                             muffled <- TRUE
[15:32:06.602]                             break
[15:32:06.602]                           }
[15:32:06.602]                         }
[15:32:06.602]                       }
[15:32:06.602]                       invisible(muffled)
[15:32:06.602]                     }
[15:32:06.602]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.602]                   }
[15:32:06.602]                 }
[15:32:06.602]                 else {
[15:32:06.602]                   if (TRUE) {
[15:32:06.602]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.602]                     {
[15:32:06.602]                       inherits <- base::inherits
[15:32:06.602]                       invokeRestart <- base::invokeRestart
[15:32:06.602]                       is.null <- base::is.null
[15:32:06.602]                       muffled <- FALSE
[15:32:06.602]                       if (inherits(cond, "message")) {
[15:32:06.602]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.602]                         if (muffled) 
[15:32:06.602]                           invokeRestart("muffleMessage")
[15:32:06.602]                       }
[15:32:06.602]                       else if (inherits(cond, "warning")) {
[15:32:06.602]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.602]                         if (muffled) 
[15:32:06.602]                           invokeRestart("muffleWarning")
[15:32:06.602]                       }
[15:32:06.602]                       else if (inherits(cond, "condition")) {
[15:32:06.602]                         if (!is.null(pattern)) {
[15:32:06.602]                           computeRestarts <- base::computeRestarts
[15:32:06.602]                           grepl <- base::grepl
[15:32:06.602]                           restarts <- computeRestarts(cond)
[15:32:06.602]                           for (restart in restarts) {
[15:32:06.602]                             name <- restart$name
[15:32:06.602]                             if (is.null(name)) 
[15:32:06.602]                               next
[15:32:06.602]                             if (!grepl(pattern, name)) 
[15:32:06.602]                               next
[15:32:06.602]                             invokeRestart(restart)
[15:32:06.602]                             muffled <- TRUE
[15:32:06.602]                             break
[15:32:06.602]                           }
[15:32:06.602]                         }
[15:32:06.602]                       }
[15:32:06.602]                       invisible(muffled)
[15:32:06.602]                     }
[15:32:06.602]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.602]                   }
[15:32:06.602]                 }
[15:32:06.602]             }
[15:32:06.602]         }))
[15:32:06.602]     }, error = function(ex) {
[15:32:06.602]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:06.602]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.602]                 ...future.rng), started = ...future.startTime, 
[15:32:06.602]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:06.602]             version = "1.8"), class = "FutureResult")
[15:32:06.602]     }, finally = {
[15:32:06.602]         if (!identical(...future.workdir, getwd())) 
[15:32:06.602]             setwd(...future.workdir)
[15:32:06.602]         {
[15:32:06.602]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:06.602]                 ...future.oldOptions$nwarnings <- NULL
[15:32:06.602]             }
[15:32:06.602]             base::options(...future.oldOptions)
[15:32:06.602]             if (.Platform$OS.type == "windows") {
[15:32:06.602]                 old_names <- names(...future.oldEnvVars)
[15:32:06.602]                 envs <- base::Sys.getenv()
[15:32:06.602]                 names <- names(envs)
[15:32:06.602]                 common <- intersect(names, old_names)
[15:32:06.602]                 added <- setdiff(names, old_names)
[15:32:06.602]                 removed <- setdiff(old_names, names)
[15:32:06.602]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:06.602]                   envs[common]]
[15:32:06.602]                 NAMES <- toupper(changed)
[15:32:06.602]                 args <- list()
[15:32:06.602]                 for (kk in seq_along(NAMES)) {
[15:32:06.602]                   name <- changed[[kk]]
[15:32:06.602]                   NAME <- NAMES[[kk]]
[15:32:06.602]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.602]                     next
[15:32:06.602]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.602]                 }
[15:32:06.602]                 NAMES <- toupper(added)
[15:32:06.602]                 for (kk in seq_along(NAMES)) {
[15:32:06.602]                   name <- added[[kk]]
[15:32:06.602]                   NAME <- NAMES[[kk]]
[15:32:06.602]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.602]                     next
[15:32:06.602]                   args[[name]] <- ""
[15:32:06.602]                 }
[15:32:06.602]                 NAMES <- toupper(removed)
[15:32:06.602]                 for (kk in seq_along(NAMES)) {
[15:32:06.602]                   name <- removed[[kk]]
[15:32:06.602]                   NAME <- NAMES[[kk]]
[15:32:06.602]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.602]                     next
[15:32:06.602]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.602]                 }
[15:32:06.602]                 if (length(args) > 0) 
[15:32:06.602]                   base::do.call(base::Sys.setenv, args = args)
[15:32:06.602]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:06.602]             }
[15:32:06.602]             else {
[15:32:06.602]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:06.602]             }
[15:32:06.602]             {
[15:32:06.602]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:06.602]                   0L) {
[15:32:06.602]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:06.602]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:06.602]                   base::options(opts)
[15:32:06.602]                 }
[15:32:06.602]                 {
[15:32:06.602]                   {
[15:32:06.602]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:06.602]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:06.602]                     -253660479L), envir = base::globalenv(), 
[15:32:06.602]                       inherits = FALSE)
[15:32:06.602]                     NULL
[15:32:06.602]                   }
[15:32:06.602]                   options(future.plan = NULL)
[15:32:06.602]                   if (is.na(NA_character_)) 
[15:32:06.602]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.602]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:06.602]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:06.602]                     .init = FALSE)
[15:32:06.602]                 }
[15:32:06.602]             }
[15:32:06.602]         }
[15:32:06.602]     })
[15:32:06.602]     if (TRUE) {
[15:32:06.602]         base::sink(type = "output", split = FALSE)
[15:32:06.602]         if (TRUE) {
[15:32:06.602]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:06.602]         }
[15:32:06.602]         else {
[15:32:06.602]             ...future.result["stdout"] <- base::list(NULL)
[15:32:06.602]         }
[15:32:06.602]         base::close(...future.stdout)
[15:32:06.602]         ...future.stdout <- NULL
[15:32:06.602]     }
[15:32:06.602]     ...future.result$conditions <- ...future.conditions
[15:32:06.602]     ...future.result$finished <- base::Sys.time()
[15:32:06.602]     ...future.result
[15:32:06.602] }
[15:32:06.609] assign_globals() ...
[15:32:06.609] List of 5
[15:32:06.609]  $ ...future.FUN            :function (x, ...)  
[15:32:06.609]  $ MoreArgs                 : NULL
[15:32:06.609]  $ ...future.elements_ii    :List of 2
[15:32:06.609]   ..$ :List of 4
[15:32:06.609]   .. ..$ : int 1
[15:32:06.609]   .. ..$ : int 2
[15:32:06.609]   .. ..$ : int 3
[15:32:06.609]   .. ..$ : int 4
[15:32:06.609]   ..$ :List of 4
[15:32:06.609]   .. ..$ : int 4
[15:32:06.609]   .. ..$ : int 3
[15:32:06.609]   .. ..$ : int 2
[15:32:06.609]   .. ..$ : int 1
[15:32:06.609]  $ ...future.seeds_ii       : NULL
[15:32:06.609]  $ ...future.globals.maxSize: NULL
[15:32:06.609]  - attr(*, "where")=List of 5
[15:32:06.609]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:06.609]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:06.609]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:06.609]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:06.609]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:06.609]  - attr(*, "resolved")= logi FALSE
[15:32:06.609]  - attr(*, "total_size")= num 504
[15:32:06.609]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.609]  - attr(*, "already-done")= logi TRUE
[15:32:06.628] - copied '...future.FUN' to environment
[15:32:06.629] - copied 'MoreArgs' to environment
[15:32:06.629] - copied '...future.elements_ii' to environment
[15:32:06.629] - copied '...future.seeds_ii' to environment
[15:32:06.630] - copied '...future.globals.maxSize' to environment
[15:32:06.630] assign_globals() ... done
[15:32:06.631] plan(): Setting new future strategy stack:
[15:32:06.631] List of future strategies:
[15:32:06.631] 1. sequential:
[15:32:06.631]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.631]    - tweaked: FALSE
[15:32:06.631]    - call: NULL
[15:32:06.632] plan(): nbrOfWorkers() = 1
[15:32:06.635] plan(): Setting new future strategy stack:
[15:32:06.635] List of future strategies:
[15:32:06.635] 1. sequential:
[15:32:06.635]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.635]    - tweaked: FALSE
[15:32:06.635]    - call: plan(strategy)
[15:32:06.636] plan(): nbrOfWorkers() = 1
[15:32:06.637] SequentialFuture started (and completed)
[15:32:06.637] - Launch lazy future ... done
[15:32:06.637] run() for 'SequentialFuture' ... done
[15:32:06.638] Created future:
[15:32:06.638] SequentialFuture:
[15:32:06.638] Label: 'future_mapply-1'
[15:32:06.638] Expression:
[15:32:06.638] {
[15:32:06.638]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.638]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:06.638]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.638]         on.exit(options(oopts), add = TRUE)
[15:32:06.638]     }
[15:32:06.638]     {
[15:32:06.638]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.638]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:06.638]         do.call(mapply, args = args)
[15:32:06.638]     }
[15:32:06.638] }
[15:32:06.638] Lazy evaluation: FALSE
[15:32:06.638] Asynchronous evaluation: FALSE
[15:32:06.638] Local evaluation: TRUE
[15:32:06.638] Environment: R_GlobalEnv
[15:32:06.638] Capture standard output: TRUE
[15:32:06.638] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:06.638] Globals: 5 objects totaling 504 bytes (function '...future.FUN' of 56 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 448 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:06.638] Packages: <none>
[15:32:06.638] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:06.638] Resolved: TRUE
[15:32:06.638] Value: 240 bytes of class 'list'
[15:32:06.638] Early signaling: FALSE
[15:32:06.638] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:06.638] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.640] Chunk #1 of 1 ... DONE
[15:32:06.640] Launching 1 futures (chunks) ... DONE
[15:32:06.640] Resolving 1 futures (chunks) ...
[15:32:06.640] resolve() on list ...
[15:32:06.641]  recursive: 0
[15:32:06.641]  length: 1
[15:32:06.641] 
[15:32:06.641] resolved() for 'SequentialFuture' ...
[15:32:06.641] - state: 'finished'
[15:32:06.642] - run: TRUE
[15:32:06.642] - result: 'FutureResult'
[15:32:06.642] resolved() for 'SequentialFuture' ... done
[15:32:06.642] Future #1
[15:32:06.642] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:06.643] - nx: 1
[15:32:06.643] - relay: TRUE
[15:32:06.643] - stdout: TRUE
[15:32:06.643] - signal: TRUE
[15:32:06.643] - resignal: FALSE
[15:32:06.644] - force: TRUE
[15:32:06.644] - relayed: [n=1] FALSE
[15:32:06.644] - queued futures: [n=1] FALSE
[15:32:06.644]  - until=1
[15:32:06.644]  - relaying element #1
[15:32:06.645] - relayed: [n=1] TRUE
[15:32:06.645] - queued futures: [n=1] TRUE
[15:32:06.645] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:06.645]  length: 0 (resolved future 1)
[15:32:06.645] Relaying remaining futures
[15:32:06.646] signalConditionsASAP(NULL, pos=0) ...
[15:32:06.646] - nx: 1
[15:32:06.646] - relay: TRUE
[15:32:06.646] - stdout: TRUE
[15:32:06.646] - signal: TRUE
[15:32:06.647] - resignal: FALSE
[15:32:06.647] - force: TRUE
[15:32:06.647] - relayed: [n=1] TRUE
[15:32:06.647] - queued futures: [n=1] TRUE
 - flush all
[15:32:06.647] - relayed: [n=1] TRUE
[15:32:06.648] - queued futures: [n=1] TRUE
[15:32:06.648] signalConditionsASAP(NULL, pos=0) ... done
[15:32:06.648] resolve() on list ... DONE
[15:32:06.648]  - Number of value chunks collected: 1
[15:32:06.648] Resolving 1 futures (chunks) ... DONE
[15:32:06.649] Reducing values from 1 chunks ...
[15:32:06.649]  - Number of values collected after concatenation: 4
[15:32:06.649]  - Number of values expected: 4
[15:32:06.649] Reducing values from 1 chunks ... DONE
[15:32:06.649] future_mapply() ... DONE
[15:32:06.650] future_mapply() ...
[15:32:06.650] Number of chunks: 1
[15:32:06.650] getGlobalsAndPackagesXApply() ...
[15:32:06.650]  - future.globals: TRUE
[15:32:06.651] getGlobalsAndPackages() ...
[15:32:06.651] Searching for globals...
[15:32:06.652] - globals found: [1] 'FUN'
[15:32:06.652] Searching for globals ... DONE
[15:32:06.652] Resolving globals: FALSE
[15:32:06.653] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:06.653] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:06.653] - globals: [1] 'FUN'
[15:32:06.654] 
[15:32:06.654] getGlobalsAndPackages() ... DONE
[15:32:06.654]  - globals found/used: [n=1] 'FUN'
[15:32:06.654]  - needed namespaces: [n=0] 
[15:32:06.654] Finding globals ... DONE
[15:32:06.655] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.655] List of 2
[15:32:06.655]  $ ...future.FUN:function (x, ...)  
[15:32:06.655]  $ MoreArgs     : NULL
[15:32:06.655]  - attr(*, "where")=List of 2
[15:32:06.655]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.655]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.655]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.655]  - attr(*, "resolved")= logi FALSE
[15:32:06.655]  - attr(*, "total_size")= num NA
[15:32:06.660] Packages to be attached in all futures: [n=0] 
[15:32:06.660] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.661] Number of futures (= number of chunks): 1
[15:32:06.661] Launching 1 futures (chunks) ...
[15:32:06.662] Chunk #1 of 1 ...
[15:32:06.662]  - Finding globals in '...' for chunk #1 ...
[15:32:06.662] getGlobalsAndPackages() ...
[15:32:06.663] Searching for globals...
[15:32:06.664] 
[15:32:06.664] Searching for globals ... DONE
[15:32:06.664] - globals: [0] <none>
[15:32:06.667] getGlobalsAndPackages() ... DONE
[15:32:06.667]    + additional globals found: [n=0] 
[15:32:06.668]    + additional namespaces needed: [n=0] 
[15:32:06.668]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.668]  - seeds: <none>
[15:32:06.668]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.669] getGlobalsAndPackages() ...
[15:32:06.669] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.670] Resolving globals: FALSE
[15:32:06.671] The total size of the 5 globals is 504 bytes (504 bytes)
[15:32:06.672] 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 504 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (448 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:06.672] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.673] 
[15:32:06.673] getGlobalsAndPackages() ... DONE
[15:32:06.674] run() for 'Future' ...
[15:32:06.674] - state: 'created'
[15:32:06.674] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:06.675] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.676] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:06.676]   - Field: 'label'
[15:32:06.676]   - Field: 'local'
[15:32:06.677]   - Field: 'owner'
[15:32:06.677]   - Field: 'envir'
[15:32:06.677]   - Field: 'packages'
[15:32:06.678]   - Field: 'gc'
[15:32:06.678]   - Field: 'conditions'
[15:32:06.678]   - Field: 'expr'
[15:32:06.679]   - Field: 'uuid'
[15:32:06.679]   - Field: 'seed'
[15:32:06.679]   - Field: 'version'
[15:32:06.680]   - Field: 'result'
[15:32:06.680]   - Field: 'asynchronous'
[15:32:06.680]   - Field: 'calls'
[15:32:06.681]   - Field: 'globals'
[15:32:06.681]   - Field: 'stdout'
[15:32:06.682]   - Field: 'earlySignal'
[15:32:06.682]   - Field: 'lazy'
[15:32:06.682]   - Field: 'state'
[15:32:06.683] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:06.683] - Launch lazy future ...
[15:32:06.683] Packages needed by the future expression (n = 0): <none>
[15:32:06.684] Packages needed by future strategies (n = 0): <none>
[15:32:06.685] {
[15:32:06.685]     {
[15:32:06.685]         {
[15:32:06.685]             ...future.startTime <- base::Sys.time()
[15:32:06.685]             {
[15:32:06.685]                 {
[15:32:06.685]                   {
[15:32:06.685]                     base::local({
[15:32:06.685]                       has_future <- base::requireNamespace("future", 
[15:32:06.685]                         quietly = TRUE)
[15:32:06.685]                       if (has_future) {
[15:32:06.685]                         ns <- base::getNamespace("future")
[15:32:06.685]                         version <- ns[[".package"]][["version"]]
[15:32:06.685]                         if (is.null(version)) 
[15:32:06.685]                           version <- utils::packageVersion("future")
[15:32:06.685]                       }
[15:32:06.685]                       else {
[15:32:06.685]                         version <- NULL
[15:32:06.685]                       }
[15:32:06.685]                       if (!has_future || version < "1.8.0") {
[15:32:06.685]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:06.685]                           "", base::R.version$version.string), 
[15:32:06.685]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:06.685]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:06.685]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:06.685]                             "release", "version")], collapse = " "), 
[15:32:06.685]                           hostname = base::Sys.info()[["nodename"]])
[15:32:06.685]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:06.685]                           info)
[15:32:06.685]                         info <- base::paste(info, collapse = "; ")
[15:32:06.685]                         if (!has_future) {
[15:32:06.685]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:06.685]                             info)
[15:32:06.685]                         }
[15:32:06.685]                         else {
[15:32:06.685]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:06.685]                             info, version)
[15:32:06.685]                         }
[15:32:06.685]                         base::stop(msg)
[15:32:06.685]                       }
[15:32:06.685]                     })
[15:32:06.685]                   }
[15:32:06.685]                   ...future.strategy.old <- future::plan("list")
[15:32:06.685]                   options(future.plan = NULL)
[15:32:06.685]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.685]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:06.685]                 }
[15:32:06.685]                 ...future.workdir <- getwd()
[15:32:06.685]             }
[15:32:06.685]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:06.685]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:06.685]         }
[15:32:06.685]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:06.685]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:06.685]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:06.685]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:06.685]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:06.685]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:06.685]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:06.685]             base::names(...future.oldOptions))
[15:32:06.685]     }
[15:32:06.685]     if (FALSE) {
[15:32:06.685]     }
[15:32:06.685]     else {
[15:32:06.685]         if (TRUE) {
[15:32:06.685]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:06.685]                 open = "w")
[15:32:06.685]         }
[15:32:06.685]         else {
[15:32:06.685]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:06.685]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:06.685]         }
[15:32:06.685]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:06.685]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:06.685]             base::sink(type = "output", split = FALSE)
[15:32:06.685]             base::close(...future.stdout)
[15:32:06.685]         }, add = TRUE)
[15:32:06.685]     }
[15:32:06.685]     ...future.frame <- base::sys.nframe()
[15:32:06.685]     ...future.conditions <- base::list()
[15:32:06.685]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:06.685]     if (FALSE) {
[15:32:06.685]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:06.685]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:06.685]     }
[15:32:06.685]     ...future.result <- base::tryCatch({
[15:32:06.685]         base::withCallingHandlers({
[15:32:06.685]             ...future.value <- base::withVisible(base::local({
[15:32:06.685]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.685]                 if (!identical(...future.globals.maxSize.org, 
[15:32:06.685]                   ...future.globals.maxSize)) {
[15:32:06.685]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.685]                   on.exit(options(oopts), add = TRUE)
[15:32:06.685]                 }
[15:32:06.685]                 {
[15:32:06.685]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.685]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:06.685]                     USE.NAMES = FALSE)
[15:32:06.685]                   do.call(mapply, args = args)
[15:32:06.685]                 }
[15:32:06.685]             }))
[15:32:06.685]             future::FutureResult(value = ...future.value$value, 
[15:32:06.685]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.685]                   ...future.rng), globalenv = if (FALSE) 
[15:32:06.685]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:06.685]                     ...future.globalenv.names))
[15:32:06.685]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:06.685]         }, condition = base::local({
[15:32:06.685]             c <- base::c
[15:32:06.685]             inherits <- base::inherits
[15:32:06.685]             invokeRestart <- base::invokeRestart
[15:32:06.685]             length <- base::length
[15:32:06.685]             list <- base::list
[15:32:06.685]             seq.int <- base::seq.int
[15:32:06.685]             signalCondition <- base::signalCondition
[15:32:06.685]             sys.calls <- base::sys.calls
[15:32:06.685]             `[[` <- base::`[[`
[15:32:06.685]             `+` <- base::`+`
[15:32:06.685]             `<<-` <- base::`<<-`
[15:32:06.685]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:06.685]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:06.685]                   3L)]
[15:32:06.685]             }
[15:32:06.685]             function(cond) {
[15:32:06.685]                 is_error <- inherits(cond, "error")
[15:32:06.685]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:06.685]                   NULL)
[15:32:06.685]                 if (is_error) {
[15:32:06.685]                   sessionInformation <- function() {
[15:32:06.685]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:06.685]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:06.685]                       search = base::search(), system = base::Sys.info())
[15:32:06.685]                   }
[15:32:06.685]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.685]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:06.685]                     cond$call), session = sessionInformation(), 
[15:32:06.685]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:06.685]                   signalCondition(cond)
[15:32:06.685]                 }
[15:32:06.685]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:06.685]                 "immediateCondition"))) {
[15:32:06.685]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:06.685]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.685]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:06.685]                   if (TRUE && !signal) {
[15:32:06.685]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.685]                     {
[15:32:06.685]                       inherits <- base::inherits
[15:32:06.685]                       invokeRestart <- base::invokeRestart
[15:32:06.685]                       is.null <- base::is.null
[15:32:06.685]                       muffled <- FALSE
[15:32:06.685]                       if (inherits(cond, "message")) {
[15:32:06.685]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.685]                         if (muffled) 
[15:32:06.685]                           invokeRestart("muffleMessage")
[15:32:06.685]                       }
[15:32:06.685]                       else if (inherits(cond, "warning")) {
[15:32:06.685]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.685]                         if (muffled) 
[15:32:06.685]                           invokeRestart("muffleWarning")
[15:32:06.685]                       }
[15:32:06.685]                       else if (inherits(cond, "condition")) {
[15:32:06.685]                         if (!is.null(pattern)) {
[15:32:06.685]                           computeRestarts <- base::computeRestarts
[15:32:06.685]                           grepl <- base::grepl
[15:32:06.685]                           restarts <- computeRestarts(cond)
[15:32:06.685]                           for (restart in restarts) {
[15:32:06.685]                             name <- restart$name
[15:32:06.685]                             if (is.null(name)) 
[15:32:06.685]                               next
[15:32:06.685]                             if (!grepl(pattern, name)) 
[15:32:06.685]                               next
[15:32:06.685]                             invokeRestart(restart)
[15:32:06.685]                             muffled <- TRUE
[15:32:06.685]                             break
[15:32:06.685]                           }
[15:32:06.685]                         }
[15:32:06.685]                       }
[15:32:06.685]                       invisible(muffled)
[15:32:06.685]                     }
[15:32:06.685]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.685]                   }
[15:32:06.685]                 }
[15:32:06.685]                 else {
[15:32:06.685]                   if (TRUE) {
[15:32:06.685]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.685]                     {
[15:32:06.685]                       inherits <- base::inherits
[15:32:06.685]                       invokeRestart <- base::invokeRestart
[15:32:06.685]                       is.null <- base::is.null
[15:32:06.685]                       muffled <- FALSE
[15:32:06.685]                       if (inherits(cond, "message")) {
[15:32:06.685]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.685]                         if (muffled) 
[15:32:06.685]                           invokeRestart("muffleMessage")
[15:32:06.685]                       }
[15:32:06.685]                       else if (inherits(cond, "warning")) {
[15:32:06.685]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.685]                         if (muffled) 
[15:32:06.685]                           invokeRestart("muffleWarning")
[15:32:06.685]                       }
[15:32:06.685]                       else if (inherits(cond, "condition")) {
[15:32:06.685]                         if (!is.null(pattern)) {
[15:32:06.685]                           computeRestarts <- base::computeRestarts
[15:32:06.685]                           grepl <- base::grepl
[15:32:06.685]                           restarts <- computeRestarts(cond)
[15:32:06.685]                           for (restart in restarts) {
[15:32:06.685]                             name <- restart$name
[15:32:06.685]                             if (is.null(name)) 
[15:32:06.685]                               next
[15:32:06.685]                             if (!grepl(pattern, name)) 
[15:32:06.685]                               next
[15:32:06.685]                             invokeRestart(restart)
[15:32:06.685]                             muffled <- TRUE
[15:32:06.685]                             break
[15:32:06.685]                           }
[15:32:06.685]                         }
[15:32:06.685]                       }
[15:32:06.685]                       invisible(muffled)
[15:32:06.685]                     }
[15:32:06.685]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.685]                   }
[15:32:06.685]                 }
[15:32:06.685]             }
[15:32:06.685]         }))
[15:32:06.685]     }, error = function(ex) {
[15:32:06.685]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:06.685]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.685]                 ...future.rng), started = ...future.startTime, 
[15:32:06.685]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:06.685]             version = "1.8"), class = "FutureResult")
[15:32:06.685]     }, finally = {
[15:32:06.685]         if (!identical(...future.workdir, getwd())) 
[15:32:06.685]             setwd(...future.workdir)
[15:32:06.685]         {
[15:32:06.685]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:06.685]                 ...future.oldOptions$nwarnings <- NULL
[15:32:06.685]             }
[15:32:06.685]             base::options(...future.oldOptions)
[15:32:06.685]             if (.Platform$OS.type == "windows") {
[15:32:06.685]                 old_names <- names(...future.oldEnvVars)
[15:32:06.685]                 envs <- base::Sys.getenv()
[15:32:06.685]                 names <- names(envs)
[15:32:06.685]                 common <- intersect(names, old_names)
[15:32:06.685]                 added <- setdiff(names, old_names)
[15:32:06.685]                 removed <- setdiff(old_names, names)
[15:32:06.685]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:06.685]                   envs[common]]
[15:32:06.685]                 NAMES <- toupper(changed)
[15:32:06.685]                 args <- list()
[15:32:06.685]                 for (kk in seq_along(NAMES)) {
[15:32:06.685]                   name <- changed[[kk]]
[15:32:06.685]                   NAME <- NAMES[[kk]]
[15:32:06.685]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.685]                     next
[15:32:06.685]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.685]                 }
[15:32:06.685]                 NAMES <- toupper(added)
[15:32:06.685]                 for (kk in seq_along(NAMES)) {
[15:32:06.685]                   name <- added[[kk]]
[15:32:06.685]                   NAME <- NAMES[[kk]]
[15:32:06.685]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.685]                     next
[15:32:06.685]                   args[[name]] <- ""
[15:32:06.685]                 }
[15:32:06.685]                 NAMES <- toupper(removed)
[15:32:06.685]                 for (kk in seq_along(NAMES)) {
[15:32:06.685]                   name <- removed[[kk]]
[15:32:06.685]                   NAME <- NAMES[[kk]]
[15:32:06.685]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.685]                     next
[15:32:06.685]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.685]                 }
[15:32:06.685]                 if (length(args) > 0) 
[15:32:06.685]                   base::do.call(base::Sys.setenv, args = args)
[15:32:06.685]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:06.685]             }
[15:32:06.685]             else {
[15:32:06.685]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:06.685]             }
[15:32:06.685]             {
[15:32:06.685]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:06.685]                   0L) {
[15:32:06.685]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:06.685]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:06.685]                   base::options(opts)
[15:32:06.685]                 }
[15:32:06.685]                 {
[15:32:06.685]                   {
[15:32:06.685]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:06.685]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:06.685]                     -253660479L), envir = base::globalenv(), 
[15:32:06.685]                       inherits = FALSE)
[15:32:06.685]                     NULL
[15:32:06.685]                   }
[15:32:06.685]                   options(future.plan = NULL)
[15:32:06.685]                   if (is.na(NA_character_)) 
[15:32:06.685]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.685]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:06.685]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:06.685]                     .init = FALSE)
[15:32:06.685]                 }
[15:32:06.685]             }
[15:32:06.685]         }
[15:32:06.685]     })
[15:32:06.685]     if (TRUE) {
[15:32:06.685]         base::sink(type = "output", split = FALSE)
[15:32:06.685]         if (TRUE) {
[15:32:06.685]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:06.685]         }
[15:32:06.685]         else {
[15:32:06.685]             ...future.result["stdout"] <- base::list(NULL)
[15:32:06.685]         }
[15:32:06.685]         base::close(...future.stdout)
[15:32:06.685]         ...future.stdout <- NULL
[15:32:06.685]     }
[15:32:06.685]     ...future.result$conditions <- ...future.conditions
[15:32:06.685]     ...future.result$finished <- base::Sys.time()
[15:32:06.685]     ...future.result
[15:32:06.685] }
[15:32:06.692] assign_globals() ...
[15:32:06.693] List of 5
[15:32:06.693]  $ ...future.FUN            :function (x, ...)  
[15:32:06.693]  $ MoreArgs                 : NULL
[15:32:06.693]  $ ...future.elements_ii    :List of 2
[15:32:06.693]   ..$ :List of 4
[15:32:06.693]   .. ..$ : int 1
[15:32:06.693]   .. ..$ : int 2
[15:32:06.693]   .. ..$ : int 3
[15:32:06.693]   .. ..$ : int 4
[15:32:06.693]   ..$ :List of 4
[15:32:06.693]   .. ..$ : int 4
[15:32:06.693]   .. ..$ : int 3
[15:32:06.693]   .. ..$ : int 2
[15:32:06.693]   .. ..$ : int 1
[15:32:06.693]  $ ...future.seeds_ii       : NULL
[15:32:06.693]  $ ...future.globals.maxSize: NULL
[15:32:06.693]  - attr(*, "where")=List of 5
[15:32:06.693]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:06.693]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:06.693]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:06.693]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:06.693]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:06.693]  - attr(*, "resolved")= logi FALSE
[15:32:06.693]  - attr(*, "total_size")= num 504
[15:32:06.693]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.693]  - attr(*, "already-done")= logi TRUE
[15:32:06.709] - copied '...future.FUN' to environment
[15:32:06.709] - copied 'MoreArgs' to environment
[15:32:06.709] - copied '...future.elements_ii' to environment
[15:32:06.710] - copied '...future.seeds_ii' to environment
[15:32:06.710] - copied '...future.globals.maxSize' to environment
[15:32:06.710] assign_globals() ... done
[15:32:06.711] plan(): Setting new future strategy stack:
[15:32:06.711] List of future strategies:
[15:32:06.711] 1. sequential:
[15:32:06.711]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.711]    - tweaked: FALSE
[15:32:06.711]    - call: NULL
[15:32:06.713] plan(): nbrOfWorkers() = 1
[15:32:06.715] plan(): Setting new future strategy stack:
[15:32:06.715] List of future strategies:
[15:32:06.715] 1. sequential:
[15:32:06.715]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.715]    - tweaked: FALSE
[15:32:06.715]    - call: plan(strategy)
[15:32:06.716] plan(): nbrOfWorkers() = 1
[15:32:06.717] SequentialFuture started (and completed)
[15:32:06.717] - Launch lazy future ... done
[15:32:06.718] run() for 'SequentialFuture' ... done
[15:32:06.718] Created future:
[15:32:06.718] SequentialFuture:
[15:32:06.718] Label: 'future_mapply-1'
[15:32:06.718] Expression:
[15:32:06.718] {
[15:32:06.718]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.718]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:06.718]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.718]         on.exit(options(oopts), add = TRUE)
[15:32:06.718]     }
[15:32:06.718]     {
[15:32:06.718]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.718]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:06.718]         do.call(mapply, args = args)
[15:32:06.718]     }
[15:32:06.718] }
[15:32:06.718] Lazy evaluation: FALSE
[15:32:06.718] Asynchronous evaluation: FALSE
[15:32:06.718] Local evaluation: TRUE
[15:32:06.718] Environment: R_GlobalEnv
[15:32:06.718] Capture standard output: TRUE
[15:32:06.718] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:06.718] Globals: 5 objects totaling 504 bytes (function '...future.FUN' of 56 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 448 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:06.718] Packages: <none>
[15:32:06.718] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:06.718] Resolved: TRUE
[15:32:06.718] Value: 240 bytes of class 'list'
[15:32:06.718] Early signaling: FALSE
[15:32:06.718] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:06.718] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.721] Chunk #1 of 1 ... DONE
[15:32:06.721] Launching 1 futures (chunks) ... DONE
[15:32:06.722] Resolving 1 futures (chunks) ...
[15:32:06.725] resolve() on list ...
[15:32:06.725]  recursive: 0
[15:32:06.725]  length: 1
[15:32:06.726] 
[15:32:06.726] resolved() for 'SequentialFuture' ...
[15:32:06.726] - state: 'finished'
[15:32:06.727] - run: TRUE
[15:32:06.727] - result: 'FutureResult'
[15:32:06.727] resolved() for 'SequentialFuture' ... done
[15:32:06.728] Future #1
[15:32:06.728] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:06.729] - nx: 1
[15:32:06.729] - relay: TRUE
[15:32:06.729] - stdout: TRUE
[15:32:06.730] - signal: TRUE
[15:32:06.730] - resignal: FALSE
[15:32:06.730] - force: TRUE
[15:32:06.730] - relayed: [n=1] FALSE
[15:32:06.731] - queued futures: [n=1] FALSE
[15:32:06.731]  - until=1
[15:32:06.731]  - relaying element #1
[15:32:06.732] - relayed: [n=1] TRUE
[15:32:06.732] - queued futures: [n=1] TRUE
[15:32:06.733] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:06.733]  length: 0 (resolved future 1)
[15:32:06.733] Relaying remaining futures
[15:32:06.734] signalConditionsASAP(NULL, pos=0) ...
[15:32:06.734] - nx: 1
[15:32:06.734] - relay: TRUE
[15:32:06.735] - stdout: TRUE
[15:32:06.735] - signal: TRUE
[15:32:06.735] - resignal: FALSE
[15:32:06.736] - force: TRUE
[15:32:06.736] - relayed: [n=1] TRUE
[15:32:06.736] - queued futures: [n=1] TRUE
 - flush all
[15:32:06.737] - relayed: [n=1] TRUE
[15:32:06.737] - queued futures: [n=1] TRUE
[15:32:06.737] signalConditionsASAP(NULL, pos=0) ... done
[15:32:06.738] resolve() on list ... DONE
[15:32:06.738]  - Number of value chunks collected: 1
[15:32:06.739] Resolving 1 futures (chunks) ... DONE
[15:32:06.739] Reducing values from 1 chunks ...
[15:32:06.739]  - Number of values collected after concatenation: 4
[15:32:06.740]  - Number of values expected: 4
[15:32:06.740] Reducing values from 1 chunks ... DONE
[15:32:06.740] future_mapply() ... DONE
[15:32:06.741] future_mapply() ...
[15:32:06.741] Number of chunks: 1
[15:32:06.741] getGlobalsAndPackagesXApply() ...
[15:32:06.742]  - future.globals: TRUE
[15:32:06.742] getGlobalsAndPackages() ...
[15:32:06.742] Searching for globals...
[15:32:06.744] - globals found: [1] 'FUN'
[15:32:06.744] Searching for globals ... DONE
[15:32:06.745] Resolving globals: FALSE
[15:32:06.745] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:06.746] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:06.747] - globals: [1] 'FUN'
[15:32:06.747] 
[15:32:06.747] getGlobalsAndPackages() ... DONE
[15:32:06.748]  - globals found/used: [n=1] 'FUN'
[15:32:06.748]  - needed namespaces: [n=0] 
[15:32:06.748] Finding globals ... DONE
[15:32:06.749] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.749] List of 2
[15:32:06.749]  $ ...future.FUN:function (x, ...)  
[15:32:06.749]  $ MoreArgs     : NULL
[15:32:06.749]  - attr(*, "where")=List of 2
[15:32:06.749]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.749]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.749]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.749]  - attr(*, "resolved")= logi FALSE
[15:32:06.749]  - attr(*, "total_size")= num NA
[15:32:06.754] Packages to be attached in all futures: [n=0] 
[15:32:06.755] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.755] Number of futures (= number of chunks): 1
[15:32:06.756] Launching 1 futures (chunks) ...
[15:32:06.756] Chunk #1 of 1 ...
[15:32:06.756]  - Finding globals in '...' for chunk #1 ...
[15:32:06.756] getGlobalsAndPackages() ...
[15:32:06.757] Searching for globals...
[15:32:06.757] 
[15:32:06.758] Searching for globals ... DONE
[15:32:06.758] - globals: [0] <none>
[15:32:06.758] getGlobalsAndPackages() ... DONE
[15:32:06.759]    + additional globals found: [n=0] 
[15:32:06.759]    + additional namespaces needed: [n=0] 
[15:32:06.759]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.759]  - seeds: <none>
[15:32:06.760]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.760] getGlobalsAndPackages() ...
[15:32:06.760] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.761] Resolving globals: FALSE
[15:32:06.762] The total size of the 5 globals is 504 bytes (504 bytes)
[15:32:06.763] 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 504 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (448 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:06.763] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.763] 
[15:32:06.764] getGlobalsAndPackages() ... DONE
[15:32:06.764] run() for 'Future' ...
[15:32:06.765] - state: 'created'
[15:32:06.765] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:06.766] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.766] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:06.766]   - Field: 'label'
[15:32:06.767]   - Field: 'local'
[15:32:06.767]   - Field: 'owner'
[15:32:06.767]   - Field: 'envir'
[15:32:06.768]   - Field: 'packages'
[15:32:06.768]   - Field: 'gc'
[15:32:06.768]   - Field: 'conditions'
[15:32:06.769]   - Field: 'expr'
[15:32:06.769]   - Field: 'uuid'
[15:32:06.769]   - Field: 'seed'
[15:32:06.769]   - Field: 'version'
[15:32:06.770]   - Field: 'result'
[15:32:06.770]   - Field: 'asynchronous'
[15:32:06.770]   - Field: 'calls'
[15:32:06.770]   - Field: 'globals'
[15:32:06.771]   - Field: 'stdout'
[15:32:06.771]   - Field: 'earlySignal'
[15:32:06.771]   - Field: 'lazy'
[15:32:06.771]   - Field: 'state'
[15:32:06.771] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:06.772] - Launch lazy future ...
[15:32:06.772] Packages needed by the future expression (n = 0): <none>
[15:32:06.772] Packages needed by future strategies (n = 0): <none>
[15:32:06.773] {
[15:32:06.773]     {
[15:32:06.773]         {
[15:32:06.773]             ...future.startTime <- base::Sys.time()
[15:32:06.773]             {
[15:32:06.773]                 {
[15:32:06.773]                   {
[15:32:06.773]                     base::local({
[15:32:06.773]                       has_future <- base::requireNamespace("future", 
[15:32:06.773]                         quietly = TRUE)
[15:32:06.773]                       if (has_future) {
[15:32:06.773]                         ns <- base::getNamespace("future")
[15:32:06.773]                         version <- ns[[".package"]][["version"]]
[15:32:06.773]                         if (is.null(version)) 
[15:32:06.773]                           version <- utils::packageVersion("future")
[15:32:06.773]                       }
[15:32:06.773]                       else {
[15:32:06.773]                         version <- NULL
[15:32:06.773]                       }
[15:32:06.773]                       if (!has_future || version < "1.8.0") {
[15:32:06.773]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:06.773]                           "", base::R.version$version.string), 
[15:32:06.773]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:06.773]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:06.773]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:06.773]                             "release", "version")], collapse = " "), 
[15:32:06.773]                           hostname = base::Sys.info()[["nodename"]])
[15:32:06.773]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:06.773]                           info)
[15:32:06.773]                         info <- base::paste(info, collapse = "; ")
[15:32:06.773]                         if (!has_future) {
[15:32:06.773]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:06.773]                             info)
[15:32:06.773]                         }
[15:32:06.773]                         else {
[15:32:06.773]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:06.773]                             info, version)
[15:32:06.773]                         }
[15:32:06.773]                         base::stop(msg)
[15:32:06.773]                       }
[15:32:06.773]                     })
[15:32:06.773]                   }
[15:32:06.773]                   ...future.strategy.old <- future::plan("list")
[15:32:06.773]                   options(future.plan = NULL)
[15:32:06.773]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.773]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:06.773]                 }
[15:32:06.773]                 ...future.workdir <- getwd()
[15:32:06.773]             }
[15:32:06.773]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:06.773]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:06.773]         }
[15:32:06.773]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:06.773]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:06.773]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:06.773]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:06.773]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:06.773]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:06.773]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:06.773]             base::names(...future.oldOptions))
[15:32:06.773]     }
[15:32:06.773]     if (FALSE) {
[15:32:06.773]     }
[15:32:06.773]     else {
[15:32:06.773]         if (TRUE) {
[15:32:06.773]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:06.773]                 open = "w")
[15:32:06.773]         }
[15:32:06.773]         else {
[15:32:06.773]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:06.773]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:06.773]         }
[15:32:06.773]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:06.773]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:06.773]             base::sink(type = "output", split = FALSE)
[15:32:06.773]             base::close(...future.stdout)
[15:32:06.773]         }, add = TRUE)
[15:32:06.773]     }
[15:32:06.773]     ...future.frame <- base::sys.nframe()
[15:32:06.773]     ...future.conditions <- base::list()
[15:32:06.773]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:06.773]     if (FALSE) {
[15:32:06.773]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:06.773]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:06.773]     }
[15:32:06.773]     ...future.result <- base::tryCatch({
[15:32:06.773]         base::withCallingHandlers({
[15:32:06.773]             ...future.value <- base::withVisible(base::local({
[15:32:06.773]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.773]                 if (!identical(...future.globals.maxSize.org, 
[15:32:06.773]                   ...future.globals.maxSize)) {
[15:32:06.773]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.773]                   on.exit(options(oopts), add = TRUE)
[15:32:06.773]                 }
[15:32:06.773]                 {
[15:32:06.773]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.773]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:06.773]                     USE.NAMES = FALSE)
[15:32:06.773]                   do.call(mapply, args = args)
[15:32:06.773]                 }
[15:32:06.773]             }))
[15:32:06.773]             future::FutureResult(value = ...future.value$value, 
[15:32:06.773]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.773]                   ...future.rng), globalenv = if (FALSE) 
[15:32:06.773]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:06.773]                     ...future.globalenv.names))
[15:32:06.773]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:06.773]         }, condition = base::local({
[15:32:06.773]             c <- base::c
[15:32:06.773]             inherits <- base::inherits
[15:32:06.773]             invokeRestart <- base::invokeRestart
[15:32:06.773]             length <- base::length
[15:32:06.773]             list <- base::list
[15:32:06.773]             seq.int <- base::seq.int
[15:32:06.773]             signalCondition <- base::signalCondition
[15:32:06.773]             sys.calls <- base::sys.calls
[15:32:06.773]             `[[` <- base::`[[`
[15:32:06.773]             `+` <- base::`+`
[15:32:06.773]             `<<-` <- base::`<<-`
[15:32:06.773]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:06.773]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:06.773]                   3L)]
[15:32:06.773]             }
[15:32:06.773]             function(cond) {
[15:32:06.773]                 is_error <- inherits(cond, "error")
[15:32:06.773]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:06.773]                   NULL)
[15:32:06.773]                 if (is_error) {
[15:32:06.773]                   sessionInformation <- function() {
[15:32:06.773]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:06.773]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:06.773]                       search = base::search(), system = base::Sys.info())
[15:32:06.773]                   }
[15:32:06.773]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.773]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:06.773]                     cond$call), session = sessionInformation(), 
[15:32:06.773]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:06.773]                   signalCondition(cond)
[15:32:06.773]                 }
[15:32:06.773]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:06.773]                 "immediateCondition"))) {
[15:32:06.773]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:06.773]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.773]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:06.773]                   if (TRUE && !signal) {
[15:32:06.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.773]                     {
[15:32:06.773]                       inherits <- base::inherits
[15:32:06.773]                       invokeRestart <- base::invokeRestart
[15:32:06.773]                       is.null <- base::is.null
[15:32:06.773]                       muffled <- FALSE
[15:32:06.773]                       if (inherits(cond, "message")) {
[15:32:06.773]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.773]                         if (muffled) 
[15:32:06.773]                           invokeRestart("muffleMessage")
[15:32:06.773]                       }
[15:32:06.773]                       else if (inherits(cond, "warning")) {
[15:32:06.773]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.773]                         if (muffled) 
[15:32:06.773]                           invokeRestart("muffleWarning")
[15:32:06.773]                       }
[15:32:06.773]                       else if (inherits(cond, "condition")) {
[15:32:06.773]                         if (!is.null(pattern)) {
[15:32:06.773]                           computeRestarts <- base::computeRestarts
[15:32:06.773]                           grepl <- base::grepl
[15:32:06.773]                           restarts <- computeRestarts(cond)
[15:32:06.773]                           for (restart in restarts) {
[15:32:06.773]                             name <- restart$name
[15:32:06.773]                             if (is.null(name)) 
[15:32:06.773]                               next
[15:32:06.773]                             if (!grepl(pattern, name)) 
[15:32:06.773]                               next
[15:32:06.773]                             invokeRestart(restart)
[15:32:06.773]                             muffled <- TRUE
[15:32:06.773]                             break
[15:32:06.773]                           }
[15:32:06.773]                         }
[15:32:06.773]                       }
[15:32:06.773]                       invisible(muffled)
[15:32:06.773]                     }
[15:32:06.773]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.773]                   }
[15:32:06.773]                 }
[15:32:06.773]                 else {
[15:32:06.773]                   if (TRUE) {
[15:32:06.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.773]                     {
[15:32:06.773]                       inherits <- base::inherits
[15:32:06.773]                       invokeRestart <- base::invokeRestart
[15:32:06.773]                       is.null <- base::is.null
[15:32:06.773]                       muffled <- FALSE
[15:32:06.773]                       if (inherits(cond, "message")) {
[15:32:06.773]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.773]                         if (muffled) 
[15:32:06.773]                           invokeRestart("muffleMessage")
[15:32:06.773]                       }
[15:32:06.773]                       else if (inherits(cond, "warning")) {
[15:32:06.773]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.773]                         if (muffled) 
[15:32:06.773]                           invokeRestart("muffleWarning")
[15:32:06.773]                       }
[15:32:06.773]                       else if (inherits(cond, "condition")) {
[15:32:06.773]                         if (!is.null(pattern)) {
[15:32:06.773]                           computeRestarts <- base::computeRestarts
[15:32:06.773]                           grepl <- base::grepl
[15:32:06.773]                           restarts <- computeRestarts(cond)
[15:32:06.773]                           for (restart in restarts) {
[15:32:06.773]                             name <- restart$name
[15:32:06.773]                             if (is.null(name)) 
[15:32:06.773]                               next
[15:32:06.773]                             if (!grepl(pattern, name)) 
[15:32:06.773]                               next
[15:32:06.773]                             invokeRestart(restart)
[15:32:06.773]                             muffled <- TRUE
[15:32:06.773]                             break
[15:32:06.773]                           }
[15:32:06.773]                         }
[15:32:06.773]                       }
[15:32:06.773]                       invisible(muffled)
[15:32:06.773]                     }
[15:32:06.773]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.773]                   }
[15:32:06.773]                 }
[15:32:06.773]             }
[15:32:06.773]         }))
[15:32:06.773]     }, error = function(ex) {
[15:32:06.773]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:06.773]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.773]                 ...future.rng), started = ...future.startTime, 
[15:32:06.773]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:06.773]             version = "1.8"), class = "FutureResult")
[15:32:06.773]     }, finally = {
[15:32:06.773]         if (!identical(...future.workdir, getwd())) 
[15:32:06.773]             setwd(...future.workdir)
[15:32:06.773]         {
[15:32:06.773]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:06.773]                 ...future.oldOptions$nwarnings <- NULL
[15:32:06.773]             }
[15:32:06.773]             base::options(...future.oldOptions)
[15:32:06.773]             if (.Platform$OS.type == "windows") {
[15:32:06.773]                 old_names <- names(...future.oldEnvVars)
[15:32:06.773]                 envs <- base::Sys.getenv()
[15:32:06.773]                 names <- names(envs)
[15:32:06.773]                 common <- intersect(names, old_names)
[15:32:06.773]                 added <- setdiff(names, old_names)
[15:32:06.773]                 removed <- setdiff(old_names, names)
[15:32:06.773]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:06.773]                   envs[common]]
[15:32:06.773]                 NAMES <- toupper(changed)
[15:32:06.773]                 args <- list()
[15:32:06.773]                 for (kk in seq_along(NAMES)) {
[15:32:06.773]                   name <- changed[[kk]]
[15:32:06.773]                   NAME <- NAMES[[kk]]
[15:32:06.773]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.773]                     next
[15:32:06.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.773]                 }
[15:32:06.773]                 NAMES <- toupper(added)
[15:32:06.773]                 for (kk in seq_along(NAMES)) {
[15:32:06.773]                   name <- added[[kk]]
[15:32:06.773]                   NAME <- NAMES[[kk]]
[15:32:06.773]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.773]                     next
[15:32:06.773]                   args[[name]] <- ""
[15:32:06.773]                 }
[15:32:06.773]                 NAMES <- toupper(removed)
[15:32:06.773]                 for (kk in seq_along(NAMES)) {
[15:32:06.773]                   name <- removed[[kk]]
[15:32:06.773]                   NAME <- NAMES[[kk]]
[15:32:06.773]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.773]                     next
[15:32:06.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.773]                 }
[15:32:06.773]                 if (length(args) > 0) 
[15:32:06.773]                   base::do.call(base::Sys.setenv, args = args)
[15:32:06.773]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:06.773]             }
[15:32:06.773]             else {
[15:32:06.773]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:06.773]             }
[15:32:06.773]             {
[15:32:06.773]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:06.773]                   0L) {
[15:32:06.773]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:06.773]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:06.773]                   base::options(opts)
[15:32:06.773]                 }
[15:32:06.773]                 {
[15:32:06.773]                   {
[15:32:06.773]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:06.773]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:06.773]                     -253660479L), envir = base::globalenv(), 
[15:32:06.773]                       inherits = FALSE)
[15:32:06.773]                     NULL
[15:32:06.773]                   }
[15:32:06.773]                   options(future.plan = NULL)
[15:32:06.773]                   if (is.na(NA_character_)) 
[15:32:06.773]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.773]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:06.773]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:06.773]                     .init = FALSE)
[15:32:06.773]                 }
[15:32:06.773]             }
[15:32:06.773]         }
[15:32:06.773]     })
[15:32:06.773]     if (TRUE) {
[15:32:06.773]         base::sink(type = "output", split = FALSE)
[15:32:06.773]         if (TRUE) {
[15:32:06.773]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:06.773]         }
[15:32:06.773]         else {
[15:32:06.773]             ...future.result["stdout"] <- base::list(NULL)
[15:32:06.773]         }
[15:32:06.773]         base::close(...future.stdout)
[15:32:06.773]         ...future.stdout <- NULL
[15:32:06.773]     }
[15:32:06.773]     ...future.result$conditions <- ...future.conditions
[15:32:06.773]     ...future.result$finished <- base::Sys.time()
[15:32:06.773]     ...future.result
[15:32:06.773] }
[15:32:06.779] assign_globals() ...
[15:32:06.780] List of 5
[15:32:06.780]  $ ...future.FUN            :function (x, ...)  
[15:32:06.780]  $ MoreArgs                 : NULL
[15:32:06.780]  $ ...future.elements_ii    :List of 2
[15:32:06.780]   ..$ times:List of 4
[15:32:06.780]   .. ..$ : int 1
[15:32:06.780]   .. ..$ : int 2
[15:32:06.780]   .. ..$ : int 3
[15:32:06.780]   .. ..$ : int 4
[15:32:06.780]   ..$ x    :List of 4
[15:32:06.780]   .. ..$ : int 4
[15:32:06.780]   .. ..$ : int 3
[15:32:06.780]   .. ..$ : int 2
[15:32:06.780]   .. ..$ : int 1
[15:32:06.780]  $ ...future.seeds_ii       : NULL
[15:32:06.780]  $ ...future.globals.maxSize: NULL
[15:32:06.780]  - attr(*, "where")=List of 5
[15:32:06.780]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:06.780]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:06.780]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:06.780]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:06.780]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:06.780]  - attr(*, "resolved")= logi FALSE
[15:32:06.780]  - attr(*, "total_size")= num 504
[15:32:06.780]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.780]  - attr(*, "already-done")= logi TRUE
[15:32:06.792] - copied '...future.FUN' to environment
[15:32:06.792] - copied 'MoreArgs' to environment
[15:32:06.792] - copied '...future.elements_ii' to environment
[15:32:06.792] - copied '...future.seeds_ii' to environment
[15:32:06.792] - copied '...future.globals.maxSize' to environment
[15:32:06.793] assign_globals() ... done
[15:32:06.793] plan(): Setting new future strategy stack:
[15:32:06.793] List of future strategies:
[15:32:06.793] 1. sequential:
[15:32:06.793]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.793]    - tweaked: FALSE
[15:32:06.793]    - call: NULL
[15:32:06.794] plan(): nbrOfWorkers() = 1
[15:32:06.795] plan(): Setting new future strategy stack:
[15:32:06.796] List of future strategies:
[15:32:06.796] 1. sequential:
[15:32:06.796]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.796]    - tweaked: FALSE
[15:32:06.796]    - call: plan(strategy)
[15:32:06.796] plan(): nbrOfWorkers() = 1
[15:32:06.797] SequentialFuture started (and completed)
[15:32:06.797] - Launch lazy future ... done
[15:32:06.797] run() for 'SequentialFuture' ... done
[15:32:06.797] Created future:
[15:32:06.797] SequentialFuture:
[15:32:06.797] Label: 'future_mapply-1'
[15:32:06.797] Expression:
[15:32:06.797] {
[15:32:06.797]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.797]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:06.797]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.797]         on.exit(options(oopts), add = TRUE)
[15:32:06.797]     }
[15:32:06.797]     {
[15:32:06.797]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.797]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:06.797]         do.call(mapply, args = args)
[15:32:06.797]     }
[15:32:06.797] }
[15:32:06.797] Lazy evaluation: FALSE
[15:32:06.797] Asynchronous evaluation: FALSE
[15:32:06.797] Local evaluation: TRUE
[15:32:06.797] Environment: R_GlobalEnv
[15:32:06.797] Capture standard output: TRUE
[15:32:06.797] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:06.797] Globals: 5 objects totaling 504 bytes (function '...future.FUN' of 56 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 448 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:06.797] Packages: <none>
[15:32:06.797] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:06.797] Resolved: TRUE
[15:32:06.797] Value: 240 bytes of class 'list'
[15:32:06.797] Early signaling: FALSE
[15:32:06.797] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:06.797] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.799] Chunk #1 of 1 ... DONE
[15:32:06.799] Launching 1 futures (chunks) ... DONE
[15:32:06.799] Resolving 1 futures (chunks) ...
[15:32:06.799] resolve() on list ...
[15:32:06.799]  recursive: 0
[15:32:06.800]  length: 1
[15:32:06.800] 
[15:32:06.800] resolved() for 'SequentialFuture' ...
[15:32:06.800] - state: 'finished'
[15:32:06.800] - run: TRUE
[15:32:06.801] - result: 'FutureResult'
[15:32:06.801] resolved() for 'SequentialFuture' ... done
[15:32:06.801] Future #1
[15:32:06.801] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:06.801] - nx: 1
[15:32:06.802] - relay: TRUE
[15:32:06.802] - stdout: TRUE
[15:32:06.802] - signal: TRUE
[15:32:06.802] - resignal: FALSE
[15:32:06.802] - force: TRUE
[15:32:06.802] - relayed: [n=1] FALSE
[15:32:06.803] - queued futures: [n=1] FALSE
[15:32:06.803]  - until=1
[15:32:06.803]  - relaying element #1
[15:32:06.803] - relayed: [n=1] TRUE
[15:32:06.803] - queued futures: [n=1] TRUE
[15:32:06.804] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:06.804]  length: 0 (resolved future 1)
[15:32:06.804] Relaying remaining futures
[15:32:06.804] signalConditionsASAP(NULL, pos=0) ...
[15:32:06.804] - nx: 1
[15:32:06.804] - relay: TRUE
[15:32:06.805] - stdout: TRUE
[15:32:06.805] - signal: TRUE
[15:32:06.805] - resignal: FALSE
[15:32:06.805] - force: TRUE
[15:32:06.805] - relayed: [n=1] TRUE
[15:32:06.805] - queued futures: [n=1] TRUE
 - flush all
[15:32:06.806] - relayed: [n=1] TRUE
[15:32:06.806] - queued futures: [n=1] TRUE
[15:32:06.806] signalConditionsASAP(NULL, pos=0) ... done
[15:32:06.806] resolve() on list ... DONE
[15:32:06.806]  - Number of value chunks collected: 1
[15:32:06.807] Resolving 1 futures (chunks) ... DONE
[15:32:06.807] Reducing values from 1 chunks ...
[15:32:06.807]  - Number of values collected after concatenation: 4
[15:32:06.807]  - Number of values expected: 4
[15:32:06.807] Reducing values from 1 chunks ... DONE
[15:32:06.808] future_mapply() ... DONE
[15:32:06.808] future_mapply() ...
[15:32:06.808] Number of chunks: 1
[15:32:06.808] getGlobalsAndPackagesXApply() ...
[15:32:06.808]  - future.globals: TRUE
[15:32:06.809] getGlobalsAndPackages() ...
[15:32:06.809] Searching for globals...
[15:32:06.811] - globals found: [1] 'FUN'
[15:32:06.812] Searching for globals ... DONE
[15:32:06.812] Resolving globals: FALSE
[15:32:06.812] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:06.813] The total size of the 1 globals exported for future expression ('FUN(x = 42)') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:06.813] - globals: [1] 'FUN'
[15:32:06.813] 
[15:32:06.813] getGlobalsAndPackages() ... DONE
[15:32:06.814]  - globals found/used: [n=1] 'FUN'
[15:32:06.814]  - needed namespaces: [n=0] 
[15:32:06.814] Finding globals ... DONE
[15:32:06.814] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.814] List of 2
[15:32:06.814]  $ ...future.FUN:function (x, ...)  
[15:32:06.814]  $ MoreArgs     :List of 1
[15:32:06.814]   ..$ x: num 42
[15:32:06.814]  - attr(*, "where")=List of 2
[15:32:06.814]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.814]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.814]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.814]  - attr(*, "resolved")= logi FALSE
[15:32:06.814]  - attr(*, "total_size")= num NA
[15:32:06.818] Packages to be attached in all futures: [n=0] 
[15:32:06.818] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.819] Number of futures (= number of chunks): 1
[15:32:06.819] Launching 1 futures (chunks) ...
[15:32:06.819] Chunk #1 of 1 ...
[15:32:06.819]  - Finding globals in '...' for chunk #1 ...
[15:32:06.819] getGlobalsAndPackages() ...
[15:32:06.819] Searching for globals...
[15:32:06.820] 
[15:32:06.820] Searching for globals ... DONE
[15:32:06.820] - globals: [0] <none>
[15:32:06.820] getGlobalsAndPackages() ... DONE
[15:32:06.821]    + additional globals found: [n=0] 
[15:32:06.821]    + additional namespaces needed: [n=0] 
[15:32:06.821]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.821]  - seeds: <none>
[15:32:06.821]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.821] getGlobalsAndPackages() ...
[15:32:06.822] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.822] Resolving globals: FALSE
[15:32:06.822] The total size of the 5 globals is 336 bytes (336 bytes)
[15:32:06.823] 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 336 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (56 bytes of class 'list')
[15:32:06.823] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.824] 
[15:32:06.824] getGlobalsAndPackages() ... DONE
[15:32:06.824] run() for 'Future' ...
[15:32:06.824] - state: 'created'
[15:32:06.825] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:06.825] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.825] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:06.825]   - Field: 'label'
[15:32:06.826]   - Field: 'local'
[15:32:06.826]   - Field: 'owner'
[15:32:06.826]   - Field: 'envir'
[15:32:06.826]   - Field: 'packages'
[15:32:06.826]   - Field: 'gc'
[15:32:06.827]   - Field: 'conditions'
[15:32:06.827]   - Field: 'expr'
[15:32:06.827]   - Field: 'uuid'
[15:32:06.827]   - Field: 'seed'
[15:32:06.827]   - Field: 'version'
[15:32:06.828]   - Field: 'result'
[15:32:06.828]   - Field: 'asynchronous'
[15:32:06.828]   - Field: 'calls'
[15:32:06.828]   - Field: 'globals'
[15:32:06.828]   - Field: 'stdout'
[15:32:06.829]   - Field: 'earlySignal'
[15:32:06.829]   - Field: 'lazy'
[15:32:06.829]   - Field: 'state'
[15:32:06.829] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:06.829] - Launch lazy future ...
[15:32:06.830] Packages needed by the future expression (n = 0): <none>
[15:32:06.830] Packages needed by future strategies (n = 0): <none>
[15:32:06.830] {
[15:32:06.830]     {
[15:32:06.830]         {
[15:32:06.830]             ...future.startTime <- base::Sys.time()
[15:32:06.830]             {
[15:32:06.830]                 {
[15:32:06.830]                   {
[15:32:06.830]                     base::local({
[15:32:06.830]                       has_future <- base::requireNamespace("future", 
[15:32:06.830]                         quietly = TRUE)
[15:32:06.830]                       if (has_future) {
[15:32:06.830]                         ns <- base::getNamespace("future")
[15:32:06.830]                         version <- ns[[".package"]][["version"]]
[15:32:06.830]                         if (is.null(version)) 
[15:32:06.830]                           version <- utils::packageVersion("future")
[15:32:06.830]                       }
[15:32:06.830]                       else {
[15:32:06.830]                         version <- NULL
[15:32:06.830]                       }
[15:32:06.830]                       if (!has_future || version < "1.8.0") {
[15:32:06.830]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:06.830]                           "", base::R.version$version.string), 
[15:32:06.830]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:06.830]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:06.830]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:06.830]                             "release", "version")], collapse = " "), 
[15:32:06.830]                           hostname = base::Sys.info()[["nodename"]])
[15:32:06.830]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:06.830]                           info)
[15:32:06.830]                         info <- base::paste(info, collapse = "; ")
[15:32:06.830]                         if (!has_future) {
[15:32:06.830]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:06.830]                             info)
[15:32:06.830]                         }
[15:32:06.830]                         else {
[15:32:06.830]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:06.830]                             info, version)
[15:32:06.830]                         }
[15:32:06.830]                         base::stop(msg)
[15:32:06.830]                       }
[15:32:06.830]                     })
[15:32:06.830]                   }
[15:32:06.830]                   ...future.strategy.old <- future::plan("list")
[15:32:06.830]                   options(future.plan = NULL)
[15:32:06.830]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.830]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:06.830]                 }
[15:32:06.830]                 ...future.workdir <- getwd()
[15:32:06.830]             }
[15:32:06.830]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:06.830]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:06.830]         }
[15:32:06.830]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:06.830]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:06.830]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:06.830]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:06.830]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:06.830]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:06.830]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:06.830]             base::names(...future.oldOptions))
[15:32:06.830]     }
[15:32:06.830]     if (FALSE) {
[15:32:06.830]     }
[15:32:06.830]     else {
[15:32:06.830]         if (TRUE) {
[15:32:06.830]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:06.830]                 open = "w")
[15:32:06.830]         }
[15:32:06.830]         else {
[15:32:06.830]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:06.830]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:06.830]         }
[15:32:06.830]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:06.830]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:06.830]             base::sink(type = "output", split = FALSE)
[15:32:06.830]             base::close(...future.stdout)
[15:32:06.830]         }, add = TRUE)
[15:32:06.830]     }
[15:32:06.830]     ...future.frame <- base::sys.nframe()
[15:32:06.830]     ...future.conditions <- base::list()
[15:32:06.830]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:06.830]     if (FALSE) {
[15:32:06.830]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:06.830]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:06.830]     }
[15:32:06.830]     ...future.result <- base::tryCatch({
[15:32:06.830]         base::withCallingHandlers({
[15:32:06.830]             ...future.value <- base::withVisible(base::local({
[15:32:06.830]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.830]                 if (!identical(...future.globals.maxSize.org, 
[15:32:06.830]                   ...future.globals.maxSize)) {
[15:32:06.830]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.830]                   on.exit(options(oopts), add = TRUE)
[15:32:06.830]                 }
[15:32:06.830]                 {
[15:32:06.830]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.830]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:06.830]                     USE.NAMES = FALSE)
[15:32:06.830]                   do.call(mapply, args = args)
[15:32:06.830]                 }
[15:32:06.830]             }))
[15:32:06.830]             future::FutureResult(value = ...future.value$value, 
[15:32:06.830]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.830]                   ...future.rng), globalenv = if (FALSE) 
[15:32:06.830]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:06.830]                     ...future.globalenv.names))
[15:32:06.830]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:06.830]         }, condition = base::local({
[15:32:06.830]             c <- base::c
[15:32:06.830]             inherits <- base::inherits
[15:32:06.830]             invokeRestart <- base::invokeRestart
[15:32:06.830]             length <- base::length
[15:32:06.830]             list <- base::list
[15:32:06.830]             seq.int <- base::seq.int
[15:32:06.830]             signalCondition <- base::signalCondition
[15:32:06.830]             sys.calls <- base::sys.calls
[15:32:06.830]             `[[` <- base::`[[`
[15:32:06.830]             `+` <- base::`+`
[15:32:06.830]             `<<-` <- base::`<<-`
[15:32:06.830]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:06.830]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:06.830]                   3L)]
[15:32:06.830]             }
[15:32:06.830]             function(cond) {
[15:32:06.830]                 is_error <- inherits(cond, "error")
[15:32:06.830]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:06.830]                   NULL)
[15:32:06.830]                 if (is_error) {
[15:32:06.830]                   sessionInformation <- function() {
[15:32:06.830]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:06.830]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:06.830]                       search = base::search(), system = base::Sys.info())
[15:32:06.830]                   }
[15:32:06.830]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.830]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:06.830]                     cond$call), session = sessionInformation(), 
[15:32:06.830]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:06.830]                   signalCondition(cond)
[15:32:06.830]                 }
[15:32:06.830]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:06.830]                 "immediateCondition"))) {
[15:32:06.830]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:06.830]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.830]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:06.830]                   if (TRUE && !signal) {
[15:32:06.830]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.830]                     {
[15:32:06.830]                       inherits <- base::inherits
[15:32:06.830]                       invokeRestart <- base::invokeRestart
[15:32:06.830]                       is.null <- base::is.null
[15:32:06.830]                       muffled <- FALSE
[15:32:06.830]                       if (inherits(cond, "message")) {
[15:32:06.830]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.830]                         if (muffled) 
[15:32:06.830]                           invokeRestart("muffleMessage")
[15:32:06.830]                       }
[15:32:06.830]                       else if (inherits(cond, "warning")) {
[15:32:06.830]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.830]                         if (muffled) 
[15:32:06.830]                           invokeRestart("muffleWarning")
[15:32:06.830]                       }
[15:32:06.830]                       else if (inherits(cond, "condition")) {
[15:32:06.830]                         if (!is.null(pattern)) {
[15:32:06.830]                           computeRestarts <- base::computeRestarts
[15:32:06.830]                           grepl <- base::grepl
[15:32:06.830]                           restarts <- computeRestarts(cond)
[15:32:06.830]                           for (restart in restarts) {
[15:32:06.830]                             name <- restart$name
[15:32:06.830]                             if (is.null(name)) 
[15:32:06.830]                               next
[15:32:06.830]                             if (!grepl(pattern, name)) 
[15:32:06.830]                               next
[15:32:06.830]                             invokeRestart(restart)
[15:32:06.830]                             muffled <- TRUE
[15:32:06.830]                             break
[15:32:06.830]                           }
[15:32:06.830]                         }
[15:32:06.830]                       }
[15:32:06.830]                       invisible(muffled)
[15:32:06.830]                     }
[15:32:06.830]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.830]                   }
[15:32:06.830]                 }
[15:32:06.830]                 else {
[15:32:06.830]                   if (TRUE) {
[15:32:06.830]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.830]                     {
[15:32:06.830]                       inherits <- base::inherits
[15:32:06.830]                       invokeRestart <- base::invokeRestart
[15:32:06.830]                       is.null <- base::is.null
[15:32:06.830]                       muffled <- FALSE
[15:32:06.830]                       if (inherits(cond, "message")) {
[15:32:06.830]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.830]                         if (muffled) 
[15:32:06.830]                           invokeRestart("muffleMessage")
[15:32:06.830]                       }
[15:32:06.830]                       else if (inherits(cond, "warning")) {
[15:32:06.830]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.830]                         if (muffled) 
[15:32:06.830]                           invokeRestart("muffleWarning")
[15:32:06.830]                       }
[15:32:06.830]                       else if (inherits(cond, "condition")) {
[15:32:06.830]                         if (!is.null(pattern)) {
[15:32:06.830]                           computeRestarts <- base::computeRestarts
[15:32:06.830]                           grepl <- base::grepl
[15:32:06.830]                           restarts <- computeRestarts(cond)
[15:32:06.830]                           for (restart in restarts) {
[15:32:06.830]                             name <- restart$name
[15:32:06.830]                             if (is.null(name)) 
[15:32:06.830]                               next
[15:32:06.830]                             if (!grepl(pattern, name)) 
[15:32:06.830]                               next
[15:32:06.830]                             invokeRestart(restart)
[15:32:06.830]                             muffled <- TRUE
[15:32:06.830]                             break
[15:32:06.830]                           }
[15:32:06.830]                         }
[15:32:06.830]                       }
[15:32:06.830]                       invisible(muffled)
[15:32:06.830]                     }
[15:32:06.830]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.830]                   }
[15:32:06.830]                 }
[15:32:06.830]             }
[15:32:06.830]         }))
[15:32:06.830]     }, error = function(ex) {
[15:32:06.830]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:06.830]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.830]                 ...future.rng), started = ...future.startTime, 
[15:32:06.830]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:06.830]             version = "1.8"), class = "FutureResult")
[15:32:06.830]     }, finally = {
[15:32:06.830]         if (!identical(...future.workdir, getwd())) 
[15:32:06.830]             setwd(...future.workdir)
[15:32:06.830]         {
[15:32:06.830]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:06.830]                 ...future.oldOptions$nwarnings <- NULL
[15:32:06.830]             }
[15:32:06.830]             base::options(...future.oldOptions)
[15:32:06.830]             if (.Platform$OS.type == "windows") {
[15:32:06.830]                 old_names <- names(...future.oldEnvVars)
[15:32:06.830]                 envs <- base::Sys.getenv()
[15:32:06.830]                 names <- names(envs)
[15:32:06.830]                 common <- intersect(names, old_names)
[15:32:06.830]                 added <- setdiff(names, old_names)
[15:32:06.830]                 removed <- setdiff(old_names, names)
[15:32:06.830]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:06.830]                   envs[common]]
[15:32:06.830]                 NAMES <- toupper(changed)
[15:32:06.830]                 args <- list()
[15:32:06.830]                 for (kk in seq_along(NAMES)) {
[15:32:06.830]                   name <- changed[[kk]]
[15:32:06.830]                   NAME <- NAMES[[kk]]
[15:32:06.830]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.830]                     next
[15:32:06.830]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.830]                 }
[15:32:06.830]                 NAMES <- toupper(added)
[15:32:06.830]                 for (kk in seq_along(NAMES)) {
[15:32:06.830]                   name <- added[[kk]]
[15:32:06.830]                   NAME <- NAMES[[kk]]
[15:32:06.830]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.830]                     next
[15:32:06.830]                   args[[name]] <- ""
[15:32:06.830]                 }
[15:32:06.830]                 NAMES <- toupper(removed)
[15:32:06.830]                 for (kk in seq_along(NAMES)) {
[15:32:06.830]                   name <- removed[[kk]]
[15:32:06.830]                   NAME <- NAMES[[kk]]
[15:32:06.830]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.830]                     next
[15:32:06.830]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.830]                 }
[15:32:06.830]                 if (length(args) > 0) 
[15:32:06.830]                   base::do.call(base::Sys.setenv, args = args)
[15:32:06.830]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:06.830]             }
[15:32:06.830]             else {
[15:32:06.830]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:06.830]             }
[15:32:06.830]             {
[15:32:06.830]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:06.830]                   0L) {
[15:32:06.830]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:06.830]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:06.830]                   base::options(opts)
[15:32:06.830]                 }
[15:32:06.830]                 {
[15:32:06.830]                   {
[15:32:06.830]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:06.830]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:06.830]                     -253660479L), envir = base::globalenv(), 
[15:32:06.830]                       inherits = FALSE)
[15:32:06.830]                     NULL
[15:32:06.830]                   }
[15:32:06.830]                   options(future.plan = NULL)
[15:32:06.830]                   if (is.na(NA_character_)) 
[15:32:06.830]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.830]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:06.830]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:06.830]                     .init = FALSE)
[15:32:06.830]                 }
[15:32:06.830]             }
[15:32:06.830]         }
[15:32:06.830]     })
[15:32:06.830]     if (TRUE) {
[15:32:06.830]         base::sink(type = "output", split = FALSE)
[15:32:06.830]         if (TRUE) {
[15:32:06.830]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:06.830]         }
[15:32:06.830]         else {
[15:32:06.830]             ...future.result["stdout"] <- base::list(NULL)
[15:32:06.830]         }
[15:32:06.830]         base::close(...future.stdout)
[15:32:06.830]         ...future.stdout <- NULL
[15:32:06.830]     }
[15:32:06.830]     ...future.result$conditions <- ...future.conditions
[15:32:06.830]     ...future.result$finished <- base::Sys.time()
[15:32:06.830]     ...future.result
[15:32:06.830] }
[15:32:06.835] assign_globals() ...
[15:32:06.835] List of 5
[15:32:06.835]  $ ...future.FUN            :function (x, ...)  
[15:32:06.835]  $ MoreArgs                 :List of 1
[15:32:06.835]   ..$ x: num 42
[15:32:06.835]  $ ...future.elements_ii    :List of 1
[15:32:06.835]   ..$ times:List of 4
[15:32:06.835]   .. ..$ : int 1
[15:32:06.835]   .. ..$ : int 2
[15:32:06.835]   .. ..$ : int 3
[15:32:06.835]   .. ..$ : int 4
[15:32:06.835]  $ ...future.seeds_ii       : NULL
[15:32:06.835]  $ ...future.globals.maxSize: NULL
[15:32:06.835]  - attr(*, "where")=List of 5
[15:32:06.835]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:06.835]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:06.835]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:06.835]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:06.835]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:06.835]  - attr(*, "resolved")= logi FALSE
[15:32:06.835]  - attr(*, "total_size")= num 336
[15:32:06.835]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.835]  - attr(*, "already-done")= logi TRUE
[15:32:06.845] - copied '...future.FUN' to environment
[15:32:06.845] - copied 'MoreArgs' to environment
[15:32:06.845] - copied '...future.elements_ii' to environment
[15:32:06.845] - copied '...future.seeds_ii' to environment
[15:32:06.845] - copied '...future.globals.maxSize' to environment
[15:32:06.846] assign_globals() ... done
[15:32:06.846] plan(): Setting new future strategy stack:
[15:32:06.846] List of future strategies:
[15:32:06.846] 1. sequential:
[15:32:06.846]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.846]    - tweaked: FALSE
[15:32:06.846]    - call: NULL
[15:32:06.847] plan(): nbrOfWorkers() = 1
[15:32:06.848] plan(): Setting new future strategy stack:
[15:32:06.848] List of future strategies:
[15:32:06.848] 1. sequential:
[15:32:06.848]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.848]    - tweaked: FALSE
[15:32:06.848]    - call: plan(strategy)
[15:32:06.849] plan(): nbrOfWorkers() = 1
[15:32:06.849] SequentialFuture started (and completed)
[15:32:06.849] - Launch lazy future ... done
[15:32:06.850] run() for 'SequentialFuture' ... done
[15:32:06.850] Created future:
[15:32:06.850] SequentialFuture:
[15:32:06.850] Label: 'future_mapply-1'
[15:32:06.850] Expression:
[15:32:06.850] {
[15:32:06.850]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.850]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:06.850]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.850]         on.exit(options(oopts), add = TRUE)
[15:32:06.850]     }
[15:32:06.850]     {
[15:32:06.850]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.850]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:06.850]         do.call(mapply, args = args)
[15:32:06.850]     }
[15:32:06.850] }
[15:32:06.850] Lazy evaluation: FALSE
[15:32:06.850] Asynchronous evaluation: FALSE
[15:32:06.850] Local evaluation: TRUE
[15:32:06.850] Environment: R_GlobalEnv
[15:32:06.850] Capture standard output: TRUE
[15:32:06.850] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:06.850] Globals: 5 objects totaling 336 bytes (function '...future.FUN' of 56 bytes, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:06.850] Packages: <none>
[15:32:06.850] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:06.850] Resolved: TRUE
[15:32:06.850] Value: 280 bytes of class 'list'
[15:32:06.850] Early signaling: FALSE
[15:32:06.850] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:06.850] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.851] Chunk #1 of 1 ... DONE
[15:32:06.852] Launching 1 futures (chunks) ... DONE
[15:32:06.852] Resolving 1 futures (chunks) ...
[15:32:06.852] resolve() on list ...
[15:32:06.852]  recursive: 0
[15:32:06.852]  length: 1
[15:32:06.852] 
[15:32:06.853] resolved() for 'SequentialFuture' ...
[15:32:06.853] - state: 'finished'
[15:32:06.853] - run: TRUE
[15:32:06.853] - result: 'FutureResult'
[15:32:06.853] resolved() for 'SequentialFuture' ... done
[15:32:06.854] Future #1
[15:32:06.854] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:06.854] - nx: 1
[15:32:06.854] - relay: TRUE
[15:32:06.854] - stdout: TRUE
[15:32:06.854] - signal: TRUE
[15:32:06.855] - resignal: FALSE
[15:32:06.855] - force: TRUE
[15:32:06.855] - relayed: [n=1] FALSE
[15:32:06.855] - queued futures: [n=1] FALSE
[15:32:06.855]  - until=1
[15:32:06.855]  - relaying element #1
[15:32:06.856] - relayed: [n=1] TRUE
[15:32:06.856] - queued futures: [n=1] TRUE
[15:32:06.856] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:06.856]  length: 0 (resolved future 1)
[15:32:06.857] Relaying remaining futures
[15:32:06.857] signalConditionsASAP(NULL, pos=0) ...
[15:32:06.857] - nx: 1
[15:32:06.857] - relay: TRUE
[15:32:06.857] - stdout: TRUE
[15:32:06.857] - signal: TRUE
[15:32:06.857] - resignal: FALSE
[15:32:06.858] - force: TRUE
[15:32:06.858] - relayed: [n=1] TRUE
[15:32:06.858] - queued futures: [n=1] TRUE
 - flush all
[15:32:06.858] - relayed: [n=1] TRUE
[15:32:06.858] - queued futures: [n=1] TRUE
[15:32:06.859] signalConditionsASAP(NULL, pos=0) ... done
[15:32:06.859] resolve() on list ... DONE
[15:32:06.859]  - Number of value chunks collected: 1
[15:32:06.860] Resolving 1 futures (chunks) ... DONE
[15:32:06.860] Reducing values from 1 chunks ...
[15:32:06.860]  - Number of values collected after concatenation: 4
[15:32:06.860]  - Number of values expected: 4
[15:32:06.861] Reducing values from 1 chunks ... DONE
[15:32:06.861] future_mapply() ... DONE
[15:32:06.861] future_mapply() ...
[15:32:06.862] Number of chunks: 1
[15:32:06.862] getGlobalsAndPackagesXApply() ...
[15:32:06.862]  - future.globals: TRUE
[15:32:06.863] getGlobalsAndPackages() ...
[15:32:06.863] Searching for globals...
[15:32:06.865] - globals found: [3] 'FUN', '+', 'seq_len'
[15:32:06.865] Searching for globals ... DONE
[15:32:06.865] Resolving globals: FALSE
[15:32:06.866] The total size of the 1 globals is 1.93 KiB (1976 bytes)
[15:32:06.867] The total size of the 1 globals exported for future expression ('FUN()') is 1.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.93 KiB of class 'function')
[15:32:06.867] - globals: [1] 'FUN'
[15:32:06.867] 
[15:32:06.867] getGlobalsAndPackages() ... DONE
[15:32:06.867]  - globals found/used: [n=1] 'FUN'
[15:32:06.867]  - needed namespaces: [n=0] 
[15:32:06.868] Finding globals ... DONE
[15:32:06.868] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.868] List of 2
[15:32:06.868]  $ ...future.FUN:function (x, y)  
[15:32:06.868]  $ MoreArgs     : NULL
[15:32:06.868]  - attr(*, "where")=List of 2
[15:32:06.868]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.868]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.868]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.868]  - attr(*, "resolved")= logi FALSE
[15:32:06.868]  - attr(*, "total_size")= num NA
[15:32:06.872] Packages to be attached in all futures: [n=0] 
[15:32:06.873] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.873] Number of futures (= number of chunks): 1
[15:32:06.873] Launching 1 futures (chunks) ...
[15:32:06.874] Chunk #1 of 1 ...
[15:32:06.874]  - Finding globals in '...' for chunk #1 ...
[15:32:06.874] getGlobalsAndPackages() ...
[15:32:06.875] Searching for globals...
[15:32:06.909] 
[15:32:06.910] Searching for globals ... DONE
[15:32:06.910] - globals: [0] <none>
[15:32:06.910] getGlobalsAndPackages() ... DONE
[15:32:06.910]    + additional globals found: [n=0] 
[15:32:06.910]    + additional namespaces needed: [n=0] 
[15:32:06.911]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.911]  - seeds: <none>
[15:32:06.911]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.912] getGlobalsAndPackages() ...
[15:32:06.912] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.912] Resolving globals: FALSE
[15:32:06.914] The total size of the 5 globals is 2.26 KiB (2312 bytes)
[15:32:06.915] 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 2.26 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.93 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:06.915] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.915] 
[15:32:06.916] getGlobalsAndPackages() ... DONE
[15:32:06.916] run() for 'Future' ...
[15:32:06.917] - state: 'created'
[15:32:06.917] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:06.918] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.918] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:06.918]   - Field: 'label'
[15:32:06.919]   - Field: 'local'
[15:32:06.919]   - Field: 'owner'
[15:32:06.919]   - Field: 'envir'
[15:32:06.920]   - Field: 'packages'
[15:32:06.920]   - Field: 'gc'
[15:32:06.920]   - Field: 'conditions'
[15:32:06.920]   - Field: 'expr'
[15:32:06.921]   - Field: 'uuid'
[15:32:06.921]   - Field: 'seed'
[15:32:06.921]   - Field: 'version'
[15:32:06.922]   - Field: 'result'
[15:32:06.922]   - Field: 'asynchronous'
[15:32:06.922]   - Field: 'calls'
[15:32:06.923]   - Field: 'globals'
[15:32:06.923]   - Field: 'stdout'
[15:32:06.923]   - Field: 'earlySignal'
[15:32:06.924]   - Field: 'lazy'
[15:32:06.924]   - Field: 'state'
[15:32:06.924] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:06.925] - Launch lazy future ...
[15:32:06.925] Packages needed by the future expression (n = 0): <none>
[15:32:06.925] Packages needed by future strategies (n = 0): <none>
[15:32:06.926] {
[15:32:06.926]     {
[15:32:06.926]         {
[15:32:06.926]             ...future.startTime <- base::Sys.time()
[15:32:06.926]             {
[15:32:06.926]                 {
[15:32:06.926]                   {
[15:32:06.926]                     base::local({
[15:32:06.926]                       has_future <- base::requireNamespace("future", 
[15:32:06.926]                         quietly = TRUE)
[15:32:06.926]                       if (has_future) {
[15:32:06.926]                         ns <- base::getNamespace("future")
[15:32:06.926]                         version <- ns[[".package"]][["version"]]
[15:32:06.926]                         if (is.null(version)) 
[15:32:06.926]                           version <- utils::packageVersion("future")
[15:32:06.926]                       }
[15:32:06.926]                       else {
[15:32:06.926]                         version <- NULL
[15:32:06.926]                       }
[15:32:06.926]                       if (!has_future || version < "1.8.0") {
[15:32:06.926]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:06.926]                           "", base::R.version$version.string), 
[15:32:06.926]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:06.926]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:06.926]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:06.926]                             "release", "version")], collapse = " "), 
[15:32:06.926]                           hostname = base::Sys.info()[["nodename"]])
[15:32:06.926]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:06.926]                           info)
[15:32:06.926]                         info <- base::paste(info, collapse = "; ")
[15:32:06.926]                         if (!has_future) {
[15:32:06.926]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:06.926]                             info)
[15:32:06.926]                         }
[15:32:06.926]                         else {
[15:32:06.926]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:06.926]                             info, version)
[15:32:06.926]                         }
[15:32:06.926]                         base::stop(msg)
[15:32:06.926]                       }
[15:32:06.926]                     })
[15:32:06.926]                   }
[15:32:06.926]                   ...future.strategy.old <- future::plan("list")
[15:32:06.926]                   options(future.plan = NULL)
[15:32:06.926]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.926]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:06.926]                 }
[15:32:06.926]                 ...future.workdir <- getwd()
[15:32:06.926]             }
[15:32:06.926]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:06.926]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:06.926]         }
[15:32:06.926]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:06.926]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:06.926]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:06.926]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:06.926]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:06.926]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:06.926]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:06.926]             base::names(...future.oldOptions))
[15:32:06.926]     }
[15:32:06.926]     if (FALSE) {
[15:32:06.926]     }
[15:32:06.926]     else {
[15:32:06.926]         if (TRUE) {
[15:32:06.926]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:06.926]                 open = "w")
[15:32:06.926]         }
[15:32:06.926]         else {
[15:32:06.926]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:06.926]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:06.926]         }
[15:32:06.926]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:06.926]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:06.926]             base::sink(type = "output", split = FALSE)
[15:32:06.926]             base::close(...future.stdout)
[15:32:06.926]         }, add = TRUE)
[15:32:06.926]     }
[15:32:06.926]     ...future.frame <- base::sys.nframe()
[15:32:06.926]     ...future.conditions <- base::list()
[15:32:06.926]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:06.926]     if (FALSE) {
[15:32:06.926]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:06.926]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:06.926]     }
[15:32:06.926]     ...future.result <- base::tryCatch({
[15:32:06.926]         base::withCallingHandlers({
[15:32:06.926]             ...future.value <- base::withVisible(base::local({
[15:32:06.926]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.926]                 if (!identical(...future.globals.maxSize.org, 
[15:32:06.926]                   ...future.globals.maxSize)) {
[15:32:06.926]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.926]                   on.exit(options(oopts), add = TRUE)
[15:32:06.926]                 }
[15:32:06.926]                 {
[15:32:06.926]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.926]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:06.926]                     USE.NAMES = FALSE)
[15:32:06.926]                   do.call(mapply, args = args)
[15:32:06.926]                 }
[15:32:06.926]             }))
[15:32:06.926]             future::FutureResult(value = ...future.value$value, 
[15:32:06.926]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.926]                   ...future.rng), globalenv = if (FALSE) 
[15:32:06.926]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:06.926]                     ...future.globalenv.names))
[15:32:06.926]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:06.926]         }, condition = base::local({
[15:32:06.926]             c <- base::c
[15:32:06.926]             inherits <- base::inherits
[15:32:06.926]             invokeRestart <- base::invokeRestart
[15:32:06.926]             length <- base::length
[15:32:06.926]             list <- base::list
[15:32:06.926]             seq.int <- base::seq.int
[15:32:06.926]             signalCondition <- base::signalCondition
[15:32:06.926]             sys.calls <- base::sys.calls
[15:32:06.926]             `[[` <- base::`[[`
[15:32:06.926]             `+` <- base::`+`
[15:32:06.926]             `<<-` <- base::`<<-`
[15:32:06.926]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:06.926]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:06.926]                   3L)]
[15:32:06.926]             }
[15:32:06.926]             function(cond) {
[15:32:06.926]                 is_error <- inherits(cond, "error")
[15:32:06.926]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:06.926]                   NULL)
[15:32:06.926]                 if (is_error) {
[15:32:06.926]                   sessionInformation <- function() {
[15:32:06.926]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:06.926]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:06.926]                       search = base::search(), system = base::Sys.info())
[15:32:06.926]                   }
[15:32:06.926]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.926]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:06.926]                     cond$call), session = sessionInformation(), 
[15:32:06.926]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:06.926]                   signalCondition(cond)
[15:32:06.926]                 }
[15:32:06.926]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:06.926]                 "immediateCondition"))) {
[15:32:06.926]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:06.926]                   ...future.conditions[[length(...future.conditions) + 
[15:32:06.926]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:06.926]                   if (TRUE && !signal) {
[15:32:06.926]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.926]                     {
[15:32:06.926]                       inherits <- base::inherits
[15:32:06.926]                       invokeRestart <- base::invokeRestart
[15:32:06.926]                       is.null <- base::is.null
[15:32:06.926]                       muffled <- FALSE
[15:32:06.926]                       if (inherits(cond, "message")) {
[15:32:06.926]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.926]                         if (muffled) 
[15:32:06.926]                           invokeRestart("muffleMessage")
[15:32:06.926]                       }
[15:32:06.926]                       else if (inherits(cond, "warning")) {
[15:32:06.926]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.926]                         if (muffled) 
[15:32:06.926]                           invokeRestart("muffleWarning")
[15:32:06.926]                       }
[15:32:06.926]                       else if (inherits(cond, "condition")) {
[15:32:06.926]                         if (!is.null(pattern)) {
[15:32:06.926]                           computeRestarts <- base::computeRestarts
[15:32:06.926]                           grepl <- base::grepl
[15:32:06.926]                           restarts <- computeRestarts(cond)
[15:32:06.926]                           for (restart in restarts) {
[15:32:06.926]                             name <- restart$name
[15:32:06.926]                             if (is.null(name)) 
[15:32:06.926]                               next
[15:32:06.926]                             if (!grepl(pattern, name)) 
[15:32:06.926]                               next
[15:32:06.926]                             invokeRestart(restart)
[15:32:06.926]                             muffled <- TRUE
[15:32:06.926]                             break
[15:32:06.926]                           }
[15:32:06.926]                         }
[15:32:06.926]                       }
[15:32:06.926]                       invisible(muffled)
[15:32:06.926]                     }
[15:32:06.926]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.926]                   }
[15:32:06.926]                 }
[15:32:06.926]                 else {
[15:32:06.926]                   if (TRUE) {
[15:32:06.926]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:06.926]                     {
[15:32:06.926]                       inherits <- base::inherits
[15:32:06.926]                       invokeRestart <- base::invokeRestart
[15:32:06.926]                       is.null <- base::is.null
[15:32:06.926]                       muffled <- FALSE
[15:32:06.926]                       if (inherits(cond, "message")) {
[15:32:06.926]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:06.926]                         if (muffled) 
[15:32:06.926]                           invokeRestart("muffleMessage")
[15:32:06.926]                       }
[15:32:06.926]                       else if (inherits(cond, "warning")) {
[15:32:06.926]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:06.926]                         if (muffled) 
[15:32:06.926]                           invokeRestart("muffleWarning")
[15:32:06.926]                       }
[15:32:06.926]                       else if (inherits(cond, "condition")) {
[15:32:06.926]                         if (!is.null(pattern)) {
[15:32:06.926]                           computeRestarts <- base::computeRestarts
[15:32:06.926]                           grepl <- base::grepl
[15:32:06.926]                           restarts <- computeRestarts(cond)
[15:32:06.926]                           for (restart in restarts) {
[15:32:06.926]                             name <- restart$name
[15:32:06.926]                             if (is.null(name)) 
[15:32:06.926]                               next
[15:32:06.926]                             if (!grepl(pattern, name)) 
[15:32:06.926]                               next
[15:32:06.926]                             invokeRestart(restart)
[15:32:06.926]                             muffled <- TRUE
[15:32:06.926]                             break
[15:32:06.926]                           }
[15:32:06.926]                         }
[15:32:06.926]                       }
[15:32:06.926]                       invisible(muffled)
[15:32:06.926]                     }
[15:32:06.926]                     muffleCondition(cond, pattern = "^muffle")
[15:32:06.926]                   }
[15:32:06.926]                 }
[15:32:06.926]             }
[15:32:06.926]         }))
[15:32:06.926]     }, error = function(ex) {
[15:32:06.926]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:06.926]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:06.926]                 ...future.rng), started = ...future.startTime, 
[15:32:06.926]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:06.926]             version = "1.8"), class = "FutureResult")
[15:32:06.926]     }, finally = {
[15:32:06.926]         if (!identical(...future.workdir, getwd())) 
[15:32:06.926]             setwd(...future.workdir)
[15:32:06.926]         {
[15:32:06.926]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:06.926]                 ...future.oldOptions$nwarnings <- NULL
[15:32:06.926]             }
[15:32:06.926]             base::options(...future.oldOptions)
[15:32:06.926]             if (.Platform$OS.type == "windows") {
[15:32:06.926]                 old_names <- names(...future.oldEnvVars)
[15:32:06.926]                 envs <- base::Sys.getenv()
[15:32:06.926]                 names <- names(envs)
[15:32:06.926]                 common <- intersect(names, old_names)
[15:32:06.926]                 added <- setdiff(names, old_names)
[15:32:06.926]                 removed <- setdiff(old_names, names)
[15:32:06.926]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:06.926]                   envs[common]]
[15:32:06.926]                 NAMES <- toupper(changed)
[15:32:06.926]                 args <- list()
[15:32:06.926]                 for (kk in seq_along(NAMES)) {
[15:32:06.926]                   name <- changed[[kk]]
[15:32:06.926]                   NAME <- NAMES[[kk]]
[15:32:06.926]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.926]                     next
[15:32:06.926]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.926]                 }
[15:32:06.926]                 NAMES <- toupper(added)
[15:32:06.926]                 for (kk in seq_along(NAMES)) {
[15:32:06.926]                   name <- added[[kk]]
[15:32:06.926]                   NAME <- NAMES[[kk]]
[15:32:06.926]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.926]                     next
[15:32:06.926]                   args[[name]] <- ""
[15:32:06.926]                 }
[15:32:06.926]                 NAMES <- toupper(removed)
[15:32:06.926]                 for (kk in seq_along(NAMES)) {
[15:32:06.926]                   name <- removed[[kk]]
[15:32:06.926]                   NAME <- NAMES[[kk]]
[15:32:06.926]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:06.926]                     next
[15:32:06.926]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:06.926]                 }
[15:32:06.926]                 if (length(args) > 0) 
[15:32:06.926]                   base::do.call(base::Sys.setenv, args = args)
[15:32:06.926]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:06.926]             }
[15:32:06.926]             else {
[15:32:06.926]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:06.926]             }
[15:32:06.926]             {
[15:32:06.926]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:06.926]                   0L) {
[15:32:06.926]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:06.926]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:06.926]                   base::options(opts)
[15:32:06.926]                 }
[15:32:06.926]                 {
[15:32:06.926]                   {
[15:32:06.926]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:06.926]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:06.926]                     -253660479L), envir = base::globalenv(), 
[15:32:06.926]                       inherits = FALSE)
[15:32:06.926]                     NULL
[15:32:06.926]                   }
[15:32:06.926]                   options(future.plan = NULL)
[15:32:06.926]                   if (is.na(NA_character_)) 
[15:32:06.926]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:06.926]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:06.926]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:06.926]                     .init = FALSE)
[15:32:06.926]                 }
[15:32:06.926]             }
[15:32:06.926]         }
[15:32:06.926]     })
[15:32:06.926]     if (TRUE) {
[15:32:06.926]         base::sink(type = "output", split = FALSE)
[15:32:06.926]         if (TRUE) {
[15:32:06.926]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:06.926]         }
[15:32:06.926]         else {
[15:32:06.926]             ...future.result["stdout"] <- base::list(NULL)
[15:32:06.926]         }
[15:32:06.926]         base::close(...future.stdout)
[15:32:06.926]         ...future.stdout <- NULL
[15:32:06.926]     }
[15:32:06.926]     ...future.result$conditions <- ...future.conditions
[15:32:06.926]     ...future.result$finished <- base::Sys.time()
[15:32:06.926]     ...future.result
[15:32:06.926] }
[15:32:06.933] assign_globals() ...
[15:32:06.933] List of 5
[15:32:06.933]  $ ...future.FUN            :function (x, y)  
[15:32:06.933]  $ MoreArgs                 : NULL
[15:32:06.933]  $ ...future.elements_ii    :List of 2
[15:32:06.933]   ..$ :List of 3
[15:32:06.933]   .. ..$ a: num 1
[15:32:06.933]   .. ..$ b: num 2
[15:32:06.933]   .. ..$ c: num 3
[15:32:06.933]   ..$ :List of 3
[15:32:06.933]   .. ..$ A: num 10
[15:32:06.933]   .. ..$ B: num 0
[15:32:06.933]   .. ..$ C: num -10
[15:32:06.933]  $ ...future.seeds_ii       : NULL
[15:32:06.933]  $ ...future.globals.maxSize: NULL
[15:32:06.933]  - attr(*, "where")=List of 5
[15:32:06.933]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:06.933]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:06.933]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:06.933]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:06.933]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:06.933]  - attr(*, "resolved")= logi FALSE
[15:32:06.933]  - attr(*, "total_size")= num 2312
[15:32:06.933]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.933]  - attr(*, "already-done")= logi TRUE
[15:32:06.947] - reassign environment for '...future.FUN'
[15:32:06.947] - copied '...future.FUN' to environment
[15:32:06.947] - copied 'MoreArgs' to environment
[15:32:06.948] - copied '...future.elements_ii' to environment
[15:32:06.948] - copied '...future.seeds_ii' to environment
[15:32:06.948] - copied '...future.globals.maxSize' to environment
[15:32:06.948] assign_globals() ... done
[15:32:06.949] plan(): Setting new future strategy stack:
[15:32:06.949] List of future strategies:
[15:32:06.949] 1. sequential:
[15:32:06.949]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.949]    - tweaked: FALSE
[15:32:06.949]    - call: NULL
[15:32:06.950] plan(): nbrOfWorkers() = 1
[15:32:06.952] plan(): Setting new future strategy stack:
[15:32:06.953] List of future strategies:
[15:32:06.953] 1. sequential:
[15:32:06.953]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:06.953]    - tweaked: FALSE
[15:32:06.953]    - call: plan(strategy)
[15:32:06.954] plan(): nbrOfWorkers() = 1
[15:32:06.954] SequentialFuture started (and completed)
[15:32:06.955] - Launch lazy future ... done
[15:32:06.955] run() for 'SequentialFuture' ... done
[15:32:06.955] Created future:
[15:32:06.955] SequentialFuture:
[15:32:06.955] Label: 'future_mapply-1'
[15:32:06.955] Expression:
[15:32:06.955] {
[15:32:06.955]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:06.955]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:06.955]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:06.955]         on.exit(options(oopts), add = TRUE)
[15:32:06.955]     }
[15:32:06.955]     {
[15:32:06.955]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:06.955]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:06.955]         do.call(mapply, args = args)
[15:32:06.955]     }
[15:32:06.955] }
[15:32:06.955] Lazy evaluation: FALSE
[15:32:06.955] Asynchronous evaluation: FALSE
[15:32:06.955] Local evaluation: TRUE
[15:32:06.955] Environment: R_GlobalEnv
[15:32:06.955] Capture standard output: TRUE
[15:32:06.955] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:06.955] Globals: 5 objects totaling 2.26 KiB (function '...future.FUN' of 1.93 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:06.955] Packages: <none>
[15:32:06.955] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:06.955] Resolved: TRUE
[15:32:06.955] Value: 200 bytes of class 'list'
[15:32:06.955] Early signaling: FALSE
[15:32:06.955] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:06.955] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:06.958] Chunk #1 of 1 ... DONE
[15:32:06.958] Launching 1 futures (chunks) ... DONE
[15:32:06.958] Resolving 1 futures (chunks) ...
[15:32:06.958] resolve() on list ...
[15:32:06.959]  recursive: 0
[15:32:06.959]  length: 1
[15:32:06.959] 
[15:32:06.959] resolved() for 'SequentialFuture' ...
[15:32:06.960] - state: 'finished'
[15:32:06.960] - run: TRUE
[15:32:06.960] - result: 'FutureResult'
[15:32:06.961] resolved() for 'SequentialFuture' ... done
[15:32:06.961] Future #1
[15:32:06.962] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:06.962] - nx: 1
[15:32:06.962] - relay: TRUE
[15:32:06.962] - stdout: TRUE
[15:32:06.963] - signal: TRUE
[15:32:06.963] - resignal: FALSE
[15:32:06.963] - force: TRUE
[15:32:06.963] - relayed: [n=1] FALSE
[15:32:06.966] - queued futures: [n=1] FALSE
[15:32:06.967]  - until=1
[15:32:06.967]  - relaying element #1
[15:32:06.967] - relayed: [n=1] TRUE
[15:32:06.968] - queued futures: [n=1] TRUE
[15:32:06.968] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:06.968]  length: 0 (resolved future 1)
[15:32:06.969] Relaying remaining futures
[15:32:06.969] signalConditionsASAP(NULL, pos=0) ...
[15:32:06.969] - nx: 1
[15:32:06.970] - relay: TRUE
[15:32:06.970] - stdout: TRUE
[15:32:06.970] - signal: TRUE
[15:32:06.970] - resignal: FALSE
[15:32:06.971] - force: TRUE
[15:32:06.971] - relayed: [n=1] TRUE
[15:32:06.971] - queued futures: [n=1] TRUE
 - flush all
[15:32:06.972] - relayed: [n=1] TRUE
[15:32:06.972] - queued futures: [n=1] TRUE
[15:32:06.972] signalConditionsASAP(NULL, pos=0) ... done
[15:32:06.973] resolve() on list ... DONE
[15:32:06.973]  - Number of value chunks collected: 1
[15:32:06.973] Resolving 1 futures (chunks) ... DONE
[15:32:06.974] Reducing values from 1 chunks ...
[15:32:06.974]  - Number of values collected after concatenation: 3
[15:32:06.974]  - Number of values expected: 3
[15:32:06.974] Reducing values from 1 chunks ... DONE
[15:32:06.975] future_mapply() ... DONE
- future_.mapply()
[15:32:06.976] future_mapply() ...
[15:32:06.977] Number of chunks: 1
[15:32:06.977] getGlobalsAndPackagesXApply() ...
[15:32:06.977]  - future.globals: TRUE
[15:32:06.978] getGlobalsAndPackages() ...
[15:32:06.978] Searching for globals...
[15:32:06.980] - globals found: [3] 'FUN', '+', 'seq_len'
[15:32:06.981] Searching for globals ... DONE
[15:32:06.981] Resolving globals: FALSE
[15:32:06.982] The total size of the 1 globals is 1.93 KiB (1976 bytes)
[15:32:06.983] The total size of the 1 globals exported for future expression ('FUN()') is 1.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.93 KiB of class 'function')
[15:32:06.983] - globals: [1] 'FUN'
[15:32:06.983] 
[15:32:06.984] getGlobalsAndPackages() ... DONE
[15:32:06.984]  - globals found/used: [n=1] 'FUN'
[15:32:06.984]  - needed namespaces: [n=0] 
[15:32:06.984] Finding globals ... DONE
[15:32:06.985] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:06.985] List of 2
[15:32:06.985]  $ ...future.FUN:function (x, y)  
[15:32:06.985]  $ MoreArgs     : list()
[15:32:06.985]  - attr(*, "where")=List of 2
[15:32:06.985]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:06.985]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:06.985]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:06.985]  - attr(*, "resolved")= logi FALSE
[15:32:06.985]  - attr(*, "total_size")= num NA
[15:32:06.990] Packages to be attached in all futures: [n=0] 
[15:32:06.991] getGlobalsAndPackagesXApply() ... DONE
[15:32:06.991] Number of futures (= number of chunks): 1
[15:32:06.991] Launching 1 futures (chunks) ...
[15:32:06.992] Chunk #1 of 1 ...
[15:32:06.992]  - Finding globals in '...' for chunk #1 ...
[15:32:06.992] getGlobalsAndPackages() ...
[15:32:06.993] Searching for globals...
[15:32:06.993] 
[15:32:06.994] Searching for globals ... DONE
[15:32:06.994] - globals: [0] <none>
[15:32:06.994] getGlobalsAndPackages() ... DONE
[15:32:06.994]    + additional globals found: [n=0] 
[15:32:06.995]    + additional namespaces needed: [n=0] 
[15:32:06.995]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:06.995]  - seeds: <none>
[15:32:06.996]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.996] getGlobalsAndPackages() ...
[15:32:06.996] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.997] Resolving globals: FALSE
[15:32:06.998] The total size of the 5 globals is 2.26 KiB (2312 bytes)
[15:32:06.999] 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 2.26 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.93 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:06.999] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:06.999] 
[15:32:07.000] getGlobalsAndPackages() ... DONE
[15:32:07.000] run() for 'Future' ...
[15:32:07.001] - state: 'created'
[15:32:07.001] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.002] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.002] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.002]   - Field: 'label'
[15:32:07.003]   - Field: 'local'
[15:32:07.003]   - Field: 'owner'
[15:32:07.003]   - Field: 'envir'
[15:32:07.003]   - Field: 'packages'
[15:32:07.004]   - Field: 'gc'
[15:32:07.004]   - Field: 'conditions'
[15:32:07.004]   - Field: 'expr'
[15:32:07.005]   - Field: 'uuid'
[15:32:07.005]   - Field: 'seed'
[15:32:07.005]   - Field: 'version'
[15:32:07.006]   - Field: 'result'
[15:32:07.006]   - Field: 'asynchronous'
[15:32:07.006]   - Field: 'calls'
[15:32:07.007]   - Field: 'globals'
[15:32:07.007]   - Field: 'stdout'
[15:32:07.007]   - Field: 'earlySignal'
[15:32:07.008]   - Field: 'lazy'
[15:32:07.008]   - Field: 'state'
[15:32:07.008] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.008] - Launch lazy future ...
[15:32:07.009] Packages needed by the future expression (n = 0): <none>
[15:32:07.009] Packages needed by future strategies (n = 0): <none>
[15:32:07.010] {
[15:32:07.010]     {
[15:32:07.010]         {
[15:32:07.010]             ...future.startTime <- base::Sys.time()
[15:32:07.010]             {
[15:32:07.010]                 {
[15:32:07.010]                   {
[15:32:07.010]                     base::local({
[15:32:07.010]                       has_future <- base::requireNamespace("future", 
[15:32:07.010]                         quietly = TRUE)
[15:32:07.010]                       if (has_future) {
[15:32:07.010]                         ns <- base::getNamespace("future")
[15:32:07.010]                         version <- ns[[".package"]][["version"]]
[15:32:07.010]                         if (is.null(version)) 
[15:32:07.010]                           version <- utils::packageVersion("future")
[15:32:07.010]                       }
[15:32:07.010]                       else {
[15:32:07.010]                         version <- NULL
[15:32:07.010]                       }
[15:32:07.010]                       if (!has_future || version < "1.8.0") {
[15:32:07.010]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.010]                           "", base::R.version$version.string), 
[15:32:07.010]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.010]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.010]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.010]                             "release", "version")], collapse = " "), 
[15:32:07.010]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.010]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.010]                           info)
[15:32:07.010]                         info <- base::paste(info, collapse = "; ")
[15:32:07.010]                         if (!has_future) {
[15:32:07.010]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.010]                             info)
[15:32:07.010]                         }
[15:32:07.010]                         else {
[15:32:07.010]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.010]                             info, version)
[15:32:07.010]                         }
[15:32:07.010]                         base::stop(msg)
[15:32:07.010]                       }
[15:32:07.010]                     })
[15:32:07.010]                   }
[15:32:07.010]                   ...future.strategy.old <- future::plan("list")
[15:32:07.010]                   options(future.plan = NULL)
[15:32:07.010]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.010]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.010]                 }
[15:32:07.010]                 ...future.workdir <- getwd()
[15:32:07.010]             }
[15:32:07.010]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.010]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.010]         }
[15:32:07.010]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.010]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:07.010]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.010]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.010]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.010]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.010]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.010]             base::names(...future.oldOptions))
[15:32:07.010]     }
[15:32:07.010]     if (FALSE) {
[15:32:07.010]     }
[15:32:07.010]     else {
[15:32:07.010]         if (TRUE) {
[15:32:07.010]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.010]                 open = "w")
[15:32:07.010]         }
[15:32:07.010]         else {
[15:32:07.010]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.010]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.010]         }
[15:32:07.010]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.010]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.010]             base::sink(type = "output", split = FALSE)
[15:32:07.010]             base::close(...future.stdout)
[15:32:07.010]         }, add = TRUE)
[15:32:07.010]     }
[15:32:07.010]     ...future.frame <- base::sys.nframe()
[15:32:07.010]     ...future.conditions <- base::list()
[15:32:07.010]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.010]     if (FALSE) {
[15:32:07.010]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.010]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.010]     }
[15:32:07.010]     ...future.result <- base::tryCatch({
[15:32:07.010]         base::withCallingHandlers({
[15:32:07.010]             ...future.value <- base::withVisible(base::local({
[15:32:07.010]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.010]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.010]                   ...future.globals.maxSize)) {
[15:32:07.010]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.010]                   on.exit(options(oopts), add = TRUE)
[15:32:07.010]                 }
[15:32:07.010]                 {
[15:32:07.010]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.010]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.010]                     USE.NAMES = FALSE)
[15:32:07.010]                   do.call(mapply, args = args)
[15:32:07.010]                 }
[15:32:07.010]             }))
[15:32:07.010]             future::FutureResult(value = ...future.value$value, 
[15:32:07.010]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.010]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.010]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.010]                     ...future.globalenv.names))
[15:32:07.010]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.010]         }, condition = base::local({
[15:32:07.010]             c <- base::c
[15:32:07.010]             inherits <- base::inherits
[15:32:07.010]             invokeRestart <- base::invokeRestart
[15:32:07.010]             length <- base::length
[15:32:07.010]             list <- base::list
[15:32:07.010]             seq.int <- base::seq.int
[15:32:07.010]             signalCondition <- base::signalCondition
[15:32:07.010]             sys.calls <- base::sys.calls
[15:32:07.010]             `[[` <- base::`[[`
[15:32:07.010]             `+` <- base::`+`
[15:32:07.010]             `<<-` <- base::`<<-`
[15:32:07.010]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.010]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.010]                   3L)]
[15:32:07.010]             }
[15:32:07.010]             function(cond) {
[15:32:07.010]                 is_error <- inherits(cond, "error")
[15:32:07.010]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.010]                   NULL)
[15:32:07.010]                 if (is_error) {
[15:32:07.010]                   sessionInformation <- function() {
[15:32:07.010]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.010]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.010]                       search = base::search(), system = base::Sys.info())
[15:32:07.010]                   }
[15:32:07.010]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.010]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.010]                     cond$call), session = sessionInformation(), 
[15:32:07.010]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.010]                   signalCondition(cond)
[15:32:07.010]                 }
[15:32:07.010]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.010]                 "immediateCondition"))) {
[15:32:07.010]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.010]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.010]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.010]                   if (TRUE && !signal) {
[15:32:07.010]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.010]                     {
[15:32:07.010]                       inherits <- base::inherits
[15:32:07.010]                       invokeRestart <- base::invokeRestart
[15:32:07.010]                       is.null <- base::is.null
[15:32:07.010]                       muffled <- FALSE
[15:32:07.010]                       if (inherits(cond, "message")) {
[15:32:07.010]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.010]                         if (muffled) 
[15:32:07.010]                           invokeRestart("muffleMessage")
[15:32:07.010]                       }
[15:32:07.010]                       else if (inherits(cond, "warning")) {
[15:32:07.010]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.010]                         if (muffled) 
[15:32:07.010]                           invokeRestart("muffleWarning")
[15:32:07.010]                       }
[15:32:07.010]                       else if (inherits(cond, "condition")) {
[15:32:07.010]                         if (!is.null(pattern)) {
[15:32:07.010]                           computeRestarts <- base::computeRestarts
[15:32:07.010]                           grepl <- base::grepl
[15:32:07.010]                           restarts <- computeRestarts(cond)
[15:32:07.010]                           for (restart in restarts) {
[15:32:07.010]                             name <- restart$name
[15:32:07.010]                             if (is.null(name)) 
[15:32:07.010]                               next
[15:32:07.010]                             if (!grepl(pattern, name)) 
[15:32:07.010]                               next
[15:32:07.010]                             invokeRestart(restart)
[15:32:07.010]                             muffled <- TRUE
[15:32:07.010]                             break
[15:32:07.010]                           }
[15:32:07.010]                         }
[15:32:07.010]                       }
[15:32:07.010]                       invisible(muffled)
[15:32:07.010]                     }
[15:32:07.010]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.010]                   }
[15:32:07.010]                 }
[15:32:07.010]                 else {
[15:32:07.010]                   if (TRUE) {
[15:32:07.010]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.010]                     {
[15:32:07.010]                       inherits <- base::inherits
[15:32:07.010]                       invokeRestart <- base::invokeRestart
[15:32:07.010]                       is.null <- base::is.null
[15:32:07.010]                       muffled <- FALSE
[15:32:07.010]                       if (inherits(cond, "message")) {
[15:32:07.010]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.010]                         if (muffled) 
[15:32:07.010]                           invokeRestart("muffleMessage")
[15:32:07.010]                       }
[15:32:07.010]                       else if (inherits(cond, "warning")) {
[15:32:07.010]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.010]                         if (muffled) 
[15:32:07.010]                           invokeRestart("muffleWarning")
[15:32:07.010]                       }
[15:32:07.010]                       else if (inherits(cond, "condition")) {
[15:32:07.010]                         if (!is.null(pattern)) {
[15:32:07.010]                           computeRestarts <- base::computeRestarts
[15:32:07.010]                           grepl <- base::grepl
[15:32:07.010]                           restarts <- computeRestarts(cond)
[15:32:07.010]                           for (restart in restarts) {
[15:32:07.010]                             name <- restart$name
[15:32:07.010]                             if (is.null(name)) 
[15:32:07.010]                               next
[15:32:07.010]                             if (!grepl(pattern, name)) 
[15:32:07.010]                               next
[15:32:07.010]                             invokeRestart(restart)
[15:32:07.010]                             muffled <- TRUE
[15:32:07.010]                             break
[15:32:07.010]                           }
[15:32:07.010]                         }
[15:32:07.010]                       }
[15:32:07.010]                       invisible(muffled)
[15:32:07.010]                     }
[15:32:07.010]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.010]                   }
[15:32:07.010]                 }
[15:32:07.010]             }
[15:32:07.010]         }))
[15:32:07.010]     }, error = function(ex) {
[15:32:07.010]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.010]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.010]                 ...future.rng), started = ...future.startTime, 
[15:32:07.010]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.010]             version = "1.8"), class = "FutureResult")
[15:32:07.010]     }, finally = {
[15:32:07.010]         if (!identical(...future.workdir, getwd())) 
[15:32:07.010]             setwd(...future.workdir)
[15:32:07.010]         {
[15:32:07.010]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.010]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.010]             }
[15:32:07.010]             base::options(...future.oldOptions)
[15:32:07.010]             if (.Platform$OS.type == "windows") {
[15:32:07.010]                 old_names <- names(...future.oldEnvVars)
[15:32:07.010]                 envs <- base::Sys.getenv()
[15:32:07.010]                 names <- names(envs)
[15:32:07.010]                 common <- intersect(names, old_names)
[15:32:07.010]                 added <- setdiff(names, old_names)
[15:32:07.010]                 removed <- setdiff(old_names, names)
[15:32:07.010]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.010]                   envs[common]]
[15:32:07.010]                 NAMES <- toupper(changed)
[15:32:07.010]                 args <- list()
[15:32:07.010]                 for (kk in seq_along(NAMES)) {
[15:32:07.010]                   name <- changed[[kk]]
[15:32:07.010]                   NAME <- NAMES[[kk]]
[15:32:07.010]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.010]                     next
[15:32:07.010]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.010]                 }
[15:32:07.010]                 NAMES <- toupper(added)
[15:32:07.010]                 for (kk in seq_along(NAMES)) {
[15:32:07.010]                   name <- added[[kk]]
[15:32:07.010]                   NAME <- NAMES[[kk]]
[15:32:07.010]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.010]                     next
[15:32:07.010]                   args[[name]] <- ""
[15:32:07.010]                 }
[15:32:07.010]                 NAMES <- toupper(removed)
[15:32:07.010]                 for (kk in seq_along(NAMES)) {
[15:32:07.010]                   name <- removed[[kk]]
[15:32:07.010]                   NAME <- NAMES[[kk]]
[15:32:07.010]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.010]                     next
[15:32:07.010]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.010]                 }
[15:32:07.010]                 if (length(args) > 0) 
[15:32:07.010]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.010]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.010]             }
[15:32:07.010]             else {
[15:32:07.010]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.010]             }
[15:32:07.010]             {
[15:32:07.010]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.010]                   0L) {
[15:32:07.010]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.010]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.010]                   base::options(opts)
[15:32:07.010]                 }
[15:32:07.010]                 {
[15:32:07.010]                   {
[15:32:07.010]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.010]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.010]                     -253660479L), envir = base::globalenv(), 
[15:32:07.010]                       inherits = FALSE)
[15:32:07.010]                     NULL
[15:32:07.010]                   }
[15:32:07.010]                   options(future.plan = NULL)
[15:32:07.010]                   if (is.na(NA_character_)) 
[15:32:07.010]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.010]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.010]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.010]                     .init = FALSE)
[15:32:07.010]                 }
[15:32:07.010]             }
[15:32:07.010]         }
[15:32:07.010]     })
[15:32:07.010]     if (TRUE) {
[15:32:07.010]         base::sink(type = "output", split = FALSE)
[15:32:07.010]         if (TRUE) {
[15:32:07.010]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.010]         }
[15:32:07.010]         else {
[15:32:07.010]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.010]         }
[15:32:07.010]         base::close(...future.stdout)
[15:32:07.010]         ...future.stdout <- NULL
[15:32:07.010]     }
[15:32:07.010]     ...future.result$conditions <- ...future.conditions
[15:32:07.010]     ...future.result$finished <- base::Sys.time()
[15:32:07.010]     ...future.result
[15:32:07.010] }
[15:32:07.017] assign_globals() ...
[15:32:07.017] List of 5
[15:32:07.017]  $ ...future.FUN            :function (x, y)  
[15:32:07.017]  $ MoreArgs                 : list()
[15:32:07.017]  $ ...future.elements_ii    :List of 2
[15:32:07.017]   ..$ :List of 3
[15:32:07.017]   .. ..$ a: num 1
[15:32:07.017]   .. ..$ b: num 2
[15:32:07.017]   .. ..$ c: num 3
[15:32:07.017]   ..$ :List of 3
[15:32:07.017]   .. ..$ A: num 10
[15:32:07.017]   .. ..$ B: num 0
[15:32:07.017]   .. ..$ C: num -10
[15:32:07.017]  $ ...future.seeds_ii       : NULL
[15:32:07.017]  $ ...future.globals.maxSize: NULL
[15:32:07.017]  - attr(*, "where")=List of 5
[15:32:07.017]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.017]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.017]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.017]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.017]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.017]  - attr(*, "resolved")= logi FALSE
[15:32:07.017]  - attr(*, "total_size")= num 2312
[15:32:07.017]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.017]  - attr(*, "already-done")= logi TRUE
[15:32:07.035] - reassign environment for '...future.FUN'
[15:32:07.035] - copied '...future.FUN' to environment
[15:32:07.036] - copied 'MoreArgs' to environment
[15:32:07.036] - copied '...future.elements_ii' to environment
[15:32:07.036] - copied '...future.seeds_ii' to environment
[15:32:07.036] - copied '...future.globals.maxSize' to environment
[15:32:07.037] assign_globals() ... done
[15:32:07.037] plan(): Setting new future strategy stack:
[15:32:07.038] List of future strategies:
[15:32:07.038] 1. sequential:
[15:32:07.038]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.038]    - tweaked: FALSE
[15:32:07.038]    - call: NULL
[15:32:07.039] plan(): nbrOfWorkers() = 1
[15:32:07.041] plan(): Setting new future strategy stack:
[15:32:07.041] List of future strategies:
[15:32:07.041] 1. sequential:
[15:32:07.041]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.041]    - tweaked: FALSE
[15:32:07.041]    - call: plan(strategy)
[15:32:07.042] plan(): nbrOfWorkers() = 1
[15:32:07.042] SequentialFuture started (and completed)
[15:32:07.043] - Launch lazy future ... done
[15:32:07.043] run() for 'SequentialFuture' ... done
[15:32:07.043] Created future:
[15:32:07.044] SequentialFuture:
[15:32:07.044] Label: 'future_.mapply-1'
[15:32:07.044] Expression:
[15:32:07.044] {
[15:32:07.044]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.044]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.044]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.044]         on.exit(options(oopts), add = TRUE)
[15:32:07.044]     }
[15:32:07.044]     {
[15:32:07.044]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.044]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.044]         do.call(mapply, args = args)
[15:32:07.044]     }
[15:32:07.044] }
[15:32:07.044] Lazy evaluation: FALSE
[15:32:07.044] Asynchronous evaluation: FALSE
[15:32:07.044] Local evaluation: TRUE
[15:32:07.044] Environment: R_GlobalEnv
[15:32:07.044] Capture standard output: TRUE
[15:32:07.044] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.044] Globals: 5 objects totaling 2.26 KiB (function '...future.FUN' of 1.93 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.044] Packages: <none>
[15:32:07.044] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.044] Resolved: TRUE
[15:32:07.044] Value: 200 bytes of class 'list'
[15:32:07.044] Early signaling: FALSE
[15:32:07.044] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.044] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.045] Chunk #1 of 1 ... DONE
[15:32:07.045] Launching 1 futures (chunks) ... DONE
[15:32:07.045] Resolving 1 futures (chunks) ...
[15:32:07.046] resolve() on list ...
[15:32:07.046]  recursive: 0
[15:32:07.046]  length: 1
[15:32:07.046] 
[15:32:07.047] resolved() for 'SequentialFuture' ...
[15:32:07.047] - state: 'finished'
[15:32:07.047] - run: TRUE
[15:32:07.048] - result: 'FutureResult'
[15:32:07.048] resolved() for 'SequentialFuture' ... done
[15:32:07.048] Future #1
[15:32:07.049] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.049] - nx: 1
[15:32:07.049] - relay: TRUE
[15:32:07.049] - stdout: TRUE
[15:32:07.050] - signal: TRUE
[15:32:07.050] - resignal: FALSE
[15:32:07.050] - force: TRUE
[15:32:07.050] - relayed: [n=1] FALSE
[15:32:07.050] - queued futures: [n=1] FALSE
[15:32:07.051]  - until=1
[15:32:07.051]  - relaying element #1
[15:32:07.051] - relayed: [n=1] TRUE
[15:32:07.051] - queued futures: [n=1] TRUE
[15:32:07.052] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.052]  length: 0 (resolved future 1)
[15:32:07.052] Relaying remaining futures
[15:32:07.052] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.052] - nx: 1
[15:32:07.052] - relay: TRUE
[15:32:07.053] - stdout: TRUE
[15:32:07.053] - signal: TRUE
[15:32:07.053] - resignal: FALSE
[15:32:07.053] - force: TRUE
[15:32:07.053] - relayed: [n=1] TRUE
[15:32:07.054] - queued futures: [n=1] TRUE
 - flush all
[15:32:07.054] - relayed: [n=1] TRUE
[15:32:07.054] - queued futures: [n=1] TRUE
[15:32:07.054] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.054] resolve() on list ... DONE
[15:32:07.055]  - Number of value chunks collected: 1
[15:32:07.055] Resolving 1 futures (chunks) ... DONE
[15:32:07.055] Reducing values from 1 chunks ...
[15:32:07.055]  - Number of values collected after concatenation: 3
[15:32:07.055]  - Number of values expected: 3
[15:32:07.056] Reducing values from 1 chunks ... DONE
[15:32:07.056] future_mapply() ... DONE
[15:32:07.056] future_mapply() ...
[15:32:07.058] Number of chunks: 5
[15:32:07.058] getGlobalsAndPackagesXApply() ...
[15:32:07.059]  - future.globals: TRUE
[15:32:07.059] getGlobalsAndPackages() ...
[15:32:07.059] Searching for globals...
[15:32:07.061] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:07.061] Searching for globals ... DONE
[15:32:07.061] Resolving globals: FALSE
[15:32:07.062] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:07.062] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:07.063] - globals: [1] 'FUN'
[15:32:07.063] 
[15:32:07.063] getGlobalsAndPackages() ... DONE
[15:32:07.064]  - globals found/used: [n=1] 'FUN'
[15:32:07.064]  - needed namespaces: [n=0] 
[15:32:07.064] Finding globals ... DONE
[15:32:07.065] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.065] List of 2
[15:32:07.065]  $ ...future.FUN:function (C, k)  
[15:32:07.065]  $ MoreArgs     : NULL
[15:32:07.065]  - attr(*, "where")=List of 2
[15:32:07.065]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.065]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.065]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.065]  - attr(*, "resolved")= logi FALSE
[15:32:07.065]  - attr(*, "total_size")= num NA
[15:32:07.073] Packages to be attached in all futures: [n=0] 
[15:32:07.073] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.074] Number of futures (= number of chunks): 5
[15:32:07.074] Launching 5 futures (chunks) ...
[15:32:07.074] Chunk #1 of 5 ...
[15:32:07.075]  - Finding globals in '...' for chunk #1 ...
[15:32:07.075] getGlobalsAndPackages() ...
[15:32:07.075] Searching for globals...
[15:32:07.076] 
[15:32:07.076] Searching for globals ... DONE
[15:32:07.077] - globals: [0] <none>
[15:32:07.077] getGlobalsAndPackages() ... DONE
[15:32:07.077]    + additional globals found: [n=0] 
[15:32:07.078]    + additional namespaces needed: [n=0] 
[15:32:07.078]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.078]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:07.078]  - seeds: <none>
[15:32:07.079]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.079] getGlobalsAndPackages() ...
[15:32:07.079] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.080] Resolving globals: FALSE
[15:32:07.081] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:07.081] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.082] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.082] 
[15:32:07.082] getGlobalsAndPackages() ... DONE
[15:32:07.083] run() for 'Future' ...
[15:32:07.083] - state: 'created'
[15:32:07.083] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.084] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.084] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.084]   - Field: 'label'
[15:32:07.085]   - Field: 'local'
[15:32:07.085]   - Field: 'owner'
[15:32:07.085]   - Field: 'envir'
[15:32:07.085]   - Field: 'packages'
[15:32:07.085]   - Field: 'gc'
[15:32:07.086]   - Field: 'conditions'
[15:32:07.086]   - Field: 'expr'
[15:32:07.086]   - Field: 'uuid'
[15:32:07.086]   - Field: 'seed'
[15:32:07.086]   - Field: 'version'
[15:32:07.087]   - Field: 'result'
[15:32:07.087]   - Field: 'asynchronous'
[15:32:07.087]   - Field: 'calls'
[15:32:07.087]   - Field: 'globals'
[15:32:07.087]   - Field: 'stdout'
[15:32:07.087]   - Field: 'earlySignal'
[15:32:07.088]   - Field: 'lazy'
[15:32:07.088]   - Field: 'state'
[15:32:07.088] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.088] - Launch lazy future ...
[15:32:07.089] Packages needed by the future expression (n = 0): <none>
[15:32:07.089] Packages needed by future strategies (n = 0): <none>
[15:32:07.090] {
[15:32:07.090]     {
[15:32:07.090]         {
[15:32:07.090]             ...future.startTime <- base::Sys.time()
[15:32:07.090]             {
[15:32:07.090]                 {
[15:32:07.090]                   {
[15:32:07.090]                     base::local({
[15:32:07.090]                       has_future <- base::requireNamespace("future", 
[15:32:07.090]                         quietly = TRUE)
[15:32:07.090]                       if (has_future) {
[15:32:07.090]                         ns <- base::getNamespace("future")
[15:32:07.090]                         version <- ns[[".package"]][["version"]]
[15:32:07.090]                         if (is.null(version)) 
[15:32:07.090]                           version <- utils::packageVersion("future")
[15:32:07.090]                       }
[15:32:07.090]                       else {
[15:32:07.090]                         version <- NULL
[15:32:07.090]                       }
[15:32:07.090]                       if (!has_future || version < "1.8.0") {
[15:32:07.090]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.090]                           "", base::R.version$version.string), 
[15:32:07.090]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.090]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.090]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.090]                             "release", "version")], collapse = " "), 
[15:32:07.090]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.090]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.090]                           info)
[15:32:07.090]                         info <- base::paste(info, collapse = "; ")
[15:32:07.090]                         if (!has_future) {
[15:32:07.090]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.090]                             info)
[15:32:07.090]                         }
[15:32:07.090]                         else {
[15:32:07.090]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.090]                             info, version)
[15:32:07.090]                         }
[15:32:07.090]                         base::stop(msg)
[15:32:07.090]                       }
[15:32:07.090]                     })
[15:32:07.090]                   }
[15:32:07.090]                   ...future.strategy.old <- future::plan("list")
[15:32:07.090]                   options(future.plan = NULL)
[15:32:07.090]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.090]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.090]                 }
[15:32:07.090]                 ...future.workdir <- getwd()
[15:32:07.090]             }
[15:32:07.090]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.090]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.090]         }
[15:32:07.090]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.090]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:07.090]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.090]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.090]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.090]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.090]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.090]             base::names(...future.oldOptions))
[15:32:07.090]     }
[15:32:07.090]     if (FALSE) {
[15:32:07.090]     }
[15:32:07.090]     else {
[15:32:07.090]         if (TRUE) {
[15:32:07.090]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.090]                 open = "w")
[15:32:07.090]         }
[15:32:07.090]         else {
[15:32:07.090]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.090]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.090]         }
[15:32:07.090]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.090]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.090]             base::sink(type = "output", split = FALSE)
[15:32:07.090]             base::close(...future.stdout)
[15:32:07.090]         }, add = TRUE)
[15:32:07.090]     }
[15:32:07.090]     ...future.frame <- base::sys.nframe()
[15:32:07.090]     ...future.conditions <- base::list()
[15:32:07.090]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.090]     if (FALSE) {
[15:32:07.090]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.090]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.090]     }
[15:32:07.090]     ...future.result <- base::tryCatch({
[15:32:07.090]         base::withCallingHandlers({
[15:32:07.090]             ...future.value <- base::withVisible(base::local({
[15:32:07.090]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.090]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.090]                   ...future.globals.maxSize)) {
[15:32:07.090]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.090]                   on.exit(options(oopts), add = TRUE)
[15:32:07.090]                 }
[15:32:07.090]                 {
[15:32:07.090]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.090]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.090]                     USE.NAMES = FALSE)
[15:32:07.090]                   do.call(mapply, args = args)
[15:32:07.090]                 }
[15:32:07.090]             }))
[15:32:07.090]             future::FutureResult(value = ...future.value$value, 
[15:32:07.090]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.090]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.090]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.090]                     ...future.globalenv.names))
[15:32:07.090]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.090]         }, condition = base::local({
[15:32:07.090]             c <- base::c
[15:32:07.090]             inherits <- base::inherits
[15:32:07.090]             invokeRestart <- base::invokeRestart
[15:32:07.090]             length <- base::length
[15:32:07.090]             list <- base::list
[15:32:07.090]             seq.int <- base::seq.int
[15:32:07.090]             signalCondition <- base::signalCondition
[15:32:07.090]             sys.calls <- base::sys.calls
[15:32:07.090]             `[[` <- base::`[[`
[15:32:07.090]             `+` <- base::`+`
[15:32:07.090]             `<<-` <- base::`<<-`
[15:32:07.090]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.090]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.090]                   3L)]
[15:32:07.090]             }
[15:32:07.090]             function(cond) {
[15:32:07.090]                 is_error <- inherits(cond, "error")
[15:32:07.090]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.090]                   NULL)
[15:32:07.090]                 if (is_error) {
[15:32:07.090]                   sessionInformation <- function() {
[15:32:07.090]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.090]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.090]                       search = base::search(), system = base::Sys.info())
[15:32:07.090]                   }
[15:32:07.090]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.090]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.090]                     cond$call), session = sessionInformation(), 
[15:32:07.090]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.090]                   signalCondition(cond)
[15:32:07.090]                 }
[15:32:07.090]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.090]                 "immediateCondition"))) {
[15:32:07.090]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.090]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.090]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.090]                   if (TRUE && !signal) {
[15:32:07.090]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.090]                     {
[15:32:07.090]                       inherits <- base::inherits
[15:32:07.090]                       invokeRestart <- base::invokeRestart
[15:32:07.090]                       is.null <- base::is.null
[15:32:07.090]                       muffled <- FALSE
[15:32:07.090]                       if (inherits(cond, "message")) {
[15:32:07.090]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.090]                         if (muffled) 
[15:32:07.090]                           invokeRestart("muffleMessage")
[15:32:07.090]                       }
[15:32:07.090]                       else if (inherits(cond, "warning")) {
[15:32:07.090]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.090]                         if (muffled) 
[15:32:07.090]                           invokeRestart("muffleWarning")
[15:32:07.090]                       }
[15:32:07.090]                       else if (inherits(cond, "condition")) {
[15:32:07.090]                         if (!is.null(pattern)) {
[15:32:07.090]                           computeRestarts <- base::computeRestarts
[15:32:07.090]                           grepl <- base::grepl
[15:32:07.090]                           restarts <- computeRestarts(cond)
[15:32:07.090]                           for (restart in restarts) {
[15:32:07.090]                             name <- restart$name
[15:32:07.090]                             if (is.null(name)) 
[15:32:07.090]                               next
[15:32:07.090]                             if (!grepl(pattern, name)) 
[15:32:07.090]                               next
[15:32:07.090]                             invokeRestart(restart)
[15:32:07.090]                             muffled <- TRUE
[15:32:07.090]                             break
[15:32:07.090]                           }
[15:32:07.090]                         }
[15:32:07.090]                       }
[15:32:07.090]                       invisible(muffled)
[15:32:07.090]                     }
[15:32:07.090]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.090]                   }
[15:32:07.090]                 }
[15:32:07.090]                 else {
[15:32:07.090]                   if (TRUE) {
[15:32:07.090]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.090]                     {
[15:32:07.090]                       inherits <- base::inherits
[15:32:07.090]                       invokeRestart <- base::invokeRestart
[15:32:07.090]                       is.null <- base::is.null
[15:32:07.090]                       muffled <- FALSE
[15:32:07.090]                       if (inherits(cond, "message")) {
[15:32:07.090]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.090]                         if (muffled) 
[15:32:07.090]                           invokeRestart("muffleMessage")
[15:32:07.090]                       }
[15:32:07.090]                       else if (inherits(cond, "warning")) {
[15:32:07.090]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.090]                         if (muffled) 
[15:32:07.090]                           invokeRestart("muffleWarning")
[15:32:07.090]                       }
[15:32:07.090]                       else if (inherits(cond, "condition")) {
[15:32:07.090]                         if (!is.null(pattern)) {
[15:32:07.090]                           computeRestarts <- base::computeRestarts
[15:32:07.090]                           grepl <- base::grepl
[15:32:07.090]                           restarts <- computeRestarts(cond)
[15:32:07.090]                           for (restart in restarts) {
[15:32:07.090]                             name <- restart$name
[15:32:07.090]                             if (is.null(name)) 
[15:32:07.090]                               next
[15:32:07.090]                             if (!grepl(pattern, name)) 
[15:32:07.090]                               next
[15:32:07.090]                             invokeRestart(restart)
[15:32:07.090]                             muffled <- TRUE
[15:32:07.090]                             break
[15:32:07.090]                           }
[15:32:07.090]                         }
[15:32:07.090]                       }
[15:32:07.090]                       invisible(muffled)
[15:32:07.090]                     }
[15:32:07.090]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.090]                   }
[15:32:07.090]                 }
[15:32:07.090]             }
[15:32:07.090]         }))
[15:32:07.090]     }, error = function(ex) {
[15:32:07.090]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.090]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.090]                 ...future.rng), started = ...future.startTime, 
[15:32:07.090]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.090]             version = "1.8"), class = "FutureResult")
[15:32:07.090]     }, finally = {
[15:32:07.090]         if (!identical(...future.workdir, getwd())) 
[15:32:07.090]             setwd(...future.workdir)
[15:32:07.090]         {
[15:32:07.090]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.090]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.090]             }
[15:32:07.090]             base::options(...future.oldOptions)
[15:32:07.090]             if (.Platform$OS.type == "windows") {
[15:32:07.090]                 old_names <- names(...future.oldEnvVars)
[15:32:07.090]                 envs <- base::Sys.getenv()
[15:32:07.090]                 names <- names(envs)
[15:32:07.090]                 common <- intersect(names, old_names)
[15:32:07.090]                 added <- setdiff(names, old_names)
[15:32:07.090]                 removed <- setdiff(old_names, names)
[15:32:07.090]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.090]                   envs[common]]
[15:32:07.090]                 NAMES <- toupper(changed)
[15:32:07.090]                 args <- list()
[15:32:07.090]                 for (kk in seq_along(NAMES)) {
[15:32:07.090]                   name <- changed[[kk]]
[15:32:07.090]                   NAME <- NAMES[[kk]]
[15:32:07.090]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.090]                     next
[15:32:07.090]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.090]                 }
[15:32:07.090]                 NAMES <- toupper(added)
[15:32:07.090]                 for (kk in seq_along(NAMES)) {
[15:32:07.090]                   name <- added[[kk]]
[15:32:07.090]                   NAME <- NAMES[[kk]]
[15:32:07.090]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.090]                     next
[15:32:07.090]                   args[[name]] <- ""
[15:32:07.090]                 }
[15:32:07.090]                 NAMES <- toupper(removed)
[15:32:07.090]                 for (kk in seq_along(NAMES)) {
[15:32:07.090]                   name <- removed[[kk]]
[15:32:07.090]                   NAME <- NAMES[[kk]]
[15:32:07.090]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.090]                     next
[15:32:07.090]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.090]                 }
[15:32:07.090]                 if (length(args) > 0) 
[15:32:07.090]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.090]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.090]             }
[15:32:07.090]             else {
[15:32:07.090]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.090]             }
[15:32:07.090]             {
[15:32:07.090]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.090]                   0L) {
[15:32:07.090]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.090]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.090]                   base::options(opts)
[15:32:07.090]                 }
[15:32:07.090]                 {
[15:32:07.090]                   {
[15:32:07.090]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.090]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.090]                     -253660479L), envir = base::globalenv(), 
[15:32:07.090]                       inherits = FALSE)
[15:32:07.090]                     NULL
[15:32:07.090]                   }
[15:32:07.090]                   options(future.plan = NULL)
[15:32:07.090]                   if (is.na(NA_character_)) 
[15:32:07.090]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.090]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.090]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.090]                     .init = FALSE)
[15:32:07.090]                 }
[15:32:07.090]             }
[15:32:07.090]         }
[15:32:07.090]     })
[15:32:07.090]     if (TRUE) {
[15:32:07.090]         base::sink(type = "output", split = FALSE)
[15:32:07.090]         if (TRUE) {
[15:32:07.090]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.090]         }
[15:32:07.090]         else {
[15:32:07.090]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.090]         }
[15:32:07.090]         base::close(...future.stdout)
[15:32:07.090]         ...future.stdout <- NULL
[15:32:07.090]     }
[15:32:07.090]     ...future.result$conditions <- ...future.conditions
[15:32:07.090]     ...future.result$finished <- base::Sys.time()
[15:32:07.090]     ...future.result
[15:32:07.090] }
[15:32:07.096] assign_globals() ...
[15:32:07.096] List of 5
[15:32:07.096]  $ ...future.FUN            :function (C, k)  
[15:32:07.096]  $ MoreArgs                 : NULL
[15:32:07.096]  $ ...future.elements_ii    :List of 2
[15:32:07.096]   ..$ :List of 1
[15:32:07.096]   .. ..$ : chr "A"
[15:32:07.096]   ..$ :List of 1
[15:32:07.096]   .. ..$ : int 5
[15:32:07.096]  $ ...future.seeds_ii       : NULL
[15:32:07.096]  $ ...future.globals.maxSize: NULL
[15:32:07.096]  - attr(*, "where")=List of 5
[15:32:07.096]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.096]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.096]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.096]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.096]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.096]  - attr(*, "resolved")= logi FALSE
[15:32:07.096]  - attr(*, "total_size")= num 3488
[15:32:07.096]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.096]  - attr(*, "already-done")= logi TRUE
[15:32:07.106] - reassign environment for '...future.FUN'
[15:32:07.107] - copied '...future.FUN' to environment
[15:32:07.107] - copied 'MoreArgs' to environment
[15:32:07.107] - copied '...future.elements_ii' to environment
[15:32:07.107] - copied '...future.seeds_ii' to environment
[15:32:07.108] - copied '...future.globals.maxSize' to environment
[15:32:07.108] assign_globals() ... done
[15:32:07.109] plan(): Setting new future strategy stack:
[15:32:07.109] List of future strategies:
[15:32:07.109] 1. sequential:
[15:32:07.109]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.109]    - tweaked: FALSE
[15:32:07.109]    - call: NULL
[15:32:07.110] plan(): nbrOfWorkers() = 1
[15:32:07.113] plan(): Setting new future strategy stack:
[15:32:07.113] List of future strategies:
[15:32:07.113] 1. sequential:
[15:32:07.113]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.113]    - tweaked: FALSE
[15:32:07.113]    - call: plan(strategy)
[15:32:07.114] plan(): nbrOfWorkers() = 1
[15:32:07.117] SequentialFuture started (and completed)
[15:32:07.117] - Launch lazy future ... done
[15:32:07.117] run() for 'SequentialFuture' ... done
[15:32:07.118] Created future:
[15:32:07.118] SequentialFuture:
[15:32:07.118] Label: 'future_mapply-1'
[15:32:07.118] Expression:
[15:32:07.118] {
[15:32:07.118]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.118]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.118]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.118]         on.exit(options(oopts), add = TRUE)
[15:32:07.118]     }
[15:32:07.118]     {
[15:32:07.118]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.118]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.118]         do.call(mapply, args = args)
[15:32:07.118]     }
[15:32:07.118] }
[15:32:07.118] Lazy evaluation: FALSE
[15:32:07.118] Asynchronous evaluation: FALSE
[15:32:07.118] Local evaluation: TRUE
[15:32:07.118] Environment: R_GlobalEnv
[15:32:07.118] Capture standard output: TRUE
[15:32:07.118] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.118] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.118] Packages: <none>
[15:32:07.118] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.118] Resolved: TRUE
[15:32:07.118] Value: 112 bytes of class 'list'
[15:32:07.118] Early signaling: FALSE
[15:32:07.118] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.118] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.120] Chunk #1 of 5 ... DONE
[15:32:07.120] Chunk #2 of 5 ...
[15:32:07.121]  - Finding globals in '...' for chunk #2 ...
[15:32:07.121] getGlobalsAndPackages() ...
[15:32:07.121] Searching for globals...
[15:32:07.122] 
[15:32:07.123] Searching for globals ... DONE
[15:32:07.123] - globals: [0] <none>
[15:32:07.123] getGlobalsAndPackages() ... DONE
[15:32:07.123]    + additional globals found: [n=0] 
[15:32:07.124]    + additional namespaces needed: [n=0] 
[15:32:07.124]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:07.124]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:07.125]  - seeds: <none>
[15:32:07.125]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.125] getGlobalsAndPackages() ...
[15:32:07.125] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.126] Resolving globals: FALSE
[15:32:07.127] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:07.127] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.128] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.128] 
[15:32:07.128] getGlobalsAndPackages() ... DONE
[15:32:07.129] run() for 'Future' ...
[15:32:07.130] - state: 'created'
[15:32:07.130] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.131] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.132] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.132]   - Field: 'label'
[15:32:07.132]   - Field: 'local'
[15:32:07.133]   - Field: 'owner'
[15:32:07.133]   - Field: 'envir'
[15:32:07.133]   - Field: 'packages'
[15:32:07.134]   - Field: 'gc'
[15:32:07.134]   - Field: 'conditions'
[15:32:07.134]   - Field: 'expr'
[15:32:07.135]   - Field: 'uuid'
[15:32:07.135]   - Field: 'seed'
[15:32:07.135]   - Field: 'version'
[15:32:07.136]   - Field: 'result'
[15:32:07.136]   - Field: 'asynchronous'
[15:32:07.136]   - Field: 'calls'
[15:32:07.137]   - Field: 'globals'
[15:32:07.137]   - Field: 'stdout'
[15:32:07.137]   - Field: 'earlySignal'
[15:32:07.137]   - Field: 'lazy'
[15:32:07.138]   - Field: 'state'
[15:32:07.138] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.139] - Launch lazy future ...
[15:32:07.139] Packages needed by the future expression (n = 0): <none>
[15:32:07.139] Packages needed by future strategies (n = 0): <none>
[15:32:07.141] {
[15:32:07.141]     {
[15:32:07.141]         {
[15:32:07.141]             ...future.startTime <- base::Sys.time()
[15:32:07.141]             {
[15:32:07.141]                 {
[15:32:07.141]                   {
[15:32:07.141]                     base::local({
[15:32:07.141]                       has_future <- base::requireNamespace("future", 
[15:32:07.141]                         quietly = TRUE)
[15:32:07.141]                       if (has_future) {
[15:32:07.141]                         ns <- base::getNamespace("future")
[15:32:07.141]                         version <- ns[[".package"]][["version"]]
[15:32:07.141]                         if (is.null(version)) 
[15:32:07.141]                           version <- utils::packageVersion("future")
[15:32:07.141]                       }
[15:32:07.141]                       else {
[15:32:07.141]                         version <- NULL
[15:32:07.141]                       }
[15:32:07.141]                       if (!has_future || version < "1.8.0") {
[15:32:07.141]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.141]                           "", base::R.version$version.string), 
[15:32:07.141]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.141]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.141]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.141]                             "release", "version")], collapse = " "), 
[15:32:07.141]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.141]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.141]                           info)
[15:32:07.141]                         info <- base::paste(info, collapse = "; ")
[15:32:07.141]                         if (!has_future) {
[15:32:07.141]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.141]                             info)
[15:32:07.141]                         }
[15:32:07.141]                         else {
[15:32:07.141]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.141]                             info, version)
[15:32:07.141]                         }
[15:32:07.141]                         base::stop(msg)
[15:32:07.141]                       }
[15:32:07.141]                     })
[15:32:07.141]                   }
[15:32:07.141]                   ...future.strategy.old <- future::plan("list")
[15:32:07.141]                   options(future.plan = NULL)
[15:32:07.141]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.141]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.141]                 }
[15:32:07.141]                 ...future.workdir <- getwd()
[15:32:07.141]             }
[15:32:07.141]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.141]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.141]         }
[15:32:07.141]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.141]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:07.141]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.141]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.141]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.141]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.141]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.141]             base::names(...future.oldOptions))
[15:32:07.141]     }
[15:32:07.141]     if (FALSE) {
[15:32:07.141]     }
[15:32:07.141]     else {
[15:32:07.141]         if (TRUE) {
[15:32:07.141]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.141]                 open = "w")
[15:32:07.141]         }
[15:32:07.141]         else {
[15:32:07.141]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.141]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.141]         }
[15:32:07.141]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.141]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.141]             base::sink(type = "output", split = FALSE)
[15:32:07.141]             base::close(...future.stdout)
[15:32:07.141]         }, add = TRUE)
[15:32:07.141]     }
[15:32:07.141]     ...future.frame <- base::sys.nframe()
[15:32:07.141]     ...future.conditions <- base::list()
[15:32:07.141]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.141]     if (FALSE) {
[15:32:07.141]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.141]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.141]     }
[15:32:07.141]     ...future.result <- base::tryCatch({
[15:32:07.141]         base::withCallingHandlers({
[15:32:07.141]             ...future.value <- base::withVisible(base::local({
[15:32:07.141]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.141]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.141]                   ...future.globals.maxSize)) {
[15:32:07.141]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.141]                   on.exit(options(oopts), add = TRUE)
[15:32:07.141]                 }
[15:32:07.141]                 {
[15:32:07.141]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.141]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.141]                     USE.NAMES = FALSE)
[15:32:07.141]                   do.call(mapply, args = args)
[15:32:07.141]                 }
[15:32:07.141]             }))
[15:32:07.141]             future::FutureResult(value = ...future.value$value, 
[15:32:07.141]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.141]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.141]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.141]                     ...future.globalenv.names))
[15:32:07.141]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.141]         }, condition = base::local({
[15:32:07.141]             c <- base::c
[15:32:07.141]             inherits <- base::inherits
[15:32:07.141]             invokeRestart <- base::invokeRestart
[15:32:07.141]             length <- base::length
[15:32:07.141]             list <- base::list
[15:32:07.141]             seq.int <- base::seq.int
[15:32:07.141]             signalCondition <- base::signalCondition
[15:32:07.141]             sys.calls <- base::sys.calls
[15:32:07.141]             `[[` <- base::`[[`
[15:32:07.141]             `+` <- base::`+`
[15:32:07.141]             `<<-` <- base::`<<-`
[15:32:07.141]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.141]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.141]                   3L)]
[15:32:07.141]             }
[15:32:07.141]             function(cond) {
[15:32:07.141]                 is_error <- inherits(cond, "error")
[15:32:07.141]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.141]                   NULL)
[15:32:07.141]                 if (is_error) {
[15:32:07.141]                   sessionInformation <- function() {
[15:32:07.141]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.141]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.141]                       search = base::search(), system = base::Sys.info())
[15:32:07.141]                   }
[15:32:07.141]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.141]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.141]                     cond$call), session = sessionInformation(), 
[15:32:07.141]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.141]                   signalCondition(cond)
[15:32:07.141]                 }
[15:32:07.141]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.141]                 "immediateCondition"))) {
[15:32:07.141]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.141]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.141]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.141]                   if (TRUE && !signal) {
[15:32:07.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.141]                     {
[15:32:07.141]                       inherits <- base::inherits
[15:32:07.141]                       invokeRestart <- base::invokeRestart
[15:32:07.141]                       is.null <- base::is.null
[15:32:07.141]                       muffled <- FALSE
[15:32:07.141]                       if (inherits(cond, "message")) {
[15:32:07.141]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.141]                         if (muffled) 
[15:32:07.141]                           invokeRestart("muffleMessage")
[15:32:07.141]                       }
[15:32:07.141]                       else if (inherits(cond, "warning")) {
[15:32:07.141]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.141]                         if (muffled) 
[15:32:07.141]                           invokeRestart("muffleWarning")
[15:32:07.141]                       }
[15:32:07.141]                       else if (inherits(cond, "condition")) {
[15:32:07.141]                         if (!is.null(pattern)) {
[15:32:07.141]                           computeRestarts <- base::computeRestarts
[15:32:07.141]                           grepl <- base::grepl
[15:32:07.141]                           restarts <- computeRestarts(cond)
[15:32:07.141]                           for (restart in restarts) {
[15:32:07.141]                             name <- restart$name
[15:32:07.141]                             if (is.null(name)) 
[15:32:07.141]                               next
[15:32:07.141]                             if (!grepl(pattern, name)) 
[15:32:07.141]                               next
[15:32:07.141]                             invokeRestart(restart)
[15:32:07.141]                             muffled <- TRUE
[15:32:07.141]                             break
[15:32:07.141]                           }
[15:32:07.141]                         }
[15:32:07.141]                       }
[15:32:07.141]                       invisible(muffled)
[15:32:07.141]                     }
[15:32:07.141]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.141]                   }
[15:32:07.141]                 }
[15:32:07.141]                 else {
[15:32:07.141]                   if (TRUE) {
[15:32:07.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.141]                     {
[15:32:07.141]                       inherits <- base::inherits
[15:32:07.141]                       invokeRestart <- base::invokeRestart
[15:32:07.141]                       is.null <- base::is.null
[15:32:07.141]                       muffled <- FALSE
[15:32:07.141]                       if (inherits(cond, "message")) {
[15:32:07.141]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.141]                         if (muffled) 
[15:32:07.141]                           invokeRestart("muffleMessage")
[15:32:07.141]                       }
[15:32:07.141]                       else if (inherits(cond, "warning")) {
[15:32:07.141]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.141]                         if (muffled) 
[15:32:07.141]                           invokeRestart("muffleWarning")
[15:32:07.141]                       }
[15:32:07.141]                       else if (inherits(cond, "condition")) {
[15:32:07.141]                         if (!is.null(pattern)) {
[15:32:07.141]                           computeRestarts <- base::computeRestarts
[15:32:07.141]                           grepl <- base::grepl
[15:32:07.141]                           restarts <- computeRestarts(cond)
[15:32:07.141]                           for (restart in restarts) {
[15:32:07.141]                             name <- restart$name
[15:32:07.141]                             if (is.null(name)) 
[15:32:07.141]                               next
[15:32:07.141]                             if (!grepl(pattern, name)) 
[15:32:07.141]                               next
[15:32:07.141]                             invokeRestart(restart)
[15:32:07.141]                             muffled <- TRUE
[15:32:07.141]                             break
[15:32:07.141]                           }
[15:32:07.141]                         }
[15:32:07.141]                       }
[15:32:07.141]                       invisible(muffled)
[15:32:07.141]                     }
[15:32:07.141]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.141]                   }
[15:32:07.141]                 }
[15:32:07.141]             }
[15:32:07.141]         }))
[15:32:07.141]     }, error = function(ex) {
[15:32:07.141]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.141]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.141]                 ...future.rng), started = ...future.startTime, 
[15:32:07.141]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.141]             version = "1.8"), class = "FutureResult")
[15:32:07.141]     }, finally = {
[15:32:07.141]         if (!identical(...future.workdir, getwd())) 
[15:32:07.141]             setwd(...future.workdir)
[15:32:07.141]         {
[15:32:07.141]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.141]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.141]             }
[15:32:07.141]             base::options(...future.oldOptions)
[15:32:07.141]             if (.Platform$OS.type == "windows") {
[15:32:07.141]                 old_names <- names(...future.oldEnvVars)
[15:32:07.141]                 envs <- base::Sys.getenv()
[15:32:07.141]                 names <- names(envs)
[15:32:07.141]                 common <- intersect(names, old_names)
[15:32:07.141]                 added <- setdiff(names, old_names)
[15:32:07.141]                 removed <- setdiff(old_names, names)
[15:32:07.141]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.141]                   envs[common]]
[15:32:07.141]                 NAMES <- toupper(changed)
[15:32:07.141]                 args <- list()
[15:32:07.141]                 for (kk in seq_along(NAMES)) {
[15:32:07.141]                   name <- changed[[kk]]
[15:32:07.141]                   NAME <- NAMES[[kk]]
[15:32:07.141]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.141]                     next
[15:32:07.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.141]                 }
[15:32:07.141]                 NAMES <- toupper(added)
[15:32:07.141]                 for (kk in seq_along(NAMES)) {
[15:32:07.141]                   name <- added[[kk]]
[15:32:07.141]                   NAME <- NAMES[[kk]]
[15:32:07.141]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.141]                     next
[15:32:07.141]                   args[[name]] <- ""
[15:32:07.141]                 }
[15:32:07.141]                 NAMES <- toupper(removed)
[15:32:07.141]                 for (kk in seq_along(NAMES)) {
[15:32:07.141]                   name <- removed[[kk]]
[15:32:07.141]                   NAME <- NAMES[[kk]]
[15:32:07.141]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.141]                     next
[15:32:07.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.141]                 }
[15:32:07.141]                 if (length(args) > 0) 
[15:32:07.141]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.141]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.141]             }
[15:32:07.141]             else {
[15:32:07.141]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.141]             }
[15:32:07.141]             {
[15:32:07.141]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.141]                   0L) {
[15:32:07.141]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.141]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.141]                   base::options(opts)
[15:32:07.141]                 }
[15:32:07.141]                 {
[15:32:07.141]                   {
[15:32:07.141]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.141]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.141]                     -253660479L), envir = base::globalenv(), 
[15:32:07.141]                       inherits = FALSE)
[15:32:07.141]                     NULL
[15:32:07.141]                   }
[15:32:07.141]                   options(future.plan = NULL)
[15:32:07.141]                   if (is.na(NA_character_)) 
[15:32:07.141]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.141]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.141]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.141]                     .init = FALSE)
[15:32:07.141]                 }
[15:32:07.141]             }
[15:32:07.141]         }
[15:32:07.141]     })
[15:32:07.141]     if (TRUE) {
[15:32:07.141]         base::sink(type = "output", split = FALSE)
[15:32:07.141]         if (TRUE) {
[15:32:07.141]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.141]         }
[15:32:07.141]         else {
[15:32:07.141]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.141]         }
[15:32:07.141]         base::close(...future.stdout)
[15:32:07.141]         ...future.stdout <- NULL
[15:32:07.141]     }
[15:32:07.141]     ...future.result$conditions <- ...future.conditions
[15:32:07.141]     ...future.result$finished <- base::Sys.time()
[15:32:07.141]     ...future.result
[15:32:07.141] }
[15:32:07.148] assign_globals() ...
[15:32:07.148] List of 5
[15:32:07.148]  $ ...future.FUN            :function (C, k)  
[15:32:07.148]  $ MoreArgs                 : NULL
[15:32:07.148]  $ ...future.elements_ii    :List of 2
[15:32:07.148]   ..$ :List of 1
[15:32:07.148]   .. ..$ : chr "B"
[15:32:07.148]   ..$ :List of 1
[15:32:07.148]   .. ..$ : int 4
[15:32:07.148]  $ ...future.seeds_ii       : NULL
[15:32:07.148]  $ ...future.globals.maxSize: NULL
[15:32:07.148]  - attr(*, "where")=List of 5
[15:32:07.148]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.148]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.148]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.148]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.148]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.148]  - attr(*, "resolved")= logi FALSE
[15:32:07.148]  - attr(*, "total_size")= num 3488
[15:32:07.148]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.148]  - attr(*, "already-done")= logi TRUE
[15:32:07.159] - reassign environment for '...future.FUN'
[15:32:07.160] - copied '...future.FUN' to environment
[15:32:07.160] - copied 'MoreArgs' to environment
[15:32:07.160] - copied '...future.elements_ii' to environment
[15:32:07.161] - copied '...future.seeds_ii' to environment
[15:32:07.161] - copied '...future.globals.maxSize' to environment
[15:32:07.161] assign_globals() ... done
[15:32:07.162] plan(): Setting new future strategy stack:
[15:32:07.162] List of future strategies:
[15:32:07.162] 1. sequential:
[15:32:07.162]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.162]    - tweaked: FALSE
[15:32:07.162]    - call: NULL
[15:32:07.163] plan(): nbrOfWorkers() = 1
[15:32:07.166] plan(): Setting new future strategy stack:
[15:32:07.166] List of future strategies:
[15:32:07.166] 1. sequential:
[15:32:07.166]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.166]    - tweaked: FALSE
[15:32:07.166]    - call: plan(strategy)
[15:32:07.167] plan(): nbrOfWorkers() = 1
[15:32:07.168] SequentialFuture started (and completed)
[15:32:07.168] - Launch lazy future ... done
[15:32:07.168] run() for 'SequentialFuture' ... done
[15:32:07.169] Created future:
[15:32:07.169] SequentialFuture:
[15:32:07.169] Label: 'future_mapply-2'
[15:32:07.169] Expression:
[15:32:07.169] {
[15:32:07.169]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.169]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.169]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.169]         on.exit(options(oopts), add = TRUE)
[15:32:07.169]     }
[15:32:07.169]     {
[15:32:07.169]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.169]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.169]         do.call(mapply, args = args)
[15:32:07.169]     }
[15:32:07.169] }
[15:32:07.169] Lazy evaluation: FALSE
[15:32:07.169] Asynchronous evaluation: FALSE
[15:32:07.169] Local evaluation: TRUE
[15:32:07.169] Environment: R_GlobalEnv
[15:32:07.169] Capture standard output: TRUE
[15:32:07.169] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.169] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.169] Packages: <none>
[15:32:07.169] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.169] Resolved: TRUE
[15:32:07.169] Value: 112 bytes of class 'list'
[15:32:07.169] Early signaling: FALSE
[15:32:07.169] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.169] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.175] Chunk #2 of 5 ... DONE
[15:32:07.175] Chunk #3 of 5 ...
[15:32:07.176]  - Finding globals in '...' for chunk #3 ...
[15:32:07.176] getGlobalsAndPackages() ...
[15:32:07.176] Searching for globals...
[15:32:07.177] 
[15:32:07.178] Searching for globals ... DONE
[15:32:07.178] - globals: [0] <none>
[15:32:07.178] getGlobalsAndPackages() ... DONE
[15:32:07.179]    + additional globals found: [n=0] 
[15:32:07.179]    + additional namespaces needed: [n=0] 
[15:32:07.179]  - Finding globals in '...' for chunk #3 ... DONE
[15:32:07.180]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:07.180]  - seeds: <none>
[15:32:07.180]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.180] getGlobalsAndPackages() ...
[15:32:07.181] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.181] Resolving globals: FALSE
[15:32:07.182] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:07.183] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.184] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.184] 
[15:32:07.184] getGlobalsAndPackages() ... DONE
[15:32:07.185] run() for 'Future' ...
[15:32:07.185] - state: 'created'
[15:32:07.185] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.186] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.186] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.186]   - Field: 'label'
[15:32:07.187]   - Field: 'local'
[15:32:07.187]   - Field: 'owner'
[15:32:07.187]   - Field: 'envir'
[15:32:07.188]   - Field: 'packages'
[15:32:07.188]   - Field: 'gc'
[15:32:07.188]   - Field: 'conditions'
[15:32:07.189]   - Field: 'expr'
[15:32:07.189]   - Field: 'uuid'
[15:32:07.189]   - Field: 'seed'
[15:32:07.189]   - Field: 'version'
[15:32:07.190]   - Field: 'result'
[15:32:07.190]   - Field: 'asynchronous'
[15:32:07.190]   - Field: 'calls'
[15:32:07.190]   - Field: 'globals'
[15:32:07.191]   - Field: 'stdout'
[15:32:07.191]   - Field: 'earlySignal'
[15:32:07.191]   - Field: 'lazy'
[15:32:07.191]   - Field: 'state'
[15:32:07.192] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.192] - Launch lazy future ...
[15:32:07.192] Packages needed by the future expression (n = 0): <none>
[15:32:07.193] Packages needed by future strategies (n = 0): <none>
[15:32:07.194] {
[15:32:07.194]     {
[15:32:07.194]         {
[15:32:07.194]             ...future.startTime <- base::Sys.time()
[15:32:07.194]             {
[15:32:07.194]                 {
[15:32:07.194]                   {
[15:32:07.194]                     base::local({
[15:32:07.194]                       has_future <- base::requireNamespace("future", 
[15:32:07.194]                         quietly = TRUE)
[15:32:07.194]                       if (has_future) {
[15:32:07.194]                         ns <- base::getNamespace("future")
[15:32:07.194]                         version <- ns[[".package"]][["version"]]
[15:32:07.194]                         if (is.null(version)) 
[15:32:07.194]                           version <- utils::packageVersion("future")
[15:32:07.194]                       }
[15:32:07.194]                       else {
[15:32:07.194]                         version <- NULL
[15:32:07.194]                       }
[15:32:07.194]                       if (!has_future || version < "1.8.0") {
[15:32:07.194]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.194]                           "", base::R.version$version.string), 
[15:32:07.194]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.194]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.194]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.194]                             "release", "version")], collapse = " "), 
[15:32:07.194]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.194]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.194]                           info)
[15:32:07.194]                         info <- base::paste(info, collapse = "; ")
[15:32:07.194]                         if (!has_future) {
[15:32:07.194]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.194]                             info)
[15:32:07.194]                         }
[15:32:07.194]                         else {
[15:32:07.194]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.194]                             info, version)
[15:32:07.194]                         }
[15:32:07.194]                         base::stop(msg)
[15:32:07.194]                       }
[15:32:07.194]                     })
[15:32:07.194]                   }
[15:32:07.194]                   ...future.strategy.old <- future::plan("list")
[15:32:07.194]                   options(future.plan = NULL)
[15:32:07.194]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.194]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.194]                 }
[15:32:07.194]                 ...future.workdir <- getwd()
[15:32:07.194]             }
[15:32:07.194]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.194]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.194]         }
[15:32:07.194]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.194]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:07.194]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.194]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.194]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.194]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.194]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.194]             base::names(...future.oldOptions))
[15:32:07.194]     }
[15:32:07.194]     if (FALSE) {
[15:32:07.194]     }
[15:32:07.194]     else {
[15:32:07.194]         if (TRUE) {
[15:32:07.194]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.194]                 open = "w")
[15:32:07.194]         }
[15:32:07.194]         else {
[15:32:07.194]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.194]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.194]         }
[15:32:07.194]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.194]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.194]             base::sink(type = "output", split = FALSE)
[15:32:07.194]             base::close(...future.stdout)
[15:32:07.194]         }, add = TRUE)
[15:32:07.194]     }
[15:32:07.194]     ...future.frame <- base::sys.nframe()
[15:32:07.194]     ...future.conditions <- base::list()
[15:32:07.194]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.194]     if (FALSE) {
[15:32:07.194]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.194]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.194]     }
[15:32:07.194]     ...future.result <- base::tryCatch({
[15:32:07.194]         base::withCallingHandlers({
[15:32:07.194]             ...future.value <- base::withVisible(base::local({
[15:32:07.194]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.194]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.194]                   ...future.globals.maxSize)) {
[15:32:07.194]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.194]                   on.exit(options(oopts), add = TRUE)
[15:32:07.194]                 }
[15:32:07.194]                 {
[15:32:07.194]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.194]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.194]                     USE.NAMES = FALSE)
[15:32:07.194]                   do.call(mapply, args = args)
[15:32:07.194]                 }
[15:32:07.194]             }))
[15:32:07.194]             future::FutureResult(value = ...future.value$value, 
[15:32:07.194]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.194]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.194]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.194]                     ...future.globalenv.names))
[15:32:07.194]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.194]         }, condition = base::local({
[15:32:07.194]             c <- base::c
[15:32:07.194]             inherits <- base::inherits
[15:32:07.194]             invokeRestart <- base::invokeRestart
[15:32:07.194]             length <- base::length
[15:32:07.194]             list <- base::list
[15:32:07.194]             seq.int <- base::seq.int
[15:32:07.194]             signalCondition <- base::signalCondition
[15:32:07.194]             sys.calls <- base::sys.calls
[15:32:07.194]             `[[` <- base::`[[`
[15:32:07.194]             `+` <- base::`+`
[15:32:07.194]             `<<-` <- base::`<<-`
[15:32:07.194]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.194]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.194]                   3L)]
[15:32:07.194]             }
[15:32:07.194]             function(cond) {
[15:32:07.194]                 is_error <- inherits(cond, "error")
[15:32:07.194]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.194]                   NULL)
[15:32:07.194]                 if (is_error) {
[15:32:07.194]                   sessionInformation <- function() {
[15:32:07.194]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.194]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.194]                       search = base::search(), system = base::Sys.info())
[15:32:07.194]                   }
[15:32:07.194]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.194]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.194]                     cond$call), session = sessionInformation(), 
[15:32:07.194]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.194]                   signalCondition(cond)
[15:32:07.194]                 }
[15:32:07.194]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.194]                 "immediateCondition"))) {
[15:32:07.194]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.194]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.194]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.194]                   if (TRUE && !signal) {
[15:32:07.194]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.194]                     {
[15:32:07.194]                       inherits <- base::inherits
[15:32:07.194]                       invokeRestart <- base::invokeRestart
[15:32:07.194]                       is.null <- base::is.null
[15:32:07.194]                       muffled <- FALSE
[15:32:07.194]                       if (inherits(cond, "message")) {
[15:32:07.194]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.194]                         if (muffled) 
[15:32:07.194]                           invokeRestart("muffleMessage")
[15:32:07.194]                       }
[15:32:07.194]                       else if (inherits(cond, "warning")) {
[15:32:07.194]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.194]                         if (muffled) 
[15:32:07.194]                           invokeRestart("muffleWarning")
[15:32:07.194]                       }
[15:32:07.194]                       else if (inherits(cond, "condition")) {
[15:32:07.194]                         if (!is.null(pattern)) {
[15:32:07.194]                           computeRestarts <- base::computeRestarts
[15:32:07.194]                           grepl <- base::grepl
[15:32:07.194]                           restarts <- computeRestarts(cond)
[15:32:07.194]                           for (restart in restarts) {
[15:32:07.194]                             name <- restart$name
[15:32:07.194]                             if (is.null(name)) 
[15:32:07.194]                               next
[15:32:07.194]                             if (!grepl(pattern, name)) 
[15:32:07.194]                               next
[15:32:07.194]                             invokeRestart(restart)
[15:32:07.194]                             muffled <- TRUE
[15:32:07.194]                             break
[15:32:07.194]                           }
[15:32:07.194]                         }
[15:32:07.194]                       }
[15:32:07.194]                       invisible(muffled)
[15:32:07.194]                     }
[15:32:07.194]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.194]                   }
[15:32:07.194]                 }
[15:32:07.194]                 else {
[15:32:07.194]                   if (TRUE) {
[15:32:07.194]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.194]                     {
[15:32:07.194]                       inherits <- base::inherits
[15:32:07.194]                       invokeRestart <- base::invokeRestart
[15:32:07.194]                       is.null <- base::is.null
[15:32:07.194]                       muffled <- FALSE
[15:32:07.194]                       if (inherits(cond, "message")) {
[15:32:07.194]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.194]                         if (muffled) 
[15:32:07.194]                           invokeRestart("muffleMessage")
[15:32:07.194]                       }
[15:32:07.194]                       else if (inherits(cond, "warning")) {
[15:32:07.194]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.194]                         if (muffled) 
[15:32:07.194]                           invokeRestart("muffleWarning")
[15:32:07.194]                       }
[15:32:07.194]                       else if (inherits(cond, "condition")) {
[15:32:07.194]                         if (!is.null(pattern)) {
[15:32:07.194]                           computeRestarts <- base::computeRestarts
[15:32:07.194]                           grepl <- base::grepl
[15:32:07.194]                           restarts <- computeRestarts(cond)
[15:32:07.194]                           for (restart in restarts) {
[15:32:07.194]                             name <- restart$name
[15:32:07.194]                             if (is.null(name)) 
[15:32:07.194]                               next
[15:32:07.194]                             if (!grepl(pattern, name)) 
[15:32:07.194]                               next
[15:32:07.194]                             invokeRestart(restart)
[15:32:07.194]                             muffled <- TRUE
[15:32:07.194]                             break
[15:32:07.194]                           }
[15:32:07.194]                         }
[15:32:07.194]                       }
[15:32:07.194]                       invisible(muffled)
[15:32:07.194]                     }
[15:32:07.194]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.194]                   }
[15:32:07.194]                 }
[15:32:07.194]             }
[15:32:07.194]         }))
[15:32:07.194]     }, error = function(ex) {
[15:32:07.194]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.194]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.194]                 ...future.rng), started = ...future.startTime, 
[15:32:07.194]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.194]             version = "1.8"), class = "FutureResult")
[15:32:07.194]     }, finally = {
[15:32:07.194]         if (!identical(...future.workdir, getwd())) 
[15:32:07.194]             setwd(...future.workdir)
[15:32:07.194]         {
[15:32:07.194]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.194]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.194]             }
[15:32:07.194]             base::options(...future.oldOptions)
[15:32:07.194]             if (.Platform$OS.type == "windows") {
[15:32:07.194]                 old_names <- names(...future.oldEnvVars)
[15:32:07.194]                 envs <- base::Sys.getenv()
[15:32:07.194]                 names <- names(envs)
[15:32:07.194]                 common <- intersect(names, old_names)
[15:32:07.194]                 added <- setdiff(names, old_names)
[15:32:07.194]                 removed <- setdiff(old_names, names)
[15:32:07.194]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.194]                   envs[common]]
[15:32:07.194]                 NAMES <- toupper(changed)
[15:32:07.194]                 args <- list()
[15:32:07.194]                 for (kk in seq_along(NAMES)) {
[15:32:07.194]                   name <- changed[[kk]]
[15:32:07.194]                   NAME <- NAMES[[kk]]
[15:32:07.194]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.194]                     next
[15:32:07.194]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.194]                 }
[15:32:07.194]                 NAMES <- toupper(added)
[15:32:07.194]                 for (kk in seq_along(NAMES)) {
[15:32:07.194]                   name <- added[[kk]]
[15:32:07.194]                   NAME <- NAMES[[kk]]
[15:32:07.194]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.194]                     next
[15:32:07.194]                   args[[name]] <- ""
[15:32:07.194]                 }
[15:32:07.194]                 NAMES <- toupper(removed)
[15:32:07.194]                 for (kk in seq_along(NAMES)) {
[15:32:07.194]                   name <- removed[[kk]]
[15:32:07.194]                   NAME <- NAMES[[kk]]
[15:32:07.194]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.194]                     next
[15:32:07.194]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.194]                 }
[15:32:07.194]                 if (length(args) > 0) 
[15:32:07.194]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.194]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.194]             }
[15:32:07.194]             else {
[15:32:07.194]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.194]             }
[15:32:07.194]             {
[15:32:07.194]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.194]                   0L) {
[15:32:07.194]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.194]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.194]                   base::options(opts)
[15:32:07.194]                 }
[15:32:07.194]                 {
[15:32:07.194]                   {
[15:32:07.194]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.194]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.194]                     -253660479L), envir = base::globalenv(), 
[15:32:07.194]                       inherits = FALSE)
[15:32:07.194]                     NULL
[15:32:07.194]                   }
[15:32:07.194]                   options(future.plan = NULL)
[15:32:07.194]                   if (is.na(NA_character_)) 
[15:32:07.194]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.194]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.194]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.194]                     .init = FALSE)
[15:32:07.194]                 }
[15:32:07.194]             }
[15:32:07.194]         }
[15:32:07.194]     })
[15:32:07.194]     if (TRUE) {
[15:32:07.194]         base::sink(type = "output", split = FALSE)
[15:32:07.194]         if (TRUE) {
[15:32:07.194]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.194]         }
[15:32:07.194]         else {
[15:32:07.194]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.194]         }
[15:32:07.194]         base::close(...future.stdout)
[15:32:07.194]         ...future.stdout <- NULL
[15:32:07.194]     }
[15:32:07.194]     ...future.result$conditions <- ...future.conditions
[15:32:07.194]     ...future.result$finished <- base::Sys.time()
[15:32:07.194]     ...future.result
[15:32:07.194] }
[15:32:07.199] assign_globals() ...
[15:32:07.200] List of 5
[15:32:07.200]  $ ...future.FUN            :function (C, k)  
[15:32:07.200]  $ MoreArgs                 : NULL
[15:32:07.200]  $ ...future.elements_ii    :List of 2
[15:32:07.200]   ..$ :List of 1
[15:32:07.200]   .. ..$ : chr "C"
[15:32:07.200]   ..$ :List of 1
[15:32:07.200]   .. ..$ : int 3
[15:32:07.200]  $ ...future.seeds_ii       : NULL
[15:32:07.200]  $ ...future.globals.maxSize: NULL
[15:32:07.200]  - attr(*, "where")=List of 5
[15:32:07.200]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.200]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.200]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.200]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.200]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.200]  - attr(*, "resolved")= logi FALSE
[15:32:07.200]  - attr(*, "total_size")= num 3488
[15:32:07.200]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.200]  - attr(*, "already-done")= logi TRUE
[15:32:07.210] - reassign environment for '...future.FUN'
[15:32:07.210] - copied '...future.FUN' to environment
[15:32:07.211] - copied 'MoreArgs' to environment
[15:32:07.211] - copied '...future.elements_ii' to environment
[15:32:07.211] - copied '...future.seeds_ii' to environment
[15:32:07.212] - copied '...future.globals.maxSize' to environment
[15:32:07.212] assign_globals() ... done
[15:32:07.213] plan(): Setting new future strategy stack:
[15:32:07.213] List of future strategies:
[15:32:07.213] 1. sequential:
[15:32:07.213]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.213]    - tweaked: FALSE
[15:32:07.213]    - call: NULL
[15:32:07.214] plan(): nbrOfWorkers() = 1
[15:32:07.216] plan(): Setting new future strategy stack:
[15:32:07.216] List of future strategies:
[15:32:07.216] 1. sequential:
[15:32:07.216]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.216]    - tweaked: FALSE
[15:32:07.216]    - call: plan(strategy)
[15:32:07.217] plan(): nbrOfWorkers() = 1
[15:32:07.217] SequentialFuture started (and completed)
[15:32:07.218] - Launch lazy future ... done
[15:32:07.218] run() for 'SequentialFuture' ... done
[15:32:07.218] Created future:
[15:32:07.218] SequentialFuture:
[15:32:07.218] Label: 'future_mapply-3'
[15:32:07.218] Expression:
[15:32:07.218] {
[15:32:07.218]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.218]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.218]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.218]         on.exit(options(oopts), add = TRUE)
[15:32:07.218]     }
[15:32:07.218]     {
[15:32:07.218]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.218]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.218]         do.call(mapply, args = args)
[15:32:07.218]     }
[15:32:07.218] }
[15:32:07.218] Lazy evaluation: FALSE
[15:32:07.218] Asynchronous evaluation: FALSE
[15:32:07.218] Local evaluation: TRUE
[15:32:07.218] Environment: R_GlobalEnv
[15:32:07.218] Capture standard output: TRUE
[15:32:07.218] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.218] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.218] Packages: <none>
[15:32:07.218] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.218] Resolved: TRUE
[15:32:07.218] Value: 112 bytes of class 'list'
[15:32:07.218] Early signaling: FALSE
[15:32:07.218] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.218] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.220] Chunk #3 of 5 ... DONE
[15:32:07.220] Chunk #4 of 5 ...
[15:32:07.220]  - Finding globals in '...' for chunk #4 ...
[15:32:07.220] getGlobalsAndPackages() ...
[15:32:07.221] Searching for globals...
[15:32:07.221] 
[15:32:07.221] Searching for globals ... DONE
[15:32:07.221] - globals: [0] <none>
[15:32:07.224] getGlobalsAndPackages() ... DONE
[15:32:07.224]    + additional globals found: [n=0] 
[15:32:07.224]    + additional namespaces needed: [n=0] 
[15:32:07.225]  - Finding globals in '...' for chunk #4 ... DONE
[15:32:07.225]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:07.225]  - seeds: <none>
[15:32:07.225]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.226] getGlobalsAndPackages() ...
[15:32:07.226] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.226] Resolving globals: FALSE
[15:32:07.227] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:07.228] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.228] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.228] 
[15:32:07.228] getGlobalsAndPackages() ... DONE
[15:32:07.229] run() for 'Future' ...
[15:32:07.229] - state: 'created'
[15:32:07.229] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.230] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.230] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.230]   - Field: 'label'
[15:32:07.230]   - Field: 'local'
[15:32:07.230]   - Field: 'owner'
[15:32:07.231]   - Field: 'envir'
[15:32:07.231]   - Field: 'packages'
[15:32:07.231]   - Field: 'gc'
[15:32:07.231]   - Field: 'conditions'
[15:32:07.231]   - Field: 'expr'
[15:32:07.232]   - Field: 'uuid'
[15:32:07.232]   - Field: 'seed'
[15:32:07.232]   - Field: 'version'
[15:32:07.232]   - Field: 'result'
[15:32:07.232]   - Field: 'asynchronous'
[15:32:07.232]   - Field: 'calls'
[15:32:07.233]   - Field: 'globals'
[15:32:07.233]   - Field: 'stdout'
[15:32:07.233]   - Field: 'earlySignal'
[15:32:07.233]   - Field: 'lazy'
[15:32:07.233]   - Field: 'state'
[15:32:07.234] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.234] - Launch lazy future ...
[15:32:07.234] Packages needed by the future expression (n = 0): <none>
[15:32:07.234] Packages needed by future strategies (n = 0): <none>
[15:32:07.235] {
[15:32:07.235]     {
[15:32:07.235]         {
[15:32:07.235]             ...future.startTime <- base::Sys.time()
[15:32:07.235]             {
[15:32:07.235]                 {
[15:32:07.235]                   {
[15:32:07.235]                     base::local({
[15:32:07.235]                       has_future <- base::requireNamespace("future", 
[15:32:07.235]                         quietly = TRUE)
[15:32:07.235]                       if (has_future) {
[15:32:07.235]                         ns <- base::getNamespace("future")
[15:32:07.235]                         version <- ns[[".package"]][["version"]]
[15:32:07.235]                         if (is.null(version)) 
[15:32:07.235]                           version <- utils::packageVersion("future")
[15:32:07.235]                       }
[15:32:07.235]                       else {
[15:32:07.235]                         version <- NULL
[15:32:07.235]                       }
[15:32:07.235]                       if (!has_future || version < "1.8.0") {
[15:32:07.235]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.235]                           "", base::R.version$version.string), 
[15:32:07.235]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.235]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.235]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.235]                             "release", "version")], collapse = " "), 
[15:32:07.235]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.235]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.235]                           info)
[15:32:07.235]                         info <- base::paste(info, collapse = "; ")
[15:32:07.235]                         if (!has_future) {
[15:32:07.235]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.235]                             info)
[15:32:07.235]                         }
[15:32:07.235]                         else {
[15:32:07.235]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.235]                             info, version)
[15:32:07.235]                         }
[15:32:07.235]                         base::stop(msg)
[15:32:07.235]                       }
[15:32:07.235]                     })
[15:32:07.235]                   }
[15:32:07.235]                   ...future.strategy.old <- future::plan("list")
[15:32:07.235]                   options(future.plan = NULL)
[15:32:07.235]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.235]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.235]                 }
[15:32:07.235]                 ...future.workdir <- getwd()
[15:32:07.235]             }
[15:32:07.235]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.235]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.235]         }
[15:32:07.235]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.235]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:07.235]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.235]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.235]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.235]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.235]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.235]             base::names(...future.oldOptions))
[15:32:07.235]     }
[15:32:07.235]     if (FALSE) {
[15:32:07.235]     }
[15:32:07.235]     else {
[15:32:07.235]         if (TRUE) {
[15:32:07.235]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.235]                 open = "w")
[15:32:07.235]         }
[15:32:07.235]         else {
[15:32:07.235]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.235]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.235]         }
[15:32:07.235]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.235]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.235]             base::sink(type = "output", split = FALSE)
[15:32:07.235]             base::close(...future.stdout)
[15:32:07.235]         }, add = TRUE)
[15:32:07.235]     }
[15:32:07.235]     ...future.frame <- base::sys.nframe()
[15:32:07.235]     ...future.conditions <- base::list()
[15:32:07.235]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.235]     if (FALSE) {
[15:32:07.235]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.235]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.235]     }
[15:32:07.235]     ...future.result <- base::tryCatch({
[15:32:07.235]         base::withCallingHandlers({
[15:32:07.235]             ...future.value <- base::withVisible(base::local({
[15:32:07.235]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.235]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.235]                   ...future.globals.maxSize)) {
[15:32:07.235]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.235]                   on.exit(options(oopts), add = TRUE)
[15:32:07.235]                 }
[15:32:07.235]                 {
[15:32:07.235]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.235]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.235]                     USE.NAMES = FALSE)
[15:32:07.235]                   do.call(mapply, args = args)
[15:32:07.235]                 }
[15:32:07.235]             }))
[15:32:07.235]             future::FutureResult(value = ...future.value$value, 
[15:32:07.235]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.235]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.235]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.235]                     ...future.globalenv.names))
[15:32:07.235]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.235]         }, condition = base::local({
[15:32:07.235]             c <- base::c
[15:32:07.235]             inherits <- base::inherits
[15:32:07.235]             invokeRestart <- base::invokeRestart
[15:32:07.235]             length <- base::length
[15:32:07.235]             list <- base::list
[15:32:07.235]             seq.int <- base::seq.int
[15:32:07.235]             signalCondition <- base::signalCondition
[15:32:07.235]             sys.calls <- base::sys.calls
[15:32:07.235]             `[[` <- base::`[[`
[15:32:07.235]             `+` <- base::`+`
[15:32:07.235]             `<<-` <- base::`<<-`
[15:32:07.235]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.235]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.235]                   3L)]
[15:32:07.235]             }
[15:32:07.235]             function(cond) {
[15:32:07.235]                 is_error <- inherits(cond, "error")
[15:32:07.235]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.235]                   NULL)
[15:32:07.235]                 if (is_error) {
[15:32:07.235]                   sessionInformation <- function() {
[15:32:07.235]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.235]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.235]                       search = base::search(), system = base::Sys.info())
[15:32:07.235]                   }
[15:32:07.235]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.235]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.235]                     cond$call), session = sessionInformation(), 
[15:32:07.235]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.235]                   signalCondition(cond)
[15:32:07.235]                 }
[15:32:07.235]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.235]                 "immediateCondition"))) {
[15:32:07.235]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.235]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.235]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.235]                   if (TRUE && !signal) {
[15:32:07.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.235]                     {
[15:32:07.235]                       inherits <- base::inherits
[15:32:07.235]                       invokeRestart <- base::invokeRestart
[15:32:07.235]                       is.null <- base::is.null
[15:32:07.235]                       muffled <- FALSE
[15:32:07.235]                       if (inherits(cond, "message")) {
[15:32:07.235]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.235]                         if (muffled) 
[15:32:07.235]                           invokeRestart("muffleMessage")
[15:32:07.235]                       }
[15:32:07.235]                       else if (inherits(cond, "warning")) {
[15:32:07.235]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.235]                         if (muffled) 
[15:32:07.235]                           invokeRestart("muffleWarning")
[15:32:07.235]                       }
[15:32:07.235]                       else if (inherits(cond, "condition")) {
[15:32:07.235]                         if (!is.null(pattern)) {
[15:32:07.235]                           computeRestarts <- base::computeRestarts
[15:32:07.235]                           grepl <- base::grepl
[15:32:07.235]                           restarts <- computeRestarts(cond)
[15:32:07.235]                           for (restart in restarts) {
[15:32:07.235]                             name <- restart$name
[15:32:07.235]                             if (is.null(name)) 
[15:32:07.235]                               next
[15:32:07.235]                             if (!grepl(pattern, name)) 
[15:32:07.235]                               next
[15:32:07.235]                             invokeRestart(restart)
[15:32:07.235]                             muffled <- TRUE
[15:32:07.235]                             break
[15:32:07.235]                           }
[15:32:07.235]                         }
[15:32:07.235]                       }
[15:32:07.235]                       invisible(muffled)
[15:32:07.235]                     }
[15:32:07.235]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.235]                   }
[15:32:07.235]                 }
[15:32:07.235]                 else {
[15:32:07.235]                   if (TRUE) {
[15:32:07.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.235]                     {
[15:32:07.235]                       inherits <- base::inherits
[15:32:07.235]                       invokeRestart <- base::invokeRestart
[15:32:07.235]                       is.null <- base::is.null
[15:32:07.235]                       muffled <- FALSE
[15:32:07.235]                       if (inherits(cond, "message")) {
[15:32:07.235]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.235]                         if (muffled) 
[15:32:07.235]                           invokeRestart("muffleMessage")
[15:32:07.235]                       }
[15:32:07.235]                       else if (inherits(cond, "warning")) {
[15:32:07.235]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.235]                         if (muffled) 
[15:32:07.235]                           invokeRestart("muffleWarning")
[15:32:07.235]                       }
[15:32:07.235]                       else if (inherits(cond, "condition")) {
[15:32:07.235]                         if (!is.null(pattern)) {
[15:32:07.235]                           computeRestarts <- base::computeRestarts
[15:32:07.235]                           grepl <- base::grepl
[15:32:07.235]                           restarts <- computeRestarts(cond)
[15:32:07.235]                           for (restart in restarts) {
[15:32:07.235]                             name <- restart$name
[15:32:07.235]                             if (is.null(name)) 
[15:32:07.235]                               next
[15:32:07.235]                             if (!grepl(pattern, name)) 
[15:32:07.235]                               next
[15:32:07.235]                             invokeRestart(restart)
[15:32:07.235]                             muffled <- TRUE
[15:32:07.235]                             break
[15:32:07.235]                           }
[15:32:07.235]                         }
[15:32:07.235]                       }
[15:32:07.235]                       invisible(muffled)
[15:32:07.235]                     }
[15:32:07.235]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.235]                   }
[15:32:07.235]                 }
[15:32:07.235]             }
[15:32:07.235]         }))
[15:32:07.235]     }, error = function(ex) {
[15:32:07.235]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.235]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.235]                 ...future.rng), started = ...future.startTime, 
[15:32:07.235]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.235]             version = "1.8"), class = "FutureResult")
[15:32:07.235]     }, finally = {
[15:32:07.235]         if (!identical(...future.workdir, getwd())) 
[15:32:07.235]             setwd(...future.workdir)
[15:32:07.235]         {
[15:32:07.235]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.235]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.235]             }
[15:32:07.235]             base::options(...future.oldOptions)
[15:32:07.235]             if (.Platform$OS.type == "windows") {
[15:32:07.235]                 old_names <- names(...future.oldEnvVars)
[15:32:07.235]                 envs <- base::Sys.getenv()
[15:32:07.235]                 names <- names(envs)
[15:32:07.235]                 common <- intersect(names, old_names)
[15:32:07.235]                 added <- setdiff(names, old_names)
[15:32:07.235]                 removed <- setdiff(old_names, names)
[15:32:07.235]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.235]                   envs[common]]
[15:32:07.235]                 NAMES <- toupper(changed)
[15:32:07.235]                 args <- list()
[15:32:07.235]                 for (kk in seq_along(NAMES)) {
[15:32:07.235]                   name <- changed[[kk]]
[15:32:07.235]                   NAME <- NAMES[[kk]]
[15:32:07.235]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.235]                     next
[15:32:07.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.235]                 }
[15:32:07.235]                 NAMES <- toupper(added)
[15:32:07.235]                 for (kk in seq_along(NAMES)) {
[15:32:07.235]                   name <- added[[kk]]
[15:32:07.235]                   NAME <- NAMES[[kk]]
[15:32:07.235]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.235]                     next
[15:32:07.235]                   args[[name]] <- ""
[15:32:07.235]                 }
[15:32:07.235]                 NAMES <- toupper(removed)
[15:32:07.235]                 for (kk in seq_along(NAMES)) {
[15:32:07.235]                   name <- removed[[kk]]
[15:32:07.235]                   NAME <- NAMES[[kk]]
[15:32:07.235]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.235]                     next
[15:32:07.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.235]                 }
[15:32:07.235]                 if (length(args) > 0) 
[15:32:07.235]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.235]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.235]             }
[15:32:07.235]             else {
[15:32:07.235]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.235]             }
[15:32:07.235]             {
[15:32:07.235]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.235]                   0L) {
[15:32:07.235]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.235]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.235]                   base::options(opts)
[15:32:07.235]                 }
[15:32:07.235]                 {
[15:32:07.235]                   {
[15:32:07.235]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.235]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.235]                     -253660479L), envir = base::globalenv(), 
[15:32:07.235]                       inherits = FALSE)
[15:32:07.235]                     NULL
[15:32:07.235]                   }
[15:32:07.235]                   options(future.plan = NULL)
[15:32:07.235]                   if (is.na(NA_character_)) 
[15:32:07.235]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.235]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.235]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.235]                     .init = FALSE)
[15:32:07.235]                 }
[15:32:07.235]             }
[15:32:07.235]         }
[15:32:07.235]     })
[15:32:07.235]     if (TRUE) {
[15:32:07.235]         base::sink(type = "output", split = FALSE)
[15:32:07.235]         if (TRUE) {
[15:32:07.235]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.235]         }
[15:32:07.235]         else {
[15:32:07.235]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.235]         }
[15:32:07.235]         base::close(...future.stdout)
[15:32:07.235]         ...future.stdout <- NULL
[15:32:07.235]     }
[15:32:07.235]     ...future.result$conditions <- ...future.conditions
[15:32:07.235]     ...future.result$finished <- base::Sys.time()
[15:32:07.235]     ...future.result
[15:32:07.235] }
[15:32:07.241] assign_globals() ...
[15:32:07.241] List of 5
[15:32:07.241]  $ ...future.FUN            :function (C, k)  
[15:32:07.241]  $ MoreArgs                 : NULL
[15:32:07.241]  $ ...future.elements_ii    :List of 2
[15:32:07.241]   ..$ :List of 1
[15:32:07.241]   .. ..$ : chr "D"
[15:32:07.241]   ..$ :List of 1
[15:32:07.241]   .. ..$ : int 2
[15:32:07.241]  $ ...future.seeds_ii       : NULL
[15:32:07.241]  $ ...future.globals.maxSize: NULL
[15:32:07.241]  - attr(*, "where")=List of 5
[15:32:07.241]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.241]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.241]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.241]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.241]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.241]  - attr(*, "resolved")= logi FALSE
[15:32:07.241]  - attr(*, "total_size")= num 3488
[15:32:07.241]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.241]  - attr(*, "already-done")= logi TRUE
[15:32:07.251] - reassign environment for '...future.FUN'
[15:32:07.251] - copied '...future.FUN' to environment
[15:32:07.252] - copied 'MoreArgs' to environment
[15:32:07.252] - copied '...future.elements_ii' to environment
[15:32:07.252] - copied '...future.seeds_ii' to environment
[15:32:07.253] - copied '...future.globals.maxSize' to environment
[15:32:07.253] assign_globals() ... done
[15:32:07.254] plan(): Setting new future strategy stack:
[15:32:07.254] List of future strategies:
[15:32:07.254] 1. sequential:
[15:32:07.254]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.254]    - tweaked: FALSE
[15:32:07.254]    - call: NULL
[15:32:07.255] plan(): nbrOfWorkers() = 1
[15:32:07.257] plan(): Setting new future strategy stack:
[15:32:07.257] List of future strategies:
[15:32:07.257] 1. sequential:
[15:32:07.257]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.257]    - tweaked: FALSE
[15:32:07.257]    - call: plan(strategy)
[15:32:07.258] plan(): nbrOfWorkers() = 1
[15:32:07.259] SequentialFuture started (and completed)
[15:32:07.259] - Launch lazy future ... done
[15:32:07.259] run() for 'SequentialFuture' ... done
[15:32:07.260] Created future:
[15:32:07.260] SequentialFuture:
[15:32:07.260] Label: 'future_mapply-4'
[15:32:07.260] Expression:
[15:32:07.260] {
[15:32:07.260]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.260]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.260]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.260]         on.exit(options(oopts), add = TRUE)
[15:32:07.260]     }
[15:32:07.260]     {
[15:32:07.260]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.260]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.260]         do.call(mapply, args = args)
[15:32:07.260]     }
[15:32:07.260] }
[15:32:07.260] Lazy evaluation: FALSE
[15:32:07.260] Asynchronous evaluation: FALSE
[15:32:07.260] Local evaluation: TRUE
[15:32:07.260] Environment: R_GlobalEnv
[15:32:07.260] Capture standard output: TRUE
[15:32:07.260] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.260] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.260] Packages: <none>
[15:32:07.260] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.260] Resolved: TRUE
[15:32:07.260] Value: 112 bytes of class 'list'
[15:32:07.260] Early signaling: FALSE
[15:32:07.260] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.260] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.262] Chunk #4 of 5 ... DONE
[15:32:07.262] Chunk #5 of 5 ...
[15:32:07.263]  - Finding globals in '...' for chunk #5 ...
[15:32:07.263] getGlobalsAndPackages() ...
[15:32:07.263] Searching for globals...
[15:32:07.264] 
[15:32:07.264] Searching for globals ... DONE
[15:32:07.265] - globals: [0] <none>
[15:32:07.265] getGlobalsAndPackages() ... DONE
[15:32:07.265]    + additional globals found: [n=0] 
[15:32:07.265]    + additional namespaces needed: [n=0] 
[15:32:07.266]  - Finding globals in '...' for chunk #5 ... DONE
[15:32:07.266]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:07.266]  - seeds: <none>
[15:32:07.266]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.267] getGlobalsAndPackages() ...
[15:32:07.267] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.267] Resolving globals: FALSE
[15:32:07.272] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:07.273] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.273] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.274] 
[15:32:07.274] getGlobalsAndPackages() ... DONE
[15:32:07.275] run() for 'Future' ...
[15:32:07.275] - state: 'created'
[15:32:07.276] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.276] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.277] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.277]   - Field: 'label'
[15:32:07.277]   - Field: 'local'
[15:32:07.278]   - Field: 'owner'
[15:32:07.278]   - Field: 'envir'
[15:32:07.278]   - Field: 'packages'
[15:32:07.279]   - Field: 'gc'
[15:32:07.279]   - Field: 'conditions'
[15:32:07.279]   - Field: 'expr'
[15:32:07.280]   - Field: 'uuid'
[15:32:07.280]   - Field: 'seed'
[15:32:07.280]   - Field: 'version'
[15:32:07.281]   - Field: 'result'
[15:32:07.281]   - Field: 'asynchronous'
[15:32:07.281]   - Field: 'calls'
[15:32:07.282]   - Field: 'globals'
[15:32:07.282]   - Field: 'stdout'
[15:32:07.282]   - Field: 'earlySignal'
[15:32:07.283]   - Field: 'lazy'
[15:32:07.283]   - Field: 'state'
[15:32:07.283] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.284] - Launch lazy future ...
[15:32:07.284] Packages needed by the future expression (n = 0): <none>
[15:32:07.285] Packages needed by future strategies (n = 0): <none>
[15:32:07.286] {
[15:32:07.286]     {
[15:32:07.286]         {
[15:32:07.286]             ...future.startTime <- base::Sys.time()
[15:32:07.286]             {
[15:32:07.286]                 {
[15:32:07.286]                   {
[15:32:07.286]                     base::local({
[15:32:07.286]                       has_future <- base::requireNamespace("future", 
[15:32:07.286]                         quietly = TRUE)
[15:32:07.286]                       if (has_future) {
[15:32:07.286]                         ns <- base::getNamespace("future")
[15:32:07.286]                         version <- ns[[".package"]][["version"]]
[15:32:07.286]                         if (is.null(version)) 
[15:32:07.286]                           version <- utils::packageVersion("future")
[15:32:07.286]                       }
[15:32:07.286]                       else {
[15:32:07.286]                         version <- NULL
[15:32:07.286]                       }
[15:32:07.286]                       if (!has_future || version < "1.8.0") {
[15:32:07.286]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.286]                           "", base::R.version$version.string), 
[15:32:07.286]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.286]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.286]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.286]                             "release", "version")], collapse = " "), 
[15:32:07.286]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.286]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.286]                           info)
[15:32:07.286]                         info <- base::paste(info, collapse = "; ")
[15:32:07.286]                         if (!has_future) {
[15:32:07.286]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.286]                             info)
[15:32:07.286]                         }
[15:32:07.286]                         else {
[15:32:07.286]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.286]                             info, version)
[15:32:07.286]                         }
[15:32:07.286]                         base::stop(msg)
[15:32:07.286]                       }
[15:32:07.286]                     })
[15:32:07.286]                   }
[15:32:07.286]                   ...future.strategy.old <- future::plan("list")
[15:32:07.286]                   options(future.plan = NULL)
[15:32:07.286]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.286]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.286]                 }
[15:32:07.286]                 ...future.workdir <- getwd()
[15:32:07.286]             }
[15:32:07.286]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.286]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.286]         }
[15:32:07.286]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.286]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:07.286]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.286]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.286]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.286]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.286]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.286]             base::names(...future.oldOptions))
[15:32:07.286]     }
[15:32:07.286]     if (FALSE) {
[15:32:07.286]     }
[15:32:07.286]     else {
[15:32:07.286]         if (TRUE) {
[15:32:07.286]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.286]                 open = "w")
[15:32:07.286]         }
[15:32:07.286]         else {
[15:32:07.286]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.286]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.286]         }
[15:32:07.286]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.286]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.286]             base::sink(type = "output", split = FALSE)
[15:32:07.286]             base::close(...future.stdout)
[15:32:07.286]         }, add = TRUE)
[15:32:07.286]     }
[15:32:07.286]     ...future.frame <- base::sys.nframe()
[15:32:07.286]     ...future.conditions <- base::list()
[15:32:07.286]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.286]     if (FALSE) {
[15:32:07.286]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.286]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.286]     }
[15:32:07.286]     ...future.result <- base::tryCatch({
[15:32:07.286]         base::withCallingHandlers({
[15:32:07.286]             ...future.value <- base::withVisible(base::local({
[15:32:07.286]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.286]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.286]                   ...future.globals.maxSize)) {
[15:32:07.286]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.286]                   on.exit(options(oopts), add = TRUE)
[15:32:07.286]                 }
[15:32:07.286]                 {
[15:32:07.286]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.286]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.286]                     USE.NAMES = FALSE)
[15:32:07.286]                   do.call(mapply, args = args)
[15:32:07.286]                 }
[15:32:07.286]             }))
[15:32:07.286]             future::FutureResult(value = ...future.value$value, 
[15:32:07.286]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.286]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.286]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.286]                     ...future.globalenv.names))
[15:32:07.286]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.286]         }, condition = base::local({
[15:32:07.286]             c <- base::c
[15:32:07.286]             inherits <- base::inherits
[15:32:07.286]             invokeRestart <- base::invokeRestart
[15:32:07.286]             length <- base::length
[15:32:07.286]             list <- base::list
[15:32:07.286]             seq.int <- base::seq.int
[15:32:07.286]             signalCondition <- base::signalCondition
[15:32:07.286]             sys.calls <- base::sys.calls
[15:32:07.286]             `[[` <- base::`[[`
[15:32:07.286]             `+` <- base::`+`
[15:32:07.286]             `<<-` <- base::`<<-`
[15:32:07.286]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.286]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.286]                   3L)]
[15:32:07.286]             }
[15:32:07.286]             function(cond) {
[15:32:07.286]                 is_error <- inherits(cond, "error")
[15:32:07.286]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.286]                   NULL)
[15:32:07.286]                 if (is_error) {
[15:32:07.286]                   sessionInformation <- function() {
[15:32:07.286]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.286]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.286]                       search = base::search(), system = base::Sys.info())
[15:32:07.286]                   }
[15:32:07.286]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.286]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.286]                     cond$call), session = sessionInformation(), 
[15:32:07.286]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.286]                   signalCondition(cond)
[15:32:07.286]                 }
[15:32:07.286]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.286]                 "immediateCondition"))) {
[15:32:07.286]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.286]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.286]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.286]                   if (TRUE && !signal) {
[15:32:07.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.286]                     {
[15:32:07.286]                       inherits <- base::inherits
[15:32:07.286]                       invokeRestart <- base::invokeRestart
[15:32:07.286]                       is.null <- base::is.null
[15:32:07.286]                       muffled <- FALSE
[15:32:07.286]                       if (inherits(cond, "message")) {
[15:32:07.286]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.286]                         if (muffled) 
[15:32:07.286]                           invokeRestart("muffleMessage")
[15:32:07.286]                       }
[15:32:07.286]                       else if (inherits(cond, "warning")) {
[15:32:07.286]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.286]                         if (muffled) 
[15:32:07.286]                           invokeRestart("muffleWarning")
[15:32:07.286]                       }
[15:32:07.286]                       else if (inherits(cond, "condition")) {
[15:32:07.286]                         if (!is.null(pattern)) {
[15:32:07.286]                           computeRestarts <- base::computeRestarts
[15:32:07.286]                           grepl <- base::grepl
[15:32:07.286]                           restarts <- computeRestarts(cond)
[15:32:07.286]                           for (restart in restarts) {
[15:32:07.286]                             name <- restart$name
[15:32:07.286]                             if (is.null(name)) 
[15:32:07.286]                               next
[15:32:07.286]                             if (!grepl(pattern, name)) 
[15:32:07.286]                               next
[15:32:07.286]                             invokeRestart(restart)
[15:32:07.286]                             muffled <- TRUE
[15:32:07.286]                             break
[15:32:07.286]                           }
[15:32:07.286]                         }
[15:32:07.286]                       }
[15:32:07.286]                       invisible(muffled)
[15:32:07.286]                     }
[15:32:07.286]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.286]                   }
[15:32:07.286]                 }
[15:32:07.286]                 else {
[15:32:07.286]                   if (TRUE) {
[15:32:07.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.286]                     {
[15:32:07.286]                       inherits <- base::inherits
[15:32:07.286]                       invokeRestart <- base::invokeRestart
[15:32:07.286]                       is.null <- base::is.null
[15:32:07.286]                       muffled <- FALSE
[15:32:07.286]                       if (inherits(cond, "message")) {
[15:32:07.286]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.286]                         if (muffled) 
[15:32:07.286]                           invokeRestart("muffleMessage")
[15:32:07.286]                       }
[15:32:07.286]                       else if (inherits(cond, "warning")) {
[15:32:07.286]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.286]                         if (muffled) 
[15:32:07.286]                           invokeRestart("muffleWarning")
[15:32:07.286]                       }
[15:32:07.286]                       else if (inherits(cond, "condition")) {
[15:32:07.286]                         if (!is.null(pattern)) {
[15:32:07.286]                           computeRestarts <- base::computeRestarts
[15:32:07.286]                           grepl <- base::grepl
[15:32:07.286]                           restarts <- computeRestarts(cond)
[15:32:07.286]                           for (restart in restarts) {
[15:32:07.286]                             name <- restart$name
[15:32:07.286]                             if (is.null(name)) 
[15:32:07.286]                               next
[15:32:07.286]                             if (!grepl(pattern, name)) 
[15:32:07.286]                               next
[15:32:07.286]                             invokeRestart(restart)
[15:32:07.286]                             muffled <- TRUE
[15:32:07.286]                             break
[15:32:07.286]                           }
[15:32:07.286]                         }
[15:32:07.286]                       }
[15:32:07.286]                       invisible(muffled)
[15:32:07.286]                     }
[15:32:07.286]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.286]                   }
[15:32:07.286]                 }
[15:32:07.286]             }
[15:32:07.286]         }))
[15:32:07.286]     }, error = function(ex) {
[15:32:07.286]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.286]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.286]                 ...future.rng), started = ...future.startTime, 
[15:32:07.286]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.286]             version = "1.8"), class = "FutureResult")
[15:32:07.286]     }, finally = {
[15:32:07.286]         if (!identical(...future.workdir, getwd())) 
[15:32:07.286]             setwd(...future.workdir)
[15:32:07.286]         {
[15:32:07.286]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.286]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.286]             }
[15:32:07.286]             base::options(...future.oldOptions)
[15:32:07.286]             if (.Platform$OS.type == "windows") {
[15:32:07.286]                 old_names <- names(...future.oldEnvVars)
[15:32:07.286]                 envs <- base::Sys.getenv()
[15:32:07.286]                 names <- names(envs)
[15:32:07.286]                 common <- intersect(names, old_names)
[15:32:07.286]                 added <- setdiff(names, old_names)
[15:32:07.286]                 removed <- setdiff(old_names, names)
[15:32:07.286]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.286]                   envs[common]]
[15:32:07.286]                 NAMES <- toupper(changed)
[15:32:07.286]                 args <- list()
[15:32:07.286]                 for (kk in seq_along(NAMES)) {
[15:32:07.286]                   name <- changed[[kk]]
[15:32:07.286]                   NAME <- NAMES[[kk]]
[15:32:07.286]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.286]                     next
[15:32:07.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.286]                 }
[15:32:07.286]                 NAMES <- toupper(added)
[15:32:07.286]                 for (kk in seq_along(NAMES)) {
[15:32:07.286]                   name <- added[[kk]]
[15:32:07.286]                   NAME <- NAMES[[kk]]
[15:32:07.286]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.286]                     next
[15:32:07.286]                   args[[name]] <- ""
[15:32:07.286]                 }
[15:32:07.286]                 NAMES <- toupper(removed)
[15:32:07.286]                 for (kk in seq_along(NAMES)) {
[15:32:07.286]                   name <- removed[[kk]]
[15:32:07.286]                   NAME <- NAMES[[kk]]
[15:32:07.286]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.286]                     next
[15:32:07.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.286]                 }
[15:32:07.286]                 if (length(args) > 0) 
[15:32:07.286]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.286]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.286]             }
[15:32:07.286]             else {
[15:32:07.286]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.286]             }
[15:32:07.286]             {
[15:32:07.286]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.286]                   0L) {
[15:32:07.286]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.286]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.286]                   base::options(opts)
[15:32:07.286]                 }
[15:32:07.286]                 {
[15:32:07.286]                   {
[15:32:07.286]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.286]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.286]                     -253660479L), envir = base::globalenv(), 
[15:32:07.286]                       inherits = FALSE)
[15:32:07.286]                     NULL
[15:32:07.286]                   }
[15:32:07.286]                   options(future.plan = NULL)
[15:32:07.286]                   if (is.na(NA_character_)) 
[15:32:07.286]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.286]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.286]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.286]                     .init = FALSE)
[15:32:07.286]                 }
[15:32:07.286]             }
[15:32:07.286]         }
[15:32:07.286]     })
[15:32:07.286]     if (TRUE) {
[15:32:07.286]         base::sink(type = "output", split = FALSE)
[15:32:07.286]         if (TRUE) {
[15:32:07.286]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.286]         }
[15:32:07.286]         else {
[15:32:07.286]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.286]         }
[15:32:07.286]         base::close(...future.stdout)
[15:32:07.286]         ...future.stdout <- NULL
[15:32:07.286]     }
[15:32:07.286]     ...future.result$conditions <- ...future.conditions
[15:32:07.286]     ...future.result$finished <- base::Sys.time()
[15:32:07.286]     ...future.result
[15:32:07.286] }
[15:32:07.292] assign_globals() ...
[15:32:07.292] List of 5
[15:32:07.292]  $ ...future.FUN            :function (C, k)  
[15:32:07.292]  $ MoreArgs                 : NULL
[15:32:07.292]  $ ...future.elements_ii    :List of 2
[15:32:07.292]   ..$ :List of 1
[15:32:07.292]   .. ..$ : chr "E"
[15:32:07.292]   ..$ :List of 1
[15:32:07.292]   .. ..$ : int 1
[15:32:07.292]  $ ...future.seeds_ii       : NULL
[15:32:07.292]  $ ...future.globals.maxSize: NULL
[15:32:07.292]  - attr(*, "where")=List of 5
[15:32:07.292]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.292]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.292]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.292]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.292]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.292]  - attr(*, "resolved")= logi FALSE
[15:32:07.292]  - attr(*, "total_size")= num 3488
[15:32:07.292]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.292]  - attr(*, "already-done")= logi TRUE
[15:32:07.305] - reassign environment for '...future.FUN'
[15:32:07.306] - copied '...future.FUN' to environment
[15:32:07.306] - copied 'MoreArgs' to environment
[15:32:07.306] - copied '...future.elements_ii' to environment
[15:32:07.307] - copied '...future.seeds_ii' to environment
[15:32:07.307] - copied '...future.globals.maxSize' to environment
[15:32:07.307] assign_globals() ... done
[15:32:07.308] plan(): Setting new future strategy stack:
[15:32:07.309] List of future strategies:
[15:32:07.309] 1. sequential:
[15:32:07.309]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.309]    - tweaked: FALSE
[15:32:07.309]    - call: NULL
[15:32:07.310] plan(): nbrOfWorkers() = 1
[15:32:07.313] plan(): Setting new future strategy stack:
[15:32:07.313] List of future strategies:
[15:32:07.313] 1. sequential:
[15:32:07.313]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.313]    - tweaked: FALSE
[15:32:07.313]    - call: plan(strategy)
[15:32:07.314] plan(): nbrOfWorkers() = 1
[15:32:07.315] SequentialFuture started (and completed)
[15:32:07.315] - Launch lazy future ... done
[15:32:07.315] run() for 'SequentialFuture' ... done
[15:32:07.316] Created future:
[15:32:07.316] SequentialFuture:
[15:32:07.316] Label: 'future_mapply-5'
[15:32:07.316] Expression:
[15:32:07.316] {
[15:32:07.316]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.316]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.316]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.316]         on.exit(options(oopts), add = TRUE)
[15:32:07.316]     }
[15:32:07.316]     {
[15:32:07.316]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.316]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.316]         do.call(mapply, args = args)
[15:32:07.316]     }
[15:32:07.316] }
[15:32:07.316] Lazy evaluation: FALSE
[15:32:07.316] Asynchronous evaluation: FALSE
[15:32:07.316] Local evaluation: TRUE
[15:32:07.316] Environment: R_GlobalEnv
[15:32:07.316] Capture standard output: TRUE
[15:32:07.316] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.316] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.316] Packages: <none>
[15:32:07.316] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.316] Resolved: TRUE
[15:32:07.316] Value: 112 bytes of class 'list'
[15:32:07.316] Early signaling: FALSE
[15:32:07.316] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.316] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.318] Chunk #5 of 5 ... DONE
[15:32:07.319] Launching 5 futures (chunks) ... DONE
[15:32:07.319] Resolving 5 futures (chunks) ...
[15:32:07.319] resolve() on list ...
[15:32:07.319]  recursive: 0
[15:32:07.320]  length: 5
[15:32:07.320] 
[15:32:07.320] resolved() for 'SequentialFuture' ...
[15:32:07.321] - state: 'finished'
[15:32:07.321] - run: TRUE
[15:32:07.321] - result: 'FutureResult'
[15:32:07.322] resolved() for 'SequentialFuture' ... done
[15:32:07.322] Future #1
[15:32:07.322] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.323] - nx: 5
[15:32:07.323] - relay: TRUE
[15:32:07.323] - stdout: TRUE
[15:32:07.324] - signal: TRUE
[15:32:07.324] - resignal: FALSE
[15:32:07.324] - force: TRUE
[15:32:07.324] - relayed: [n=5] FALSE, FALSE, FALSE, FALSE, FALSE
[15:32:07.325] - queued futures: [n=5] FALSE, FALSE, FALSE, FALSE, FALSE
[15:32:07.325]  - until=1
[15:32:07.325]  - relaying element #1
[15:32:07.326] - relayed: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:07.326] - queued futures: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:07.326] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.327]  length: 4 (resolved future 1)
[15:32:07.327] resolved() for 'SequentialFuture' ...
[15:32:07.331] - state: 'finished'
[15:32:07.331] - run: TRUE
[15:32:07.332] - result: 'FutureResult'
[15:32:07.332] resolved() for 'SequentialFuture' ... done
[15:32:07.332] Future #2
[15:32:07.333] signalConditionsASAP(SequentialFuture, pos=2) ...
[15:32:07.333] - nx: 5
[15:32:07.333] - relay: TRUE
[15:32:07.334] - stdout: TRUE
[15:32:07.334] - signal: TRUE
[15:32:07.334] - resignal: FALSE
[15:32:07.335] - force: TRUE
[15:32:07.335] - relayed: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:07.335] - queued futures: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:07.336]  - until=2
[15:32:07.336]  - relaying element #2
[15:32:07.337] - relayed: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:07.337] - queued futures: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:07.337] signalConditionsASAP(SequentialFuture, pos=2) ... done
[15:32:07.338]  length: 3 (resolved future 2)
[15:32:07.338] resolved() for 'SequentialFuture' ...
[15:32:07.338] - state: 'finished'
[15:32:07.339] - run: TRUE
[15:32:07.339] - result: 'FutureResult'
[15:32:07.339] resolved() for 'SequentialFuture' ... done
[15:32:07.340] Future #3
[15:32:07.340] signalConditionsASAP(SequentialFuture, pos=3) ...
[15:32:07.340] - nx: 5
[15:32:07.340] - relay: TRUE
[15:32:07.341] - stdout: TRUE
[15:32:07.341] - signal: TRUE
[15:32:07.341] - resignal: FALSE
[15:32:07.342] - force: TRUE
[15:32:07.342] - relayed: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:07.342] - queued futures: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:07.342]  - until=3
[15:32:07.343]  - relaying element #3
[15:32:07.343] - relayed: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:07.343] - queued futures: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:07.344] signalConditionsASAP(SequentialFuture, pos=3) ... done
[15:32:07.344]  length: 2 (resolved future 3)
[15:32:07.344] resolved() for 'SequentialFuture' ...
[15:32:07.345] - state: 'finished'
[15:32:07.345] - run: TRUE
[15:32:07.345] - result: 'FutureResult'
[15:32:07.345] resolved() for 'SequentialFuture' ... done
[15:32:07.346] Future #4
[15:32:07.346] signalConditionsASAP(SequentialFuture, pos=4) ...
[15:32:07.346] - nx: 5
[15:32:07.347] - relay: TRUE
[15:32:07.347] - stdout: TRUE
[15:32:07.347] - signal: TRUE
[15:32:07.347] - resignal: FALSE
[15:32:07.347] - force: TRUE
[15:32:07.348] - relayed: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:07.348] - queued futures: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:07.348]  - until=4
[15:32:07.348]  - relaying element #4
[15:32:07.349] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:07.349] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:07.349] signalConditionsASAP(SequentialFuture, pos=4) ... done
[15:32:07.350]  length: 1 (resolved future 4)
[15:32:07.350] resolved() for 'SequentialFuture' ...
[15:32:07.350] - state: 'finished'
[15:32:07.351] - run: TRUE
[15:32:07.351] - result: 'FutureResult'
[15:32:07.351] resolved() for 'SequentialFuture' ... done
[15:32:07.351] Future #5
[15:32:07.352] signalConditionsASAP(SequentialFuture, pos=5) ...
[15:32:07.352] - nx: 5
[15:32:07.352] - relay: TRUE
[15:32:07.352] - stdout: TRUE
[15:32:07.353] - signal: TRUE
[15:32:07.353] - resignal: FALSE
[15:32:07.353] - force: TRUE
[15:32:07.353] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:07.353] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:07.354]  - until=5
[15:32:07.354]  - relaying element #5
[15:32:07.354] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:07.355] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:07.355] signalConditionsASAP(SequentialFuture, pos=5) ... done
[15:32:07.355]  length: 0 (resolved future 5)
[15:32:07.355] Relaying remaining futures
[15:32:07.356] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.356] - nx: 5
[15:32:07.356] - relay: TRUE
[15:32:07.356] - stdout: TRUE
[15:32:07.357] - signal: TRUE
[15:32:07.357] - resignal: FALSE
[15:32:07.357] - force: TRUE
[15:32:07.357] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:07.357] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
 - flush all
[15:32:07.358] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:07.358] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:07.358] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.359] resolve() on list ... DONE
[15:32:07.359]  - Number of value chunks collected: 5
[15:32:07.360] Resolving 5 futures (chunks) ... DONE
[15:32:07.360] Reducing values from 5 chunks ...
[15:32:07.360]  - Number of values collected after concatenation: 5
[15:32:07.360]  - Number of values expected: 5
[15:32:07.361] Reducing values from 5 chunks ... DONE
[15:32:07.361] future_mapply() ... DONE
[15:32:07.362] future_mapply() ...
[15:32:07.362] Number of chunks: 1
[15:32:07.362] getGlobalsAndPackagesXApply() ...
[15:32:07.362]  - future.globals: TRUE
[15:32:07.363] getGlobalsAndPackages() ...
[15:32:07.363] Searching for globals...
[15:32:07.365] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:07.366] Searching for globals ... DONE
[15:32:07.366] Resolving globals: FALSE
[15:32:07.367] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:07.367] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:07.368] - globals: [1] 'FUN'
[15:32:07.368] 
[15:32:07.368] getGlobalsAndPackages() ... DONE
[15:32:07.368]  - globals found/used: [n=1] 'FUN'
[15:32:07.369]  - needed namespaces: [n=0] 
[15:32:07.369] Finding globals ... DONE
[15:32:07.369] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.369] List of 2
[15:32:07.369]  $ ...future.FUN:function (C, k)  
[15:32:07.369]  $ MoreArgs     : list()
[15:32:07.369]  - attr(*, "where")=List of 2
[15:32:07.369]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.369]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.369]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.369]  - attr(*, "resolved")= logi FALSE
[15:32:07.369]  - attr(*, "total_size")= num NA
[15:32:07.377] Packages to be attached in all futures: [n=0] 
[15:32:07.377] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.377] Number of futures (= number of chunks): 1
[15:32:07.378] Launching 1 futures (chunks) ...
[15:32:07.378] Chunk #1 of 1 ...
[15:32:07.378]  - Finding globals in '...' for chunk #1 ...
[15:32:07.379] getGlobalsAndPackages() ...
[15:32:07.379] Searching for globals...
[15:32:07.380] 
[15:32:07.380] Searching for globals ... DONE
[15:32:07.380] - globals: [0] <none>
[15:32:07.380] getGlobalsAndPackages() ... DONE
[15:32:07.381]    + additional globals found: [n=0] 
[15:32:07.381]    + additional namespaces needed: [n=0] 
[15:32:07.381]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.381]  - seeds: <none>
[15:32:07.382]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.382] getGlobalsAndPackages() ...
[15:32:07.382] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.383] Resolving globals: FALSE
[15:32:07.384] The total size of the 5 globals is 4.06 KiB (4160 bytes)
[15:32:07.385] 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 4.06 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (840 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:07.385] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.385] 
[15:32:07.385] getGlobalsAndPackages() ... DONE
[15:32:07.386] run() for 'Future' ...
[15:32:07.386] - state: 'created'
[15:32:07.387] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.387] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.387] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.388]   - Field: 'label'
[15:32:07.388]   - Field: 'local'
[15:32:07.388]   - Field: 'owner'
[15:32:07.389]   - Field: 'envir'
[15:32:07.389]   - Field: 'packages'
[15:32:07.389]   - Field: 'gc'
[15:32:07.389]   - Field: 'conditions'
[15:32:07.390]   - Field: 'expr'
[15:32:07.390]   - Field: 'uuid'
[15:32:07.390]   - Field: 'seed'
[15:32:07.390]   - Field: 'version'
[15:32:07.391]   - Field: 'result'
[15:32:07.391]   - Field: 'asynchronous'
[15:32:07.391]   - Field: 'calls'
[15:32:07.392]   - Field: 'globals'
[15:32:07.392]   - Field: 'stdout'
[15:32:07.392]   - Field: 'earlySignal'
[15:32:07.392]   - Field: 'lazy'
[15:32:07.393]   - Field: 'state'
[15:32:07.393] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.393] - Launch lazy future ...
[15:32:07.394] Packages needed by the future expression (n = 0): <none>
[15:32:07.394] Packages needed by future strategies (n = 0): <none>
[15:32:07.395] {
[15:32:07.395]     {
[15:32:07.395]         {
[15:32:07.395]             ...future.startTime <- base::Sys.time()
[15:32:07.395]             {
[15:32:07.395]                 {
[15:32:07.395]                   {
[15:32:07.395]                     base::local({
[15:32:07.395]                       has_future <- base::requireNamespace("future", 
[15:32:07.395]                         quietly = TRUE)
[15:32:07.395]                       if (has_future) {
[15:32:07.395]                         ns <- base::getNamespace("future")
[15:32:07.395]                         version <- ns[[".package"]][["version"]]
[15:32:07.395]                         if (is.null(version)) 
[15:32:07.395]                           version <- utils::packageVersion("future")
[15:32:07.395]                       }
[15:32:07.395]                       else {
[15:32:07.395]                         version <- NULL
[15:32:07.395]                       }
[15:32:07.395]                       if (!has_future || version < "1.8.0") {
[15:32:07.395]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.395]                           "", base::R.version$version.string), 
[15:32:07.395]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.395]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.395]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.395]                             "release", "version")], collapse = " "), 
[15:32:07.395]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.395]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.395]                           info)
[15:32:07.395]                         info <- base::paste(info, collapse = "; ")
[15:32:07.395]                         if (!has_future) {
[15:32:07.395]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.395]                             info)
[15:32:07.395]                         }
[15:32:07.395]                         else {
[15:32:07.395]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.395]                             info, version)
[15:32:07.395]                         }
[15:32:07.395]                         base::stop(msg)
[15:32:07.395]                       }
[15:32:07.395]                     })
[15:32:07.395]                   }
[15:32:07.395]                   ...future.strategy.old <- future::plan("list")
[15:32:07.395]                   options(future.plan = NULL)
[15:32:07.395]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.395]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.395]                 }
[15:32:07.395]                 ...future.workdir <- getwd()
[15:32:07.395]             }
[15:32:07.395]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.395]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.395]         }
[15:32:07.395]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.395]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:07.395]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.395]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.395]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.395]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.395]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.395]             base::names(...future.oldOptions))
[15:32:07.395]     }
[15:32:07.395]     if (FALSE) {
[15:32:07.395]     }
[15:32:07.395]     else {
[15:32:07.395]         if (TRUE) {
[15:32:07.395]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.395]                 open = "w")
[15:32:07.395]         }
[15:32:07.395]         else {
[15:32:07.395]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.395]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.395]         }
[15:32:07.395]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.395]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.395]             base::sink(type = "output", split = FALSE)
[15:32:07.395]             base::close(...future.stdout)
[15:32:07.395]         }, add = TRUE)
[15:32:07.395]     }
[15:32:07.395]     ...future.frame <- base::sys.nframe()
[15:32:07.395]     ...future.conditions <- base::list()
[15:32:07.395]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.395]     if (FALSE) {
[15:32:07.395]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.395]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.395]     }
[15:32:07.395]     ...future.result <- base::tryCatch({
[15:32:07.395]         base::withCallingHandlers({
[15:32:07.395]             ...future.value <- base::withVisible(base::local({
[15:32:07.395]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.395]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.395]                   ...future.globals.maxSize)) {
[15:32:07.395]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.395]                   on.exit(options(oopts), add = TRUE)
[15:32:07.395]                 }
[15:32:07.395]                 {
[15:32:07.395]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.395]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.395]                     USE.NAMES = FALSE)
[15:32:07.395]                   do.call(mapply, args = args)
[15:32:07.395]                 }
[15:32:07.395]             }))
[15:32:07.395]             future::FutureResult(value = ...future.value$value, 
[15:32:07.395]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.395]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.395]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.395]                     ...future.globalenv.names))
[15:32:07.395]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.395]         }, condition = base::local({
[15:32:07.395]             c <- base::c
[15:32:07.395]             inherits <- base::inherits
[15:32:07.395]             invokeRestart <- base::invokeRestart
[15:32:07.395]             length <- base::length
[15:32:07.395]             list <- base::list
[15:32:07.395]             seq.int <- base::seq.int
[15:32:07.395]             signalCondition <- base::signalCondition
[15:32:07.395]             sys.calls <- base::sys.calls
[15:32:07.395]             `[[` <- base::`[[`
[15:32:07.395]             `+` <- base::`+`
[15:32:07.395]             `<<-` <- base::`<<-`
[15:32:07.395]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.395]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.395]                   3L)]
[15:32:07.395]             }
[15:32:07.395]             function(cond) {
[15:32:07.395]                 is_error <- inherits(cond, "error")
[15:32:07.395]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.395]                   NULL)
[15:32:07.395]                 if (is_error) {
[15:32:07.395]                   sessionInformation <- function() {
[15:32:07.395]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.395]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.395]                       search = base::search(), system = base::Sys.info())
[15:32:07.395]                   }
[15:32:07.395]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.395]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.395]                     cond$call), session = sessionInformation(), 
[15:32:07.395]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.395]                   signalCondition(cond)
[15:32:07.395]                 }
[15:32:07.395]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.395]                 "immediateCondition"))) {
[15:32:07.395]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.395]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.395]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.395]                   if (TRUE && !signal) {
[15:32:07.395]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.395]                     {
[15:32:07.395]                       inherits <- base::inherits
[15:32:07.395]                       invokeRestart <- base::invokeRestart
[15:32:07.395]                       is.null <- base::is.null
[15:32:07.395]                       muffled <- FALSE
[15:32:07.395]                       if (inherits(cond, "message")) {
[15:32:07.395]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.395]                         if (muffled) 
[15:32:07.395]                           invokeRestart("muffleMessage")
[15:32:07.395]                       }
[15:32:07.395]                       else if (inherits(cond, "warning")) {
[15:32:07.395]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.395]                         if (muffled) 
[15:32:07.395]                           invokeRestart("muffleWarning")
[15:32:07.395]                       }
[15:32:07.395]                       else if (inherits(cond, "condition")) {
[15:32:07.395]                         if (!is.null(pattern)) {
[15:32:07.395]                           computeRestarts <- base::computeRestarts
[15:32:07.395]                           grepl <- base::grepl
[15:32:07.395]                           restarts <- computeRestarts(cond)
[15:32:07.395]                           for (restart in restarts) {
[15:32:07.395]                             name <- restart$name
[15:32:07.395]                             if (is.null(name)) 
[15:32:07.395]                               next
[15:32:07.395]                             if (!grepl(pattern, name)) 
[15:32:07.395]                               next
[15:32:07.395]                             invokeRestart(restart)
[15:32:07.395]                             muffled <- TRUE
[15:32:07.395]                             break
[15:32:07.395]                           }
[15:32:07.395]                         }
[15:32:07.395]                       }
[15:32:07.395]                       invisible(muffled)
[15:32:07.395]                     }
[15:32:07.395]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.395]                   }
[15:32:07.395]                 }
[15:32:07.395]                 else {
[15:32:07.395]                   if (TRUE) {
[15:32:07.395]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.395]                     {
[15:32:07.395]                       inherits <- base::inherits
[15:32:07.395]                       invokeRestart <- base::invokeRestart
[15:32:07.395]                       is.null <- base::is.null
[15:32:07.395]                       muffled <- FALSE
[15:32:07.395]                       if (inherits(cond, "message")) {
[15:32:07.395]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.395]                         if (muffled) 
[15:32:07.395]                           invokeRestart("muffleMessage")
[15:32:07.395]                       }
[15:32:07.395]                       else if (inherits(cond, "warning")) {
[15:32:07.395]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.395]                         if (muffled) 
[15:32:07.395]                           invokeRestart("muffleWarning")
[15:32:07.395]                       }
[15:32:07.395]                       else if (inherits(cond, "condition")) {
[15:32:07.395]                         if (!is.null(pattern)) {
[15:32:07.395]                           computeRestarts <- base::computeRestarts
[15:32:07.395]                           grepl <- base::grepl
[15:32:07.395]                           restarts <- computeRestarts(cond)
[15:32:07.395]                           for (restart in restarts) {
[15:32:07.395]                             name <- restart$name
[15:32:07.395]                             if (is.null(name)) 
[15:32:07.395]                               next
[15:32:07.395]                             if (!grepl(pattern, name)) 
[15:32:07.395]                               next
[15:32:07.395]                             invokeRestart(restart)
[15:32:07.395]                             muffled <- TRUE
[15:32:07.395]                             break
[15:32:07.395]                           }
[15:32:07.395]                         }
[15:32:07.395]                       }
[15:32:07.395]                       invisible(muffled)
[15:32:07.395]                     }
[15:32:07.395]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.395]                   }
[15:32:07.395]                 }
[15:32:07.395]             }
[15:32:07.395]         }))
[15:32:07.395]     }, error = function(ex) {
[15:32:07.395]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.395]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.395]                 ...future.rng), started = ...future.startTime, 
[15:32:07.395]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.395]             version = "1.8"), class = "FutureResult")
[15:32:07.395]     }, finally = {
[15:32:07.395]         if (!identical(...future.workdir, getwd())) 
[15:32:07.395]             setwd(...future.workdir)
[15:32:07.395]         {
[15:32:07.395]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.395]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.395]             }
[15:32:07.395]             base::options(...future.oldOptions)
[15:32:07.395]             if (.Platform$OS.type == "windows") {
[15:32:07.395]                 old_names <- names(...future.oldEnvVars)
[15:32:07.395]                 envs <- base::Sys.getenv()
[15:32:07.395]                 names <- names(envs)
[15:32:07.395]                 common <- intersect(names, old_names)
[15:32:07.395]                 added <- setdiff(names, old_names)
[15:32:07.395]                 removed <- setdiff(old_names, names)
[15:32:07.395]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.395]                   envs[common]]
[15:32:07.395]                 NAMES <- toupper(changed)
[15:32:07.395]                 args <- list()
[15:32:07.395]                 for (kk in seq_along(NAMES)) {
[15:32:07.395]                   name <- changed[[kk]]
[15:32:07.395]                   NAME <- NAMES[[kk]]
[15:32:07.395]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.395]                     next
[15:32:07.395]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.395]                 }
[15:32:07.395]                 NAMES <- toupper(added)
[15:32:07.395]                 for (kk in seq_along(NAMES)) {
[15:32:07.395]                   name <- added[[kk]]
[15:32:07.395]                   NAME <- NAMES[[kk]]
[15:32:07.395]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.395]                     next
[15:32:07.395]                   args[[name]] <- ""
[15:32:07.395]                 }
[15:32:07.395]                 NAMES <- toupper(removed)
[15:32:07.395]                 for (kk in seq_along(NAMES)) {
[15:32:07.395]                   name <- removed[[kk]]
[15:32:07.395]                   NAME <- NAMES[[kk]]
[15:32:07.395]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.395]                     next
[15:32:07.395]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.395]                 }
[15:32:07.395]                 if (length(args) > 0) 
[15:32:07.395]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.395]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.395]             }
[15:32:07.395]             else {
[15:32:07.395]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.395]             }
[15:32:07.395]             {
[15:32:07.395]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.395]                   0L) {
[15:32:07.395]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.395]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.395]                   base::options(opts)
[15:32:07.395]                 }
[15:32:07.395]                 {
[15:32:07.395]                   {
[15:32:07.395]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.395]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.395]                     -253660479L), envir = base::globalenv(), 
[15:32:07.395]                       inherits = FALSE)
[15:32:07.395]                     NULL
[15:32:07.395]                   }
[15:32:07.395]                   options(future.plan = NULL)
[15:32:07.395]                   if (is.na(NA_character_)) 
[15:32:07.395]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.395]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.395]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.395]                     .init = FALSE)
[15:32:07.395]                 }
[15:32:07.395]             }
[15:32:07.395]         }
[15:32:07.395]     })
[15:32:07.395]     if (TRUE) {
[15:32:07.395]         base::sink(type = "output", split = FALSE)
[15:32:07.395]         if (TRUE) {
[15:32:07.395]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.395]         }
[15:32:07.395]         else {
[15:32:07.395]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.395]         }
[15:32:07.395]         base::close(...future.stdout)
[15:32:07.395]         ...future.stdout <- NULL
[15:32:07.395]     }
[15:32:07.395]     ...future.result$conditions <- ...future.conditions
[15:32:07.395]     ...future.result$finished <- base::Sys.time()
[15:32:07.395]     ...future.result
[15:32:07.395] }
[15:32:07.401] assign_globals() ...
[15:32:07.401] List of 5
[15:32:07.401]  $ ...future.FUN            :function (C, k)  
[15:32:07.401]  $ MoreArgs                 : list()
[15:32:07.401]  $ ...future.elements_ii    :List of 2
[15:32:07.401]   ..$ :List of 5
[15:32:07.401]   .. ..$ : chr "A"
[15:32:07.401]   .. ..$ : chr "B"
[15:32:07.401]   .. ..$ : chr "C"
[15:32:07.401]   .. ..$ : chr "D"
[15:32:07.401]   .. ..$ : chr "E"
[15:32:07.401]   ..$ :List of 5
[15:32:07.401]   .. ..$ : int 5
[15:32:07.401]   .. ..$ : int 4
[15:32:07.401]   .. ..$ : int 3
[15:32:07.401]   .. ..$ : int 2
[15:32:07.401]   .. ..$ : int 1
[15:32:07.401]  $ ...future.seeds_ii       : NULL
[15:32:07.401]  $ ...future.globals.maxSize: NULL
[15:32:07.401]  - attr(*, "where")=List of 5
[15:32:07.401]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.401]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.401]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.401]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.401]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.401]  - attr(*, "resolved")= logi FALSE
[15:32:07.401]  - attr(*, "total_size")= num 4160
[15:32:07.401]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.401]  - attr(*, "already-done")= logi TRUE
[15:32:07.414] - reassign environment for '...future.FUN'
[15:32:07.414] - copied '...future.FUN' to environment
[15:32:07.415] - copied 'MoreArgs' to environment
[15:32:07.415] - copied '...future.elements_ii' to environment
[15:32:07.415] - copied '...future.seeds_ii' to environment
[15:32:07.415] - copied '...future.globals.maxSize' to environment
[15:32:07.416] assign_globals() ... done
[15:32:07.416] plan(): Setting new future strategy stack:
[15:32:07.416] List of future strategies:
[15:32:07.416] 1. sequential:
[15:32:07.416]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.416]    - tweaked: FALSE
[15:32:07.416]    - call: NULL
[15:32:07.420] plan(): nbrOfWorkers() = 1
[15:32:07.422] plan(): Setting new future strategy stack:
[15:32:07.422] List of future strategies:
[15:32:07.422] 1. sequential:
[15:32:07.422]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.422]    - tweaked: FALSE
[15:32:07.422]    - call: plan(strategy)
[15:32:07.423] plan(): nbrOfWorkers() = 1
[15:32:07.423] SequentialFuture started (and completed)
[15:32:07.424] - Launch lazy future ... done
[15:32:07.424] run() for 'SequentialFuture' ... done
[15:32:07.424] Created future:
[15:32:07.425] SequentialFuture:
[15:32:07.425] Label: 'future_.mapply-1'
[15:32:07.425] Expression:
[15:32:07.425] {
[15:32:07.425]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.425]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.425]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.425]         on.exit(options(oopts), add = TRUE)
[15:32:07.425]     }
[15:32:07.425]     {
[15:32:07.425]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.425]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.425]         do.call(mapply, args = args)
[15:32:07.425]     }
[15:32:07.425] }
[15:32:07.425] Lazy evaluation: FALSE
[15:32:07.425] Asynchronous evaluation: FALSE
[15:32:07.425] Local evaluation: TRUE
[15:32:07.425] Environment: R_GlobalEnv
[15:32:07.425] Capture standard output: TRUE
[15:32:07.425] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.425] Globals: 5 objects totaling 4.06 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 840 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.425] Packages: <none>
[15:32:07.425] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.425] Resolved: TRUE
[15:32:07.425] Value: 560 bytes of class 'list'
[15:32:07.425] Early signaling: FALSE
[15:32:07.425] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.425] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.426] Chunk #1 of 1 ... DONE
[15:32:07.427] Launching 1 futures (chunks) ... DONE
[15:32:07.427] Resolving 1 futures (chunks) ...
[15:32:07.427] resolve() on list ...
[15:32:07.427]  recursive: 0
[15:32:07.427]  length: 1
[15:32:07.428] 
[15:32:07.428] resolved() for 'SequentialFuture' ...
[15:32:07.428] - state: 'finished'
[15:32:07.428] - run: TRUE
[15:32:07.429] - result: 'FutureResult'
[15:32:07.429] resolved() for 'SequentialFuture' ... done
[15:32:07.429] Future #1
[15:32:07.430] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.430] - nx: 1
[15:32:07.430] - relay: TRUE
[15:32:07.430] - stdout: TRUE
[15:32:07.430] - signal: TRUE
[15:32:07.431] - resignal: FALSE
[15:32:07.431] - force: TRUE
[15:32:07.431] - relayed: [n=1] FALSE
[15:32:07.431] - queued futures: [n=1] FALSE
[15:32:07.432]  - until=1
[15:32:07.432]  - relaying element #1
[15:32:07.432] - relayed: [n=1] TRUE
[15:32:07.432] - queued futures: [n=1] TRUE
[15:32:07.433] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.433]  length: 0 (resolved future 1)
[15:32:07.433] Relaying remaining futures
[15:32:07.433] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.434] - nx: 1
[15:32:07.434] - relay: TRUE
[15:32:07.434] - stdout: TRUE
[15:32:07.434] - signal: TRUE
[15:32:07.434] - resignal: FALSE
[15:32:07.435] - force: TRUE
[15:32:07.435] - relayed: [n=1] TRUE
[15:32:07.435] - queued futures: [n=1] TRUE
 - flush all
[15:32:07.435] - relayed: [n=1] TRUE
[15:32:07.436] - queued futures: [n=1] TRUE
[15:32:07.436] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.436] resolve() on list ... DONE
[15:32:07.436]  - Number of value chunks collected: 1
[15:32:07.437] Resolving 1 futures (chunks) ... DONE
[15:32:07.437] Reducing values from 1 chunks ...
[15:32:07.437]  - Number of values collected after concatenation: 5
[15:32:07.437]  - Number of values expected: 5
[15:32:07.438] Reducing values from 1 chunks ... DONE
[15:32:07.438] future_mapply() ... DONE
[15:32:07.438] future_mapply() ...
[15:32:07.439] Number of chunks: 3
[15:32:07.439] Index remapping (attribute 'ordering'): [n = 5] 1, 5, 2, 4, 3
[15:32:07.440] getGlobalsAndPackagesXApply() ...
[15:32:07.440]  - future.globals: TRUE
[15:32:07.440] getGlobalsAndPackages() ...
[15:32:07.440] Searching for globals...
[15:32:07.443] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:07.443] Searching for globals ... DONE
[15:32:07.443] Resolving globals: FALSE
[15:32:07.444] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:07.445] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:07.445] - globals: [1] 'FUN'
[15:32:07.445] 
[15:32:07.445] getGlobalsAndPackages() ... DONE
[15:32:07.446]  - globals found/used: [n=1] 'FUN'
[15:32:07.446]  - needed namespaces: [n=0] 
[15:32:07.446] Finding globals ... DONE
[15:32:07.446] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.447] List of 2
[15:32:07.447]  $ ...future.FUN:function (C, k)  
[15:32:07.447]  $ MoreArgs     : NULL
[15:32:07.447]  - attr(*, "where")=List of 2
[15:32:07.447]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.447]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.447]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.447]  - attr(*, "resolved")= logi FALSE
[15:32:07.447]  - attr(*, "total_size")= num NA
[15:32:07.451] Packages to be attached in all futures: [n=0] 
[15:32:07.451] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.452] Number of futures (= number of chunks): 3
[15:32:07.452] Launching 3 futures (chunks) ...
[15:32:07.452] Chunk #1 of 3 ...
[15:32:07.452]  - Finding globals in '...' for chunk #1 ...
[15:32:07.453] getGlobalsAndPackages() ...
[15:32:07.453] Searching for globals...
[15:32:07.453] 
[15:32:07.454] Searching for globals ... DONE
[15:32:07.454] - globals: [0] <none>
[15:32:07.454] getGlobalsAndPackages() ... DONE
[15:32:07.454]    + additional globals found: [n=0] 
[15:32:07.455]    + additional namespaces needed: [n=0] 
[15:32:07.455]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.455]  - Adjusted option 'future.globals.maxSize': 524288000 -> 3 * 524288000 = 1572864000 (bytes)
[15:32:07.455]  - seeds: <none>
[15:32:07.455]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.456] getGlobalsAndPackages() ...
[15:32:07.456] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.456] Resolving globals: FALSE
[15:32:07.460] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:07.461] 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 3.57 KiB.. This exceeds the maximum allowed size of 1.46 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.461] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.461] 
[15:32:07.462] getGlobalsAndPackages() ... DONE
[15:32:07.462] run() for 'Future' ...
[15:32:07.463] - state: 'created'
[15:32:07.463] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.463] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.464] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.464]   - Field: 'label'
[15:32:07.464]   - Field: 'local'
[15:32:07.465]   - Field: 'owner'
[15:32:07.465]   - Field: 'envir'
[15:32:07.465]   - Field: 'packages'
[15:32:07.465]   - Field: 'gc'
[15:32:07.466]   - Field: 'conditions'
[15:32:07.466]   - Field: 'expr'
[15:32:07.466]   - Field: 'uuid'
[15:32:07.466]   - Field: 'seed'
[15:32:07.467]   - Field: 'version'
[15:32:07.467]   - Field: 'result'
[15:32:07.467]   - Field: 'asynchronous'
[15:32:07.467]   - Field: 'calls'
[15:32:07.468]   - Field: 'globals'
[15:32:07.468]   - Field: 'stdout'
[15:32:07.468]   - Field: 'earlySignal'
[15:32:07.468]   - Field: 'lazy'
[15:32:07.469]   - Field: 'state'
[15:32:07.469] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.469] - Launch lazy future ...
[15:32:07.469] Packages needed by the future expression (n = 0): <none>
[15:32:07.470] Packages needed by future strategies (n = 0): <none>
[15:32:07.471] {
[15:32:07.471]     {
[15:32:07.471]         {
[15:32:07.471]             ...future.startTime <- base::Sys.time()
[15:32:07.471]             {
[15:32:07.471]                 {
[15:32:07.471]                   {
[15:32:07.471]                     base::local({
[15:32:07.471]                       has_future <- base::requireNamespace("future", 
[15:32:07.471]                         quietly = TRUE)
[15:32:07.471]                       if (has_future) {
[15:32:07.471]                         ns <- base::getNamespace("future")
[15:32:07.471]                         version <- ns[[".package"]][["version"]]
[15:32:07.471]                         if (is.null(version)) 
[15:32:07.471]                           version <- utils::packageVersion("future")
[15:32:07.471]                       }
[15:32:07.471]                       else {
[15:32:07.471]                         version <- NULL
[15:32:07.471]                       }
[15:32:07.471]                       if (!has_future || version < "1.8.0") {
[15:32:07.471]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.471]                           "", base::R.version$version.string), 
[15:32:07.471]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.471]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.471]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.471]                             "release", "version")], collapse = " "), 
[15:32:07.471]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.471]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.471]                           info)
[15:32:07.471]                         info <- base::paste(info, collapse = "; ")
[15:32:07.471]                         if (!has_future) {
[15:32:07.471]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.471]                             info)
[15:32:07.471]                         }
[15:32:07.471]                         else {
[15:32:07.471]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.471]                             info, version)
[15:32:07.471]                         }
[15:32:07.471]                         base::stop(msg)
[15:32:07.471]                       }
[15:32:07.471]                     })
[15:32:07.471]                   }
[15:32:07.471]                   ...future.strategy.old <- future::plan("list")
[15:32:07.471]                   options(future.plan = NULL)
[15:32:07.471]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.471]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.471]                 }
[15:32:07.471]                 ...future.workdir <- getwd()
[15:32:07.471]             }
[15:32:07.471]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.471]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.471]         }
[15:32:07.471]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.471]             future.globals.maxSize = 1572864000, future.globals.method = NULL, 
[15:32:07.471]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.471]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.471]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.471]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.471]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.471]             base::names(...future.oldOptions))
[15:32:07.471]     }
[15:32:07.471]     if (FALSE) {
[15:32:07.471]     }
[15:32:07.471]     else {
[15:32:07.471]         if (TRUE) {
[15:32:07.471]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.471]                 open = "w")
[15:32:07.471]         }
[15:32:07.471]         else {
[15:32:07.471]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.471]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.471]         }
[15:32:07.471]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.471]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.471]             base::sink(type = "output", split = FALSE)
[15:32:07.471]             base::close(...future.stdout)
[15:32:07.471]         }, add = TRUE)
[15:32:07.471]     }
[15:32:07.471]     ...future.frame <- base::sys.nframe()
[15:32:07.471]     ...future.conditions <- base::list()
[15:32:07.471]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.471]     if (FALSE) {
[15:32:07.471]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.471]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.471]     }
[15:32:07.471]     ...future.result <- base::tryCatch({
[15:32:07.471]         base::withCallingHandlers({
[15:32:07.471]             ...future.value <- base::withVisible(base::local({
[15:32:07.471]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.471]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.471]                   ...future.globals.maxSize)) {
[15:32:07.471]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.471]                   on.exit(options(oopts), add = TRUE)
[15:32:07.471]                 }
[15:32:07.471]                 {
[15:32:07.471]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.471]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.471]                     USE.NAMES = FALSE)
[15:32:07.471]                   do.call(mapply, args = args)
[15:32:07.471]                 }
[15:32:07.471]             }))
[15:32:07.471]             future::FutureResult(value = ...future.value$value, 
[15:32:07.471]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.471]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.471]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.471]                     ...future.globalenv.names))
[15:32:07.471]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.471]         }, condition = base::local({
[15:32:07.471]             c <- base::c
[15:32:07.471]             inherits <- base::inherits
[15:32:07.471]             invokeRestart <- base::invokeRestart
[15:32:07.471]             length <- base::length
[15:32:07.471]             list <- base::list
[15:32:07.471]             seq.int <- base::seq.int
[15:32:07.471]             signalCondition <- base::signalCondition
[15:32:07.471]             sys.calls <- base::sys.calls
[15:32:07.471]             `[[` <- base::`[[`
[15:32:07.471]             `+` <- base::`+`
[15:32:07.471]             `<<-` <- base::`<<-`
[15:32:07.471]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.471]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.471]                   3L)]
[15:32:07.471]             }
[15:32:07.471]             function(cond) {
[15:32:07.471]                 is_error <- inherits(cond, "error")
[15:32:07.471]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.471]                   NULL)
[15:32:07.471]                 if (is_error) {
[15:32:07.471]                   sessionInformation <- function() {
[15:32:07.471]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.471]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.471]                       search = base::search(), system = base::Sys.info())
[15:32:07.471]                   }
[15:32:07.471]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.471]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.471]                     cond$call), session = sessionInformation(), 
[15:32:07.471]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.471]                   signalCondition(cond)
[15:32:07.471]                 }
[15:32:07.471]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.471]                 "immediateCondition"))) {
[15:32:07.471]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.471]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.471]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.471]                   if (TRUE && !signal) {
[15:32:07.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.471]                     {
[15:32:07.471]                       inherits <- base::inherits
[15:32:07.471]                       invokeRestart <- base::invokeRestart
[15:32:07.471]                       is.null <- base::is.null
[15:32:07.471]                       muffled <- FALSE
[15:32:07.471]                       if (inherits(cond, "message")) {
[15:32:07.471]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.471]                         if (muffled) 
[15:32:07.471]                           invokeRestart("muffleMessage")
[15:32:07.471]                       }
[15:32:07.471]                       else if (inherits(cond, "warning")) {
[15:32:07.471]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.471]                         if (muffled) 
[15:32:07.471]                           invokeRestart("muffleWarning")
[15:32:07.471]                       }
[15:32:07.471]                       else if (inherits(cond, "condition")) {
[15:32:07.471]                         if (!is.null(pattern)) {
[15:32:07.471]                           computeRestarts <- base::computeRestarts
[15:32:07.471]                           grepl <- base::grepl
[15:32:07.471]                           restarts <- computeRestarts(cond)
[15:32:07.471]                           for (restart in restarts) {
[15:32:07.471]                             name <- restart$name
[15:32:07.471]                             if (is.null(name)) 
[15:32:07.471]                               next
[15:32:07.471]                             if (!grepl(pattern, name)) 
[15:32:07.471]                               next
[15:32:07.471]                             invokeRestart(restart)
[15:32:07.471]                             muffled <- TRUE
[15:32:07.471]                             break
[15:32:07.471]                           }
[15:32:07.471]                         }
[15:32:07.471]                       }
[15:32:07.471]                       invisible(muffled)
[15:32:07.471]                     }
[15:32:07.471]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.471]                   }
[15:32:07.471]                 }
[15:32:07.471]                 else {
[15:32:07.471]                   if (TRUE) {
[15:32:07.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.471]                     {
[15:32:07.471]                       inherits <- base::inherits
[15:32:07.471]                       invokeRestart <- base::invokeRestart
[15:32:07.471]                       is.null <- base::is.null
[15:32:07.471]                       muffled <- FALSE
[15:32:07.471]                       if (inherits(cond, "message")) {
[15:32:07.471]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.471]                         if (muffled) 
[15:32:07.471]                           invokeRestart("muffleMessage")
[15:32:07.471]                       }
[15:32:07.471]                       else if (inherits(cond, "warning")) {
[15:32:07.471]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.471]                         if (muffled) 
[15:32:07.471]                           invokeRestart("muffleWarning")
[15:32:07.471]                       }
[15:32:07.471]                       else if (inherits(cond, "condition")) {
[15:32:07.471]                         if (!is.null(pattern)) {
[15:32:07.471]                           computeRestarts <- base::computeRestarts
[15:32:07.471]                           grepl <- base::grepl
[15:32:07.471]                           restarts <- computeRestarts(cond)
[15:32:07.471]                           for (restart in restarts) {
[15:32:07.471]                             name <- restart$name
[15:32:07.471]                             if (is.null(name)) 
[15:32:07.471]                               next
[15:32:07.471]                             if (!grepl(pattern, name)) 
[15:32:07.471]                               next
[15:32:07.471]                             invokeRestart(restart)
[15:32:07.471]                             muffled <- TRUE
[15:32:07.471]                             break
[15:32:07.471]                           }
[15:32:07.471]                         }
[15:32:07.471]                       }
[15:32:07.471]                       invisible(muffled)
[15:32:07.471]                     }
[15:32:07.471]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.471]                   }
[15:32:07.471]                 }
[15:32:07.471]             }
[15:32:07.471]         }))
[15:32:07.471]     }, error = function(ex) {
[15:32:07.471]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.471]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.471]                 ...future.rng), started = ...future.startTime, 
[15:32:07.471]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.471]             version = "1.8"), class = "FutureResult")
[15:32:07.471]     }, finally = {
[15:32:07.471]         if (!identical(...future.workdir, getwd())) 
[15:32:07.471]             setwd(...future.workdir)
[15:32:07.471]         {
[15:32:07.471]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.471]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.471]             }
[15:32:07.471]             base::options(...future.oldOptions)
[15:32:07.471]             if (.Platform$OS.type == "windows") {
[15:32:07.471]                 old_names <- names(...future.oldEnvVars)
[15:32:07.471]                 envs <- base::Sys.getenv()
[15:32:07.471]                 names <- names(envs)
[15:32:07.471]                 common <- intersect(names, old_names)
[15:32:07.471]                 added <- setdiff(names, old_names)
[15:32:07.471]                 removed <- setdiff(old_names, names)
[15:32:07.471]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.471]                   envs[common]]
[15:32:07.471]                 NAMES <- toupper(changed)
[15:32:07.471]                 args <- list()
[15:32:07.471]                 for (kk in seq_along(NAMES)) {
[15:32:07.471]                   name <- changed[[kk]]
[15:32:07.471]                   NAME <- NAMES[[kk]]
[15:32:07.471]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.471]                     next
[15:32:07.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.471]                 }
[15:32:07.471]                 NAMES <- toupper(added)
[15:32:07.471]                 for (kk in seq_along(NAMES)) {
[15:32:07.471]                   name <- added[[kk]]
[15:32:07.471]                   NAME <- NAMES[[kk]]
[15:32:07.471]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.471]                     next
[15:32:07.471]                   args[[name]] <- ""
[15:32:07.471]                 }
[15:32:07.471]                 NAMES <- toupper(removed)
[15:32:07.471]                 for (kk in seq_along(NAMES)) {
[15:32:07.471]                   name <- removed[[kk]]
[15:32:07.471]                   NAME <- NAMES[[kk]]
[15:32:07.471]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.471]                     next
[15:32:07.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.471]                 }
[15:32:07.471]                 if (length(args) > 0) 
[15:32:07.471]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.471]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.471]             }
[15:32:07.471]             else {
[15:32:07.471]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.471]             }
[15:32:07.471]             {
[15:32:07.471]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.471]                   0L) {
[15:32:07.471]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.471]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.471]                   base::options(opts)
[15:32:07.471]                 }
[15:32:07.471]                 {
[15:32:07.471]                   {
[15:32:07.471]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.471]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.471]                     -253660479L), envir = base::globalenv(), 
[15:32:07.471]                       inherits = FALSE)
[15:32:07.471]                     NULL
[15:32:07.471]                   }
[15:32:07.471]                   options(future.plan = NULL)
[15:32:07.471]                   if (is.na(NA_character_)) 
[15:32:07.471]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.471]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.471]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.471]                     .init = FALSE)
[15:32:07.471]                 }
[15:32:07.471]             }
[15:32:07.471]         }
[15:32:07.471]     })
[15:32:07.471]     if (TRUE) {
[15:32:07.471]         base::sink(type = "output", split = FALSE)
[15:32:07.471]         if (TRUE) {
[15:32:07.471]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.471]         }
[15:32:07.471]         else {
[15:32:07.471]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.471]         }
[15:32:07.471]         base::close(...future.stdout)
[15:32:07.471]         ...future.stdout <- NULL
[15:32:07.471]     }
[15:32:07.471]     ...future.result$conditions <- ...future.conditions
[15:32:07.471]     ...future.result$finished <- base::Sys.time()
[15:32:07.471]     ...future.result
[15:32:07.471] }
[15:32:07.476] assign_globals() ...
[15:32:07.476] List of 5
[15:32:07.476]  $ ...future.FUN            :function (C, k)  
[15:32:07.476]  $ MoreArgs                 : NULL
[15:32:07.476]  $ ...future.elements_ii    :List of 2
[15:32:07.476]   ..$ :List of 2
[15:32:07.476]   .. ..$ : chr "A"
[15:32:07.476]   .. ..$ : chr "E"
[15:32:07.476]   ..$ :List of 2
[15:32:07.476]   .. ..$ : int 5
[15:32:07.476]   .. ..$ : int 1
[15:32:07.476]  $ ...future.seeds_ii       : NULL
[15:32:07.476]  $ ...future.globals.maxSize: NULL
[15:32:07.476]  - attr(*, "where")=List of 5
[15:32:07.476]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.476]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.476]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.476]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.476]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.476]  - attr(*, "resolved")= logi FALSE
[15:32:07.476]  - attr(*, "total_size")= num 3656
[15:32:07.476]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.476]  - attr(*, "already-done")= logi TRUE
[15:32:07.486] - reassign environment for '...future.FUN'
[15:32:07.486] - copied '...future.FUN' to environment
[15:32:07.487] - copied 'MoreArgs' to environment
[15:32:07.487] - copied '...future.elements_ii' to environment
[15:32:07.487] - copied '...future.seeds_ii' to environment
[15:32:07.487] - copied '...future.globals.maxSize' to environment
[15:32:07.488] assign_globals() ... done
[15:32:07.488] plan(): Setting new future strategy stack:
[15:32:07.488] List of future strategies:
[15:32:07.488] 1. sequential:
[15:32:07.488]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.488]    - tweaked: FALSE
[15:32:07.488]    - call: NULL
[15:32:07.489] plan(): nbrOfWorkers() = 1
[15:32:07.491] plan(): Setting new future strategy stack:
[15:32:07.491] List of future strategies:
[15:32:07.491] 1. sequential:
[15:32:07.491]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.491]    - tweaked: FALSE
[15:32:07.491]    - call: plan(strategy)
[15:32:07.492] plan(): nbrOfWorkers() = 1
[15:32:07.492] SequentialFuture started (and completed)
[15:32:07.493] - Launch lazy future ... done
[15:32:07.493] run() for 'SequentialFuture' ... done
[15:32:07.493] Created future:
[15:32:07.494] SequentialFuture:
[15:32:07.494] Label: 'future_mapply-1'
[15:32:07.494] Expression:
[15:32:07.494] {
[15:32:07.494]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.494]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.494]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.494]         on.exit(options(oopts), add = TRUE)
[15:32:07.494]     }
[15:32:07.494]     {
[15:32:07.494]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.494]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.494]         do.call(mapply, args = args)
[15:32:07.494]     }
[15:32:07.494] }
[15:32:07.494] Lazy evaluation: FALSE
[15:32:07.494] Asynchronous evaluation: FALSE
[15:32:07.494] Local evaluation: TRUE
[15:32:07.494] Environment: R_GlobalEnv
[15:32:07.494] Capture standard output: TRUE
[15:32:07.494] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.494] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.494] Packages: <none>
[15:32:07.494] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.494] Resolved: TRUE
[15:32:07.494] Value: 224 bytes of class 'list'
[15:32:07.494] Early signaling: FALSE
[15:32:07.494] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.494] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.495] Chunk #1 of 3 ... DONE
[15:32:07.496] Chunk #2 of 3 ...
[15:32:07.496]  - Finding globals in '...' for chunk #2 ...
[15:32:07.496] getGlobalsAndPackages() ...
[15:32:07.496] Searching for globals...
[15:32:07.497] 
[15:32:07.497] Searching for globals ... DONE
[15:32:07.497] - globals: [0] <none>
[15:32:07.498] getGlobalsAndPackages() ... DONE
[15:32:07.498]    + additional globals found: [n=0] 
[15:32:07.498]    + additional namespaces needed: [n=0] 
[15:32:07.498]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:07.499]  - Adjusted option 'future.globals.maxSize': 524288000 -> 3 * 524288000 = 1572864000 (bytes)
[15:32:07.499]  - seeds: <none>
[15:32:07.499]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.499] getGlobalsAndPackages() ...
[15:32:07.502] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.502] Resolving globals: FALSE
[15:32:07.503] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:07.504] 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 3.41 KiB.. This exceeds the maximum allowed size of 1.46 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.505] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.505] 
[15:32:07.505] getGlobalsAndPackages() ... DONE
[15:32:07.506] run() for 'Future' ...
[15:32:07.506] - state: 'created'
[15:32:07.506] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.507] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.507] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.507]   - Field: 'label'
[15:32:07.508]   - Field: 'local'
[15:32:07.508]   - Field: 'owner'
[15:32:07.508]   - Field: 'envir'
[15:32:07.509]   - Field: 'packages'
[15:32:07.509]   - Field: 'gc'
[15:32:07.509]   - Field: 'conditions'
[15:32:07.509]   - Field: 'expr'
[15:32:07.510]   - Field: 'uuid'
[15:32:07.510]   - Field: 'seed'
[15:32:07.510]   - Field: 'version'
[15:32:07.510]   - Field: 'result'
[15:32:07.511]   - Field: 'asynchronous'
[15:32:07.511]   - Field: 'calls'
[15:32:07.511]   - Field: 'globals'
[15:32:07.511]   - Field: 'stdout'
[15:32:07.512]   - Field: 'earlySignal'
[15:32:07.512]   - Field: 'lazy'
[15:32:07.512]   - Field: 'state'
[15:32:07.512] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.513] - Launch lazy future ...
[15:32:07.513] Packages needed by the future expression (n = 0): <none>
[15:32:07.513] Packages needed by future strategies (n = 0): <none>
[15:32:07.514] {
[15:32:07.514]     {
[15:32:07.514]         {
[15:32:07.514]             ...future.startTime <- base::Sys.time()
[15:32:07.514]             {
[15:32:07.514]                 {
[15:32:07.514]                   {
[15:32:07.514]                     base::local({
[15:32:07.514]                       has_future <- base::requireNamespace("future", 
[15:32:07.514]                         quietly = TRUE)
[15:32:07.514]                       if (has_future) {
[15:32:07.514]                         ns <- base::getNamespace("future")
[15:32:07.514]                         version <- ns[[".package"]][["version"]]
[15:32:07.514]                         if (is.null(version)) 
[15:32:07.514]                           version <- utils::packageVersion("future")
[15:32:07.514]                       }
[15:32:07.514]                       else {
[15:32:07.514]                         version <- NULL
[15:32:07.514]                       }
[15:32:07.514]                       if (!has_future || version < "1.8.0") {
[15:32:07.514]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.514]                           "", base::R.version$version.string), 
[15:32:07.514]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.514]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.514]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.514]                             "release", "version")], collapse = " "), 
[15:32:07.514]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.514]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.514]                           info)
[15:32:07.514]                         info <- base::paste(info, collapse = "; ")
[15:32:07.514]                         if (!has_future) {
[15:32:07.514]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.514]                             info)
[15:32:07.514]                         }
[15:32:07.514]                         else {
[15:32:07.514]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.514]                             info, version)
[15:32:07.514]                         }
[15:32:07.514]                         base::stop(msg)
[15:32:07.514]                       }
[15:32:07.514]                     })
[15:32:07.514]                   }
[15:32:07.514]                   ...future.strategy.old <- future::plan("list")
[15:32:07.514]                   options(future.plan = NULL)
[15:32:07.514]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.514]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.514]                 }
[15:32:07.514]                 ...future.workdir <- getwd()
[15:32:07.514]             }
[15:32:07.514]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.514]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.514]         }
[15:32:07.514]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.514]             future.globals.maxSize = 1572864000, future.globals.method = NULL, 
[15:32:07.514]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.514]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.514]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.514]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.514]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.514]             base::names(...future.oldOptions))
[15:32:07.514]     }
[15:32:07.514]     if (FALSE) {
[15:32:07.514]     }
[15:32:07.514]     else {
[15:32:07.514]         if (TRUE) {
[15:32:07.514]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.514]                 open = "w")
[15:32:07.514]         }
[15:32:07.514]         else {
[15:32:07.514]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.514]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.514]         }
[15:32:07.514]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.514]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.514]             base::sink(type = "output", split = FALSE)
[15:32:07.514]             base::close(...future.stdout)
[15:32:07.514]         }, add = TRUE)
[15:32:07.514]     }
[15:32:07.514]     ...future.frame <- base::sys.nframe()
[15:32:07.514]     ...future.conditions <- base::list()
[15:32:07.514]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.514]     if (FALSE) {
[15:32:07.514]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.514]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.514]     }
[15:32:07.514]     ...future.result <- base::tryCatch({
[15:32:07.514]         base::withCallingHandlers({
[15:32:07.514]             ...future.value <- base::withVisible(base::local({
[15:32:07.514]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.514]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.514]                   ...future.globals.maxSize)) {
[15:32:07.514]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.514]                   on.exit(options(oopts), add = TRUE)
[15:32:07.514]                 }
[15:32:07.514]                 {
[15:32:07.514]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.514]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.514]                     USE.NAMES = FALSE)
[15:32:07.514]                   do.call(mapply, args = args)
[15:32:07.514]                 }
[15:32:07.514]             }))
[15:32:07.514]             future::FutureResult(value = ...future.value$value, 
[15:32:07.514]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.514]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.514]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.514]                     ...future.globalenv.names))
[15:32:07.514]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.514]         }, condition = base::local({
[15:32:07.514]             c <- base::c
[15:32:07.514]             inherits <- base::inherits
[15:32:07.514]             invokeRestart <- base::invokeRestart
[15:32:07.514]             length <- base::length
[15:32:07.514]             list <- base::list
[15:32:07.514]             seq.int <- base::seq.int
[15:32:07.514]             signalCondition <- base::signalCondition
[15:32:07.514]             sys.calls <- base::sys.calls
[15:32:07.514]             `[[` <- base::`[[`
[15:32:07.514]             `+` <- base::`+`
[15:32:07.514]             `<<-` <- base::`<<-`
[15:32:07.514]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.514]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.514]                   3L)]
[15:32:07.514]             }
[15:32:07.514]             function(cond) {
[15:32:07.514]                 is_error <- inherits(cond, "error")
[15:32:07.514]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.514]                   NULL)
[15:32:07.514]                 if (is_error) {
[15:32:07.514]                   sessionInformation <- function() {
[15:32:07.514]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.514]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.514]                       search = base::search(), system = base::Sys.info())
[15:32:07.514]                   }
[15:32:07.514]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.514]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.514]                     cond$call), session = sessionInformation(), 
[15:32:07.514]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.514]                   signalCondition(cond)
[15:32:07.514]                 }
[15:32:07.514]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.514]                 "immediateCondition"))) {
[15:32:07.514]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.514]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.514]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.514]                   if (TRUE && !signal) {
[15:32:07.514]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.514]                     {
[15:32:07.514]                       inherits <- base::inherits
[15:32:07.514]                       invokeRestart <- base::invokeRestart
[15:32:07.514]                       is.null <- base::is.null
[15:32:07.514]                       muffled <- FALSE
[15:32:07.514]                       if (inherits(cond, "message")) {
[15:32:07.514]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.514]                         if (muffled) 
[15:32:07.514]                           invokeRestart("muffleMessage")
[15:32:07.514]                       }
[15:32:07.514]                       else if (inherits(cond, "warning")) {
[15:32:07.514]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.514]                         if (muffled) 
[15:32:07.514]                           invokeRestart("muffleWarning")
[15:32:07.514]                       }
[15:32:07.514]                       else if (inherits(cond, "condition")) {
[15:32:07.514]                         if (!is.null(pattern)) {
[15:32:07.514]                           computeRestarts <- base::computeRestarts
[15:32:07.514]                           grepl <- base::grepl
[15:32:07.514]                           restarts <- computeRestarts(cond)
[15:32:07.514]                           for (restart in restarts) {
[15:32:07.514]                             name <- restart$name
[15:32:07.514]                             if (is.null(name)) 
[15:32:07.514]                               next
[15:32:07.514]                             if (!grepl(pattern, name)) 
[15:32:07.514]                               next
[15:32:07.514]                             invokeRestart(restart)
[15:32:07.514]                             muffled <- TRUE
[15:32:07.514]                             break
[15:32:07.514]                           }
[15:32:07.514]                         }
[15:32:07.514]                       }
[15:32:07.514]                       invisible(muffled)
[15:32:07.514]                     }
[15:32:07.514]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.514]                   }
[15:32:07.514]                 }
[15:32:07.514]                 else {
[15:32:07.514]                   if (TRUE) {
[15:32:07.514]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.514]                     {
[15:32:07.514]                       inherits <- base::inherits
[15:32:07.514]                       invokeRestart <- base::invokeRestart
[15:32:07.514]                       is.null <- base::is.null
[15:32:07.514]                       muffled <- FALSE
[15:32:07.514]                       if (inherits(cond, "message")) {
[15:32:07.514]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.514]                         if (muffled) 
[15:32:07.514]                           invokeRestart("muffleMessage")
[15:32:07.514]                       }
[15:32:07.514]                       else if (inherits(cond, "warning")) {
[15:32:07.514]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.514]                         if (muffled) 
[15:32:07.514]                           invokeRestart("muffleWarning")
[15:32:07.514]                       }
[15:32:07.514]                       else if (inherits(cond, "condition")) {
[15:32:07.514]                         if (!is.null(pattern)) {
[15:32:07.514]                           computeRestarts <- base::computeRestarts
[15:32:07.514]                           grepl <- base::grepl
[15:32:07.514]                           restarts <- computeRestarts(cond)
[15:32:07.514]                           for (restart in restarts) {
[15:32:07.514]                             name <- restart$name
[15:32:07.514]                             if (is.null(name)) 
[15:32:07.514]                               next
[15:32:07.514]                             if (!grepl(pattern, name)) 
[15:32:07.514]                               next
[15:32:07.514]                             invokeRestart(restart)
[15:32:07.514]                             muffled <- TRUE
[15:32:07.514]                             break
[15:32:07.514]                           }
[15:32:07.514]                         }
[15:32:07.514]                       }
[15:32:07.514]                       invisible(muffled)
[15:32:07.514]                     }
[15:32:07.514]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.514]                   }
[15:32:07.514]                 }
[15:32:07.514]             }
[15:32:07.514]         }))
[15:32:07.514]     }, error = function(ex) {
[15:32:07.514]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.514]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.514]                 ...future.rng), started = ...future.startTime, 
[15:32:07.514]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.514]             version = "1.8"), class = "FutureResult")
[15:32:07.514]     }, finally = {
[15:32:07.514]         if (!identical(...future.workdir, getwd())) 
[15:32:07.514]             setwd(...future.workdir)
[15:32:07.514]         {
[15:32:07.514]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.514]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.514]             }
[15:32:07.514]             base::options(...future.oldOptions)
[15:32:07.514]             if (.Platform$OS.type == "windows") {
[15:32:07.514]                 old_names <- names(...future.oldEnvVars)
[15:32:07.514]                 envs <- base::Sys.getenv()
[15:32:07.514]                 names <- names(envs)
[15:32:07.514]                 common <- intersect(names, old_names)
[15:32:07.514]                 added <- setdiff(names, old_names)
[15:32:07.514]                 removed <- setdiff(old_names, names)
[15:32:07.514]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.514]                   envs[common]]
[15:32:07.514]                 NAMES <- toupper(changed)
[15:32:07.514]                 args <- list()
[15:32:07.514]                 for (kk in seq_along(NAMES)) {
[15:32:07.514]                   name <- changed[[kk]]
[15:32:07.514]                   NAME <- NAMES[[kk]]
[15:32:07.514]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.514]                     next
[15:32:07.514]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.514]                 }
[15:32:07.514]                 NAMES <- toupper(added)
[15:32:07.514]                 for (kk in seq_along(NAMES)) {
[15:32:07.514]                   name <- added[[kk]]
[15:32:07.514]                   NAME <- NAMES[[kk]]
[15:32:07.514]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.514]                     next
[15:32:07.514]                   args[[name]] <- ""
[15:32:07.514]                 }
[15:32:07.514]                 NAMES <- toupper(removed)
[15:32:07.514]                 for (kk in seq_along(NAMES)) {
[15:32:07.514]                   name <- removed[[kk]]
[15:32:07.514]                   NAME <- NAMES[[kk]]
[15:32:07.514]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.514]                     next
[15:32:07.514]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.514]                 }
[15:32:07.514]                 if (length(args) > 0) 
[15:32:07.514]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.514]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.514]             }
[15:32:07.514]             else {
[15:32:07.514]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.514]             }
[15:32:07.514]             {
[15:32:07.514]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.514]                   0L) {
[15:32:07.514]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.514]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.514]                   base::options(opts)
[15:32:07.514]                 }
[15:32:07.514]                 {
[15:32:07.514]                   {
[15:32:07.514]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.514]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.514]                     -253660479L), envir = base::globalenv(), 
[15:32:07.514]                       inherits = FALSE)
[15:32:07.514]                     NULL
[15:32:07.514]                   }
[15:32:07.514]                   options(future.plan = NULL)
[15:32:07.514]                   if (is.na(NA_character_)) 
[15:32:07.514]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.514]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.514]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.514]                     .init = FALSE)
[15:32:07.514]                 }
[15:32:07.514]             }
[15:32:07.514]         }
[15:32:07.514]     })
[15:32:07.514]     if (TRUE) {
[15:32:07.514]         base::sink(type = "output", split = FALSE)
[15:32:07.514]         if (TRUE) {
[15:32:07.514]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.514]         }
[15:32:07.514]         else {
[15:32:07.514]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.514]         }
[15:32:07.514]         base::close(...future.stdout)
[15:32:07.514]         ...future.stdout <- NULL
[15:32:07.514]     }
[15:32:07.514]     ...future.result$conditions <- ...future.conditions
[15:32:07.514]     ...future.result$finished <- base::Sys.time()
[15:32:07.514]     ...future.result
[15:32:07.514] }
[15:32:07.520] assign_globals() ...
[15:32:07.520] List of 5
[15:32:07.520]  $ ...future.FUN            :function (C, k)  
[15:32:07.520]  $ MoreArgs                 : NULL
[15:32:07.520]  $ ...future.elements_ii    :List of 2
[15:32:07.520]   ..$ :List of 1
[15:32:07.520]   .. ..$ : chr "B"
[15:32:07.520]   ..$ :List of 1
[15:32:07.520]   .. ..$ : int 4
[15:32:07.520]  $ ...future.seeds_ii       : NULL
[15:32:07.520]  $ ...future.globals.maxSize: NULL
[15:32:07.520]  - attr(*, "where")=List of 5
[15:32:07.520]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.520]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.520]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.520]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.520]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.520]  - attr(*, "resolved")= logi FALSE
[15:32:07.520]  - attr(*, "total_size")= num 3488
[15:32:07.520]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.520]  - attr(*, "already-done")= logi TRUE
[15:32:07.529] - reassign environment for '...future.FUN'
[15:32:07.529] - copied '...future.FUN' to environment
[15:32:07.529] - copied 'MoreArgs' to environment
[15:32:07.530] - copied '...future.elements_ii' to environment
[15:32:07.530] - copied '...future.seeds_ii' to environment
[15:32:07.530] - copied '...future.globals.maxSize' to environment
[15:32:07.530] assign_globals() ... done
[15:32:07.531] plan(): Setting new future strategy stack:
[15:32:07.531] List of future strategies:
[15:32:07.531] 1. sequential:
[15:32:07.531]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.531]    - tweaked: FALSE
[15:32:07.531]    - call: NULL
[15:32:07.532] plan(): nbrOfWorkers() = 1
[15:32:07.534] plan(): Setting new future strategy stack:
[15:32:07.534] List of future strategies:
[15:32:07.534] 1. sequential:
[15:32:07.534]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.534]    - tweaked: FALSE
[15:32:07.534]    - call: plan(strategy)
[15:32:07.535] plan(): nbrOfWorkers() = 1
[15:32:07.535] SequentialFuture started (and completed)
[15:32:07.536] - Launch lazy future ... done
[15:32:07.536] run() for 'SequentialFuture' ... done
[15:32:07.536] Created future:
[15:32:07.536] SequentialFuture:
[15:32:07.536] Label: 'future_mapply-2'
[15:32:07.536] Expression:
[15:32:07.536] {
[15:32:07.536]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.536]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.536]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.536]         on.exit(options(oopts), add = TRUE)
[15:32:07.536]     }
[15:32:07.536]     {
[15:32:07.536]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.536]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.536]         do.call(mapply, args = args)
[15:32:07.536]     }
[15:32:07.536] }
[15:32:07.536] Lazy evaluation: FALSE
[15:32:07.536] Asynchronous evaluation: FALSE
[15:32:07.536] Local evaluation: TRUE
[15:32:07.536] Environment: R_GlobalEnv
[15:32:07.536] Capture standard output: TRUE
[15:32:07.536] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.536] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.536] Packages: <none>
[15:32:07.536] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.536] Resolved: TRUE
[15:32:07.536] Value: 112 bytes of class 'list'
[15:32:07.536] Early signaling: FALSE
[15:32:07.536] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.536] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.538] Chunk #2 of 3 ... DONE
[15:32:07.538] Chunk #3 of 3 ...
[15:32:07.539]  - Finding globals in '...' for chunk #3 ...
[15:32:07.539] getGlobalsAndPackages() ...
[15:32:07.539] Searching for globals...
[15:32:07.540] 
[15:32:07.540] Searching for globals ... DONE
[15:32:07.540] - globals: [0] <none>
[15:32:07.540] getGlobalsAndPackages() ... DONE
[15:32:07.541]    + additional globals found: [n=0] 
[15:32:07.541]    + additional namespaces needed: [n=0] 
[15:32:07.541]  - Finding globals in '...' for chunk #3 ... DONE
[15:32:07.541]  - Adjusted option 'future.globals.maxSize': 524288000 -> 3 * 524288000 = 1572864000 (bytes)
[15:32:07.542]  - seeds: <none>
[15:32:07.542]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.542] getGlobalsAndPackages() ...
[15:32:07.542] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.543] Resolving globals: FALSE
[15:32:07.546] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:07.547] 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 3.57 KiB.. This exceeds the maximum allowed size of 1.46 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.548] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.548] 
[15:32:07.548] getGlobalsAndPackages() ... DONE
[15:32:07.549] run() for 'Future' ...
[15:32:07.549] - state: 'created'
[15:32:07.549] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.550] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.550] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.551]   - Field: 'label'
[15:32:07.551]   - Field: 'local'
[15:32:07.551]   - Field: 'owner'
[15:32:07.551]   - Field: 'envir'
[15:32:07.552]   - Field: 'packages'
[15:32:07.552]   - Field: 'gc'
[15:32:07.552]   - Field: 'conditions'
[15:32:07.552]   - Field: 'expr'
[15:32:07.553]   - Field: 'uuid'
[15:32:07.553]   - Field: 'seed'
[15:32:07.553]   - Field: 'version'
[15:32:07.553]   - Field: 'result'
[15:32:07.554]   - Field: 'asynchronous'
[15:32:07.554]   - Field: 'calls'
[15:32:07.554]   - Field: 'globals'
[15:32:07.554]   - Field: 'stdout'
[15:32:07.555]   - Field: 'earlySignal'
[15:32:07.555]   - Field: 'lazy'
[15:32:07.555]   - Field: 'state'
[15:32:07.555] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.556] - Launch lazy future ...
[15:32:07.556] Packages needed by the future expression (n = 0): <none>
[15:32:07.556] Packages needed by future strategies (n = 0): <none>
[15:32:07.557] {
[15:32:07.557]     {
[15:32:07.557]         {
[15:32:07.557]             ...future.startTime <- base::Sys.time()
[15:32:07.557]             {
[15:32:07.557]                 {
[15:32:07.557]                   {
[15:32:07.557]                     base::local({
[15:32:07.557]                       has_future <- base::requireNamespace("future", 
[15:32:07.557]                         quietly = TRUE)
[15:32:07.557]                       if (has_future) {
[15:32:07.557]                         ns <- base::getNamespace("future")
[15:32:07.557]                         version <- ns[[".package"]][["version"]]
[15:32:07.557]                         if (is.null(version)) 
[15:32:07.557]                           version <- utils::packageVersion("future")
[15:32:07.557]                       }
[15:32:07.557]                       else {
[15:32:07.557]                         version <- NULL
[15:32:07.557]                       }
[15:32:07.557]                       if (!has_future || version < "1.8.0") {
[15:32:07.557]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.557]                           "", base::R.version$version.string), 
[15:32:07.557]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.557]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.557]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.557]                             "release", "version")], collapse = " "), 
[15:32:07.557]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.557]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.557]                           info)
[15:32:07.557]                         info <- base::paste(info, collapse = "; ")
[15:32:07.557]                         if (!has_future) {
[15:32:07.557]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.557]                             info)
[15:32:07.557]                         }
[15:32:07.557]                         else {
[15:32:07.557]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.557]                             info, version)
[15:32:07.557]                         }
[15:32:07.557]                         base::stop(msg)
[15:32:07.557]                       }
[15:32:07.557]                     })
[15:32:07.557]                   }
[15:32:07.557]                   ...future.strategy.old <- future::plan("list")
[15:32:07.557]                   options(future.plan = NULL)
[15:32:07.557]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.557]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.557]                 }
[15:32:07.557]                 ...future.workdir <- getwd()
[15:32:07.557]             }
[15:32:07.557]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.557]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.557]         }
[15:32:07.557]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.557]             future.globals.maxSize = 1572864000, future.globals.method = NULL, 
[15:32:07.557]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.557]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.557]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.557]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.557]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.557]             base::names(...future.oldOptions))
[15:32:07.557]     }
[15:32:07.557]     if (FALSE) {
[15:32:07.557]     }
[15:32:07.557]     else {
[15:32:07.557]         if (TRUE) {
[15:32:07.557]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.557]                 open = "w")
[15:32:07.557]         }
[15:32:07.557]         else {
[15:32:07.557]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.557]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.557]         }
[15:32:07.557]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.557]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.557]             base::sink(type = "output", split = FALSE)
[15:32:07.557]             base::close(...future.stdout)
[15:32:07.557]         }, add = TRUE)
[15:32:07.557]     }
[15:32:07.557]     ...future.frame <- base::sys.nframe()
[15:32:07.557]     ...future.conditions <- base::list()
[15:32:07.557]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.557]     if (FALSE) {
[15:32:07.557]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.557]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.557]     }
[15:32:07.557]     ...future.result <- base::tryCatch({
[15:32:07.557]         base::withCallingHandlers({
[15:32:07.557]             ...future.value <- base::withVisible(base::local({
[15:32:07.557]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.557]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.557]                   ...future.globals.maxSize)) {
[15:32:07.557]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.557]                   on.exit(options(oopts), add = TRUE)
[15:32:07.557]                 }
[15:32:07.557]                 {
[15:32:07.557]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.557]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.557]                     USE.NAMES = FALSE)
[15:32:07.557]                   do.call(mapply, args = args)
[15:32:07.557]                 }
[15:32:07.557]             }))
[15:32:07.557]             future::FutureResult(value = ...future.value$value, 
[15:32:07.557]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.557]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.557]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.557]                     ...future.globalenv.names))
[15:32:07.557]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.557]         }, condition = base::local({
[15:32:07.557]             c <- base::c
[15:32:07.557]             inherits <- base::inherits
[15:32:07.557]             invokeRestart <- base::invokeRestart
[15:32:07.557]             length <- base::length
[15:32:07.557]             list <- base::list
[15:32:07.557]             seq.int <- base::seq.int
[15:32:07.557]             signalCondition <- base::signalCondition
[15:32:07.557]             sys.calls <- base::sys.calls
[15:32:07.557]             `[[` <- base::`[[`
[15:32:07.557]             `+` <- base::`+`
[15:32:07.557]             `<<-` <- base::`<<-`
[15:32:07.557]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.557]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.557]                   3L)]
[15:32:07.557]             }
[15:32:07.557]             function(cond) {
[15:32:07.557]                 is_error <- inherits(cond, "error")
[15:32:07.557]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.557]                   NULL)
[15:32:07.557]                 if (is_error) {
[15:32:07.557]                   sessionInformation <- function() {
[15:32:07.557]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.557]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.557]                       search = base::search(), system = base::Sys.info())
[15:32:07.557]                   }
[15:32:07.557]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.557]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.557]                     cond$call), session = sessionInformation(), 
[15:32:07.557]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.557]                   signalCondition(cond)
[15:32:07.557]                 }
[15:32:07.557]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.557]                 "immediateCondition"))) {
[15:32:07.557]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.557]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.557]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.557]                   if (TRUE && !signal) {
[15:32:07.557]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.557]                     {
[15:32:07.557]                       inherits <- base::inherits
[15:32:07.557]                       invokeRestart <- base::invokeRestart
[15:32:07.557]                       is.null <- base::is.null
[15:32:07.557]                       muffled <- FALSE
[15:32:07.557]                       if (inherits(cond, "message")) {
[15:32:07.557]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.557]                         if (muffled) 
[15:32:07.557]                           invokeRestart("muffleMessage")
[15:32:07.557]                       }
[15:32:07.557]                       else if (inherits(cond, "warning")) {
[15:32:07.557]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.557]                         if (muffled) 
[15:32:07.557]                           invokeRestart("muffleWarning")
[15:32:07.557]                       }
[15:32:07.557]                       else if (inherits(cond, "condition")) {
[15:32:07.557]                         if (!is.null(pattern)) {
[15:32:07.557]                           computeRestarts <- base::computeRestarts
[15:32:07.557]                           grepl <- base::grepl
[15:32:07.557]                           restarts <- computeRestarts(cond)
[15:32:07.557]                           for (restart in restarts) {
[15:32:07.557]                             name <- restart$name
[15:32:07.557]                             if (is.null(name)) 
[15:32:07.557]                               next
[15:32:07.557]                             if (!grepl(pattern, name)) 
[15:32:07.557]                               next
[15:32:07.557]                             invokeRestart(restart)
[15:32:07.557]                             muffled <- TRUE
[15:32:07.557]                             break
[15:32:07.557]                           }
[15:32:07.557]                         }
[15:32:07.557]                       }
[15:32:07.557]                       invisible(muffled)
[15:32:07.557]                     }
[15:32:07.557]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.557]                   }
[15:32:07.557]                 }
[15:32:07.557]                 else {
[15:32:07.557]                   if (TRUE) {
[15:32:07.557]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.557]                     {
[15:32:07.557]                       inherits <- base::inherits
[15:32:07.557]                       invokeRestart <- base::invokeRestart
[15:32:07.557]                       is.null <- base::is.null
[15:32:07.557]                       muffled <- FALSE
[15:32:07.557]                       if (inherits(cond, "message")) {
[15:32:07.557]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.557]                         if (muffled) 
[15:32:07.557]                           invokeRestart("muffleMessage")
[15:32:07.557]                       }
[15:32:07.557]                       else if (inherits(cond, "warning")) {
[15:32:07.557]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.557]                         if (muffled) 
[15:32:07.557]                           invokeRestart("muffleWarning")
[15:32:07.557]                       }
[15:32:07.557]                       else if (inherits(cond, "condition")) {
[15:32:07.557]                         if (!is.null(pattern)) {
[15:32:07.557]                           computeRestarts <- base::computeRestarts
[15:32:07.557]                           grepl <- base::grepl
[15:32:07.557]                           restarts <- computeRestarts(cond)
[15:32:07.557]                           for (restart in restarts) {
[15:32:07.557]                             name <- restart$name
[15:32:07.557]                             if (is.null(name)) 
[15:32:07.557]                               next
[15:32:07.557]                             if (!grepl(pattern, name)) 
[15:32:07.557]                               next
[15:32:07.557]                             invokeRestart(restart)
[15:32:07.557]                             muffled <- TRUE
[15:32:07.557]                             break
[15:32:07.557]                           }
[15:32:07.557]                         }
[15:32:07.557]                       }
[15:32:07.557]                       invisible(muffled)
[15:32:07.557]                     }
[15:32:07.557]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.557]                   }
[15:32:07.557]                 }
[15:32:07.557]             }
[15:32:07.557]         }))
[15:32:07.557]     }, error = function(ex) {
[15:32:07.557]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.557]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.557]                 ...future.rng), started = ...future.startTime, 
[15:32:07.557]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.557]             version = "1.8"), class = "FutureResult")
[15:32:07.557]     }, finally = {
[15:32:07.557]         if (!identical(...future.workdir, getwd())) 
[15:32:07.557]             setwd(...future.workdir)
[15:32:07.557]         {
[15:32:07.557]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.557]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.557]             }
[15:32:07.557]             base::options(...future.oldOptions)
[15:32:07.557]             if (.Platform$OS.type == "windows") {
[15:32:07.557]                 old_names <- names(...future.oldEnvVars)
[15:32:07.557]                 envs <- base::Sys.getenv()
[15:32:07.557]                 names <- names(envs)
[15:32:07.557]                 common <- intersect(names, old_names)
[15:32:07.557]                 added <- setdiff(names, old_names)
[15:32:07.557]                 removed <- setdiff(old_names, names)
[15:32:07.557]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.557]                   envs[common]]
[15:32:07.557]                 NAMES <- toupper(changed)
[15:32:07.557]                 args <- list()
[15:32:07.557]                 for (kk in seq_along(NAMES)) {
[15:32:07.557]                   name <- changed[[kk]]
[15:32:07.557]                   NAME <- NAMES[[kk]]
[15:32:07.557]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.557]                     next
[15:32:07.557]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.557]                 }
[15:32:07.557]                 NAMES <- toupper(added)
[15:32:07.557]                 for (kk in seq_along(NAMES)) {
[15:32:07.557]                   name <- added[[kk]]
[15:32:07.557]                   NAME <- NAMES[[kk]]
[15:32:07.557]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.557]                     next
[15:32:07.557]                   args[[name]] <- ""
[15:32:07.557]                 }
[15:32:07.557]                 NAMES <- toupper(removed)
[15:32:07.557]                 for (kk in seq_along(NAMES)) {
[15:32:07.557]                   name <- removed[[kk]]
[15:32:07.557]                   NAME <- NAMES[[kk]]
[15:32:07.557]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.557]                     next
[15:32:07.557]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.557]                 }
[15:32:07.557]                 if (length(args) > 0) 
[15:32:07.557]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.557]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.557]             }
[15:32:07.557]             else {
[15:32:07.557]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.557]             }
[15:32:07.557]             {
[15:32:07.557]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.557]                   0L) {
[15:32:07.557]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.557]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.557]                   base::options(opts)
[15:32:07.557]                 }
[15:32:07.557]                 {
[15:32:07.557]                   {
[15:32:07.557]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.557]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.557]                     -253660479L), envir = base::globalenv(), 
[15:32:07.557]                       inherits = FALSE)
[15:32:07.557]                     NULL
[15:32:07.557]                   }
[15:32:07.557]                   options(future.plan = NULL)
[15:32:07.557]                   if (is.na(NA_character_)) 
[15:32:07.557]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.557]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.557]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.557]                     .init = FALSE)
[15:32:07.557]                 }
[15:32:07.557]             }
[15:32:07.557]         }
[15:32:07.557]     })
[15:32:07.557]     if (TRUE) {
[15:32:07.557]         base::sink(type = "output", split = FALSE)
[15:32:07.557]         if (TRUE) {
[15:32:07.557]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.557]         }
[15:32:07.557]         else {
[15:32:07.557]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.557]         }
[15:32:07.557]         base::close(...future.stdout)
[15:32:07.557]         ...future.stdout <- NULL
[15:32:07.557]     }
[15:32:07.557]     ...future.result$conditions <- ...future.conditions
[15:32:07.557]     ...future.result$finished <- base::Sys.time()
[15:32:07.557]     ...future.result
[15:32:07.557] }
[15:32:07.563] assign_globals() ...
[15:32:07.563] List of 5
[15:32:07.563]  $ ...future.FUN            :function (C, k)  
[15:32:07.563]  $ MoreArgs                 : NULL
[15:32:07.563]  $ ...future.elements_ii    :List of 2
[15:32:07.563]   ..$ :List of 2
[15:32:07.563]   .. ..$ : chr "D"
[15:32:07.563]   .. ..$ : chr "C"
[15:32:07.563]   ..$ :List of 2
[15:32:07.563]   .. ..$ : int 2
[15:32:07.563]   .. ..$ : int 3
[15:32:07.563]  $ ...future.seeds_ii       : NULL
[15:32:07.563]  $ ...future.globals.maxSize: NULL
[15:32:07.563]  - attr(*, "where")=List of 5
[15:32:07.563]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.563]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.563]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.563]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.563]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.563]  - attr(*, "resolved")= logi FALSE
[15:32:07.563]  - attr(*, "total_size")= num 3656
[15:32:07.563]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.563]  - attr(*, "already-done")= logi TRUE
[15:32:07.573] - reassign environment for '...future.FUN'
[15:32:07.573] - copied '...future.FUN' to environment
[15:32:07.574] - copied 'MoreArgs' to environment
[15:32:07.574] - copied '...future.elements_ii' to environment
[15:32:07.574] - copied '...future.seeds_ii' to environment
[15:32:07.574] - copied '...future.globals.maxSize' to environment
[15:32:07.575] assign_globals() ... done
[15:32:07.575] plan(): Setting new future strategy stack:
[15:32:07.575] List of future strategies:
[15:32:07.575] 1. sequential:
[15:32:07.575]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.575]    - tweaked: FALSE
[15:32:07.575]    - call: NULL
[15:32:07.576] plan(): nbrOfWorkers() = 1
[15:32:07.578] plan(): Setting new future strategy stack:
[15:32:07.579] List of future strategies:
[15:32:07.579] 1. sequential:
[15:32:07.579]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.579]    - tweaked: FALSE
[15:32:07.579]    - call: plan(strategy)
[15:32:07.579] plan(): nbrOfWorkers() = 1
[15:32:07.580] SequentialFuture started (and completed)
[15:32:07.580] - Launch lazy future ... done
[15:32:07.580] run() for 'SequentialFuture' ... done
[15:32:07.581] Created future:
[15:32:07.581] SequentialFuture:
[15:32:07.581] Label: 'future_mapply-3'
[15:32:07.581] Expression:
[15:32:07.581] {
[15:32:07.581]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.581]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.581]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.581]         on.exit(options(oopts), add = TRUE)
[15:32:07.581]     }
[15:32:07.581]     {
[15:32:07.581]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.581]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.581]         do.call(mapply, args = args)
[15:32:07.581]     }
[15:32:07.581] }
[15:32:07.581] Lazy evaluation: FALSE
[15:32:07.581] Asynchronous evaluation: FALSE
[15:32:07.581] Local evaluation: TRUE
[15:32:07.581] Environment: R_GlobalEnv
[15:32:07.581] Capture standard output: TRUE
[15:32:07.581] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.581] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.581] Packages: <none>
[15:32:07.581] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.581] Resolved: TRUE
[15:32:07.581] Value: 224 bytes of class 'list'
[15:32:07.581] Early signaling: FALSE
[15:32:07.581] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.581] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.583] Chunk #3 of 3 ... DONE
[15:32:07.583] Launching 3 futures (chunks) ... DONE
[15:32:07.583] Resolving 3 futures (chunks) ...
[15:32:07.583] resolve() on list ...
[15:32:07.584]  recursive: 0
[15:32:07.584]  length: 3
[15:32:07.584] 
[15:32:07.584] resolved() for 'SequentialFuture' ...
[15:32:07.585] - state: 'finished'
[15:32:07.585] - run: TRUE
[15:32:07.585] - result: 'FutureResult'
[15:32:07.586] resolved() for 'SequentialFuture' ... done
[15:32:07.586] Future #1
[15:32:07.586] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.586] - nx: 3
[15:32:07.587] - relay: TRUE
[15:32:07.590] - stdout: TRUE
[15:32:07.590] - signal: TRUE
[15:32:07.590] - resignal: FALSE
[15:32:07.591] - force: TRUE
[15:32:07.591] - relayed: [n=3] FALSE, FALSE, FALSE
[15:32:07.591] - queued futures: [n=3] FALSE, FALSE, FALSE
[15:32:07.591]  - until=1
[15:32:07.592]  - relaying element #1
[15:32:07.592] - relayed: [n=3] TRUE, FALSE, FALSE
[15:32:07.593] - queued futures: [n=3] TRUE, FALSE, FALSE
[15:32:07.593] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.593]  length: 2 (resolved future 1)
[15:32:07.593] resolved() for 'SequentialFuture' ...
[15:32:07.594] - state: 'finished'
[15:32:07.594] - run: TRUE
[15:32:07.594] - result: 'FutureResult'
[15:32:07.595] resolved() for 'SequentialFuture' ... done
[15:32:07.595] Future #2
[15:32:07.595] signalConditionsASAP(SequentialFuture, pos=2) ...
[15:32:07.595] - nx: 3
[15:32:07.596] - relay: TRUE
[15:32:07.596] - stdout: TRUE
[15:32:07.596] - signal: TRUE
[15:32:07.596] - resignal: FALSE
[15:32:07.597] - force: TRUE
[15:32:07.597] - relayed: [n=3] TRUE, FALSE, FALSE
[15:32:07.597] - queued futures: [n=3] TRUE, FALSE, FALSE
[15:32:07.597]  - until=2
[15:32:07.597]  - relaying element #2
[15:32:07.598] - relayed: [n=3] TRUE, TRUE, FALSE
[15:32:07.598] - queued futures: [n=3] TRUE, TRUE, FALSE
[15:32:07.598] signalConditionsASAP(SequentialFuture, pos=2) ... done
[15:32:07.599]  length: 1 (resolved future 2)
[15:32:07.599] resolved() for 'SequentialFuture' ...
[15:32:07.599] - state: 'finished'
[15:32:07.599] - run: TRUE
[15:32:07.600] - result: 'FutureResult'
[15:32:07.600] resolved() for 'SequentialFuture' ... done
[15:32:07.600] Future #3
[15:32:07.601] signalConditionsASAP(SequentialFuture, pos=3) ...
[15:32:07.601] - nx: 3
[15:32:07.601] - relay: TRUE
[15:32:07.601] - stdout: TRUE
[15:32:07.601] - signal: TRUE
[15:32:07.602] - resignal: FALSE
[15:32:07.602] - force: TRUE
[15:32:07.602] - relayed: [n=3] TRUE, TRUE, FALSE
[15:32:07.602] - queued futures: [n=3] TRUE, TRUE, FALSE
[15:32:07.603]  - until=3
[15:32:07.603]  - relaying element #3
[15:32:07.603] - relayed: [n=3] TRUE, TRUE, TRUE
[15:32:07.603] - queued futures: [n=3] TRUE, TRUE, TRUE
[15:32:07.604] signalConditionsASAP(SequentialFuture, pos=3) ... done
[15:32:07.604]  length: 0 (resolved future 3)
[15:32:07.604] Relaying remaining futures
[15:32:07.604] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.605] - nx: 3
[15:32:07.605] - relay: TRUE
[15:32:07.605] - stdout: TRUE
[15:32:07.605] - signal: TRUE
[15:32:07.605] - resignal: FALSE
[15:32:07.606] - force: TRUE
[15:32:07.606] - relayed: [n=3] TRUE, TRUE, TRUE
[15:32:07.606] - queued futures: [n=3] TRUE, TRUE, TRUE
 - flush all
[15:32:07.606] - relayed: [n=3] TRUE, TRUE, TRUE
[15:32:07.607] - queued futures: [n=3] TRUE, TRUE, TRUE
[15:32:07.607] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.607] resolve() on list ... DONE
[15:32:07.608]  - Number of value chunks collected: 3
[15:32:07.608] Resolving 3 futures (chunks) ... DONE
[15:32:07.608] Reducing values from 3 chunks ...
[15:32:07.608]  - Number of values collected after concatenation: 5
[15:32:07.609]  - Number of values expected: 5
[15:32:07.609] Reverse index remapping (attribute 'ordering'): [n = 5] 1, 3, 5, 4, 2
[15:32:07.609] Reducing values from 3 chunks ... DONE
[15:32:07.609] future_mapply() ... DONE
[15:32:07.610] future_mapply() ...
[15:32:07.610] Number of chunks: 1
[15:32:07.610] getGlobalsAndPackagesXApply() ...
[15:32:07.611]  - future.globals: TRUE
[15:32:07.611] getGlobalsAndPackages() ...
[15:32:07.611] Searching for globals...
[15:32:07.613] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:07.614] Searching for globals ... DONE
[15:32:07.614] Resolving globals: FALSE
[15:32:07.615] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:07.615] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:07.615] - globals: [1] 'FUN'
[15:32:07.616] 
[15:32:07.616] getGlobalsAndPackages() ... DONE
[15:32:07.616]  - globals found/used: [n=1] 'FUN'
[15:32:07.616]  - needed namespaces: [n=0] 
[15:32:07.617] Finding globals ... DONE
[15:32:07.617] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.617] List of 2
[15:32:07.617]  $ ...future.FUN:function (C, k)  
[15:32:07.617]  $ MoreArgs     : list()
[15:32:07.617]  - attr(*, "where")=List of 2
[15:32:07.617]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.617]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.617]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.617]  - attr(*, "resolved")= logi FALSE
[15:32:07.617]  - attr(*, "total_size")= num NA
[15:32:07.621] Packages to be attached in all futures: [n=0] 
[15:32:07.622] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.622] Number of futures (= number of chunks): 1
[15:32:07.622] Launching 1 futures (chunks) ...
[15:32:07.622] Chunk #1 of 1 ...
[15:32:07.623]  - Finding globals in '...' for chunk #1 ...
[15:32:07.623] getGlobalsAndPackages() ...
[15:32:07.623] Searching for globals...
[15:32:07.624] 
[15:32:07.624] Searching for globals ... DONE
[15:32:07.624] - globals: [0] <none>
[15:32:07.624] getGlobalsAndPackages() ... DONE
[15:32:07.625]    + additional globals found: [n=0] 
[15:32:07.625]    + additional namespaces needed: [n=0] 
[15:32:07.625]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.625]  - seeds: <none>
[15:32:07.626]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.628] getGlobalsAndPackages() ...
[15:32:07.629] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.629] Resolving globals: FALSE
[15:32:07.630] The total size of the 5 globals is 4.06 KiB (4160 bytes)
[15:32:07.631] 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 4.06 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (840 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:07.631] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.632] 
[15:32:07.632] getGlobalsAndPackages() ... DONE
[15:32:07.632] run() for 'Future' ...
[15:32:07.633] - state: 'created'
[15:32:07.633] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.633] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.634] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.634]   - Field: 'label'
[15:32:07.634]   - Field: 'local'
[15:32:07.635]   - Field: 'owner'
[15:32:07.635]   - Field: 'envir'
[15:32:07.635]   - Field: 'packages'
[15:32:07.635]   - Field: 'gc'
[15:32:07.636]   - Field: 'conditions'
[15:32:07.636]   - Field: 'expr'
[15:32:07.636]   - Field: 'uuid'
[15:32:07.636]   - Field: 'seed'
[15:32:07.637]   - Field: 'version'
[15:32:07.637]   - Field: 'result'
[15:32:07.637]   - Field: 'asynchronous'
[15:32:07.637]   - Field: 'calls'
[15:32:07.638]   - Field: 'globals'
[15:32:07.638]   - Field: 'stdout'
[15:32:07.638]   - Field: 'earlySignal'
[15:32:07.638]   - Field: 'lazy'
[15:32:07.638]   - Field: 'state'
[15:32:07.639] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.639] - Launch lazy future ...
[15:32:07.639] Packages needed by the future expression (n = 0): <none>
[15:32:07.640] Packages needed by future strategies (n = 0): <none>
[15:32:07.640] {
[15:32:07.640]     {
[15:32:07.640]         {
[15:32:07.640]             ...future.startTime <- base::Sys.time()
[15:32:07.640]             {
[15:32:07.640]                 {
[15:32:07.640]                   {
[15:32:07.640]                     base::local({
[15:32:07.640]                       has_future <- base::requireNamespace("future", 
[15:32:07.640]                         quietly = TRUE)
[15:32:07.640]                       if (has_future) {
[15:32:07.640]                         ns <- base::getNamespace("future")
[15:32:07.640]                         version <- ns[[".package"]][["version"]]
[15:32:07.640]                         if (is.null(version)) 
[15:32:07.640]                           version <- utils::packageVersion("future")
[15:32:07.640]                       }
[15:32:07.640]                       else {
[15:32:07.640]                         version <- NULL
[15:32:07.640]                       }
[15:32:07.640]                       if (!has_future || version < "1.8.0") {
[15:32:07.640]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.640]                           "", base::R.version$version.string), 
[15:32:07.640]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.640]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.640]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.640]                             "release", "version")], collapse = " "), 
[15:32:07.640]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.640]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.640]                           info)
[15:32:07.640]                         info <- base::paste(info, collapse = "; ")
[15:32:07.640]                         if (!has_future) {
[15:32:07.640]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.640]                             info)
[15:32:07.640]                         }
[15:32:07.640]                         else {
[15:32:07.640]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.640]                             info, version)
[15:32:07.640]                         }
[15:32:07.640]                         base::stop(msg)
[15:32:07.640]                       }
[15:32:07.640]                     })
[15:32:07.640]                   }
[15:32:07.640]                   ...future.strategy.old <- future::plan("list")
[15:32:07.640]                   options(future.plan = NULL)
[15:32:07.640]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.640]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.640]                 }
[15:32:07.640]                 ...future.workdir <- getwd()
[15:32:07.640]             }
[15:32:07.640]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.640]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.640]         }
[15:32:07.640]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.640]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:07.640]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.640]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.640]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.640]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.640]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.640]             base::names(...future.oldOptions))
[15:32:07.640]     }
[15:32:07.640]     if (FALSE) {
[15:32:07.640]     }
[15:32:07.640]     else {
[15:32:07.640]         if (TRUE) {
[15:32:07.640]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.640]                 open = "w")
[15:32:07.640]         }
[15:32:07.640]         else {
[15:32:07.640]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.640]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.640]         }
[15:32:07.640]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.640]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.640]             base::sink(type = "output", split = FALSE)
[15:32:07.640]             base::close(...future.stdout)
[15:32:07.640]         }, add = TRUE)
[15:32:07.640]     }
[15:32:07.640]     ...future.frame <- base::sys.nframe()
[15:32:07.640]     ...future.conditions <- base::list()
[15:32:07.640]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.640]     if (FALSE) {
[15:32:07.640]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.640]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.640]     }
[15:32:07.640]     ...future.result <- base::tryCatch({
[15:32:07.640]         base::withCallingHandlers({
[15:32:07.640]             ...future.value <- base::withVisible(base::local({
[15:32:07.640]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.640]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.640]                   ...future.globals.maxSize)) {
[15:32:07.640]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.640]                   on.exit(options(oopts), add = TRUE)
[15:32:07.640]                 }
[15:32:07.640]                 {
[15:32:07.640]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.640]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.640]                     USE.NAMES = FALSE)
[15:32:07.640]                   do.call(mapply, args = args)
[15:32:07.640]                 }
[15:32:07.640]             }))
[15:32:07.640]             future::FutureResult(value = ...future.value$value, 
[15:32:07.640]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.640]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.640]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.640]                     ...future.globalenv.names))
[15:32:07.640]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.640]         }, condition = base::local({
[15:32:07.640]             c <- base::c
[15:32:07.640]             inherits <- base::inherits
[15:32:07.640]             invokeRestart <- base::invokeRestart
[15:32:07.640]             length <- base::length
[15:32:07.640]             list <- base::list
[15:32:07.640]             seq.int <- base::seq.int
[15:32:07.640]             signalCondition <- base::signalCondition
[15:32:07.640]             sys.calls <- base::sys.calls
[15:32:07.640]             `[[` <- base::`[[`
[15:32:07.640]             `+` <- base::`+`
[15:32:07.640]             `<<-` <- base::`<<-`
[15:32:07.640]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.640]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.640]                   3L)]
[15:32:07.640]             }
[15:32:07.640]             function(cond) {
[15:32:07.640]                 is_error <- inherits(cond, "error")
[15:32:07.640]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.640]                   NULL)
[15:32:07.640]                 if (is_error) {
[15:32:07.640]                   sessionInformation <- function() {
[15:32:07.640]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.640]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.640]                       search = base::search(), system = base::Sys.info())
[15:32:07.640]                   }
[15:32:07.640]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.640]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.640]                     cond$call), session = sessionInformation(), 
[15:32:07.640]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.640]                   signalCondition(cond)
[15:32:07.640]                 }
[15:32:07.640]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.640]                 "immediateCondition"))) {
[15:32:07.640]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.640]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.640]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.640]                   if (TRUE && !signal) {
[15:32:07.640]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.640]                     {
[15:32:07.640]                       inherits <- base::inherits
[15:32:07.640]                       invokeRestart <- base::invokeRestart
[15:32:07.640]                       is.null <- base::is.null
[15:32:07.640]                       muffled <- FALSE
[15:32:07.640]                       if (inherits(cond, "message")) {
[15:32:07.640]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.640]                         if (muffled) 
[15:32:07.640]                           invokeRestart("muffleMessage")
[15:32:07.640]                       }
[15:32:07.640]                       else if (inherits(cond, "warning")) {
[15:32:07.640]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.640]                         if (muffled) 
[15:32:07.640]                           invokeRestart("muffleWarning")
[15:32:07.640]                       }
[15:32:07.640]                       else if (inherits(cond, "condition")) {
[15:32:07.640]                         if (!is.null(pattern)) {
[15:32:07.640]                           computeRestarts <- base::computeRestarts
[15:32:07.640]                           grepl <- base::grepl
[15:32:07.640]                           restarts <- computeRestarts(cond)
[15:32:07.640]                           for (restart in restarts) {
[15:32:07.640]                             name <- restart$name
[15:32:07.640]                             if (is.null(name)) 
[15:32:07.640]                               next
[15:32:07.640]                             if (!grepl(pattern, name)) 
[15:32:07.640]                               next
[15:32:07.640]                             invokeRestart(restart)
[15:32:07.640]                             muffled <- TRUE
[15:32:07.640]                             break
[15:32:07.640]                           }
[15:32:07.640]                         }
[15:32:07.640]                       }
[15:32:07.640]                       invisible(muffled)
[15:32:07.640]                     }
[15:32:07.640]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.640]                   }
[15:32:07.640]                 }
[15:32:07.640]                 else {
[15:32:07.640]                   if (TRUE) {
[15:32:07.640]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.640]                     {
[15:32:07.640]                       inherits <- base::inherits
[15:32:07.640]                       invokeRestart <- base::invokeRestart
[15:32:07.640]                       is.null <- base::is.null
[15:32:07.640]                       muffled <- FALSE
[15:32:07.640]                       if (inherits(cond, "message")) {
[15:32:07.640]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.640]                         if (muffled) 
[15:32:07.640]                           invokeRestart("muffleMessage")
[15:32:07.640]                       }
[15:32:07.640]                       else if (inherits(cond, "warning")) {
[15:32:07.640]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.640]                         if (muffled) 
[15:32:07.640]                           invokeRestart("muffleWarning")
[15:32:07.640]                       }
[15:32:07.640]                       else if (inherits(cond, "condition")) {
[15:32:07.640]                         if (!is.null(pattern)) {
[15:32:07.640]                           computeRestarts <- base::computeRestarts
[15:32:07.640]                           grepl <- base::grepl
[15:32:07.640]                           restarts <- computeRestarts(cond)
[15:32:07.640]                           for (restart in restarts) {
[15:32:07.640]                             name <- restart$name
[15:32:07.640]                             if (is.null(name)) 
[15:32:07.640]                               next
[15:32:07.640]                             if (!grepl(pattern, name)) 
[15:32:07.640]                               next
[15:32:07.640]                             invokeRestart(restart)
[15:32:07.640]                             muffled <- TRUE
[15:32:07.640]                             break
[15:32:07.640]                           }
[15:32:07.640]                         }
[15:32:07.640]                       }
[15:32:07.640]                       invisible(muffled)
[15:32:07.640]                     }
[15:32:07.640]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.640]                   }
[15:32:07.640]                 }
[15:32:07.640]             }
[15:32:07.640]         }))
[15:32:07.640]     }, error = function(ex) {
[15:32:07.640]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.640]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.640]                 ...future.rng), started = ...future.startTime, 
[15:32:07.640]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.640]             version = "1.8"), class = "FutureResult")
[15:32:07.640]     }, finally = {
[15:32:07.640]         if (!identical(...future.workdir, getwd())) 
[15:32:07.640]             setwd(...future.workdir)
[15:32:07.640]         {
[15:32:07.640]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.640]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.640]             }
[15:32:07.640]             base::options(...future.oldOptions)
[15:32:07.640]             if (.Platform$OS.type == "windows") {
[15:32:07.640]                 old_names <- names(...future.oldEnvVars)
[15:32:07.640]                 envs <- base::Sys.getenv()
[15:32:07.640]                 names <- names(envs)
[15:32:07.640]                 common <- intersect(names, old_names)
[15:32:07.640]                 added <- setdiff(names, old_names)
[15:32:07.640]                 removed <- setdiff(old_names, names)
[15:32:07.640]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.640]                   envs[common]]
[15:32:07.640]                 NAMES <- toupper(changed)
[15:32:07.640]                 args <- list()
[15:32:07.640]                 for (kk in seq_along(NAMES)) {
[15:32:07.640]                   name <- changed[[kk]]
[15:32:07.640]                   NAME <- NAMES[[kk]]
[15:32:07.640]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.640]                     next
[15:32:07.640]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.640]                 }
[15:32:07.640]                 NAMES <- toupper(added)
[15:32:07.640]                 for (kk in seq_along(NAMES)) {
[15:32:07.640]                   name <- added[[kk]]
[15:32:07.640]                   NAME <- NAMES[[kk]]
[15:32:07.640]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.640]                     next
[15:32:07.640]                   args[[name]] <- ""
[15:32:07.640]                 }
[15:32:07.640]                 NAMES <- toupper(removed)
[15:32:07.640]                 for (kk in seq_along(NAMES)) {
[15:32:07.640]                   name <- removed[[kk]]
[15:32:07.640]                   NAME <- NAMES[[kk]]
[15:32:07.640]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.640]                     next
[15:32:07.640]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.640]                 }
[15:32:07.640]                 if (length(args) > 0) 
[15:32:07.640]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.640]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.640]             }
[15:32:07.640]             else {
[15:32:07.640]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.640]             }
[15:32:07.640]             {
[15:32:07.640]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.640]                   0L) {
[15:32:07.640]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.640]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.640]                   base::options(opts)
[15:32:07.640]                 }
[15:32:07.640]                 {
[15:32:07.640]                   {
[15:32:07.640]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.640]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.640]                     -253660479L), envir = base::globalenv(), 
[15:32:07.640]                       inherits = FALSE)
[15:32:07.640]                     NULL
[15:32:07.640]                   }
[15:32:07.640]                   options(future.plan = NULL)
[15:32:07.640]                   if (is.na(NA_character_)) 
[15:32:07.640]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.640]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.640]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.640]                     .init = FALSE)
[15:32:07.640]                 }
[15:32:07.640]             }
[15:32:07.640]         }
[15:32:07.640]     })
[15:32:07.640]     if (TRUE) {
[15:32:07.640]         base::sink(type = "output", split = FALSE)
[15:32:07.640]         if (TRUE) {
[15:32:07.640]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.640]         }
[15:32:07.640]         else {
[15:32:07.640]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.640]         }
[15:32:07.640]         base::close(...future.stdout)
[15:32:07.640]         ...future.stdout <- NULL
[15:32:07.640]     }
[15:32:07.640]     ...future.result$conditions <- ...future.conditions
[15:32:07.640]     ...future.result$finished <- base::Sys.time()
[15:32:07.640]     ...future.result
[15:32:07.640] }
[15:32:07.646] assign_globals() ...
[15:32:07.646] List of 5
[15:32:07.646]  $ ...future.FUN            :function (C, k)  
[15:32:07.646]  $ MoreArgs                 : list()
[15:32:07.646]  $ ...future.elements_ii    :List of 2
[15:32:07.646]   ..$ :List of 5
[15:32:07.646]   .. ..$ : chr "A"
[15:32:07.646]   .. ..$ : chr "B"
[15:32:07.646]   .. ..$ : chr "C"
[15:32:07.646]   .. ..$ : chr "D"
[15:32:07.646]   .. ..$ : chr "E"
[15:32:07.646]   ..$ :List of 5
[15:32:07.646]   .. ..$ : int 5
[15:32:07.646]   .. ..$ : int 4
[15:32:07.646]   .. ..$ : int 3
[15:32:07.646]   .. ..$ : int 2
[15:32:07.646]   .. ..$ : int 1
[15:32:07.646]  $ ...future.seeds_ii       : NULL
[15:32:07.646]  $ ...future.globals.maxSize: NULL
[15:32:07.646]  - attr(*, "where")=List of 5
[15:32:07.646]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.646]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.646]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.646]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.646]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.646]  - attr(*, "resolved")= logi FALSE
[15:32:07.646]  - attr(*, "total_size")= num 4160
[15:32:07.646]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.646]  - attr(*, "already-done")= logi TRUE
[15:32:07.658] - reassign environment for '...future.FUN'
[15:32:07.659] - copied '...future.FUN' to environment
[15:32:07.659] - copied 'MoreArgs' to environment
[15:32:07.659] - copied '...future.elements_ii' to environment
[15:32:07.659] - copied '...future.seeds_ii' to environment
[15:32:07.660] - copied '...future.globals.maxSize' to environment
[15:32:07.660] assign_globals() ... done
[15:32:07.660] plan(): Setting new future strategy stack:
[15:32:07.661] List of future strategies:
[15:32:07.661] 1. sequential:
[15:32:07.661]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.661]    - tweaked: FALSE
[15:32:07.661]    - call: NULL
[15:32:07.661] plan(): nbrOfWorkers() = 1
[15:32:07.663] plan(): Setting new future strategy stack:
[15:32:07.663] List of future strategies:
[15:32:07.663] 1. sequential:
[15:32:07.663]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.663]    - tweaked: FALSE
[15:32:07.663]    - call: plan(strategy)
[15:32:07.664] plan(): nbrOfWorkers() = 1
[15:32:07.665] SequentialFuture started (and completed)
[15:32:07.665] - Launch lazy future ... done
[15:32:07.668] run() for 'SequentialFuture' ... done
[15:32:07.668] Created future:
[15:32:07.668] SequentialFuture:
[15:32:07.668] Label: 'future_.mapply-1'
[15:32:07.668] Expression:
[15:32:07.668] {
[15:32:07.668]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.668]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.668]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.668]         on.exit(options(oopts), add = TRUE)
[15:32:07.668]     }
[15:32:07.668]     {
[15:32:07.668]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.668]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.668]         do.call(mapply, args = args)
[15:32:07.668]     }
[15:32:07.668] }
[15:32:07.668] Lazy evaluation: FALSE
[15:32:07.668] Asynchronous evaluation: FALSE
[15:32:07.668] Local evaluation: TRUE
[15:32:07.668] Environment: R_GlobalEnv
[15:32:07.668] Capture standard output: TRUE
[15:32:07.668] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.668] Globals: 5 objects totaling 4.06 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 840 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.668] Packages: <none>
[15:32:07.668] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.668] Resolved: TRUE
[15:32:07.668] Value: 560 bytes of class 'list'
[15:32:07.668] Early signaling: FALSE
[15:32:07.668] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.668] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.670] Chunk #1 of 1 ... DONE
[15:32:07.671] Launching 1 futures (chunks) ... DONE
[15:32:07.671] Resolving 1 futures (chunks) ...
[15:32:07.671] resolve() on list ...
[15:32:07.671]  recursive: 0
[15:32:07.672]  length: 1
[15:32:07.672] 
[15:32:07.672] resolved() for 'SequentialFuture' ...
[15:32:07.672] - state: 'finished'
[15:32:07.673] - run: TRUE
[15:32:07.673] - result: 'FutureResult'
[15:32:07.673] resolved() for 'SequentialFuture' ... done
[15:32:07.673] Future #1
[15:32:07.674] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.674] - nx: 1
[15:32:07.674] - relay: TRUE
[15:32:07.674] - stdout: TRUE
[15:32:07.675] - signal: TRUE
[15:32:07.675] - resignal: FALSE
[15:32:07.675] - force: TRUE
[15:32:07.675] - relayed: [n=1] FALSE
[15:32:07.675] - queued futures: [n=1] FALSE
[15:32:07.676]  - until=1
[15:32:07.676]  - relaying element #1
[15:32:07.676] - relayed: [n=1] TRUE
[15:32:07.676] - queued futures: [n=1] TRUE
[15:32:07.677] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.677]  length: 0 (resolved future 1)
[15:32:07.677] Relaying remaining futures
[15:32:07.677] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.678] - nx: 1
[15:32:07.678] - relay: TRUE
[15:32:07.678] - stdout: TRUE
[15:32:07.678] - signal: TRUE
[15:32:07.678] - resignal: FALSE
[15:32:07.679] - force: TRUE
[15:32:07.679] - relayed: [n=1] TRUE
[15:32:07.679] - queued futures: [n=1] TRUE
 - flush all
[15:32:07.679] - relayed: [n=1] TRUE
[15:32:07.680] - queued futures: [n=1] TRUE
[15:32:07.680] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.680] resolve() on list ... DONE
[15:32:07.680]  - Number of value chunks collected: 1
[15:32:07.681] Resolving 1 futures (chunks) ... DONE
[15:32:07.681] Reducing values from 1 chunks ...
[15:32:07.681]  - Number of values collected after concatenation: 5
[15:32:07.681]  - Number of values expected: 5
[15:32:07.682] Reducing values from 1 chunks ... DONE
[15:32:07.682] future_mapply() ... DONE
[15:32:07.682] future_mapply() ...
[15:32:07.683] Number of chunks: 2
[15:32:07.683] Index remapping (attribute 'ordering'): [n = 5] 5, 4, 3, 2, 1
[15:32:07.684] getGlobalsAndPackagesXApply() ...
[15:32:07.684]  - future.globals: TRUE
[15:32:07.684] getGlobalsAndPackages() ...
[15:32:07.684] Searching for globals...
[15:32:07.686] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:07.687] Searching for globals ... DONE
[15:32:07.687] Resolving globals: FALSE
[15:32:07.688] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:07.688] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:07.688] - globals: [1] 'FUN'
[15:32:07.689] 
[15:32:07.689] getGlobalsAndPackages() ... DONE
[15:32:07.689]  - globals found/used: [n=1] 'FUN'
[15:32:07.689]  - needed namespaces: [n=0] 
[15:32:07.690] Finding globals ... DONE
[15:32:07.690] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.690] List of 2
[15:32:07.690]  $ ...future.FUN:function (C, k)  
[15:32:07.690]  $ MoreArgs     : NULL
[15:32:07.690]  - attr(*, "where")=List of 2
[15:32:07.690]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.690]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.690]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.690]  - attr(*, "resolved")= logi FALSE
[15:32:07.690]  - attr(*, "total_size")= num NA
[15:32:07.694] Packages to be attached in all futures: [n=0] 
[15:32:07.695] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.695] Number of futures (= number of chunks): 2
[15:32:07.696] Launching 2 futures (chunks) ...
[15:32:07.696] Chunk #1 of 2 ...
[15:32:07.696]  - Finding globals in '...' for chunk #1 ...
[15:32:07.696] getGlobalsAndPackages() ...
[15:32:07.697] Searching for globals...
[15:32:07.697] 
[15:32:07.698] Searching for globals ... DONE
[15:32:07.698] - globals: [0] <none>
[15:32:07.698] getGlobalsAndPackages() ... DONE
[15:32:07.698]    + additional globals found: [n=0] 
[15:32:07.699]    + additional namespaces needed: [n=0] 
[15:32:07.699]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.699]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:07.699]  - seeds: <none>
[15:32:07.700]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.700] getGlobalsAndPackages() ...
[15:32:07.700] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.700] Resolving globals: FALSE
[15:32:07.701] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:07.702] 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 3.57 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.702] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.703] 
[15:32:07.703] getGlobalsAndPackages() ... DONE
[15:32:07.706] run() for 'Future' ...
[15:32:07.706] - state: 'created'
[15:32:07.707] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.707] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.708] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.708]   - Field: 'label'
[15:32:07.708]   - Field: 'local'
[15:32:07.708]   - Field: 'owner'
[15:32:07.709]   - Field: 'envir'
[15:32:07.709]   - Field: 'packages'
[15:32:07.709]   - Field: 'gc'
[15:32:07.710]   - Field: 'conditions'
[15:32:07.710]   - Field: 'expr'
[15:32:07.710]   - Field: 'uuid'
[15:32:07.710]   - Field: 'seed'
[15:32:07.711]   - Field: 'version'
[15:32:07.711]   - Field: 'result'
[15:32:07.711]   - Field: 'asynchronous'
[15:32:07.712]   - Field: 'calls'
[15:32:07.712]   - Field: 'globals'
[15:32:07.712]   - Field: 'stdout'
[15:32:07.712]   - Field: 'earlySignal'
[15:32:07.713]   - Field: 'lazy'
[15:32:07.713]   - Field: 'state'
[15:32:07.713] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.714] - Launch lazy future ...
[15:32:07.714] Packages needed by the future expression (n = 0): <none>
[15:32:07.714] Packages needed by future strategies (n = 0): <none>
[15:32:07.715] {
[15:32:07.715]     {
[15:32:07.715]         {
[15:32:07.715]             ...future.startTime <- base::Sys.time()
[15:32:07.715]             {
[15:32:07.715]                 {
[15:32:07.715]                   {
[15:32:07.715]                     base::local({
[15:32:07.715]                       has_future <- base::requireNamespace("future", 
[15:32:07.715]                         quietly = TRUE)
[15:32:07.715]                       if (has_future) {
[15:32:07.715]                         ns <- base::getNamespace("future")
[15:32:07.715]                         version <- ns[[".package"]][["version"]]
[15:32:07.715]                         if (is.null(version)) 
[15:32:07.715]                           version <- utils::packageVersion("future")
[15:32:07.715]                       }
[15:32:07.715]                       else {
[15:32:07.715]                         version <- NULL
[15:32:07.715]                       }
[15:32:07.715]                       if (!has_future || version < "1.8.0") {
[15:32:07.715]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.715]                           "", base::R.version$version.string), 
[15:32:07.715]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.715]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.715]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.715]                             "release", "version")], collapse = " "), 
[15:32:07.715]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.715]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.715]                           info)
[15:32:07.715]                         info <- base::paste(info, collapse = "; ")
[15:32:07.715]                         if (!has_future) {
[15:32:07.715]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.715]                             info)
[15:32:07.715]                         }
[15:32:07.715]                         else {
[15:32:07.715]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.715]                             info, version)
[15:32:07.715]                         }
[15:32:07.715]                         base::stop(msg)
[15:32:07.715]                       }
[15:32:07.715]                     })
[15:32:07.715]                   }
[15:32:07.715]                   ...future.strategy.old <- future::plan("list")
[15:32:07.715]                   options(future.plan = NULL)
[15:32:07.715]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.715]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.715]                 }
[15:32:07.715]                 ...future.workdir <- getwd()
[15:32:07.715]             }
[15:32:07.715]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.715]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.715]         }
[15:32:07.715]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.715]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:07.715]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.715]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.715]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.715]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.715]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.715]             base::names(...future.oldOptions))
[15:32:07.715]     }
[15:32:07.715]     if (FALSE) {
[15:32:07.715]     }
[15:32:07.715]     else {
[15:32:07.715]         if (TRUE) {
[15:32:07.715]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.715]                 open = "w")
[15:32:07.715]         }
[15:32:07.715]         else {
[15:32:07.715]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.715]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.715]         }
[15:32:07.715]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.715]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.715]             base::sink(type = "output", split = FALSE)
[15:32:07.715]             base::close(...future.stdout)
[15:32:07.715]         }, add = TRUE)
[15:32:07.715]     }
[15:32:07.715]     ...future.frame <- base::sys.nframe()
[15:32:07.715]     ...future.conditions <- base::list()
[15:32:07.715]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.715]     if (FALSE) {
[15:32:07.715]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.715]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.715]     }
[15:32:07.715]     ...future.result <- base::tryCatch({
[15:32:07.715]         base::withCallingHandlers({
[15:32:07.715]             ...future.value <- base::withVisible(base::local({
[15:32:07.715]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.715]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.715]                   ...future.globals.maxSize)) {
[15:32:07.715]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.715]                   on.exit(options(oopts), add = TRUE)
[15:32:07.715]                 }
[15:32:07.715]                 {
[15:32:07.715]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.715]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.715]                     USE.NAMES = FALSE)
[15:32:07.715]                   do.call(mapply, args = args)
[15:32:07.715]                 }
[15:32:07.715]             }))
[15:32:07.715]             future::FutureResult(value = ...future.value$value, 
[15:32:07.715]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.715]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.715]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.715]                     ...future.globalenv.names))
[15:32:07.715]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.715]         }, condition = base::local({
[15:32:07.715]             c <- base::c
[15:32:07.715]             inherits <- base::inherits
[15:32:07.715]             invokeRestart <- base::invokeRestart
[15:32:07.715]             length <- base::length
[15:32:07.715]             list <- base::list
[15:32:07.715]             seq.int <- base::seq.int
[15:32:07.715]             signalCondition <- base::signalCondition
[15:32:07.715]             sys.calls <- base::sys.calls
[15:32:07.715]             `[[` <- base::`[[`
[15:32:07.715]             `+` <- base::`+`
[15:32:07.715]             `<<-` <- base::`<<-`
[15:32:07.715]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.715]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.715]                   3L)]
[15:32:07.715]             }
[15:32:07.715]             function(cond) {
[15:32:07.715]                 is_error <- inherits(cond, "error")
[15:32:07.715]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.715]                   NULL)
[15:32:07.715]                 if (is_error) {
[15:32:07.715]                   sessionInformation <- function() {
[15:32:07.715]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.715]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.715]                       search = base::search(), system = base::Sys.info())
[15:32:07.715]                   }
[15:32:07.715]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.715]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.715]                     cond$call), session = sessionInformation(), 
[15:32:07.715]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.715]                   signalCondition(cond)
[15:32:07.715]                 }
[15:32:07.715]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.715]                 "immediateCondition"))) {
[15:32:07.715]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.715]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.715]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.715]                   if (TRUE && !signal) {
[15:32:07.715]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.715]                     {
[15:32:07.715]                       inherits <- base::inherits
[15:32:07.715]                       invokeRestart <- base::invokeRestart
[15:32:07.715]                       is.null <- base::is.null
[15:32:07.715]                       muffled <- FALSE
[15:32:07.715]                       if (inherits(cond, "message")) {
[15:32:07.715]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.715]                         if (muffled) 
[15:32:07.715]                           invokeRestart("muffleMessage")
[15:32:07.715]                       }
[15:32:07.715]                       else if (inherits(cond, "warning")) {
[15:32:07.715]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.715]                         if (muffled) 
[15:32:07.715]                           invokeRestart("muffleWarning")
[15:32:07.715]                       }
[15:32:07.715]                       else if (inherits(cond, "condition")) {
[15:32:07.715]                         if (!is.null(pattern)) {
[15:32:07.715]                           computeRestarts <- base::computeRestarts
[15:32:07.715]                           grepl <- base::grepl
[15:32:07.715]                           restarts <- computeRestarts(cond)
[15:32:07.715]                           for (restart in restarts) {
[15:32:07.715]                             name <- restart$name
[15:32:07.715]                             if (is.null(name)) 
[15:32:07.715]                               next
[15:32:07.715]                             if (!grepl(pattern, name)) 
[15:32:07.715]                               next
[15:32:07.715]                             invokeRestart(restart)
[15:32:07.715]                             muffled <- TRUE
[15:32:07.715]                             break
[15:32:07.715]                           }
[15:32:07.715]                         }
[15:32:07.715]                       }
[15:32:07.715]                       invisible(muffled)
[15:32:07.715]                     }
[15:32:07.715]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.715]                   }
[15:32:07.715]                 }
[15:32:07.715]                 else {
[15:32:07.715]                   if (TRUE) {
[15:32:07.715]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.715]                     {
[15:32:07.715]                       inherits <- base::inherits
[15:32:07.715]                       invokeRestart <- base::invokeRestart
[15:32:07.715]                       is.null <- base::is.null
[15:32:07.715]                       muffled <- FALSE
[15:32:07.715]                       if (inherits(cond, "message")) {
[15:32:07.715]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.715]                         if (muffled) 
[15:32:07.715]                           invokeRestart("muffleMessage")
[15:32:07.715]                       }
[15:32:07.715]                       else if (inherits(cond, "warning")) {
[15:32:07.715]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.715]                         if (muffled) 
[15:32:07.715]                           invokeRestart("muffleWarning")
[15:32:07.715]                       }
[15:32:07.715]                       else if (inherits(cond, "condition")) {
[15:32:07.715]                         if (!is.null(pattern)) {
[15:32:07.715]                           computeRestarts <- base::computeRestarts
[15:32:07.715]                           grepl <- base::grepl
[15:32:07.715]                           restarts <- computeRestarts(cond)
[15:32:07.715]                           for (restart in restarts) {
[15:32:07.715]                             name <- restart$name
[15:32:07.715]                             if (is.null(name)) 
[15:32:07.715]                               next
[15:32:07.715]                             if (!grepl(pattern, name)) 
[15:32:07.715]                               next
[15:32:07.715]                             invokeRestart(restart)
[15:32:07.715]                             muffled <- TRUE
[15:32:07.715]                             break
[15:32:07.715]                           }
[15:32:07.715]                         }
[15:32:07.715]                       }
[15:32:07.715]                       invisible(muffled)
[15:32:07.715]                     }
[15:32:07.715]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.715]                   }
[15:32:07.715]                 }
[15:32:07.715]             }
[15:32:07.715]         }))
[15:32:07.715]     }, error = function(ex) {
[15:32:07.715]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.715]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.715]                 ...future.rng), started = ...future.startTime, 
[15:32:07.715]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.715]             version = "1.8"), class = "FutureResult")
[15:32:07.715]     }, finally = {
[15:32:07.715]         if (!identical(...future.workdir, getwd())) 
[15:32:07.715]             setwd(...future.workdir)
[15:32:07.715]         {
[15:32:07.715]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.715]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.715]             }
[15:32:07.715]             base::options(...future.oldOptions)
[15:32:07.715]             if (.Platform$OS.type == "windows") {
[15:32:07.715]                 old_names <- names(...future.oldEnvVars)
[15:32:07.715]                 envs <- base::Sys.getenv()
[15:32:07.715]                 names <- names(envs)
[15:32:07.715]                 common <- intersect(names, old_names)
[15:32:07.715]                 added <- setdiff(names, old_names)
[15:32:07.715]                 removed <- setdiff(old_names, names)
[15:32:07.715]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.715]                   envs[common]]
[15:32:07.715]                 NAMES <- toupper(changed)
[15:32:07.715]                 args <- list()
[15:32:07.715]                 for (kk in seq_along(NAMES)) {
[15:32:07.715]                   name <- changed[[kk]]
[15:32:07.715]                   NAME <- NAMES[[kk]]
[15:32:07.715]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.715]                     next
[15:32:07.715]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.715]                 }
[15:32:07.715]                 NAMES <- toupper(added)
[15:32:07.715]                 for (kk in seq_along(NAMES)) {
[15:32:07.715]                   name <- added[[kk]]
[15:32:07.715]                   NAME <- NAMES[[kk]]
[15:32:07.715]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.715]                     next
[15:32:07.715]                   args[[name]] <- ""
[15:32:07.715]                 }
[15:32:07.715]                 NAMES <- toupper(removed)
[15:32:07.715]                 for (kk in seq_along(NAMES)) {
[15:32:07.715]                   name <- removed[[kk]]
[15:32:07.715]                   NAME <- NAMES[[kk]]
[15:32:07.715]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.715]                     next
[15:32:07.715]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.715]                 }
[15:32:07.715]                 if (length(args) > 0) 
[15:32:07.715]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.715]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.715]             }
[15:32:07.715]             else {
[15:32:07.715]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.715]             }
[15:32:07.715]             {
[15:32:07.715]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.715]                   0L) {
[15:32:07.715]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.715]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.715]                   base::options(opts)
[15:32:07.715]                 }
[15:32:07.715]                 {
[15:32:07.715]                   {
[15:32:07.715]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.715]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.715]                     -253660479L), envir = base::globalenv(), 
[15:32:07.715]                       inherits = FALSE)
[15:32:07.715]                     NULL
[15:32:07.715]                   }
[15:32:07.715]                   options(future.plan = NULL)
[15:32:07.715]                   if (is.na(NA_character_)) 
[15:32:07.715]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.715]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.715]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.715]                     .init = FALSE)
[15:32:07.715]                 }
[15:32:07.715]             }
[15:32:07.715]         }
[15:32:07.715]     })
[15:32:07.715]     if (TRUE) {
[15:32:07.715]         base::sink(type = "output", split = FALSE)
[15:32:07.715]         if (TRUE) {
[15:32:07.715]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.715]         }
[15:32:07.715]         else {
[15:32:07.715]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.715]         }
[15:32:07.715]         base::close(...future.stdout)
[15:32:07.715]         ...future.stdout <- NULL
[15:32:07.715]     }
[15:32:07.715]     ...future.result$conditions <- ...future.conditions
[15:32:07.715]     ...future.result$finished <- base::Sys.time()
[15:32:07.715]     ...future.result
[15:32:07.715] }
[15:32:07.721] assign_globals() ...
[15:32:07.722] List of 5
[15:32:07.722]  $ ...future.FUN            :function (C, k)  
[15:32:07.722]  $ MoreArgs                 : NULL
[15:32:07.722]  $ ...future.elements_ii    :List of 2
[15:32:07.722]   ..$ :List of 2
[15:32:07.722]   .. ..$ : chr "E"
[15:32:07.722]   .. ..$ : chr "D"
[15:32:07.722]   ..$ :List of 2
[15:32:07.722]   .. ..$ : int 1
[15:32:07.722]   .. ..$ : int 2
[15:32:07.722]  $ ...future.seeds_ii       : NULL
[15:32:07.722]  $ ...future.globals.maxSize: NULL
[15:32:07.722]  - attr(*, "where")=List of 5
[15:32:07.722]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.722]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.722]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.722]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.722]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.722]  - attr(*, "resolved")= logi FALSE
[15:32:07.722]  - attr(*, "total_size")= num 3656
[15:32:07.722]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.722]  - attr(*, "already-done")= logi TRUE
[15:32:07.732] - reassign environment for '...future.FUN'
[15:32:07.732] - copied '...future.FUN' to environment
[15:32:07.732] - copied 'MoreArgs' to environment
[15:32:07.732] - copied '...future.elements_ii' to environment
[15:32:07.732] - copied '...future.seeds_ii' to environment
[15:32:07.733] - copied '...future.globals.maxSize' to environment
[15:32:07.733] assign_globals() ... done
[15:32:07.733] plan(): Setting new future strategy stack:
[15:32:07.733] List of future strategies:
[15:32:07.733] 1. sequential:
[15:32:07.733]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.733]    - tweaked: FALSE
[15:32:07.733]    - call: NULL
[15:32:07.734] plan(): nbrOfWorkers() = 1
[15:32:07.736] plan(): Setting new future strategy stack:
[15:32:07.736] List of future strategies:
[15:32:07.736] 1. sequential:
[15:32:07.736]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.736]    - tweaked: FALSE
[15:32:07.736]    - call: plan(strategy)
[15:32:07.737] plan(): nbrOfWorkers() = 1
[15:32:07.737] SequentialFuture started (and completed)
[15:32:07.738] - Launch lazy future ... done
[15:32:07.738] run() for 'SequentialFuture' ... done
[15:32:07.738] Created future:
[15:32:07.738] SequentialFuture:
[15:32:07.738] Label: 'future_mapply-1'
[15:32:07.738] Expression:
[15:32:07.738] {
[15:32:07.738]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.738]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.738]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.738]         on.exit(options(oopts), add = TRUE)
[15:32:07.738]     }
[15:32:07.738]     {
[15:32:07.738]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.738]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.738]         do.call(mapply, args = args)
[15:32:07.738]     }
[15:32:07.738] }
[15:32:07.738] Lazy evaluation: FALSE
[15:32:07.738] Asynchronous evaluation: FALSE
[15:32:07.738] Local evaluation: TRUE
[15:32:07.738] Environment: R_GlobalEnv
[15:32:07.738] Capture standard output: TRUE
[15:32:07.738] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.738] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.738] Packages: <none>
[15:32:07.738] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.738] Resolved: TRUE
[15:32:07.738] Value: 224 bytes of class 'list'
[15:32:07.738] Early signaling: FALSE
[15:32:07.738] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.738] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.740] Chunk #1 of 2 ... DONE
[15:32:07.740] Chunk #2 of 2 ...
[15:32:07.740]  - Finding globals in '...' for chunk #2 ...
[15:32:07.741] getGlobalsAndPackages() ...
[15:32:07.741] Searching for globals...
[15:32:07.741] 
[15:32:07.742] Searching for globals ... DONE
[15:32:07.742] - globals: [0] <none>
[15:32:07.742] getGlobalsAndPackages() ... DONE
[15:32:07.742]    + additional globals found: [n=0] 
[15:32:07.743]    + additional namespaces needed: [n=0] 
[15:32:07.743]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:07.743]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:07.743]  - seeds: <none>
[15:32:07.743]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.744] getGlobalsAndPackages() ...
[15:32:07.744] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.744] Resolving globals: FALSE
[15:32:07.748] The total size of the 5 globals is 3.73 KiB (3824 bytes)
[15:32:07.748] 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 3.73 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (504 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.749] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.749] 
[15:32:07.749] getGlobalsAndPackages() ... DONE
[15:32:07.750] run() for 'Future' ...
[15:32:07.750] - state: 'created'
[15:32:07.750] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.751] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.751] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.752]   - Field: 'label'
[15:32:07.752]   - Field: 'local'
[15:32:07.752]   - Field: 'owner'
[15:32:07.752]   - Field: 'envir'
[15:32:07.753]   - Field: 'packages'
[15:32:07.753]   - Field: 'gc'
[15:32:07.753]   - Field: 'conditions'
[15:32:07.753]   - Field: 'expr'
[15:32:07.754]   - Field: 'uuid'
[15:32:07.754]   - Field: 'seed'
[15:32:07.754]   - Field: 'version'
[15:32:07.755]   - Field: 'result'
[15:32:07.755]   - Field: 'asynchronous'
[15:32:07.755]   - Field: 'calls'
[15:32:07.755]   - Field: 'globals'
[15:32:07.756]   - Field: 'stdout'
[15:32:07.756]   - Field: 'earlySignal'
[15:32:07.756]   - Field: 'lazy'
[15:32:07.756]   - Field: 'state'
[15:32:07.757] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.757] - Launch lazy future ...
[15:32:07.757] Packages needed by the future expression (n = 0): <none>
[15:32:07.758] Packages needed by future strategies (n = 0): <none>
[15:32:07.759] {
[15:32:07.759]     {
[15:32:07.759]         {
[15:32:07.759]             ...future.startTime <- base::Sys.time()
[15:32:07.759]             {
[15:32:07.759]                 {
[15:32:07.759]                   {
[15:32:07.759]                     base::local({
[15:32:07.759]                       has_future <- base::requireNamespace("future", 
[15:32:07.759]                         quietly = TRUE)
[15:32:07.759]                       if (has_future) {
[15:32:07.759]                         ns <- base::getNamespace("future")
[15:32:07.759]                         version <- ns[[".package"]][["version"]]
[15:32:07.759]                         if (is.null(version)) 
[15:32:07.759]                           version <- utils::packageVersion("future")
[15:32:07.759]                       }
[15:32:07.759]                       else {
[15:32:07.759]                         version <- NULL
[15:32:07.759]                       }
[15:32:07.759]                       if (!has_future || version < "1.8.0") {
[15:32:07.759]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.759]                           "", base::R.version$version.string), 
[15:32:07.759]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.759]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.759]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.759]                             "release", "version")], collapse = " "), 
[15:32:07.759]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.759]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.759]                           info)
[15:32:07.759]                         info <- base::paste(info, collapse = "; ")
[15:32:07.759]                         if (!has_future) {
[15:32:07.759]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.759]                             info)
[15:32:07.759]                         }
[15:32:07.759]                         else {
[15:32:07.759]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.759]                             info, version)
[15:32:07.759]                         }
[15:32:07.759]                         base::stop(msg)
[15:32:07.759]                       }
[15:32:07.759]                     })
[15:32:07.759]                   }
[15:32:07.759]                   ...future.strategy.old <- future::plan("list")
[15:32:07.759]                   options(future.plan = NULL)
[15:32:07.759]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.759]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.759]                 }
[15:32:07.759]                 ...future.workdir <- getwd()
[15:32:07.759]             }
[15:32:07.759]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.759]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.759]         }
[15:32:07.759]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.759]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:07.759]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.759]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.759]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.759]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.759]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.759]             base::names(...future.oldOptions))
[15:32:07.759]     }
[15:32:07.759]     if (FALSE) {
[15:32:07.759]     }
[15:32:07.759]     else {
[15:32:07.759]         if (TRUE) {
[15:32:07.759]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.759]                 open = "w")
[15:32:07.759]         }
[15:32:07.759]         else {
[15:32:07.759]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.759]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.759]         }
[15:32:07.759]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.759]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.759]             base::sink(type = "output", split = FALSE)
[15:32:07.759]             base::close(...future.stdout)
[15:32:07.759]         }, add = TRUE)
[15:32:07.759]     }
[15:32:07.759]     ...future.frame <- base::sys.nframe()
[15:32:07.759]     ...future.conditions <- base::list()
[15:32:07.759]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.759]     if (FALSE) {
[15:32:07.759]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.759]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.759]     }
[15:32:07.759]     ...future.result <- base::tryCatch({
[15:32:07.759]         base::withCallingHandlers({
[15:32:07.759]             ...future.value <- base::withVisible(base::local({
[15:32:07.759]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.759]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.759]                   ...future.globals.maxSize)) {
[15:32:07.759]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.759]                   on.exit(options(oopts), add = TRUE)
[15:32:07.759]                 }
[15:32:07.759]                 {
[15:32:07.759]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.759]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.759]                     USE.NAMES = FALSE)
[15:32:07.759]                   do.call(mapply, args = args)
[15:32:07.759]                 }
[15:32:07.759]             }))
[15:32:07.759]             future::FutureResult(value = ...future.value$value, 
[15:32:07.759]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.759]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.759]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.759]                     ...future.globalenv.names))
[15:32:07.759]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.759]         }, condition = base::local({
[15:32:07.759]             c <- base::c
[15:32:07.759]             inherits <- base::inherits
[15:32:07.759]             invokeRestart <- base::invokeRestart
[15:32:07.759]             length <- base::length
[15:32:07.759]             list <- base::list
[15:32:07.759]             seq.int <- base::seq.int
[15:32:07.759]             signalCondition <- base::signalCondition
[15:32:07.759]             sys.calls <- base::sys.calls
[15:32:07.759]             `[[` <- base::`[[`
[15:32:07.759]             `+` <- base::`+`
[15:32:07.759]             `<<-` <- base::`<<-`
[15:32:07.759]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.759]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.759]                   3L)]
[15:32:07.759]             }
[15:32:07.759]             function(cond) {
[15:32:07.759]                 is_error <- inherits(cond, "error")
[15:32:07.759]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.759]                   NULL)
[15:32:07.759]                 if (is_error) {
[15:32:07.759]                   sessionInformation <- function() {
[15:32:07.759]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.759]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.759]                       search = base::search(), system = base::Sys.info())
[15:32:07.759]                   }
[15:32:07.759]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.759]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.759]                     cond$call), session = sessionInformation(), 
[15:32:07.759]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.759]                   signalCondition(cond)
[15:32:07.759]                 }
[15:32:07.759]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.759]                 "immediateCondition"))) {
[15:32:07.759]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.759]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.759]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.759]                   if (TRUE && !signal) {
[15:32:07.759]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.759]                     {
[15:32:07.759]                       inherits <- base::inherits
[15:32:07.759]                       invokeRestart <- base::invokeRestart
[15:32:07.759]                       is.null <- base::is.null
[15:32:07.759]                       muffled <- FALSE
[15:32:07.759]                       if (inherits(cond, "message")) {
[15:32:07.759]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.759]                         if (muffled) 
[15:32:07.759]                           invokeRestart("muffleMessage")
[15:32:07.759]                       }
[15:32:07.759]                       else if (inherits(cond, "warning")) {
[15:32:07.759]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.759]                         if (muffled) 
[15:32:07.759]                           invokeRestart("muffleWarning")
[15:32:07.759]                       }
[15:32:07.759]                       else if (inherits(cond, "condition")) {
[15:32:07.759]                         if (!is.null(pattern)) {
[15:32:07.759]                           computeRestarts <- base::computeRestarts
[15:32:07.759]                           grepl <- base::grepl
[15:32:07.759]                           restarts <- computeRestarts(cond)
[15:32:07.759]                           for (restart in restarts) {
[15:32:07.759]                             name <- restart$name
[15:32:07.759]                             if (is.null(name)) 
[15:32:07.759]                               next
[15:32:07.759]                             if (!grepl(pattern, name)) 
[15:32:07.759]                               next
[15:32:07.759]                             invokeRestart(restart)
[15:32:07.759]                             muffled <- TRUE
[15:32:07.759]                             break
[15:32:07.759]                           }
[15:32:07.759]                         }
[15:32:07.759]                       }
[15:32:07.759]                       invisible(muffled)
[15:32:07.759]                     }
[15:32:07.759]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.759]                   }
[15:32:07.759]                 }
[15:32:07.759]                 else {
[15:32:07.759]                   if (TRUE) {
[15:32:07.759]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.759]                     {
[15:32:07.759]                       inherits <- base::inherits
[15:32:07.759]                       invokeRestart <- base::invokeRestart
[15:32:07.759]                       is.null <- base::is.null
[15:32:07.759]                       muffled <- FALSE
[15:32:07.759]                       if (inherits(cond, "message")) {
[15:32:07.759]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.759]                         if (muffled) 
[15:32:07.759]                           invokeRestart("muffleMessage")
[15:32:07.759]                       }
[15:32:07.759]                       else if (inherits(cond, "warning")) {
[15:32:07.759]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.759]                         if (muffled) 
[15:32:07.759]                           invokeRestart("muffleWarning")
[15:32:07.759]                       }
[15:32:07.759]                       else if (inherits(cond, "condition")) {
[15:32:07.759]                         if (!is.null(pattern)) {
[15:32:07.759]                           computeRestarts <- base::computeRestarts
[15:32:07.759]                           grepl <- base::grepl
[15:32:07.759]                           restarts <- computeRestarts(cond)
[15:32:07.759]                           for (restart in restarts) {
[15:32:07.759]                             name <- restart$name
[15:32:07.759]                             if (is.null(name)) 
[15:32:07.759]                               next
[15:32:07.759]                             if (!grepl(pattern, name)) 
[15:32:07.759]                               next
[15:32:07.759]                             invokeRestart(restart)
[15:32:07.759]                             muffled <- TRUE
[15:32:07.759]                             break
[15:32:07.759]                           }
[15:32:07.759]                         }
[15:32:07.759]                       }
[15:32:07.759]                       invisible(muffled)
[15:32:07.759]                     }
[15:32:07.759]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.759]                   }
[15:32:07.759]                 }
[15:32:07.759]             }
[15:32:07.759]         }))
[15:32:07.759]     }, error = function(ex) {
[15:32:07.759]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.759]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.759]                 ...future.rng), started = ...future.startTime, 
[15:32:07.759]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.759]             version = "1.8"), class = "FutureResult")
[15:32:07.759]     }, finally = {
[15:32:07.759]         if (!identical(...future.workdir, getwd())) 
[15:32:07.759]             setwd(...future.workdir)
[15:32:07.759]         {
[15:32:07.759]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.759]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.759]             }
[15:32:07.759]             base::options(...future.oldOptions)
[15:32:07.759]             if (.Platform$OS.type == "windows") {
[15:32:07.759]                 old_names <- names(...future.oldEnvVars)
[15:32:07.759]                 envs <- base::Sys.getenv()
[15:32:07.759]                 names <- names(envs)
[15:32:07.759]                 common <- intersect(names, old_names)
[15:32:07.759]                 added <- setdiff(names, old_names)
[15:32:07.759]                 removed <- setdiff(old_names, names)
[15:32:07.759]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.759]                   envs[common]]
[15:32:07.759]                 NAMES <- toupper(changed)
[15:32:07.759]                 args <- list()
[15:32:07.759]                 for (kk in seq_along(NAMES)) {
[15:32:07.759]                   name <- changed[[kk]]
[15:32:07.759]                   NAME <- NAMES[[kk]]
[15:32:07.759]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.759]                     next
[15:32:07.759]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.759]                 }
[15:32:07.759]                 NAMES <- toupper(added)
[15:32:07.759]                 for (kk in seq_along(NAMES)) {
[15:32:07.759]                   name <- added[[kk]]
[15:32:07.759]                   NAME <- NAMES[[kk]]
[15:32:07.759]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.759]                     next
[15:32:07.759]                   args[[name]] <- ""
[15:32:07.759]                 }
[15:32:07.759]                 NAMES <- toupper(removed)
[15:32:07.759]                 for (kk in seq_along(NAMES)) {
[15:32:07.759]                   name <- removed[[kk]]
[15:32:07.759]                   NAME <- NAMES[[kk]]
[15:32:07.759]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.759]                     next
[15:32:07.759]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.759]                 }
[15:32:07.759]                 if (length(args) > 0) 
[15:32:07.759]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.759]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.759]             }
[15:32:07.759]             else {
[15:32:07.759]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.759]             }
[15:32:07.759]             {
[15:32:07.759]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.759]                   0L) {
[15:32:07.759]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.759]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.759]                   base::options(opts)
[15:32:07.759]                 }
[15:32:07.759]                 {
[15:32:07.759]                   {
[15:32:07.759]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.759]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.759]                     -253660479L), envir = base::globalenv(), 
[15:32:07.759]                       inherits = FALSE)
[15:32:07.759]                     NULL
[15:32:07.759]                   }
[15:32:07.759]                   options(future.plan = NULL)
[15:32:07.759]                   if (is.na(NA_character_)) 
[15:32:07.759]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.759]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.759]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.759]                     .init = FALSE)
[15:32:07.759]                 }
[15:32:07.759]             }
[15:32:07.759]         }
[15:32:07.759]     })
[15:32:07.759]     if (TRUE) {
[15:32:07.759]         base::sink(type = "output", split = FALSE)
[15:32:07.759]         if (TRUE) {
[15:32:07.759]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.759]         }
[15:32:07.759]         else {
[15:32:07.759]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.759]         }
[15:32:07.759]         base::close(...future.stdout)
[15:32:07.759]         ...future.stdout <- NULL
[15:32:07.759]     }
[15:32:07.759]     ...future.result$conditions <- ...future.conditions
[15:32:07.759]     ...future.result$finished <- base::Sys.time()
[15:32:07.759]     ...future.result
[15:32:07.759] }
[15:32:07.764] assign_globals() ...
[15:32:07.764] List of 5
[15:32:07.764]  $ ...future.FUN            :function (C, k)  
[15:32:07.764]  $ MoreArgs                 : NULL
[15:32:07.764]  $ ...future.elements_ii    :List of 2
[15:32:07.764]   ..$ :List of 3
[15:32:07.764]   .. ..$ : chr "C"
[15:32:07.764]   .. ..$ : chr "B"
[15:32:07.764]   .. ..$ : chr "A"
[15:32:07.764]   ..$ :List of 3
[15:32:07.764]   .. ..$ : int 3
[15:32:07.764]   .. ..$ : int 4
[15:32:07.764]   .. ..$ : int 5
[15:32:07.764]  $ ...future.seeds_ii       : NULL
[15:32:07.764]  $ ...future.globals.maxSize: NULL
[15:32:07.764]  - attr(*, "where")=List of 5
[15:32:07.764]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.764]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.764]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.764]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.764]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.764]  - attr(*, "resolved")= logi FALSE
[15:32:07.764]  - attr(*, "total_size")= num 3824
[15:32:07.764]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.764]  - attr(*, "already-done")= logi TRUE
[15:32:07.775] - reassign environment for '...future.FUN'
[15:32:07.776] - copied '...future.FUN' to environment
[15:32:07.776] - copied 'MoreArgs' to environment
[15:32:07.776] - copied '...future.elements_ii' to environment
[15:32:07.776] - copied '...future.seeds_ii' to environment
[15:32:07.777] - copied '...future.globals.maxSize' to environment
[15:32:07.777] assign_globals() ... done
[15:32:07.778] plan(): Setting new future strategy stack:
[15:32:07.778] List of future strategies:
[15:32:07.778] 1. sequential:
[15:32:07.778]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.778]    - tweaked: FALSE
[15:32:07.778]    - call: NULL
[15:32:07.779] plan(): nbrOfWorkers() = 1
[15:32:07.781] plan(): Setting new future strategy stack:
[15:32:07.781] List of future strategies:
[15:32:07.781] 1. sequential:
[15:32:07.781]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.781]    - tweaked: FALSE
[15:32:07.781]    - call: plan(strategy)
[15:32:07.782] plan(): nbrOfWorkers() = 1
[15:32:07.782] SequentialFuture started (and completed)
[15:32:07.782] - Launch lazy future ... done
[15:32:07.783] run() for 'SequentialFuture' ... done
[15:32:07.783] Created future:
[15:32:07.783] SequentialFuture:
[15:32:07.783] Label: 'future_mapply-2'
[15:32:07.783] Expression:
[15:32:07.783] {
[15:32:07.783]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.783]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.783]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.783]         on.exit(options(oopts), add = TRUE)
[15:32:07.783]     }
[15:32:07.783]     {
[15:32:07.783]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.783]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.783]         do.call(mapply, args = args)
[15:32:07.783]     }
[15:32:07.783] }
[15:32:07.783] Lazy evaluation: FALSE
[15:32:07.783] Asynchronous evaluation: FALSE
[15:32:07.783] Local evaluation: TRUE
[15:32:07.783] Environment: R_GlobalEnv
[15:32:07.783] Capture standard output: TRUE
[15:32:07.783] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.783] Globals: 5 objects totaling 3.73 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 504 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.783] Packages: <none>
[15:32:07.783] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.783] Resolved: TRUE
[15:32:07.783] Value: 336 bytes of class 'list'
[15:32:07.783] Early signaling: FALSE
[15:32:07.783] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.783] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.785] Chunk #2 of 2 ... DONE
[15:32:07.785] Launching 2 futures (chunks) ... DONE
[15:32:07.785] Resolving 2 futures (chunks) ...
[15:32:07.786] resolve() on list ...
[15:32:07.786]  recursive: 0
[15:32:07.786]  length: 2
[15:32:07.786] 
[15:32:07.788] resolved() for 'SequentialFuture' ...
[15:32:07.789] - state: 'finished'
[15:32:07.789] - run: TRUE
[15:32:07.789] - result: 'FutureResult'
[15:32:07.789] resolved() for 'SequentialFuture' ... done
[15:32:07.789] Future #1
[15:32:07.790] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.790] - nx: 2
[15:32:07.790] - relay: TRUE
[15:32:07.790] - stdout: TRUE
[15:32:07.790] - signal: TRUE
[15:32:07.791] - resignal: FALSE
[15:32:07.791] - force: TRUE
[15:32:07.791] - relayed: [n=2] FALSE, FALSE
[15:32:07.791] - queued futures: [n=2] FALSE, FALSE
[15:32:07.791]  - until=1
[15:32:07.792]  - relaying element #1
[15:32:07.792] - relayed: [n=2] TRUE, FALSE
[15:32:07.792] - queued futures: [n=2] TRUE, FALSE
[15:32:07.792] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.793]  length: 1 (resolved future 1)
[15:32:07.793] resolved() for 'SequentialFuture' ...
[15:32:07.793] - state: 'finished'
[15:32:07.793] - run: TRUE
[15:32:07.793] - result: 'FutureResult'
[15:32:07.794] resolved() for 'SequentialFuture' ... done
[15:32:07.794] Future #2
[15:32:07.794] signalConditionsASAP(SequentialFuture, pos=2) ...
[15:32:07.794] - nx: 2
[15:32:07.794] - relay: TRUE
[15:32:07.794] - stdout: TRUE
[15:32:07.795] - signal: TRUE
[15:32:07.795] - resignal: FALSE
[15:32:07.795] - force: TRUE
[15:32:07.795] - relayed: [n=2] TRUE, FALSE
[15:32:07.795] - queued futures: [n=2] TRUE, FALSE
[15:32:07.795]  - until=2
[15:32:07.796]  - relaying element #2
[15:32:07.796] - relayed: [n=2] TRUE, TRUE
[15:32:07.796] - queued futures: [n=2] TRUE, TRUE
[15:32:07.797] signalConditionsASAP(SequentialFuture, pos=2) ... done
[15:32:07.797]  length: 0 (resolved future 2)
[15:32:07.797] Relaying remaining futures
[15:32:07.797] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.798] - nx: 2
[15:32:07.798] - relay: TRUE
[15:32:07.798] - stdout: TRUE
[15:32:07.799] - signal: TRUE
[15:32:07.799] - resignal: FALSE
[15:32:07.799] - force: TRUE
[15:32:07.800] - relayed: [n=2] TRUE, TRUE
[15:32:07.800] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:07.800] - relayed: [n=2] TRUE, TRUE
[15:32:07.801] - queued futures: [n=2] TRUE, TRUE
[15:32:07.801] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.801] resolve() on list ... DONE
[15:32:07.802]  - Number of value chunks collected: 2
[15:32:07.802] Resolving 2 futures (chunks) ... DONE
[15:32:07.802] Reducing values from 2 chunks ...
[15:32:07.802]  - Number of values collected after concatenation: 5
[15:32:07.803]  - Number of values expected: 5
[15:32:07.803] Reverse index remapping (attribute 'ordering'): [n = 5] 5, 4, 3, 2, 1
[15:32:07.803] Reducing values from 2 chunks ... DONE
[15:32:07.803] future_mapply() ... DONE
[15:32:07.804] future_mapply() ...
[15:32:07.804] Number of chunks: 1
[15:32:07.804] getGlobalsAndPackagesXApply() ...
[15:32:07.804]  - future.globals: TRUE
[15:32:07.804] getGlobalsAndPackages() ...
[15:32:07.805] Searching for globals...
[15:32:07.806] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:07.807] Searching for globals ... DONE
[15:32:07.807] Resolving globals: FALSE
[15:32:07.807] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:07.808] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:07.808] - globals: [1] 'FUN'
[15:32:07.808] 
[15:32:07.809] getGlobalsAndPackages() ... DONE
[15:32:07.809]  - globals found/used: [n=1] 'FUN'
[15:32:07.809]  - needed namespaces: [n=0] 
[15:32:07.809] Finding globals ... DONE
[15:32:07.809] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.810] List of 2
[15:32:07.810]  $ ...future.FUN:function (C, k)  
[15:32:07.810]  $ MoreArgs     : list()
[15:32:07.810]  - attr(*, "where")=List of 2
[15:32:07.810]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.810]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.810]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.810]  - attr(*, "resolved")= logi FALSE
[15:32:07.810]  - attr(*, "total_size")= num NA
[15:32:07.813] Packages to be attached in all futures: [n=0] 
[15:32:07.813] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.814] Number of futures (= number of chunks): 1
[15:32:07.814] Launching 1 futures (chunks) ...
[15:32:07.814] Chunk #1 of 1 ...
[15:32:07.815]  - Finding globals in '...' for chunk #1 ...
[15:32:07.815] getGlobalsAndPackages() ...
[15:32:07.815] Searching for globals...
[15:32:07.815] 
[15:32:07.816] Searching for globals ... DONE
[15:32:07.816] - globals: [0] <none>
[15:32:07.816] getGlobalsAndPackages() ... DONE
[15:32:07.816]    + additional globals found: [n=0] 
[15:32:07.816]    + additional namespaces needed: [n=0] 
[15:32:07.816]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.817]  - seeds: <none>
[15:32:07.817]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.817] getGlobalsAndPackages() ...
[15:32:07.817] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.817] Resolving globals: FALSE
[15:32:07.818] The total size of the 5 globals is 4.06 KiB (4160 bytes)
[15:32:07.821] 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 4.06 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (840 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:07.821] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.821] 
[15:32:07.821] getGlobalsAndPackages() ... DONE
[15:32:07.822] run() for 'Future' ...
[15:32:07.822] - state: 'created'
[15:32:07.822] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.823] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.823] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.823]   - Field: 'label'
[15:32:07.824]   - Field: 'local'
[15:32:07.824]   - Field: 'owner'
[15:32:07.824]   - Field: 'envir'
[15:32:07.824]   - Field: 'packages'
[15:32:07.824]   - Field: 'gc'
[15:32:07.824]   - Field: 'conditions'
[15:32:07.825]   - Field: 'expr'
[15:32:07.825]   - Field: 'uuid'
[15:32:07.825]   - Field: 'seed'
[15:32:07.825]   - Field: 'version'
[15:32:07.825]   - Field: 'result'
[15:32:07.826]   - Field: 'asynchronous'
[15:32:07.826]   - Field: 'calls'
[15:32:07.826]   - Field: 'globals'
[15:32:07.826]   - Field: 'stdout'
[15:32:07.826]   - Field: 'earlySignal'
[15:32:07.827]   - Field: 'lazy'
[15:32:07.827]   - Field: 'state'
[15:32:07.827] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.827] - Launch lazy future ...
[15:32:07.827] Packages needed by the future expression (n = 0): <none>
[15:32:07.828] Packages needed by future strategies (n = 0): <none>
[15:32:07.828] {
[15:32:07.828]     {
[15:32:07.828]         {
[15:32:07.828]             ...future.startTime <- base::Sys.time()
[15:32:07.828]             {
[15:32:07.828]                 {
[15:32:07.828]                   {
[15:32:07.828]                     base::local({
[15:32:07.828]                       has_future <- base::requireNamespace("future", 
[15:32:07.828]                         quietly = TRUE)
[15:32:07.828]                       if (has_future) {
[15:32:07.828]                         ns <- base::getNamespace("future")
[15:32:07.828]                         version <- ns[[".package"]][["version"]]
[15:32:07.828]                         if (is.null(version)) 
[15:32:07.828]                           version <- utils::packageVersion("future")
[15:32:07.828]                       }
[15:32:07.828]                       else {
[15:32:07.828]                         version <- NULL
[15:32:07.828]                       }
[15:32:07.828]                       if (!has_future || version < "1.8.0") {
[15:32:07.828]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.828]                           "", base::R.version$version.string), 
[15:32:07.828]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.828]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.828]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.828]                             "release", "version")], collapse = " "), 
[15:32:07.828]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.828]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.828]                           info)
[15:32:07.828]                         info <- base::paste(info, collapse = "; ")
[15:32:07.828]                         if (!has_future) {
[15:32:07.828]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.828]                             info)
[15:32:07.828]                         }
[15:32:07.828]                         else {
[15:32:07.828]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.828]                             info, version)
[15:32:07.828]                         }
[15:32:07.828]                         base::stop(msg)
[15:32:07.828]                       }
[15:32:07.828]                     })
[15:32:07.828]                   }
[15:32:07.828]                   ...future.strategy.old <- future::plan("list")
[15:32:07.828]                   options(future.plan = NULL)
[15:32:07.828]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.828]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.828]                 }
[15:32:07.828]                 ...future.workdir <- getwd()
[15:32:07.828]             }
[15:32:07.828]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.828]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.828]         }
[15:32:07.828]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.828]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:07.828]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.828]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.828]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.828]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.828]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.828]             base::names(...future.oldOptions))
[15:32:07.828]     }
[15:32:07.828]     if (FALSE) {
[15:32:07.828]     }
[15:32:07.828]     else {
[15:32:07.828]         if (TRUE) {
[15:32:07.828]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.828]                 open = "w")
[15:32:07.828]         }
[15:32:07.828]         else {
[15:32:07.828]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.828]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.828]         }
[15:32:07.828]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.828]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.828]             base::sink(type = "output", split = FALSE)
[15:32:07.828]             base::close(...future.stdout)
[15:32:07.828]         }, add = TRUE)
[15:32:07.828]     }
[15:32:07.828]     ...future.frame <- base::sys.nframe()
[15:32:07.828]     ...future.conditions <- base::list()
[15:32:07.828]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.828]     if (FALSE) {
[15:32:07.828]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.828]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.828]     }
[15:32:07.828]     ...future.result <- base::tryCatch({
[15:32:07.828]         base::withCallingHandlers({
[15:32:07.828]             ...future.value <- base::withVisible(base::local({
[15:32:07.828]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.828]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.828]                   ...future.globals.maxSize)) {
[15:32:07.828]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.828]                   on.exit(options(oopts), add = TRUE)
[15:32:07.828]                 }
[15:32:07.828]                 {
[15:32:07.828]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.828]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.828]                     USE.NAMES = FALSE)
[15:32:07.828]                   do.call(mapply, args = args)
[15:32:07.828]                 }
[15:32:07.828]             }))
[15:32:07.828]             future::FutureResult(value = ...future.value$value, 
[15:32:07.828]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.828]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.828]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.828]                     ...future.globalenv.names))
[15:32:07.828]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.828]         }, condition = base::local({
[15:32:07.828]             c <- base::c
[15:32:07.828]             inherits <- base::inherits
[15:32:07.828]             invokeRestart <- base::invokeRestart
[15:32:07.828]             length <- base::length
[15:32:07.828]             list <- base::list
[15:32:07.828]             seq.int <- base::seq.int
[15:32:07.828]             signalCondition <- base::signalCondition
[15:32:07.828]             sys.calls <- base::sys.calls
[15:32:07.828]             `[[` <- base::`[[`
[15:32:07.828]             `+` <- base::`+`
[15:32:07.828]             `<<-` <- base::`<<-`
[15:32:07.828]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.828]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.828]                   3L)]
[15:32:07.828]             }
[15:32:07.828]             function(cond) {
[15:32:07.828]                 is_error <- inherits(cond, "error")
[15:32:07.828]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.828]                   NULL)
[15:32:07.828]                 if (is_error) {
[15:32:07.828]                   sessionInformation <- function() {
[15:32:07.828]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.828]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.828]                       search = base::search(), system = base::Sys.info())
[15:32:07.828]                   }
[15:32:07.828]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.828]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.828]                     cond$call), session = sessionInformation(), 
[15:32:07.828]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.828]                   signalCondition(cond)
[15:32:07.828]                 }
[15:32:07.828]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.828]                 "immediateCondition"))) {
[15:32:07.828]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.828]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.828]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.828]                   if (TRUE && !signal) {
[15:32:07.828]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.828]                     {
[15:32:07.828]                       inherits <- base::inherits
[15:32:07.828]                       invokeRestart <- base::invokeRestart
[15:32:07.828]                       is.null <- base::is.null
[15:32:07.828]                       muffled <- FALSE
[15:32:07.828]                       if (inherits(cond, "message")) {
[15:32:07.828]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.828]                         if (muffled) 
[15:32:07.828]                           invokeRestart("muffleMessage")
[15:32:07.828]                       }
[15:32:07.828]                       else if (inherits(cond, "warning")) {
[15:32:07.828]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.828]                         if (muffled) 
[15:32:07.828]                           invokeRestart("muffleWarning")
[15:32:07.828]                       }
[15:32:07.828]                       else if (inherits(cond, "condition")) {
[15:32:07.828]                         if (!is.null(pattern)) {
[15:32:07.828]                           computeRestarts <- base::computeRestarts
[15:32:07.828]                           grepl <- base::grepl
[15:32:07.828]                           restarts <- computeRestarts(cond)
[15:32:07.828]                           for (restart in restarts) {
[15:32:07.828]                             name <- restart$name
[15:32:07.828]                             if (is.null(name)) 
[15:32:07.828]                               next
[15:32:07.828]                             if (!grepl(pattern, name)) 
[15:32:07.828]                               next
[15:32:07.828]                             invokeRestart(restart)
[15:32:07.828]                             muffled <- TRUE
[15:32:07.828]                             break
[15:32:07.828]                           }
[15:32:07.828]                         }
[15:32:07.828]                       }
[15:32:07.828]                       invisible(muffled)
[15:32:07.828]                     }
[15:32:07.828]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.828]                   }
[15:32:07.828]                 }
[15:32:07.828]                 else {
[15:32:07.828]                   if (TRUE) {
[15:32:07.828]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.828]                     {
[15:32:07.828]                       inherits <- base::inherits
[15:32:07.828]                       invokeRestart <- base::invokeRestart
[15:32:07.828]                       is.null <- base::is.null
[15:32:07.828]                       muffled <- FALSE
[15:32:07.828]                       if (inherits(cond, "message")) {
[15:32:07.828]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.828]                         if (muffled) 
[15:32:07.828]                           invokeRestart("muffleMessage")
[15:32:07.828]                       }
[15:32:07.828]                       else if (inherits(cond, "warning")) {
[15:32:07.828]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.828]                         if (muffled) 
[15:32:07.828]                           invokeRestart("muffleWarning")
[15:32:07.828]                       }
[15:32:07.828]                       else if (inherits(cond, "condition")) {
[15:32:07.828]                         if (!is.null(pattern)) {
[15:32:07.828]                           computeRestarts <- base::computeRestarts
[15:32:07.828]                           grepl <- base::grepl
[15:32:07.828]                           restarts <- computeRestarts(cond)
[15:32:07.828]                           for (restart in restarts) {
[15:32:07.828]                             name <- restart$name
[15:32:07.828]                             if (is.null(name)) 
[15:32:07.828]                               next
[15:32:07.828]                             if (!grepl(pattern, name)) 
[15:32:07.828]                               next
[15:32:07.828]                             invokeRestart(restart)
[15:32:07.828]                             muffled <- TRUE
[15:32:07.828]                             break
[15:32:07.828]                           }
[15:32:07.828]                         }
[15:32:07.828]                       }
[15:32:07.828]                       invisible(muffled)
[15:32:07.828]                     }
[15:32:07.828]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.828]                   }
[15:32:07.828]                 }
[15:32:07.828]             }
[15:32:07.828]         }))
[15:32:07.828]     }, error = function(ex) {
[15:32:07.828]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.828]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.828]                 ...future.rng), started = ...future.startTime, 
[15:32:07.828]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.828]             version = "1.8"), class = "FutureResult")
[15:32:07.828]     }, finally = {
[15:32:07.828]         if (!identical(...future.workdir, getwd())) 
[15:32:07.828]             setwd(...future.workdir)
[15:32:07.828]         {
[15:32:07.828]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.828]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.828]             }
[15:32:07.828]             base::options(...future.oldOptions)
[15:32:07.828]             if (.Platform$OS.type == "windows") {
[15:32:07.828]                 old_names <- names(...future.oldEnvVars)
[15:32:07.828]                 envs <- base::Sys.getenv()
[15:32:07.828]                 names <- names(envs)
[15:32:07.828]                 common <- intersect(names, old_names)
[15:32:07.828]                 added <- setdiff(names, old_names)
[15:32:07.828]                 removed <- setdiff(old_names, names)
[15:32:07.828]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.828]                   envs[common]]
[15:32:07.828]                 NAMES <- toupper(changed)
[15:32:07.828]                 args <- list()
[15:32:07.828]                 for (kk in seq_along(NAMES)) {
[15:32:07.828]                   name <- changed[[kk]]
[15:32:07.828]                   NAME <- NAMES[[kk]]
[15:32:07.828]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.828]                     next
[15:32:07.828]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.828]                 }
[15:32:07.828]                 NAMES <- toupper(added)
[15:32:07.828]                 for (kk in seq_along(NAMES)) {
[15:32:07.828]                   name <- added[[kk]]
[15:32:07.828]                   NAME <- NAMES[[kk]]
[15:32:07.828]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.828]                     next
[15:32:07.828]                   args[[name]] <- ""
[15:32:07.828]                 }
[15:32:07.828]                 NAMES <- toupper(removed)
[15:32:07.828]                 for (kk in seq_along(NAMES)) {
[15:32:07.828]                   name <- removed[[kk]]
[15:32:07.828]                   NAME <- NAMES[[kk]]
[15:32:07.828]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.828]                     next
[15:32:07.828]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.828]                 }
[15:32:07.828]                 if (length(args) > 0) 
[15:32:07.828]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.828]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.828]             }
[15:32:07.828]             else {
[15:32:07.828]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.828]             }
[15:32:07.828]             {
[15:32:07.828]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.828]                   0L) {
[15:32:07.828]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.828]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.828]                   base::options(opts)
[15:32:07.828]                 }
[15:32:07.828]                 {
[15:32:07.828]                   {
[15:32:07.828]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.828]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.828]                     -253660479L), envir = base::globalenv(), 
[15:32:07.828]                       inherits = FALSE)
[15:32:07.828]                     NULL
[15:32:07.828]                   }
[15:32:07.828]                   options(future.plan = NULL)
[15:32:07.828]                   if (is.na(NA_character_)) 
[15:32:07.828]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.828]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.828]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.828]                     .init = FALSE)
[15:32:07.828]                 }
[15:32:07.828]             }
[15:32:07.828]         }
[15:32:07.828]     })
[15:32:07.828]     if (TRUE) {
[15:32:07.828]         base::sink(type = "output", split = FALSE)
[15:32:07.828]         if (TRUE) {
[15:32:07.828]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.828]         }
[15:32:07.828]         else {
[15:32:07.828]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.828]         }
[15:32:07.828]         base::close(...future.stdout)
[15:32:07.828]         ...future.stdout <- NULL
[15:32:07.828]     }
[15:32:07.828]     ...future.result$conditions <- ...future.conditions
[15:32:07.828]     ...future.result$finished <- base::Sys.time()
[15:32:07.828]     ...future.result
[15:32:07.828] }
[15:32:07.832] assign_globals() ...
[15:32:07.833] List of 5
[15:32:07.833]  $ ...future.FUN            :function (C, k)  
[15:32:07.833]  $ MoreArgs                 : list()
[15:32:07.833]  $ ...future.elements_ii    :List of 2
[15:32:07.833]   ..$ :List of 5
[15:32:07.833]   .. ..$ : chr "A"
[15:32:07.833]   .. ..$ : chr "B"
[15:32:07.833]   .. ..$ : chr "C"
[15:32:07.833]   .. ..$ : chr "D"
[15:32:07.833]   .. ..$ : chr "E"
[15:32:07.833]   ..$ :List of 5
[15:32:07.833]   .. ..$ : int 5
[15:32:07.833]   .. ..$ : int 4
[15:32:07.833]   .. ..$ : int 3
[15:32:07.833]   .. ..$ : int 2
[15:32:07.833]   .. ..$ : int 1
[15:32:07.833]  $ ...future.seeds_ii       : NULL
[15:32:07.833]  $ ...future.globals.maxSize: NULL
[15:32:07.833]  - attr(*, "where")=List of 5
[15:32:07.833]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.833]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.833]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.833]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.833]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.833]  - attr(*, "resolved")= logi FALSE
[15:32:07.833]  - attr(*, "total_size")= num 4160
[15:32:07.833]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.833]  - attr(*, "already-done")= logi TRUE
[15:32:07.843] - reassign environment for '...future.FUN'
[15:32:07.843] - copied '...future.FUN' to environment
[15:32:07.843] - copied 'MoreArgs' to environment
[15:32:07.843] - copied '...future.elements_ii' to environment
[15:32:07.844] - copied '...future.seeds_ii' to environment
[15:32:07.844] - copied '...future.globals.maxSize' to environment
[15:32:07.844] assign_globals() ... done
[15:32:07.844] plan(): Setting new future strategy stack:
[15:32:07.845] List of future strategies:
[15:32:07.845] 1. sequential:
[15:32:07.845]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.845]    - tweaked: FALSE
[15:32:07.845]    - call: NULL
[15:32:07.845] plan(): nbrOfWorkers() = 1
[15:32:07.847] plan(): Setting new future strategy stack:
[15:32:07.847] List of future strategies:
[15:32:07.847] 1. sequential:
[15:32:07.847]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.847]    - tweaked: FALSE
[15:32:07.847]    - call: plan(strategy)
[15:32:07.848] plan(): nbrOfWorkers() = 1
[15:32:07.848] SequentialFuture started (and completed)
[15:32:07.848] - Launch lazy future ... done
[15:32:07.848] run() for 'SequentialFuture' ... done
[15:32:07.849] Created future:
[15:32:07.849] SequentialFuture:
[15:32:07.849] Label: 'future_.mapply-1'
[15:32:07.849] Expression:
[15:32:07.849] {
[15:32:07.849]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.849]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.849]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.849]         on.exit(options(oopts), add = TRUE)
[15:32:07.849]     }
[15:32:07.849]     {
[15:32:07.849]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.849]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.849]         do.call(mapply, args = args)
[15:32:07.849]     }
[15:32:07.849] }
[15:32:07.849] Lazy evaluation: FALSE
[15:32:07.849] Asynchronous evaluation: FALSE
[15:32:07.849] Local evaluation: TRUE
[15:32:07.849] Environment: R_GlobalEnv
[15:32:07.849] Capture standard output: TRUE
[15:32:07.849] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.849] Globals: 5 objects totaling 4.06 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 840 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.849] Packages: <none>
[15:32:07.849] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.849] Resolved: TRUE
[15:32:07.849] Value: 560 bytes of class 'list'
[15:32:07.849] Early signaling: FALSE
[15:32:07.849] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.849] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.855] Chunk #1 of 1 ... DONE
[15:32:07.855] Launching 1 futures (chunks) ... DONE
[15:32:07.855] Resolving 1 futures (chunks) ...
[15:32:07.855] resolve() on list ...
[15:32:07.855]  recursive: 0
[15:32:07.856]  length: 1
[15:32:07.856] 
[15:32:07.856] resolved() for 'SequentialFuture' ...
[15:32:07.856] - state: 'finished'
[15:32:07.856] - run: TRUE
[15:32:07.857] - result: 'FutureResult'
[15:32:07.857] resolved() for 'SequentialFuture' ... done
[15:32:07.857] Future #1
[15:32:07.857] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.857] - nx: 1
[15:32:07.858] - relay: TRUE
[15:32:07.858] - stdout: TRUE
[15:32:07.858] - signal: TRUE
[15:32:07.858] - resignal: FALSE
[15:32:07.859] - force: TRUE
[15:32:07.859] - relayed: [n=1] FALSE
[15:32:07.859] - queued futures: [n=1] FALSE
[15:32:07.860]  - until=1
[15:32:07.860]  - relaying element #1
[15:32:07.860] - relayed: [n=1] TRUE
[15:32:07.861] - queued futures: [n=1] TRUE
[15:32:07.861] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.861]  length: 0 (resolved future 1)
[15:32:07.861] Relaying remaining futures
[15:32:07.862] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.862] - nx: 1
[15:32:07.862] - relay: TRUE
[15:32:07.863] - stdout: TRUE
[15:32:07.863] - signal: TRUE
[15:32:07.863] - resignal: FALSE
[15:32:07.863] - force: TRUE
[15:32:07.864] - relayed: [n=1] TRUE
[15:32:07.864] - queued futures: [n=1] TRUE
 - flush all
[15:32:07.864] - relayed: [n=1] TRUE
[15:32:07.865] - queued futures: [n=1] TRUE
[15:32:07.865] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.865] resolve() on list ... DONE
[15:32:07.866]  - Number of value chunks collected: 1
[15:32:07.866] Resolving 1 futures (chunks) ... DONE
[15:32:07.866] Reducing values from 1 chunks ...
[15:32:07.866]  - Number of values collected after concatenation: 5
[15:32:07.867]  - Number of values expected: 5
[15:32:07.867] Reducing values from 1 chunks ... DONE
[15:32:07.867] future_mapply() ... DONE
- Subsetting (Issue #17) ...
[15:32:07.869] future_mapply() ...
[15:32:07.869] Number of chunks: 1
[15:32:07.869] getGlobalsAndPackagesXApply() ...
[15:32:07.870]  - future.globals: TRUE
[15:32:07.870] getGlobalsAndPackages() ...
[15:32:07.870] Searching for globals...
[15:32:07.872] - globals found: [1] 'FUN'
[15:32:07.873] Searching for globals ... DONE
[15:32:07.873] Resolving globals: FALSE
[15:32:07.874] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:07.874] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:07.874] - globals: [1] 'FUN'
[15:32:07.875] 
[15:32:07.875] getGlobalsAndPackages() ... DONE
[15:32:07.875]  - globals found/used: [n=1] 'FUN'
[15:32:07.876]  - needed namespaces: [n=0] 
[15:32:07.876] Finding globals ... DONE
[15:32:07.876] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.877] List of 2
[15:32:07.877]  $ ...future.FUN:function (x)  
[15:32:07.877]  $ MoreArgs     : NULL
[15:32:07.877]  - attr(*, "where")=List of 2
[15:32:07.877]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.877]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.877]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.877]  - attr(*, "resolved")= logi FALSE
[15:32:07.877]  - attr(*, "total_size")= num NA
[15:32:07.882] Packages to be attached in all futures: [n=0] 
[15:32:07.882] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.882] Number of futures (= number of chunks): 1
[15:32:07.883] Launching 1 futures (chunks) ...
[15:32:07.883] Chunk #1 of 1 ...
[15:32:07.884]  - Finding globals in '...' for chunk #1 ...
[15:32:07.884] getGlobalsAndPackages() ...
[15:32:07.884] Searching for globals...
[15:32:07.885] 
[15:32:07.885] Searching for globals ... DONE
[15:32:07.885] - globals: [0] <none>
[15:32:07.886] getGlobalsAndPackages() ... DONE
[15:32:07.886]    + additional globals found: [n=0] 
[15:32:07.886]    + additional namespaces needed: [n=0] 
[15:32:07.887]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.887]  - seeds: <none>
[15:32:07.887]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.887] getGlobalsAndPackages() ...
[15:32:07.888] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.888] Resolving globals: FALSE
[15:32:07.889] The total size of the 5 globals is 1.10 KiB (1128 bytes)
[15:32:07.890] 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 1.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (280 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:07.891] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.891] 
[15:32:07.891] getGlobalsAndPackages() ... DONE
[15:32:07.892] run() for 'Future' ...
[15:32:07.892] - state: 'created'
[15:32:07.893] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.893] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.894] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.894]   - Field: 'label'
[15:32:07.894]   - Field: 'local'
[15:32:07.895]   - Field: 'owner'
[15:32:07.895]   - Field: 'envir'
[15:32:07.895]   - Field: 'packages'
[15:32:07.895]   - Field: 'gc'
[15:32:07.896]   - Field: 'conditions'
[15:32:07.896]   - Field: 'expr'
[15:32:07.896]   - Field: 'uuid'
[15:32:07.897]   - Field: 'seed'
[15:32:07.897]   - Field: 'version'
[15:32:07.897]   - Field: 'result'
[15:32:07.898]   - Field: 'asynchronous'
[15:32:07.901]   - Field: 'calls'
[15:32:07.901]   - Field: 'globals'
[15:32:07.902]   - Field: 'stdout'
[15:32:07.902]   - Field: 'earlySignal'
[15:32:07.902]   - Field: 'lazy'
[15:32:07.903]   - Field: 'state'
[15:32:07.903] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.903] - Launch lazy future ...
[15:32:07.904] Packages needed by the future expression (n = 0): <none>
[15:32:07.904] Packages needed by future strategies (n = 0): <none>
[15:32:07.905] {
[15:32:07.905]     {
[15:32:07.905]         {
[15:32:07.905]             ...future.startTime <- base::Sys.time()
[15:32:07.905]             {
[15:32:07.905]                 {
[15:32:07.905]                   {
[15:32:07.905]                     base::local({
[15:32:07.905]                       has_future <- base::requireNamespace("future", 
[15:32:07.905]                         quietly = TRUE)
[15:32:07.905]                       if (has_future) {
[15:32:07.905]                         ns <- base::getNamespace("future")
[15:32:07.905]                         version <- ns[[".package"]][["version"]]
[15:32:07.905]                         if (is.null(version)) 
[15:32:07.905]                           version <- utils::packageVersion("future")
[15:32:07.905]                       }
[15:32:07.905]                       else {
[15:32:07.905]                         version <- NULL
[15:32:07.905]                       }
[15:32:07.905]                       if (!has_future || version < "1.8.0") {
[15:32:07.905]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.905]                           "", base::R.version$version.string), 
[15:32:07.905]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.905]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.905]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.905]                             "release", "version")], collapse = " "), 
[15:32:07.905]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.905]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.905]                           info)
[15:32:07.905]                         info <- base::paste(info, collapse = "; ")
[15:32:07.905]                         if (!has_future) {
[15:32:07.905]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.905]                             info)
[15:32:07.905]                         }
[15:32:07.905]                         else {
[15:32:07.905]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.905]                             info, version)
[15:32:07.905]                         }
[15:32:07.905]                         base::stop(msg)
[15:32:07.905]                       }
[15:32:07.905]                     })
[15:32:07.905]                   }
[15:32:07.905]                   ...future.strategy.old <- future::plan("list")
[15:32:07.905]                   options(future.plan = NULL)
[15:32:07.905]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.905]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.905]                 }
[15:32:07.905]                 ...future.workdir <- getwd()
[15:32:07.905]             }
[15:32:07.905]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.905]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.905]         }
[15:32:07.905]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.905]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:07.905]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.905]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.905]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.905]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.905]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.905]             base::names(...future.oldOptions))
[15:32:07.905]     }
[15:32:07.905]     if (FALSE) {
[15:32:07.905]     }
[15:32:07.905]     else {
[15:32:07.905]         if (TRUE) {
[15:32:07.905]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.905]                 open = "w")
[15:32:07.905]         }
[15:32:07.905]         else {
[15:32:07.905]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.905]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.905]         }
[15:32:07.905]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.905]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.905]             base::sink(type = "output", split = FALSE)
[15:32:07.905]             base::close(...future.stdout)
[15:32:07.905]         }, add = TRUE)
[15:32:07.905]     }
[15:32:07.905]     ...future.frame <- base::sys.nframe()
[15:32:07.905]     ...future.conditions <- base::list()
[15:32:07.905]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.905]     if (FALSE) {
[15:32:07.905]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.905]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.905]     }
[15:32:07.905]     ...future.result <- base::tryCatch({
[15:32:07.905]         base::withCallingHandlers({
[15:32:07.905]             ...future.value <- base::withVisible(base::local({
[15:32:07.905]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.905]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.905]                   ...future.globals.maxSize)) {
[15:32:07.905]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.905]                   on.exit(options(oopts), add = TRUE)
[15:32:07.905]                 }
[15:32:07.905]                 {
[15:32:07.905]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.905]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.905]                     USE.NAMES = FALSE)
[15:32:07.905]                   do.call(mapply, args = args)
[15:32:07.905]                 }
[15:32:07.905]             }))
[15:32:07.905]             future::FutureResult(value = ...future.value$value, 
[15:32:07.905]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.905]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.905]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.905]                     ...future.globalenv.names))
[15:32:07.905]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.905]         }, condition = base::local({
[15:32:07.905]             c <- base::c
[15:32:07.905]             inherits <- base::inherits
[15:32:07.905]             invokeRestart <- base::invokeRestart
[15:32:07.905]             length <- base::length
[15:32:07.905]             list <- base::list
[15:32:07.905]             seq.int <- base::seq.int
[15:32:07.905]             signalCondition <- base::signalCondition
[15:32:07.905]             sys.calls <- base::sys.calls
[15:32:07.905]             `[[` <- base::`[[`
[15:32:07.905]             `+` <- base::`+`
[15:32:07.905]             `<<-` <- base::`<<-`
[15:32:07.905]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.905]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.905]                   3L)]
[15:32:07.905]             }
[15:32:07.905]             function(cond) {
[15:32:07.905]                 is_error <- inherits(cond, "error")
[15:32:07.905]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.905]                   NULL)
[15:32:07.905]                 if (is_error) {
[15:32:07.905]                   sessionInformation <- function() {
[15:32:07.905]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.905]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.905]                       search = base::search(), system = base::Sys.info())
[15:32:07.905]                   }
[15:32:07.905]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.905]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.905]                     cond$call), session = sessionInformation(), 
[15:32:07.905]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.905]                   signalCondition(cond)
[15:32:07.905]                 }
[15:32:07.905]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.905]                 "immediateCondition"))) {
[15:32:07.905]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.905]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.905]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.905]                   if (TRUE && !signal) {
[15:32:07.905]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.905]                     {
[15:32:07.905]                       inherits <- base::inherits
[15:32:07.905]                       invokeRestart <- base::invokeRestart
[15:32:07.905]                       is.null <- base::is.null
[15:32:07.905]                       muffled <- FALSE
[15:32:07.905]                       if (inherits(cond, "message")) {
[15:32:07.905]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.905]                         if (muffled) 
[15:32:07.905]                           invokeRestart("muffleMessage")
[15:32:07.905]                       }
[15:32:07.905]                       else if (inherits(cond, "warning")) {
[15:32:07.905]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.905]                         if (muffled) 
[15:32:07.905]                           invokeRestart("muffleWarning")
[15:32:07.905]                       }
[15:32:07.905]                       else if (inherits(cond, "condition")) {
[15:32:07.905]                         if (!is.null(pattern)) {
[15:32:07.905]                           computeRestarts <- base::computeRestarts
[15:32:07.905]                           grepl <- base::grepl
[15:32:07.905]                           restarts <- computeRestarts(cond)
[15:32:07.905]                           for (restart in restarts) {
[15:32:07.905]                             name <- restart$name
[15:32:07.905]                             if (is.null(name)) 
[15:32:07.905]                               next
[15:32:07.905]                             if (!grepl(pattern, name)) 
[15:32:07.905]                               next
[15:32:07.905]                             invokeRestart(restart)
[15:32:07.905]                             muffled <- TRUE
[15:32:07.905]                             break
[15:32:07.905]                           }
[15:32:07.905]                         }
[15:32:07.905]                       }
[15:32:07.905]                       invisible(muffled)
[15:32:07.905]                     }
[15:32:07.905]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.905]                   }
[15:32:07.905]                 }
[15:32:07.905]                 else {
[15:32:07.905]                   if (TRUE) {
[15:32:07.905]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.905]                     {
[15:32:07.905]                       inherits <- base::inherits
[15:32:07.905]                       invokeRestart <- base::invokeRestart
[15:32:07.905]                       is.null <- base::is.null
[15:32:07.905]                       muffled <- FALSE
[15:32:07.905]                       if (inherits(cond, "message")) {
[15:32:07.905]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.905]                         if (muffled) 
[15:32:07.905]                           invokeRestart("muffleMessage")
[15:32:07.905]                       }
[15:32:07.905]                       else if (inherits(cond, "warning")) {
[15:32:07.905]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.905]                         if (muffled) 
[15:32:07.905]                           invokeRestart("muffleWarning")
[15:32:07.905]                       }
[15:32:07.905]                       else if (inherits(cond, "condition")) {
[15:32:07.905]                         if (!is.null(pattern)) {
[15:32:07.905]                           computeRestarts <- base::computeRestarts
[15:32:07.905]                           grepl <- base::grepl
[15:32:07.905]                           restarts <- computeRestarts(cond)
[15:32:07.905]                           for (restart in restarts) {
[15:32:07.905]                             name <- restart$name
[15:32:07.905]                             if (is.null(name)) 
[15:32:07.905]                               next
[15:32:07.905]                             if (!grepl(pattern, name)) 
[15:32:07.905]                               next
[15:32:07.905]                             invokeRestart(restart)
[15:32:07.905]                             muffled <- TRUE
[15:32:07.905]                             break
[15:32:07.905]                           }
[15:32:07.905]                         }
[15:32:07.905]                       }
[15:32:07.905]                       invisible(muffled)
[15:32:07.905]                     }
[15:32:07.905]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.905]                   }
[15:32:07.905]                 }
[15:32:07.905]             }
[15:32:07.905]         }))
[15:32:07.905]     }, error = function(ex) {
[15:32:07.905]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.905]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.905]                 ...future.rng), started = ...future.startTime, 
[15:32:07.905]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.905]             version = "1.8"), class = "FutureResult")
[15:32:07.905]     }, finally = {
[15:32:07.905]         if (!identical(...future.workdir, getwd())) 
[15:32:07.905]             setwd(...future.workdir)
[15:32:07.905]         {
[15:32:07.905]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.905]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.905]             }
[15:32:07.905]             base::options(...future.oldOptions)
[15:32:07.905]             if (.Platform$OS.type == "windows") {
[15:32:07.905]                 old_names <- names(...future.oldEnvVars)
[15:32:07.905]                 envs <- base::Sys.getenv()
[15:32:07.905]                 names <- names(envs)
[15:32:07.905]                 common <- intersect(names, old_names)
[15:32:07.905]                 added <- setdiff(names, old_names)
[15:32:07.905]                 removed <- setdiff(old_names, names)
[15:32:07.905]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.905]                   envs[common]]
[15:32:07.905]                 NAMES <- toupper(changed)
[15:32:07.905]                 args <- list()
[15:32:07.905]                 for (kk in seq_along(NAMES)) {
[15:32:07.905]                   name <- changed[[kk]]
[15:32:07.905]                   NAME <- NAMES[[kk]]
[15:32:07.905]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.905]                     next
[15:32:07.905]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.905]                 }
[15:32:07.905]                 NAMES <- toupper(added)
[15:32:07.905]                 for (kk in seq_along(NAMES)) {
[15:32:07.905]                   name <- added[[kk]]
[15:32:07.905]                   NAME <- NAMES[[kk]]
[15:32:07.905]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.905]                     next
[15:32:07.905]                   args[[name]] <- ""
[15:32:07.905]                 }
[15:32:07.905]                 NAMES <- toupper(removed)
[15:32:07.905]                 for (kk in seq_along(NAMES)) {
[15:32:07.905]                   name <- removed[[kk]]
[15:32:07.905]                   NAME <- NAMES[[kk]]
[15:32:07.905]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.905]                     next
[15:32:07.905]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.905]                 }
[15:32:07.905]                 if (length(args) > 0) 
[15:32:07.905]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.905]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.905]             }
[15:32:07.905]             else {
[15:32:07.905]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.905]             }
[15:32:07.905]             {
[15:32:07.905]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.905]                   0L) {
[15:32:07.905]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.905]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.905]                   base::options(opts)
[15:32:07.905]                 }
[15:32:07.905]                 {
[15:32:07.905]                   {
[15:32:07.905]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.905]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.905]                     -253660479L), envir = base::globalenv(), 
[15:32:07.905]                       inherits = FALSE)
[15:32:07.905]                     NULL
[15:32:07.905]                   }
[15:32:07.905]                   options(future.plan = NULL)
[15:32:07.905]                   if (is.na(NA_character_)) 
[15:32:07.905]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.905]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.905]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.905]                     .init = FALSE)
[15:32:07.905]                 }
[15:32:07.905]             }
[15:32:07.905]         }
[15:32:07.905]     })
[15:32:07.905]     if (TRUE) {
[15:32:07.905]         base::sink(type = "output", split = FALSE)
[15:32:07.905]         if (TRUE) {
[15:32:07.905]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.905]         }
[15:32:07.905]         else {
[15:32:07.905]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.905]         }
[15:32:07.905]         base::close(...future.stdout)
[15:32:07.905]         ...future.stdout <- NULL
[15:32:07.905]     }
[15:32:07.905]     ...future.result$conditions <- ...future.conditions
[15:32:07.905]     ...future.result$finished <- base::Sys.time()
[15:32:07.905]     ...future.result
[15:32:07.905] }
[15:32:07.912] assign_globals() ...
[15:32:07.912] List of 5
[15:32:07.912]  $ ...future.FUN            :function (x)  
[15:32:07.912]  $ MoreArgs                 : NULL
[15:32:07.912]  $ ...future.elements_ii    :List of 1
[15:32:07.912]   ..$ :List of 1
[15:32:07.912]   .. ..$ : Date[1:1], format: "2018-06-01"
[15:32:07.912]  $ ...future.seeds_ii       : NULL
[15:32:07.912]  $ ...future.globals.maxSize: NULL
[15:32:07.912]  - attr(*, "where")=List of 5
[15:32:07.912]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:07.912]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:07.912]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:07.912]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:07.912]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:07.912]  - attr(*, "resolved")= logi FALSE
[15:32:07.912]  - attr(*, "total_size")= num 1128
[15:32:07.912]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.912]  - attr(*, "already-done")= logi TRUE
[15:32:07.922] - copied '...future.FUN' to environment
[15:32:07.922] - copied 'MoreArgs' to environment
[15:32:07.923] - copied '...future.elements_ii' to environment
[15:32:07.923] - copied '...future.seeds_ii' to environment
[15:32:07.923] - copied '...future.globals.maxSize' to environment
[15:32:07.923] assign_globals() ... done
[15:32:07.924] plan(): Setting new future strategy stack:
[15:32:07.924] List of future strategies:
[15:32:07.924] 1. sequential:
[15:32:07.924]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.924]    - tweaked: FALSE
[15:32:07.924]    - call: NULL
[15:32:07.925] plan(): nbrOfWorkers() = 1
[15:32:07.927] plan(): Setting new future strategy stack:
[15:32:07.928] List of future strategies:
[15:32:07.928] 1. sequential:
[15:32:07.928]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:07.928]    - tweaked: FALSE
[15:32:07.928]    - call: plan(strategy)
[15:32:07.929] plan(): nbrOfWorkers() = 1
[15:32:07.929] SequentialFuture started (and completed)
[15:32:07.929] - Launch lazy future ... done
[15:32:07.930] run() for 'SequentialFuture' ... done
[15:32:07.930] Created future:
[15:32:07.930] SequentialFuture:
[15:32:07.930] Label: 'future_mapply-1'
[15:32:07.930] Expression:
[15:32:07.930] {
[15:32:07.930]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.930]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:07.930]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.930]         on.exit(options(oopts), add = TRUE)
[15:32:07.930]     }
[15:32:07.930]     {
[15:32:07.930]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.930]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:07.930]         do.call(mapply, args = args)
[15:32:07.930]     }
[15:32:07.930] }
[15:32:07.930] Lazy evaluation: FALSE
[15:32:07.930] Asynchronous evaluation: FALSE
[15:32:07.930] Local evaluation: TRUE
[15:32:07.930] Environment: R_GlobalEnv
[15:32:07.930] Capture standard output: TRUE
[15:32:07.930] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:07.930] Globals: 5 objects totaling 1.10 KiB (function '...future.FUN' of 848 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 280 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:07.930] Packages: <none>
[15:32:07.930] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:07.930] Resolved: TRUE
[15:32:07.930] Value: 280 bytes of class 'list'
[15:32:07.930] Early signaling: FALSE
[15:32:07.930] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:07.930] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.932] Chunk #1 of 1 ... DONE
[15:32:07.933] Launching 1 futures (chunks) ... DONE
[15:32:07.933] Resolving 1 futures (chunks) ...
[15:32:07.933] resolve() on list ...
[15:32:07.934]  recursive: 0
[15:32:07.934]  length: 1
[15:32:07.934] 
[15:32:07.934] resolved() for 'SequentialFuture' ...
[15:32:07.935] - state: 'finished'
[15:32:07.935] - run: TRUE
[15:32:07.935] - result: 'FutureResult'
[15:32:07.936] resolved() for 'SequentialFuture' ... done
[15:32:07.936] Future #1
[15:32:07.937] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:07.937] - nx: 1
[15:32:07.938] - relay: TRUE
[15:32:07.938] - stdout: TRUE
[15:32:07.940] - signal: TRUE
[15:32:07.940] - resignal: FALSE
[15:32:07.941] - force: TRUE
[15:32:07.941] - relayed: [n=1] FALSE
[15:32:07.941] - queued futures: [n=1] FALSE
[15:32:07.941]  - until=1
[15:32:07.941]  - relaying element #1
[15:32:07.942] - relayed: [n=1] TRUE
[15:32:07.942] - queued futures: [n=1] TRUE
[15:32:07.942] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:07.943]  length: 0 (resolved future 1)
[15:32:07.943] Relaying remaining futures
[15:32:07.943] signalConditionsASAP(NULL, pos=0) ...
[15:32:07.943] - nx: 1
[15:32:07.943] - relay: TRUE
[15:32:07.944] - stdout: TRUE
[15:32:07.944] - signal: TRUE
[15:32:07.944] - resignal: FALSE
[15:32:07.944] - force: TRUE
[15:32:07.944] - relayed: [n=1] TRUE
[15:32:07.944] - queued futures: [n=1] TRUE
 - flush all
[15:32:07.945] - relayed: [n=1] TRUE
[15:32:07.945] - queued futures: [n=1] TRUE
[15:32:07.945] signalConditionsASAP(NULL, pos=0) ... done
[15:32:07.945] resolve() on list ... DONE
[15:32:07.946]  - Number of value chunks collected: 1
[15:32:07.946] Resolving 1 futures (chunks) ... DONE
[15:32:07.946] Reducing values from 1 chunks ...
[15:32:07.946]  - Number of values collected after concatenation: 1
[15:32:07.946]  - Number of values expected: 1
[15:32:07.947] Reducing values from 1 chunks ... DONE
[15:32:07.947] future_mapply() ... DONE
[15:32:07.947] future_mapply() ...
[15:32:07.947] Number of chunks: 1
[15:32:07.948] getGlobalsAndPackagesXApply() ...
[15:32:07.948]  - future.globals: TRUE
[15:32:07.948] getGlobalsAndPackages() ...
[15:32:07.948] Searching for globals...
[15:32:07.955] - globals found: [1] 'FUN'
[15:32:07.956] Searching for globals ... DONE
[15:32:07.956] Resolving globals: FALSE
[15:32:07.957] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:07.958] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:07.958] - globals: [1] 'FUN'
[15:32:07.959] 
[15:32:07.959] getGlobalsAndPackages() ... DONE
[15:32:07.959]  - globals found/used: [n=1] 'FUN'
[15:32:07.960]  - needed namespaces: [n=0] 
[15:32:07.960] Finding globals ... DONE
[15:32:07.960] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:07.961] List of 2
[15:32:07.961]  $ ...future.FUN:function (x)  
[15:32:07.961]  $ MoreArgs     : list()
[15:32:07.961]  - attr(*, "where")=List of 2
[15:32:07.961]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:07.961]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:07.961]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:07.961]  - attr(*, "resolved")= logi FALSE
[15:32:07.961]  - attr(*, "total_size")= num NA
[15:32:07.966] Packages to be attached in all futures: [n=0] 
[15:32:07.966] getGlobalsAndPackagesXApply() ... DONE
[15:32:07.966] Number of futures (= number of chunks): 1
[15:32:07.967] Launching 1 futures (chunks) ...
[15:32:07.967] Chunk #1 of 1 ...
[15:32:07.967]  - Finding globals in '...' for chunk #1 ...
[15:32:07.968] getGlobalsAndPackages() ...
[15:32:07.968] Searching for globals...
[15:32:07.969] 
[15:32:07.969] Searching for globals ... DONE
[15:32:07.969] - globals: [0] <none>
[15:32:07.969] getGlobalsAndPackages() ... DONE
[15:32:07.969]    + additional globals found: [n=0] 
[15:32:07.970]    + additional namespaces needed: [n=0] 
[15:32:07.970]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:07.970]  - seeds: <none>
[15:32:07.970]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.970] getGlobalsAndPackages() ...
[15:32:07.970] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.971] Resolving globals: FALSE
[15:32:07.971] The total size of the 5 globals is 1.10 KiB (1128 bytes)
[15:32:07.972] 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 1.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (280 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:07.972] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:07.973] 
[15:32:07.973] getGlobalsAndPackages() ... DONE
[15:32:07.973] run() for 'Future' ...
[15:32:07.973] - state: 'created'
[15:32:07.974] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:07.974] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:07.974] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:07.975]   - Field: 'label'
[15:32:07.975]   - Field: 'local'
[15:32:07.975]   - Field: 'owner'
[15:32:07.975]   - Field: 'envir'
[15:32:07.975]   - Field: 'packages'
[15:32:07.976]   - Field: 'gc'
[15:32:07.976]   - Field: 'conditions'
[15:32:07.976]   - Field: 'expr'
[15:32:07.976]   - Field: 'uuid'
[15:32:07.976]   - Field: 'seed'
[15:32:07.977]   - Field: 'version'
[15:32:07.977]   - Field: 'result'
[15:32:07.977]   - Field: 'asynchronous'
[15:32:07.977]   - Field: 'calls'
[15:32:07.978]   - Field: 'globals'
[15:32:07.978]   - Field: 'stdout'
[15:32:07.978]   - Field: 'earlySignal'
[15:32:07.979]   - Field: 'lazy'
[15:32:07.979]   - Field: 'state'
[15:32:07.979] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:07.979] - Launch lazy future ...
[15:32:07.980] Packages needed by the future expression (n = 0): <none>
[15:32:07.980] Packages needed by future strategies (n = 0): <none>
[15:32:07.981] {
[15:32:07.981]     {
[15:32:07.981]         {
[15:32:07.981]             ...future.startTime <- base::Sys.time()
[15:32:07.981]             {
[15:32:07.981]                 {
[15:32:07.981]                   {
[15:32:07.981]                     base::local({
[15:32:07.981]                       has_future <- base::requireNamespace("future", 
[15:32:07.981]                         quietly = TRUE)
[15:32:07.981]                       if (has_future) {
[15:32:07.981]                         ns <- base::getNamespace("future")
[15:32:07.981]                         version <- ns[[".package"]][["version"]]
[15:32:07.981]                         if (is.null(version)) 
[15:32:07.981]                           version <- utils::packageVersion("future")
[15:32:07.981]                       }
[15:32:07.981]                       else {
[15:32:07.981]                         version <- NULL
[15:32:07.981]                       }
[15:32:07.981]                       if (!has_future || version < "1.8.0") {
[15:32:07.981]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:07.981]                           "", base::R.version$version.string), 
[15:32:07.981]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:07.981]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:07.981]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:07.981]                             "release", "version")], collapse = " "), 
[15:32:07.981]                           hostname = base::Sys.info()[["nodename"]])
[15:32:07.981]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:07.981]                           info)
[15:32:07.981]                         info <- base::paste(info, collapse = "; ")
[15:32:07.981]                         if (!has_future) {
[15:32:07.981]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:07.981]                             info)
[15:32:07.981]                         }
[15:32:07.981]                         else {
[15:32:07.981]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:07.981]                             info, version)
[15:32:07.981]                         }
[15:32:07.981]                         base::stop(msg)
[15:32:07.981]                       }
[15:32:07.981]                     })
[15:32:07.981]                   }
[15:32:07.981]                   ...future.strategy.old <- future::plan("list")
[15:32:07.981]                   options(future.plan = NULL)
[15:32:07.981]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.981]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:07.981]                 }
[15:32:07.981]                 ...future.workdir <- getwd()
[15:32:07.981]             }
[15:32:07.981]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:07.981]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:07.981]         }
[15:32:07.981]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:07.981]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:07.981]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:07.981]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:07.981]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:07.981]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:07.981]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:07.981]             base::names(...future.oldOptions))
[15:32:07.981]     }
[15:32:07.981]     if (FALSE) {
[15:32:07.981]     }
[15:32:07.981]     else {
[15:32:07.981]         if (TRUE) {
[15:32:07.981]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:07.981]                 open = "w")
[15:32:07.981]         }
[15:32:07.981]         else {
[15:32:07.981]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:07.981]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:07.981]         }
[15:32:07.981]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:07.981]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:07.981]             base::sink(type = "output", split = FALSE)
[15:32:07.981]             base::close(...future.stdout)
[15:32:07.981]         }, add = TRUE)
[15:32:07.981]     }
[15:32:07.981]     ...future.frame <- base::sys.nframe()
[15:32:07.981]     ...future.conditions <- base::list()
[15:32:07.981]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:07.981]     if (FALSE) {
[15:32:07.981]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:07.981]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:07.981]     }
[15:32:07.981]     ...future.result <- base::tryCatch({
[15:32:07.981]         base::withCallingHandlers({
[15:32:07.981]             ...future.value <- base::withVisible(base::local({
[15:32:07.981]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:07.981]                 if (!identical(...future.globals.maxSize.org, 
[15:32:07.981]                   ...future.globals.maxSize)) {
[15:32:07.981]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:07.981]                   on.exit(options(oopts), add = TRUE)
[15:32:07.981]                 }
[15:32:07.981]                 {
[15:32:07.981]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:07.981]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:07.981]                     USE.NAMES = FALSE)
[15:32:07.981]                   do.call(mapply, args = args)
[15:32:07.981]                 }
[15:32:07.981]             }))
[15:32:07.981]             future::FutureResult(value = ...future.value$value, 
[15:32:07.981]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.981]                   ...future.rng), globalenv = if (FALSE) 
[15:32:07.981]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:07.981]                     ...future.globalenv.names))
[15:32:07.981]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:07.981]         }, condition = base::local({
[15:32:07.981]             c <- base::c
[15:32:07.981]             inherits <- base::inherits
[15:32:07.981]             invokeRestart <- base::invokeRestart
[15:32:07.981]             length <- base::length
[15:32:07.981]             list <- base::list
[15:32:07.981]             seq.int <- base::seq.int
[15:32:07.981]             signalCondition <- base::signalCondition
[15:32:07.981]             sys.calls <- base::sys.calls
[15:32:07.981]             `[[` <- base::`[[`
[15:32:07.981]             `+` <- base::`+`
[15:32:07.981]             `<<-` <- base::`<<-`
[15:32:07.981]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:07.981]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:07.981]                   3L)]
[15:32:07.981]             }
[15:32:07.981]             function(cond) {
[15:32:07.981]                 is_error <- inherits(cond, "error")
[15:32:07.981]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:07.981]                   NULL)
[15:32:07.981]                 if (is_error) {
[15:32:07.981]                   sessionInformation <- function() {
[15:32:07.981]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:07.981]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:07.981]                       search = base::search(), system = base::Sys.info())
[15:32:07.981]                   }
[15:32:07.981]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.981]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:07.981]                     cond$call), session = sessionInformation(), 
[15:32:07.981]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:07.981]                   signalCondition(cond)
[15:32:07.981]                 }
[15:32:07.981]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:07.981]                 "immediateCondition"))) {
[15:32:07.981]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:07.981]                   ...future.conditions[[length(...future.conditions) + 
[15:32:07.981]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:07.981]                   if (TRUE && !signal) {
[15:32:07.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.981]                     {
[15:32:07.981]                       inherits <- base::inherits
[15:32:07.981]                       invokeRestart <- base::invokeRestart
[15:32:07.981]                       is.null <- base::is.null
[15:32:07.981]                       muffled <- FALSE
[15:32:07.981]                       if (inherits(cond, "message")) {
[15:32:07.981]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.981]                         if (muffled) 
[15:32:07.981]                           invokeRestart("muffleMessage")
[15:32:07.981]                       }
[15:32:07.981]                       else if (inherits(cond, "warning")) {
[15:32:07.981]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.981]                         if (muffled) 
[15:32:07.981]                           invokeRestart("muffleWarning")
[15:32:07.981]                       }
[15:32:07.981]                       else if (inherits(cond, "condition")) {
[15:32:07.981]                         if (!is.null(pattern)) {
[15:32:07.981]                           computeRestarts <- base::computeRestarts
[15:32:07.981]                           grepl <- base::grepl
[15:32:07.981]                           restarts <- computeRestarts(cond)
[15:32:07.981]                           for (restart in restarts) {
[15:32:07.981]                             name <- restart$name
[15:32:07.981]                             if (is.null(name)) 
[15:32:07.981]                               next
[15:32:07.981]                             if (!grepl(pattern, name)) 
[15:32:07.981]                               next
[15:32:07.981]                             invokeRestart(restart)
[15:32:07.981]                             muffled <- TRUE
[15:32:07.981]                             break
[15:32:07.981]                           }
[15:32:07.981]                         }
[15:32:07.981]                       }
[15:32:07.981]                       invisible(muffled)
[15:32:07.981]                     }
[15:32:07.981]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.981]                   }
[15:32:07.981]                 }
[15:32:07.981]                 else {
[15:32:07.981]                   if (TRUE) {
[15:32:07.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:07.981]                     {
[15:32:07.981]                       inherits <- base::inherits
[15:32:07.981]                       invokeRestart <- base::invokeRestart
[15:32:07.981]                       is.null <- base::is.null
[15:32:07.981]                       muffled <- FALSE
[15:32:07.981]                       if (inherits(cond, "message")) {
[15:32:07.981]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:07.981]                         if (muffled) 
[15:32:07.981]                           invokeRestart("muffleMessage")
[15:32:07.981]                       }
[15:32:07.981]                       else if (inherits(cond, "warning")) {
[15:32:07.981]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:07.981]                         if (muffled) 
[15:32:07.981]                           invokeRestart("muffleWarning")
[15:32:07.981]                       }
[15:32:07.981]                       else if (inherits(cond, "condition")) {
[15:32:07.981]                         if (!is.null(pattern)) {
[15:32:07.981]                           computeRestarts <- base::computeRestarts
[15:32:07.981]                           grepl <- base::grepl
[15:32:07.981]                           restarts <- computeRestarts(cond)
[15:32:07.981]                           for (restart in restarts) {
[15:32:07.981]                             name <- restart$name
[15:32:07.981]                             if (is.null(name)) 
[15:32:07.981]                               next
[15:32:07.981]                             if (!grepl(pattern, name)) 
[15:32:07.981]                               next
[15:32:07.981]                             invokeRestart(restart)
[15:32:07.981]                             muffled <- TRUE
[15:32:07.981]                             break
[15:32:07.981]                           }
[15:32:07.981]                         }
[15:32:07.981]                       }
[15:32:07.981]                       invisible(muffled)
[15:32:07.981]                     }
[15:32:07.981]                     muffleCondition(cond, pattern = "^muffle")
[15:32:07.981]                   }
[15:32:07.981]                 }
[15:32:07.981]             }
[15:32:07.981]         }))
[15:32:07.981]     }, error = function(ex) {
[15:32:07.981]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:07.981]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:07.981]                 ...future.rng), started = ...future.startTime, 
[15:32:07.981]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:07.981]             version = "1.8"), class = "FutureResult")
[15:32:07.981]     }, finally = {
[15:32:07.981]         if (!identical(...future.workdir, getwd())) 
[15:32:07.981]             setwd(...future.workdir)
[15:32:07.981]         {
[15:32:07.981]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:07.981]                 ...future.oldOptions$nwarnings <- NULL
[15:32:07.981]             }
[15:32:07.981]             base::options(...future.oldOptions)
[15:32:07.981]             if (.Platform$OS.type == "windows") {
[15:32:07.981]                 old_names <- names(...future.oldEnvVars)
[15:32:07.981]                 envs <- base::Sys.getenv()
[15:32:07.981]                 names <- names(envs)
[15:32:07.981]                 common <- intersect(names, old_names)
[15:32:07.981]                 added <- setdiff(names, old_names)
[15:32:07.981]                 removed <- setdiff(old_names, names)
[15:32:07.981]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:07.981]                   envs[common]]
[15:32:07.981]                 NAMES <- toupper(changed)
[15:32:07.981]                 args <- list()
[15:32:07.981]                 for (kk in seq_along(NAMES)) {
[15:32:07.981]                   name <- changed[[kk]]
[15:32:07.981]                   NAME <- NAMES[[kk]]
[15:32:07.981]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.981]                     next
[15:32:07.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.981]                 }
[15:32:07.981]                 NAMES <- toupper(added)
[15:32:07.981]                 for (kk in seq_along(NAMES)) {
[15:32:07.981]                   name <- added[[kk]]
[15:32:07.981]                   NAME <- NAMES[[kk]]
[15:32:07.981]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.981]                     next
[15:32:07.981]                   args[[name]] <- ""
[15:32:07.981]                 }
[15:32:07.981]                 NAMES <- toupper(removed)
[15:32:07.981]                 for (kk in seq_along(NAMES)) {
[15:32:07.981]                   name <- removed[[kk]]
[15:32:07.981]                   NAME <- NAMES[[kk]]
[15:32:07.981]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:07.981]                     next
[15:32:07.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:07.981]                 }
[15:32:07.981]                 if (length(args) > 0) 
[15:32:07.981]                   base::do.call(base::Sys.setenv, args = args)
[15:32:07.981]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:07.981]             }
[15:32:07.981]             else {
[15:32:07.981]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:07.981]             }
[15:32:07.981]             {
[15:32:07.981]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:07.981]                   0L) {
[15:32:07.981]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:07.981]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:07.981]                   base::options(opts)
[15:32:07.981]                 }
[15:32:07.981]                 {
[15:32:07.981]                   {
[15:32:07.981]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:07.981]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:07.981]                     -253660479L), envir = base::globalenv(), 
[15:32:07.981]                       inherits = FALSE)
[15:32:07.981]                     NULL
[15:32:07.981]                   }
[15:32:07.981]                   options(future.plan = NULL)
[15:32:07.981]                   if (is.na(NA_character_)) 
[15:32:07.981]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:07.981]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:07.981]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:07.981]                     .init = FALSE)
[15:32:07.981]                 }
[15:32:07.981]             }
[15:32:07.981]         }
[15:32:07.981]     })
[15:32:07.981]     if (TRUE) {
[15:32:07.981]         base::sink(type = "output", split = FALSE)
[15:32:07.981]         if (TRUE) {
[15:32:07.981]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:07.981]         }
[15:32:07.981]         else {
[15:32:07.981]             ...future.result["stdout"] <- base::list(NULL)
[15:32:07.981]         }
[15:32:07.981]         base::close(...future.stdout)
[15:32:07.981]         ...future.stdout <- NULL
[15:32:07.981]     }
[15:32:07.981]     ...future.result$conditions <- ...future.conditions
[15:32:07.981]     ...future.result$finished <- base::Sys.time()
[15:32:07.981]     ...future.result
[15:32:07.981] }
[15:32:08.005] assign_globals() ...
[15:32:08.005] List of 5
[15:32:08.005]  $ ...future.FUN            :function (x)  
[15:32:08.005]  $ MoreArgs                 : list()
[15:32:08.005]  $ ...future.elements_ii    :List of 1
[15:32:08.005]   ..$ :List of 1
[15:32:08.005]   .. ..$ : Date[1:1], format: "2018-06-01"
[15:32:08.005]  $ ...future.seeds_ii       : NULL
[15:32:08.005]  $ ...future.globals.maxSize: NULL
[15:32:08.005]  - attr(*, "where")=List of 5
[15:32:08.005]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.005]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.005]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.005]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.005]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.005]  - attr(*, "resolved")= logi FALSE
[15:32:08.005]  - attr(*, "total_size")= num 1128
[15:32:08.005]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.005]  - attr(*, "already-done")= logi TRUE
[15:32:08.013] - copied '...future.FUN' to environment
[15:32:08.017] - copied 'MoreArgs' to environment
[15:32:08.017] - copied '...future.elements_ii' to environment
[15:32:08.017] - copied '...future.seeds_ii' to environment
[15:32:08.017] - copied '...future.globals.maxSize' to environment
[15:32:08.018] assign_globals() ... done
[15:32:08.018] plan(): Setting new future strategy stack:
[15:32:08.018] List of future strategies:
[15:32:08.018] 1. sequential:
[15:32:08.018]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.018]    - tweaked: FALSE
[15:32:08.018]    - call: NULL
[15:32:08.019] plan(): nbrOfWorkers() = 1
[15:32:08.021] plan(): Setting new future strategy stack:
[15:32:08.021] List of future strategies:
[15:32:08.021] 1. sequential:
[15:32:08.021]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.021]    - tweaked: FALSE
[15:32:08.021]    - call: plan(strategy)
[15:32:08.022] plan(): nbrOfWorkers() = 1
[15:32:08.023] SequentialFuture started (and completed)
[15:32:08.023] - Launch lazy future ... done
[15:32:08.023] run() for 'SequentialFuture' ... done
[15:32:08.024] Created future:
[15:32:08.024] SequentialFuture:
[15:32:08.024] Label: 'future_.mapply-1'
[15:32:08.024] Expression:
[15:32:08.024] {
[15:32:08.024]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.024]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.024]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.024]         on.exit(options(oopts), add = TRUE)
[15:32:08.024]     }
[15:32:08.024]     {
[15:32:08.024]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.024]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.024]         do.call(mapply, args = args)
[15:32:08.024]     }
[15:32:08.024] }
[15:32:08.024] Lazy evaluation: FALSE
[15:32:08.024] Asynchronous evaluation: FALSE
[15:32:08.024] Local evaluation: TRUE
[15:32:08.024] Environment: R_GlobalEnv
[15:32:08.024] Capture standard output: TRUE
[15:32:08.024] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.024] Globals: 5 objects totaling 1.10 KiB (function '...future.FUN' of 848 bytes, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 280 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.024] Packages: <none>
[15:32:08.024] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.024] Resolved: TRUE
[15:32:08.024] Value: 280 bytes of class 'list'
[15:32:08.024] Early signaling: FALSE
[15:32:08.024] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.024] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.025] Chunk #1 of 1 ... DONE
[15:32:08.026] Launching 1 futures (chunks) ... DONE
[15:32:08.026] Resolving 1 futures (chunks) ...
[15:32:08.026] resolve() on list ...
[15:32:08.026]  recursive: 0
[15:32:08.026]  length: 1
[15:32:08.027] 
[15:32:08.027] resolved() for 'SequentialFuture' ...
[15:32:08.027] - state: 'finished'
[15:32:08.027] - run: TRUE
[15:32:08.028] - result: 'FutureResult'
[15:32:08.028] resolved() for 'SequentialFuture' ... done
[15:32:08.028] Future #1
[15:32:08.028] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.029] - nx: 1
[15:32:08.029] - relay: TRUE
[15:32:08.029] - stdout: TRUE
[15:32:08.029] - signal: TRUE
[15:32:08.029] - resignal: FALSE
[15:32:08.030] - force: TRUE
[15:32:08.030] - relayed: [n=1] FALSE
[15:32:08.030] - queued futures: [n=1] FALSE
[15:32:08.031]  - until=1
[15:32:08.031]  - relaying element #1
[15:32:08.031] - relayed: [n=1] TRUE
[15:32:08.032] - queued futures: [n=1] TRUE
[15:32:08.032] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.032]  length: 0 (resolved future 1)
[15:32:08.032] Relaying remaining futures
[15:32:08.033] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.033] - nx: 1
[15:32:08.033] - relay: TRUE
[15:32:08.033] - stdout: TRUE
[15:32:08.033] - signal: TRUE
[15:32:08.034] - resignal: FALSE
[15:32:08.034] - force: TRUE
[15:32:08.034] - relayed: [n=1] TRUE
[15:32:08.034] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.035] - relayed: [n=1] TRUE
[15:32:08.035] - queued futures: [n=1] TRUE
[15:32:08.035] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.035] resolve() on list ... DONE
[15:32:08.036]  - Number of value chunks collected: 1
[15:32:08.036] Resolving 1 futures (chunks) ... DONE
[15:32:08.036] Reducing values from 1 chunks ...
[15:32:08.036]  - Number of values collected after concatenation: 1
[15:32:08.037]  - Number of values expected: 1
[15:32:08.037] Reducing values from 1 chunks ... DONE
[15:32:08.037] future_mapply() ... DONE
- Non-recycling of MoreArgs (Issue #51) ...
[15:32:08.038] future_mapply() ...
[15:32:08.038] Number of chunks: 1
[15:32:08.038] getGlobalsAndPackagesXApply() ...
[15:32:08.039]  - future.globals: TRUE
[15:32:08.039] getGlobalsAndPackages() ...
[15:32:08.039] Searching for globals...
[15:32:08.041] - globals found: [1] 'FUN'
[15:32:08.041] Searching for globals ... DONE
[15:32:08.042] Resolving globals: FALSE
[15:32:08.042] The total size of the 1 globals is 1.66 KiB (1704 bytes)
[15:32:08.043] The total size of the 1 globals exported for future expression ('FUN(y = 3:4)') is 1.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.66 KiB of class 'function')
[15:32:08.043] - globals: [1] 'FUN'
[15:32:08.043] 
[15:32:08.044] getGlobalsAndPackages() ... DONE
[15:32:08.044]  - globals found/used: [n=1] 'FUN'
[15:32:08.044]  - needed namespaces: [n=0] 
[15:32:08.044] Finding globals ... DONE
[15:32:08.045] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.045] List of 2
[15:32:08.045]  $ ...future.FUN:function (x, y)  
[15:32:08.045]  $ MoreArgs     :List of 1
[15:32:08.045]   ..$ y: int [1:2] 3 4
[15:32:08.045]  - attr(*, "where")=List of 2
[15:32:08.045]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.045]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.045]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.045]  - attr(*, "resolved")= logi FALSE
[15:32:08.045]  - attr(*, "total_size")= num NA
[15:32:08.049] Packages to be attached in all futures: [n=0] 
[15:32:08.049] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.050] Number of futures (= number of chunks): 1
[15:32:08.050] Launching 1 futures (chunks) ...
[15:32:08.050] Chunk #1 of 1 ...
[15:32:08.050]  - Finding globals in '...' for chunk #1 ...
[15:32:08.050] getGlobalsAndPackages() ...
[15:32:08.051] Searching for globals...
[15:32:08.051] 
[15:32:08.051] Searching for globals ... DONE
[15:32:08.051] - globals: [0] <none>
[15:32:08.052] getGlobalsAndPackages() ... DONE
[15:32:08.052]    + additional globals found: [n=0] 
[15:32:08.052]    + additional namespaces needed: [n=0] 
[15:32:08.052]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.052]  - seeds: <none>
[15:32:08.056]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.056] getGlobalsAndPackages() ...
[15:32:08.056] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.057] Resolving globals: FALSE
[15:32:08.058] The total size of the 5 globals is 1.83 KiB (1872 bytes)
[15:32:08.059] 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 1.83 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (56 bytes of class 'list')
[15:32:08.059] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.059] 
[15:32:08.060] getGlobalsAndPackages() ... DONE
[15:32:08.060] run() for 'Future' ...
[15:32:08.060] - state: 'created'
[15:32:08.061] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.061] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.062] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.062]   - Field: 'label'
[15:32:08.062]   - Field: 'local'
[15:32:08.062]   - Field: 'owner'
[15:32:08.063]   - Field: 'envir'
[15:32:08.063]   - Field: 'packages'
[15:32:08.063]   - Field: 'gc'
[15:32:08.063]   - Field: 'conditions'
[15:32:08.064]   - Field: 'expr'
[15:32:08.064]   - Field: 'uuid'
[15:32:08.064]   - Field: 'seed'
[15:32:08.064]   - Field: 'version'
[15:32:08.064]   - Field: 'result'
[15:32:08.065]   - Field: 'asynchronous'
[15:32:08.065]   - Field: 'calls'
[15:32:08.065]   - Field: 'globals'
[15:32:08.065]   - Field: 'stdout'
[15:32:08.065]   - Field: 'earlySignal'
[15:32:08.066]   - Field: 'lazy'
[15:32:08.066]   - Field: 'state'
[15:32:08.066] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.066] - Launch lazy future ...
[15:32:08.067] Packages needed by the future expression (n = 0): <none>
[15:32:08.067] Packages needed by future strategies (n = 0): <none>
[15:32:08.068] {
[15:32:08.068]     {
[15:32:08.068]         {
[15:32:08.068]             ...future.startTime <- base::Sys.time()
[15:32:08.068]             {
[15:32:08.068]                 {
[15:32:08.068]                   {
[15:32:08.068]                     base::local({
[15:32:08.068]                       has_future <- base::requireNamespace("future", 
[15:32:08.068]                         quietly = TRUE)
[15:32:08.068]                       if (has_future) {
[15:32:08.068]                         ns <- base::getNamespace("future")
[15:32:08.068]                         version <- ns[[".package"]][["version"]]
[15:32:08.068]                         if (is.null(version)) 
[15:32:08.068]                           version <- utils::packageVersion("future")
[15:32:08.068]                       }
[15:32:08.068]                       else {
[15:32:08.068]                         version <- NULL
[15:32:08.068]                       }
[15:32:08.068]                       if (!has_future || version < "1.8.0") {
[15:32:08.068]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.068]                           "", base::R.version$version.string), 
[15:32:08.068]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:08.068]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.068]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.068]                             "release", "version")], collapse = " "), 
[15:32:08.068]                           hostname = base::Sys.info()[["nodename"]])
[15:32:08.068]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.068]                           info)
[15:32:08.068]                         info <- base::paste(info, collapse = "; ")
[15:32:08.068]                         if (!has_future) {
[15:32:08.068]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.068]                             info)
[15:32:08.068]                         }
[15:32:08.068]                         else {
[15:32:08.068]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.068]                             info, version)
[15:32:08.068]                         }
[15:32:08.068]                         base::stop(msg)
[15:32:08.068]                       }
[15:32:08.068]                     })
[15:32:08.068]                   }
[15:32:08.068]                   ...future.strategy.old <- future::plan("list")
[15:32:08.068]                   options(future.plan = NULL)
[15:32:08.068]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.068]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.068]                 }
[15:32:08.068]                 ...future.workdir <- getwd()
[15:32:08.068]             }
[15:32:08.068]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.068]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.068]         }
[15:32:08.068]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.068]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.068]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.068]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.068]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.068]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.068]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.068]             base::names(...future.oldOptions))
[15:32:08.068]     }
[15:32:08.068]     if (FALSE) {
[15:32:08.068]     }
[15:32:08.068]     else {
[15:32:08.068]         if (TRUE) {
[15:32:08.068]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.068]                 open = "w")
[15:32:08.068]         }
[15:32:08.068]         else {
[15:32:08.068]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.068]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.068]         }
[15:32:08.068]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.068]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.068]             base::sink(type = "output", split = FALSE)
[15:32:08.068]             base::close(...future.stdout)
[15:32:08.068]         }, add = TRUE)
[15:32:08.068]     }
[15:32:08.068]     ...future.frame <- base::sys.nframe()
[15:32:08.068]     ...future.conditions <- base::list()
[15:32:08.068]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.068]     if (FALSE) {
[15:32:08.068]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.068]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.068]     }
[15:32:08.068]     ...future.result <- base::tryCatch({
[15:32:08.068]         base::withCallingHandlers({
[15:32:08.068]             ...future.value <- base::withVisible(base::local({
[15:32:08.068]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.068]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.068]                   ...future.globals.maxSize)) {
[15:32:08.068]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.068]                   on.exit(options(oopts), add = TRUE)
[15:32:08.068]                 }
[15:32:08.068]                 {
[15:32:08.068]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.068]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.068]                     USE.NAMES = FALSE)
[15:32:08.068]                   do.call(mapply, args = args)
[15:32:08.068]                 }
[15:32:08.068]             }))
[15:32:08.068]             future::FutureResult(value = ...future.value$value, 
[15:32:08.068]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.068]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.068]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.068]                     ...future.globalenv.names))
[15:32:08.068]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.068]         }, condition = base::local({
[15:32:08.068]             c <- base::c
[15:32:08.068]             inherits <- base::inherits
[15:32:08.068]             invokeRestart <- base::invokeRestart
[15:32:08.068]             length <- base::length
[15:32:08.068]             list <- base::list
[15:32:08.068]             seq.int <- base::seq.int
[15:32:08.068]             signalCondition <- base::signalCondition
[15:32:08.068]             sys.calls <- base::sys.calls
[15:32:08.068]             `[[` <- base::`[[`
[15:32:08.068]             `+` <- base::`+`
[15:32:08.068]             `<<-` <- base::`<<-`
[15:32:08.068]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.068]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.068]                   3L)]
[15:32:08.068]             }
[15:32:08.068]             function(cond) {
[15:32:08.068]                 is_error <- inherits(cond, "error")
[15:32:08.068]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.068]                   NULL)
[15:32:08.068]                 if (is_error) {
[15:32:08.068]                   sessionInformation <- function() {
[15:32:08.068]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.068]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.068]                       search = base::search(), system = base::Sys.info())
[15:32:08.068]                   }
[15:32:08.068]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.068]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.068]                     cond$call), session = sessionInformation(), 
[15:32:08.068]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.068]                   signalCondition(cond)
[15:32:08.068]                 }
[15:32:08.068]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.068]                 "immediateCondition"))) {
[15:32:08.068]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.068]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.068]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.068]                   if (TRUE && !signal) {
[15:32:08.068]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.068]                     {
[15:32:08.068]                       inherits <- base::inherits
[15:32:08.068]                       invokeRestart <- base::invokeRestart
[15:32:08.068]                       is.null <- base::is.null
[15:32:08.068]                       muffled <- FALSE
[15:32:08.068]                       if (inherits(cond, "message")) {
[15:32:08.068]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.068]                         if (muffled) 
[15:32:08.068]                           invokeRestart("muffleMessage")
[15:32:08.068]                       }
[15:32:08.068]                       else if (inherits(cond, "warning")) {
[15:32:08.068]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.068]                         if (muffled) 
[15:32:08.068]                           invokeRestart("muffleWarning")
[15:32:08.068]                       }
[15:32:08.068]                       else if (inherits(cond, "condition")) {
[15:32:08.068]                         if (!is.null(pattern)) {
[15:32:08.068]                           computeRestarts <- base::computeRestarts
[15:32:08.068]                           grepl <- base::grepl
[15:32:08.068]                           restarts <- computeRestarts(cond)
[15:32:08.068]                           for (restart in restarts) {
[15:32:08.068]                             name <- restart$name
[15:32:08.068]                             if (is.null(name)) 
[15:32:08.068]                               next
[15:32:08.068]                             if (!grepl(pattern, name)) 
[15:32:08.068]                               next
[15:32:08.068]                             invokeRestart(restart)
[15:32:08.068]                             muffled <- TRUE
[15:32:08.068]                             break
[15:32:08.068]                           }
[15:32:08.068]                         }
[15:32:08.068]                       }
[15:32:08.068]                       invisible(muffled)
[15:32:08.068]                     }
[15:32:08.068]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.068]                   }
[15:32:08.068]                 }
[15:32:08.068]                 else {
[15:32:08.068]                   if (TRUE) {
[15:32:08.068]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.068]                     {
[15:32:08.068]                       inherits <- base::inherits
[15:32:08.068]                       invokeRestart <- base::invokeRestart
[15:32:08.068]                       is.null <- base::is.null
[15:32:08.068]                       muffled <- FALSE
[15:32:08.068]                       if (inherits(cond, "message")) {
[15:32:08.068]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.068]                         if (muffled) 
[15:32:08.068]                           invokeRestart("muffleMessage")
[15:32:08.068]                       }
[15:32:08.068]                       else if (inherits(cond, "warning")) {
[15:32:08.068]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.068]                         if (muffled) 
[15:32:08.068]                           invokeRestart("muffleWarning")
[15:32:08.068]                       }
[15:32:08.068]                       else if (inherits(cond, "condition")) {
[15:32:08.068]                         if (!is.null(pattern)) {
[15:32:08.068]                           computeRestarts <- base::computeRestarts
[15:32:08.068]                           grepl <- base::grepl
[15:32:08.068]                           restarts <- computeRestarts(cond)
[15:32:08.068]                           for (restart in restarts) {
[15:32:08.068]                             name <- restart$name
[15:32:08.068]                             if (is.null(name)) 
[15:32:08.068]                               next
[15:32:08.068]                             if (!grepl(pattern, name)) 
[15:32:08.068]                               next
[15:32:08.068]                             invokeRestart(restart)
[15:32:08.068]                             muffled <- TRUE
[15:32:08.068]                             break
[15:32:08.068]                           }
[15:32:08.068]                         }
[15:32:08.068]                       }
[15:32:08.068]                       invisible(muffled)
[15:32:08.068]                     }
[15:32:08.068]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.068]                   }
[15:32:08.068]                 }
[15:32:08.068]             }
[15:32:08.068]         }))
[15:32:08.068]     }, error = function(ex) {
[15:32:08.068]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.068]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.068]                 ...future.rng), started = ...future.startTime, 
[15:32:08.068]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.068]             version = "1.8"), class = "FutureResult")
[15:32:08.068]     }, finally = {
[15:32:08.068]         if (!identical(...future.workdir, getwd())) 
[15:32:08.068]             setwd(...future.workdir)
[15:32:08.068]         {
[15:32:08.068]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.068]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.068]             }
[15:32:08.068]             base::options(...future.oldOptions)
[15:32:08.068]             if (.Platform$OS.type == "windows") {
[15:32:08.068]                 old_names <- names(...future.oldEnvVars)
[15:32:08.068]                 envs <- base::Sys.getenv()
[15:32:08.068]                 names <- names(envs)
[15:32:08.068]                 common <- intersect(names, old_names)
[15:32:08.068]                 added <- setdiff(names, old_names)
[15:32:08.068]                 removed <- setdiff(old_names, names)
[15:32:08.068]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.068]                   envs[common]]
[15:32:08.068]                 NAMES <- toupper(changed)
[15:32:08.068]                 args <- list()
[15:32:08.068]                 for (kk in seq_along(NAMES)) {
[15:32:08.068]                   name <- changed[[kk]]
[15:32:08.068]                   NAME <- NAMES[[kk]]
[15:32:08.068]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.068]                     next
[15:32:08.068]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.068]                 }
[15:32:08.068]                 NAMES <- toupper(added)
[15:32:08.068]                 for (kk in seq_along(NAMES)) {
[15:32:08.068]                   name <- added[[kk]]
[15:32:08.068]                   NAME <- NAMES[[kk]]
[15:32:08.068]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.068]                     next
[15:32:08.068]                   args[[name]] <- ""
[15:32:08.068]                 }
[15:32:08.068]                 NAMES <- toupper(removed)
[15:32:08.068]                 for (kk in seq_along(NAMES)) {
[15:32:08.068]                   name <- removed[[kk]]
[15:32:08.068]                   NAME <- NAMES[[kk]]
[15:32:08.068]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.068]                     next
[15:32:08.068]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.068]                 }
[15:32:08.068]                 if (length(args) > 0) 
[15:32:08.068]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.068]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.068]             }
[15:32:08.068]             else {
[15:32:08.068]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.068]             }
[15:32:08.068]             {
[15:32:08.068]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.068]                   0L) {
[15:32:08.068]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.068]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.068]                   base::options(opts)
[15:32:08.068]                 }
[15:32:08.068]                 {
[15:32:08.068]                   {
[15:32:08.068]                     base::assign(".Random.seed", c(10407L, 949485115L, 
[15:32:08.068]                     -138203693L, 511393082L, -128431090L, 758578777L, 
[15:32:08.068]                     -253660479L), envir = base::globalenv(), 
[15:32:08.068]                       inherits = FALSE)
[15:32:08.068]                     NULL
[15:32:08.068]                   }
[15:32:08.068]                   options(future.plan = NULL)
[15:32:08.068]                   if (is.na(NA_character_)) 
[15:32:08.068]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.068]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.068]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.068]                     .init = FALSE)
[15:32:08.068]                 }
[15:32:08.068]             }
[15:32:08.068]         }
[15:32:08.068]     })
[15:32:08.068]     if (TRUE) {
[15:32:08.068]         base::sink(type = "output", split = FALSE)
[15:32:08.068]         if (TRUE) {
[15:32:08.068]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.068]         }
[15:32:08.068]         else {
[15:32:08.068]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.068]         }
[15:32:08.068]         base::close(...future.stdout)
[15:32:08.068]         ...future.stdout <- NULL
[15:32:08.068]     }
[15:32:08.068]     ...future.result$conditions <- ...future.conditions
[15:32:08.068]     ...future.result$finished <- base::Sys.time()
[15:32:08.068]     ...future.result
[15:32:08.068] }
[15:32:08.072] assign_globals() ...
[15:32:08.072] List of 5
[15:32:08.072]  $ ...future.FUN            :function (x, y)  
[15:32:08.072]  $ MoreArgs                 :List of 1
[15:32:08.072]   ..$ y: int [1:2] 3 4
[15:32:08.072]  $ ...future.elements_ii    :List of 1
[15:32:08.072]   ..$ x:List of 2
[15:32:08.072]   .. ..$ : int 1
[15:32:08.072]   .. ..$ : int 2
[15:32:08.072]  $ ...future.seeds_ii       : NULL
[15:32:08.072]  $ ...future.globals.maxSize: NULL
[15:32:08.072]  - attr(*, "where")=List of 5
[15:32:08.072]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.072]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.072]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.072]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.072]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.072]  - attr(*, "resolved")= logi FALSE
[15:32:08.072]  - attr(*, "total_size")= num 1872
[15:32:08.072]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.072]  - attr(*, "already-done")= logi TRUE
[15:32:08.080] - reassign environment for '...future.FUN'
[15:32:08.080] - copied '...future.FUN' to environment
[15:32:08.080] - copied 'MoreArgs' to environment
[15:32:08.080] - copied '...future.elements_ii' to environment
[15:32:08.080] - copied '...future.seeds_ii' to environment
[15:32:08.081] - copied '...future.globals.maxSize' to environment
[15:32:08.081] assign_globals() ... done
[15:32:08.081] plan(): Setting new future strategy stack:
[15:32:08.081] List of future strategies:
[15:32:08.081] 1. sequential:
[15:32:08.081]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.081]    - tweaked: FALSE
[15:32:08.081]    - call: NULL
[15:32:08.082] plan(): nbrOfWorkers() = 1
[15:32:08.084] plan(): Setting new future strategy stack:
[15:32:08.084] List of future strategies:
[15:32:08.084] 1. sequential:
[15:32:08.084]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.084]    - tweaked: FALSE
[15:32:08.084]    - call: plan(strategy)
[15:32:08.085] plan(): nbrOfWorkers() = 1
[15:32:08.085] SequentialFuture started (and completed)
[15:32:08.085] - Launch lazy future ... done
[15:32:08.085] run() for 'SequentialFuture' ... done
[15:32:08.086] Created future:
[15:32:08.086] SequentialFuture:
[15:32:08.086] Label: 'future_mapply-1'
[15:32:08.086] Expression:
[15:32:08.086] {
[15:32:08.086]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.086]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.086]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.086]         on.exit(options(oopts), add = TRUE)
[15:32:08.086]     }
[15:32:08.086]     {
[15:32:08.086]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.086]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.086]         do.call(mapply, args = args)
[15:32:08.086]     }
[15:32:08.086] }
[15:32:08.086] Lazy evaluation: FALSE
[15:32:08.086] Asynchronous evaluation: FALSE
[15:32:08.086] Local evaluation: TRUE
[15:32:08.086] Environment: R_GlobalEnv
[15:32:08.086] Capture standard output: TRUE
[15:32:08.086] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.086] Globals: 5 objects totaling 1.83 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.086] Packages: <none>
[15:32:08.086] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.086] Resolved: TRUE
[15:32:08.086] Value: 112 bytes of class 'list'
[15:32:08.086] Early signaling: FALSE
[15:32:08.086] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.086] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.087] Chunk #1 of 1 ... DONE
[15:32:08.087] Launching 1 futures (chunks) ... DONE
[15:32:08.088] Resolving 1 futures (chunks) ...
[15:32:08.088] resolve() on list ...
[15:32:08.088]  recursive: 0
[15:32:08.088]  length: 1
[15:32:08.088] 
[15:32:08.088] resolved() for 'SequentialFuture' ...
[15:32:08.089] - state: 'finished'
[15:32:08.089] - run: TRUE
[15:32:08.089] - result: 'FutureResult'
[15:32:08.089] resolved() for 'SequentialFuture' ... done
[15:32:08.089] Future #1
[15:32:08.090] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.090] - nx: 1
[15:32:08.090] - relay: TRUE
[15:32:08.093] - stdout: TRUE
[15:32:08.093] - signal: TRUE
[15:32:08.094] - resignal: FALSE
[15:32:08.094] - force: TRUE
[15:32:08.094] - relayed: [n=1] FALSE
[15:32:08.094] - queued futures: [n=1] FALSE
[15:32:08.095]  - until=1
[15:32:08.095]  - relaying element #1
[15:32:08.095] - relayed: [n=1] TRUE
[15:32:08.095] - queued futures: [n=1] TRUE
[15:32:08.096] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.096]  length: 0 (resolved future 1)
[15:32:08.096] Relaying remaining futures
[15:32:08.096] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.097] - nx: 1
[15:32:08.097] - relay: TRUE
[15:32:08.097] - stdout: TRUE
[15:32:08.097] - signal: TRUE
[15:32:08.097] - resignal: FALSE
[15:32:08.098] - force: TRUE
[15:32:08.098] - relayed: [n=1] TRUE
[15:32:08.098] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.098] - relayed: [n=1] TRUE
[15:32:08.099] - queued futures: [n=1] TRUE
[15:32:08.099] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.099] resolve() on list ... DONE
[15:32:08.099]  - Number of value chunks collected: 1
[15:32:08.100] Resolving 1 futures (chunks) ... DONE
[15:32:08.100] Reducing values from 1 chunks ...
[15:32:08.100]  - Number of values collected after concatenation: 2
[15:32:08.100]  - Number of values expected: 2
[15:32:08.100] Reducing values from 1 chunks ... DONE
[15:32:08.100] future_mapply() ... DONE
[15:32:08.101] future_mapply() ...
[15:32:08.101] Generating random seeds ...
[15:32:08.101] Generating random seed streams for 2 elements ...
[15:32:08.101] Generating random seed streams for 2 elements ... DONE
[15:32:08.102] Generating random seeds ... DONE
[15:32:08.102] Will set RNG state on exit: 10407, 511393082, -1854767632, 240297729, -253660479, 602526664, 344058409
[15:32:08.102] Number of chunks: 1
[15:32:08.102] getGlobalsAndPackagesXApply() ...
[15:32:08.102]  - future.globals: TRUE
[15:32:08.103] getGlobalsAndPackages() ...
[15:32:08.103] Searching for globals...
[15:32:08.104] - globals found: [1] 'FUN'
[15:32:08.105] Searching for globals ... DONE
[15:32:08.105] Resolving globals: FALSE
[15:32:08.105] The total size of the 1 globals is 1.66 KiB (1704 bytes)
[15:32:08.106] The total size of the 1 globals exported for future expression ('FUN(y = 3:4)') is 1.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.66 KiB of class 'function')
[15:32:08.106] - globals: [1] 'FUN'
[15:32:08.106] 
[15:32:08.106] getGlobalsAndPackages() ... DONE
[15:32:08.107]  - globals found/used: [n=1] 'FUN'
[15:32:08.107]  - needed namespaces: [n=0] 
[15:32:08.107] Finding globals ... DONE
[15:32:08.107] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.108] List of 2
[15:32:08.108]  $ ...future.FUN:function (x, y)  
[15:32:08.108]  $ MoreArgs     :List of 1
[15:32:08.108]   ..$ y: int [1:2] 3 4
[15:32:08.108]  - attr(*, "where")=List of 2
[15:32:08.108]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.108]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.108]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.108]  - attr(*, "resolved")= logi FALSE
[15:32:08.108]  - attr(*, "total_size")= num NA
[15:32:08.113] Packages to be attached in all futures: [n=0] 
[15:32:08.114] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.114] Number of futures (= number of chunks): 1
[15:32:08.114] Launching 1 futures (chunks) ...
[15:32:08.115] Chunk #1 of 1 ...
[15:32:08.115]  - Finding globals in '...' for chunk #1 ...
[15:32:08.115] getGlobalsAndPackages() ...
[15:32:08.116] Searching for globals...
[15:32:08.116] 
[15:32:08.117] Searching for globals ... DONE
[15:32:08.117] - globals: [0] <none>
[15:32:08.117] getGlobalsAndPackages() ... DONE
[15:32:08.118]    + additional globals found: [n=0] 
[15:32:08.118]    + additional namespaces needed: [n=0] 
[15:32:08.118]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.119]  - seeds: [2] <seeds>
[15:32:08.119]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.119] getGlobalsAndPackages() ...
[15:32:08.119] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.120] Resolving globals: FALSE
[15:32:08.121] The total size of the 5 globals is 1.98 KiB (2032 bytes)
[15:32:08.122] 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 1.98 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), '...future.seeds_ii' (160 bytes of class 'list') and '...future.elements_ii' (112 bytes of class 'list')
[15:32:08.123] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.123] 
[15:32:08.123] getGlobalsAndPackages() ... DONE
[15:32:08.124] run() for 'Future' ...
[15:32:08.124] - state: 'created'
[15:32:08.125] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.125] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.126] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.126]   - Field: 'label'
[15:32:08.126]   - Field: 'local'
[15:32:08.127]   - Field: 'owner'
[15:32:08.127]   - Field: 'envir'
[15:32:08.127]   - Field: 'packages'
[15:32:08.127]   - Field: 'gc'
[15:32:08.128]   - Field: 'conditions'
[15:32:08.128]   - Field: 'expr'
[15:32:08.128]   - Field: 'uuid'
[15:32:08.129]   - Field: 'seed'
[15:32:08.129]   - Field: 'version'
[15:32:08.129]   - Field: 'result'
[15:32:08.130]   - Field: 'asynchronous'
[15:32:08.130]   - Field: 'calls'
[15:32:08.130]   - Field: 'globals'
[15:32:08.131]   - Field: 'stdout'
[15:32:08.131]   - Field: 'earlySignal'
[15:32:08.131]   - Field: 'lazy'
[15:32:08.132]   - Field: 'state'
[15:32:08.132] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.132] - Launch lazy future ...
[15:32:08.137] Packages needed by the future expression (n = 0): <none>
[15:32:08.138] Packages needed by future strategies (n = 0): <none>
[15:32:08.139] {
[15:32:08.139]     {
[15:32:08.139]         {
[15:32:08.139]             ...future.startTime <- base::Sys.time()
[15:32:08.139]             {
[15:32:08.139]                 {
[15:32:08.139]                   {
[15:32:08.139]                     base::local({
[15:32:08.139]                       has_future <- base::requireNamespace("future", 
[15:32:08.139]                         quietly = TRUE)
[15:32:08.139]                       if (has_future) {
[15:32:08.139]                         ns <- base::getNamespace("future")
[15:32:08.139]                         version <- ns[[".package"]][["version"]]
[15:32:08.139]                         if (is.null(version)) 
[15:32:08.139]                           version <- utils::packageVersion("future")
[15:32:08.139]                       }
[15:32:08.139]                       else {
[15:32:08.139]                         version <- NULL
[15:32:08.139]                       }
[15:32:08.139]                       if (!has_future || version < "1.8.0") {
[15:32:08.139]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.139]                           "", base::R.version$version.string), 
[15:32:08.139]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:08.139]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.139]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.139]                             "release", "version")], collapse = " "), 
[15:32:08.139]                           hostname = base::Sys.info()[["nodename"]])
[15:32:08.139]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.139]                           info)
[15:32:08.139]                         info <- base::paste(info, collapse = "; ")
[15:32:08.139]                         if (!has_future) {
[15:32:08.139]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.139]                             info)
[15:32:08.139]                         }
[15:32:08.139]                         else {
[15:32:08.139]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.139]                             info, version)
[15:32:08.139]                         }
[15:32:08.139]                         base::stop(msg)
[15:32:08.139]                       }
[15:32:08.139]                     })
[15:32:08.139]                   }
[15:32:08.139]                   ...future.strategy.old <- future::plan("list")
[15:32:08.139]                   options(future.plan = NULL)
[15:32:08.139]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.139]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.139]                 }
[15:32:08.139]                 ...future.workdir <- getwd()
[15:32:08.139]             }
[15:32:08.139]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.139]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.139]         }
[15:32:08.139]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.139]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.139]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.139]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.139]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.139]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.139]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.139]             base::names(...future.oldOptions))
[15:32:08.139]     }
[15:32:08.139]     if (FALSE) {
[15:32:08.139]     }
[15:32:08.139]     else {
[15:32:08.139]         if (TRUE) {
[15:32:08.139]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.139]                 open = "w")
[15:32:08.139]         }
[15:32:08.139]         else {
[15:32:08.139]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.139]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.139]         }
[15:32:08.139]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.139]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.139]             base::sink(type = "output", split = FALSE)
[15:32:08.139]             base::close(...future.stdout)
[15:32:08.139]         }, add = TRUE)
[15:32:08.139]     }
[15:32:08.139]     ...future.frame <- base::sys.nframe()
[15:32:08.139]     ...future.conditions <- base::list()
[15:32:08.139]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.139]     if (FALSE) {
[15:32:08.139]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.139]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.139]     }
[15:32:08.139]     ...future.result <- base::tryCatch({
[15:32:08.139]         base::withCallingHandlers({
[15:32:08.139]             ...future.value <- base::withVisible(base::local({
[15:32:08.139]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.139]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.139]                   ...future.globals.maxSize)) {
[15:32:08.139]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.139]                   on.exit(options(oopts), add = TRUE)
[15:32:08.139]                 }
[15:32:08.139]                 {
[15:32:08.139]                   ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:08.139]                     assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:08.139]                       envir = globalenv(), inherits = FALSE)
[15:32:08.139]                     ...future.FUN(...)
[15:32:08.139]                   }
[15:32:08.139]                   args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:08.139]                     list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:08.139]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.139]                     USE.NAMES = FALSE)
[15:32:08.139]                   do.call(mapply, args = args)
[15:32:08.139]                 }
[15:32:08.139]             }))
[15:32:08.139]             future::FutureResult(value = ...future.value$value, 
[15:32:08.139]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.139]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.139]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.139]                     ...future.globalenv.names))
[15:32:08.139]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.139]         }, condition = base::local({
[15:32:08.139]             c <- base::c
[15:32:08.139]             inherits <- base::inherits
[15:32:08.139]             invokeRestart <- base::invokeRestart
[15:32:08.139]             length <- base::length
[15:32:08.139]             list <- base::list
[15:32:08.139]             seq.int <- base::seq.int
[15:32:08.139]             signalCondition <- base::signalCondition
[15:32:08.139]             sys.calls <- base::sys.calls
[15:32:08.139]             `[[` <- base::`[[`
[15:32:08.139]             `+` <- base::`+`
[15:32:08.139]             `<<-` <- base::`<<-`
[15:32:08.139]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.139]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.139]                   3L)]
[15:32:08.139]             }
[15:32:08.139]             function(cond) {
[15:32:08.139]                 is_error <- inherits(cond, "error")
[15:32:08.139]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.139]                   NULL)
[15:32:08.139]                 if (is_error) {
[15:32:08.139]                   sessionInformation <- function() {
[15:32:08.139]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.139]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.139]                       search = base::search(), system = base::Sys.info())
[15:32:08.139]                   }
[15:32:08.139]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.139]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.139]                     cond$call), session = sessionInformation(), 
[15:32:08.139]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.139]                   signalCondition(cond)
[15:32:08.139]                 }
[15:32:08.139]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.139]                 "immediateCondition"))) {
[15:32:08.139]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.139]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.139]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.139]                   if (TRUE && !signal) {
[15:32:08.139]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.139]                     {
[15:32:08.139]                       inherits <- base::inherits
[15:32:08.139]                       invokeRestart <- base::invokeRestart
[15:32:08.139]                       is.null <- base::is.null
[15:32:08.139]                       muffled <- FALSE
[15:32:08.139]                       if (inherits(cond, "message")) {
[15:32:08.139]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.139]                         if (muffled) 
[15:32:08.139]                           invokeRestart("muffleMessage")
[15:32:08.139]                       }
[15:32:08.139]                       else if (inherits(cond, "warning")) {
[15:32:08.139]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.139]                         if (muffled) 
[15:32:08.139]                           invokeRestart("muffleWarning")
[15:32:08.139]                       }
[15:32:08.139]                       else if (inherits(cond, "condition")) {
[15:32:08.139]                         if (!is.null(pattern)) {
[15:32:08.139]                           computeRestarts <- base::computeRestarts
[15:32:08.139]                           grepl <- base::grepl
[15:32:08.139]                           restarts <- computeRestarts(cond)
[15:32:08.139]                           for (restart in restarts) {
[15:32:08.139]                             name <- restart$name
[15:32:08.139]                             if (is.null(name)) 
[15:32:08.139]                               next
[15:32:08.139]                             if (!grepl(pattern, name)) 
[15:32:08.139]                               next
[15:32:08.139]                             invokeRestart(restart)
[15:32:08.139]                             muffled <- TRUE
[15:32:08.139]                             break
[15:32:08.139]                           }
[15:32:08.139]                         }
[15:32:08.139]                       }
[15:32:08.139]                       invisible(muffled)
[15:32:08.139]                     }
[15:32:08.139]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.139]                   }
[15:32:08.139]                 }
[15:32:08.139]                 else {
[15:32:08.139]                   if (TRUE) {
[15:32:08.139]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.139]                     {
[15:32:08.139]                       inherits <- base::inherits
[15:32:08.139]                       invokeRestart <- base::invokeRestart
[15:32:08.139]                       is.null <- base::is.null
[15:32:08.139]                       muffled <- FALSE
[15:32:08.139]                       if (inherits(cond, "message")) {
[15:32:08.139]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.139]                         if (muffled) 
[15:32:08.139]                           invokeRestart("muffleMessage")
[15:32:08.139]                       }
[15:32:08.139]                       else if (inherits(cond, "warning")) {
[15:32:08.139]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.139]                         if (muffled) 
[15:32:08.139]                           invokeRestart("muffleWarning")
[15:32:08.139]                       }
[15:32:08.139]                       else if (inherits(cond, "condition")) {
[15:32:08.139]                         if (!is.null(pattern)) {
[15:32:08.139]                           computeRestarts <- base::computeRestarts
[15:32:08.139]                           grepl <- base::grepl
[15:32:08.139]                           restarts <- computeRestarts(cond)
[15:32:08.139]                           for (restart in restarts) {
[15:32:08.139]                             name <- restart$name
[15:32:08.139]                             if (is.null(name)) 
[15:32:08.139]                               next
[15:32:08.139]                             if (!grepl(pattern, name)) 
[15:32:08.139]                               next
[15:32:08.139]                             invokeRestart(restart)
[15:32:08.139]                             muffled <- TRUE
[15:32:08.139]                             break
[15:32:08.139]                           }
[15:32:08.139]                         }
[15:32:08.139]                       }
[15:32:08.139]                       invisible(muffled)
[15:32:08.139]                     }
[15:32:08.139]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.139]                   }
[15:32:08.139]                 }
[15:32:08.139]             }
[15:32:08.139]         }))
[15:32:08.139]     }, error = function(ex) {
[15:32:08.139]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.139]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.139]                 ...future.rng), started = ...future.startTime, 
[15:32:08.139]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.139]             version = "1.8"), class = "FutureResult")
[15:32:08.139]     }, finally = {
[15:32:08.139]         if (!identical(...future.workdir, getwd())) 
[15:32:08.139]             setwd(...future.workdir)
[15:32:08.139]         {
[15:32:08.139]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.139]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.139]             }
[15:32:08.139]             base::options(...future.oldOptions)
[15:32:08.139]             if (.Platform$OS.type == "windows") {
[15:32:08.139]                 old_names <- names(...future.oldEnvVars)
[15:32:08.139]                 envs <- base::Sys.getenv()
[15:32:08.139]                 names <- names(envs)
[15:32:08.139]                 common <- intersect(names, old_names)
[15:32:08.139]                 added <- setdiff(names, old_names)
[15:32:08.139]                 removed <- setdiff(old_names, names)
[15:32:08.139]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.139]                   envs[common]]
[15:32:08.139]                 NAMES <- toupper(changed)
[15:32:08.139]                 args <- list()
[15:32:08.139]                 for (kk in seq_along(NAMES)) {
[15:32:08.139]                   name <- changed[[kk]]
[15:32:08.139]                   NAME <- NAMES[[kk]]
[15:32:08.139]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.139]                     next
[15:32:08.139]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.139]                 }
[15:32:08.139]                 NAMES <- toupper(added)
[15:32:08.139]                 for (kk in seq_along(NAMES)) {
[15:32:08.139]                   name <- added[[kk]]
[15:32:08.139]                   NAME <- NAMES[[kk]]
[15:32:08.139]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.139]                     next
[15:32:08.139]                   args[[name]] <- ""
[15:32:08.139]                 }
[15:32:08.139]                 NAMES <- toupper(removed)
[15:32:08.139]                 for (kk in seq_along(NAMES)) {
[15:32:08.139]                   name <- removed[[kk]]
[15:32:08.139]                   NAME <- NAMES[[kk]]
[15:32:08.139]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.139]                     next
[15:32:08.139]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.139]                 }
[15:32:08.139]                 if (length(args) > 0) 
[15:32:08.139]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.139]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.139]             }
[15:32:08.139]             else {
[15:32:08.139]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.139]             }
[15:32:08.139]             {
[15:32:08.139]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.139]                   0L) {
[15:32:08.139]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.139]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.139]                   base::options(opts)
[15:32:08.139]                 }
[15:32:08.139]                 {
[15:32:08.139]                   {
[15:32:08.139]                     base::assign(".Random.seed", c(10407L, 511393082L, 
[15:32:08.139]                     -1854767632L, 240297729L, -253660479L, 602526664L, 
[15:32:08.139]                     344058409L), envir = base::globalenv(), inherits = FALSE)
[15:32:08.139]                     NULL
[15:32:08.139]                   }
[15:32:08.139]                   options(future.plan = NULL)
[15:32:08.139]                   if (is.na(NA_character_)) 
[15:32:08.139]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.139]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.139]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.139]                     .init = FALSE)
[15:32:08.139]                 }
[15:32:08.139]             }
[15:32:08.139]         }
[15:32:08.139]     })
[15:32:08.139]     if (TRUE) {
[15:32:08.139]         base::sink(type = "output", split = FALSE)
[15:32:08.139]         if (TRUE) {
[15:32:08.139]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.139]         }
[15:32:08.139]         else {
[15:32:08.139]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.139]         }
[15:32:08.139]         base::close(...future.stdout)
[15:32:08.139]         ...future.stdout <- NULL
[15:32:08.139]     }
[15:32:08.139]     ...future.result$conditions <- ...future.conditions
[15:32:08.139]     ...future.result$finished <- base::Sys.time()
[15:32:08.139]     ...future.result
[15:32:08.139] }
[15:32:08.146] assign_globals() ...
[15:32:08.146] List of 5
[15:32:08.146]  $ ...future.FUN            :function (x, y)  
[15:32:08.146]  $ MoreArgs                 :List of 1
[15:32:08.146]   ..$ y: int [1:2] 3 4
[15:32:08.146]  $ ...future.elements_ii    :List of 1
[15:32:08.146]   ..$ x:List of 2
[15:32:08.146]   .. ..$ : int 1
[15:32:08.146]   .. ..$ : int 2
[15:32:08.146]  $ ...future.seeds_ii       :List of 2
[15:32:08.146]   ..$ : int [1:7] 10407 1693966110 -1115123941 1696028654 557958439 300205678 2014396551
[15:32:08.146]   ..$ : int [1:7] 10407 1019953568 -2043183536 793031878 832062425 1747647222 632539939
[15:32:08.146]  $ ...future.globals.maxSize: NULL
[15:32:08.146]  - attr(*, "where")=List of 5
[15:32:08.146]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.146]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.146]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.146]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.146]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.146]  - attr(*, "resolved")= logi FALSE
[15:32:08.146]  - attr(*, "total_size")= num 2032
[15:32:08.146]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.146]  - attr(*, "already-done")= logi TRUE
[15:32:08.160] - reassign environment for '...future.FUN'
[15:32:08.160] - copied '...future.FUN' to environment
[15:32:08.161] - copied 'MoreArgs' to environment
[15:32:08.161] - copied '...future.elements_ii' to environment
[15:32:08.161] - copied '...future.seeds_ii' to environment
[15:32:08.161] - copied '...future.globals.maxSize' to environment
[15:32:08.161] assign_globals() ... done
[15:32:08.162] plan(): Setting new future strategy stack:
[15:32:08.162] List of future strategies:
[15:32:08.162] 1. sequential:
[15:32:08.162]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.162]    - tweaked: FALSE
[15:32:08.162]    - call: NULL
[15:32:08.163] plan(): nbrOfWorkers() = 1
[15:32:08.166] plan(): Setting new future strategy stack:
[15:32:08.166] List of future strategies:
[15:32:08.166] 1. sequential:
[15:32:08.166]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.166]    - tweaked: FALSE
[15:32:08.166]    - call: plan(strategy)
[15:32:08.167] plan(): nbrOfWorkers() = 1
[15:32:08.168] SequentialFuture started (and completed)
[15:32:08.168] - Launch lazy future ... done
[15:32:08.168] run() for 'SequentialFuture' ... done
[15:32:08.169] Created future:
[15:32:08.169] SequentialFuture:
[15:32:08.169] Label: 'future_mapply-1'
[15:32:08.169] Expression:
[15:32:08.169] {
[15:32:08.169]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.169]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.169]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.169]         on.exit(options(oopts), add = TRUE)
[15:32:08.169]     }
[15:32:08.169]     {
[15:32:08.169]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:08.169]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:08.169]                 inherits = FALSE)
[15:32:08.169]             ...future.FUN(...)
[15:32:08.169]         }
[15:32:08.169]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:08.169]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:08.169]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.169]         do.call(mapply, args = args)
[15:32:08.169]     }
[15:32:08.169] }
[15:32:08.169] Lazy evaluation: FALSE
[15:32:08.169] Asynchronous evaluation: FALSE
[15:32:08.169] Local evaluation: TRUE
[15:32:08.169] Environment: R_GlobalEnv
[15:32:08.169] Capture standard output: TRUE
[15:32:08.169] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.169] Globals: 5 objects totaling 1.98 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 112 bytes, list '...future.seeds_ii' of 160 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.169] Packages: <none>
[15:32:08.169] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:08.169] Resolved: TRUE
[15:32:08.169] Value: 112 bytes of class 'list'
[15:32:08.169] Early signaling: FALSE
[15:32:08.169] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.169] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.172] Chunk #1 of 1 ... DONE
[15:32:08.172] Launching 1 futures (chunks) ... DONE
[15:32:08.172] Resolving 1 futures (chunks) ...
[15:32:08.173] resolve() on list ...
[15:32:08.173]  recursive: 0
[15:32:08.173]  length: 1
[15:32:08.174] 
[15:32:08.174] resolved() for 'SequentialFuture' ...
[15:32:08.174] - state: 'finished'
[15:32:08.175] - run: TRUE
[15:32:08.175] - result: 'FutureResult'
[15:32:08.175] resolved() for 'SequentialFuture' ... done
[15:32:08.176] Future #1
[15:32:08.176] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.177] - nx: 1
[15:32:08.177] - relay: TRUE
[15:32:08.177] - stdout: TRUE
[15:32:08.177] - signal: TRUE
[15:32:08.178] - resignal: FALSE
[15:32:08.178] - force: TRUE
[15:32:08.178] - relayed: [n=1] FALSE
[15:32:08.179] - queued futures: [n=1] FALSE
[15:32:08.179]  - until=1
[15:32:08.179]  - relaying element #1
[15:32:08.180] - relayed: [n=1] TRUE
[15:32:08.180] - queued futures: [n=1] TRUE
[15:32:08.181] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.181]  length: 0 (resolved future 1)
[15:32:08.181] Relaying remaining futures
[15:32:08.182] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.182] - nx: 1
[15:32:08.182] - relay: TRUE
[15:32:08.183] - stdout: TRUE
[15:32:08.183] - signal: TRUE
[15:32:08.183] - resignal: FALSE
[15:32:08.183] - force: TRUE
[15:32:08.184] - relayed: [n=1] TRUE
[15:32:08.184] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.185] - relayed: [n=1] TRUE
[15:32:08.185] - queued futures: [n=1] TRUE
[15:32:08.185] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.185] resolve() on list ... DONE
[15:32:08.186]  - Number of value chunks collected: 1
[15:32:08.186] Resolving 1 futures (chunks) ... DONE
[15:32:08.187] Reducing values from 1 chunks ...
[15:32:08.187]  - Number of values collected after concatenation: 2
[15:32:08.187]  - Number of values expected: 2
[15:32:08.188] Reducing values from 1 chunks ... DONE
[15:32:08.188] future_mapply() ... DONE
[15:32:08.188] future_mapply() ...
[15:32:08.194] Number of chunks: 1
[15:32:08.195] getGlobalsAndPackagesXApply() ...
[15:32:08.195]  - future.globals: TRUE
[15:32:08.196] getGlobalsAndPackages() ...
[15:32:08.196] Searching for globals...
[15:32:08.199] - globals found: [1] 'FUN'
[15:32:08.200] Searching for globals ... DONE
[15:32:08.200] Resolving globals: FALSE
[15:32:08.201] The total size of the 1 globals is 1.66 KiB (1704 bytes)
[15:32:08.202] The total size of the 1 globals exported for future expression ('FUN(y = 3:4)') is 1.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.66 KiB of class 'function')
[15:32:08.202] - globals: [1] 'FUN'
[15:32:08.203] 
[15:32:08.203] getGlobalsAndPackages() ... DONE
[15:32:08.203]  - globals found/used: [n=1] 'FUN'
[15:32:08.204]  - needed namespaces: [n=0] 
[15:32:08.204] Finding globals ... DONE
[15:32:08.205] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.205] List of 2
[15:32:08.205]  $ ...future.FUN:function (x, y)  
[15:32:08.205]  $ MoreArgs     :List of 1
[15:32:08.205]   ..$ y: int [1:2] 3 4
[15:32:08.205]  - attr(*, "where")=List of 2
[15:32:08.205]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.205]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.205]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.205]  - attr(*, "resolved")= logi FALSE
[15:32:08.205]  - attr(*, "total_size")= num NA
[15:32:08.212] Packages to be attached in all futures: [n=0] 
[15:32:08.212] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.212] Number of futures (= number of chunks): 1
[15:32:08.213] Launching 1 futures (chunks) ...
[15:32:08.213] Chunk #1 of 1 ...
[15:32:08.214]  - Finding globals in '...' for chunk #1 ...
[15:32:08.214] getGlobalsAndPackages() ...
[15:32:08.214] Searching for globals...
[15:32:08.215] 
[15:32:08.215] Searching for globals ... DONE
[15:32:08.216] - globals: [0] <none>
[15:32:08.216] getGlobalsAndPackages() ... DONE
[15:32:08.216]    + additional globals found: [n=0] 
[15:32:08.217]    + additional namespaces needed: [n=0] 
[15:32:08.217]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.217]  - seeds: <none>
[15:32:08.217]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.218] getGlobalsAndPackages() ...
[15:32:08.218] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.219] Resolving globals: FALSE
[15:32:08.220] The total size of the 5 globals is 1.83 KiB (1872 bytes)
[15:32:08.221] 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 1.83 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (56 bytes of class 'list')
[15:32:08.221] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.222] 
[15:32:08.222] getGlobalsAndPackages() ... DONE
[15:32:08.223] run() for 'Future' ...
[15:32:08.223] - state: 'created'
[15:32:08.224] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.224] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.225] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.225]   - Field: 'label'
[15:32:08.225]   - Field: 'local'
[15:32:08.226]   - Field: 'owner'
[15:32:08.226]   - Field: 'envir'
[15:32:08.226]   - Field: 'packages'
[15:32:08.227]   - Field: 'gc'
[15:32:08.227]   - Field: 'conditions'
[15:32:08.227]   - Field: 'expr'
[15:32:08.228]   - Field: 'uuid'
[15:32:08.228]   - Field: 'seed'
[15:32:08.228]   - Field: 'version'
[15:32:08.228]   - Field: 'result'
[15:32:08.229]   - Field: 'asynchronous'
[15:32:08.229]   - Field: 'calls'
[15:32:08.229]   - Field: 'globals'
[15:32:08.230]   - Field: 'stdout'
[15:32:08.230]   - Field: 'earlySignal'
[15:32:08.230]   - Field: 'lazy'
[15:32:08.231]   - Field: 'state'
[15:32:08.231] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.231] - Launch lazy future ...
[15:32:08.232] Packages needed by the future expression (n = 0): <none>
[15:32:08.232] Packages needed by future strategies (n = 0): <none>
[15:32:08.233] {
[15:32:08.233]     {
[15:32:08.233]         {
[15:32:08.233]             ...future.startTime <- base::Sys.time()
[15:32:08.233]             {
[15:32:08.233]                 {
[15:32:08.233]                   {
[15:32:08.233]                     base::local({
[15:32:08.233]                       has_future <- base::requireNamespace("future", 
[15:32:08.233]                         quietly = TRUE)
[15:32:08.233]                       if (has_future) {
[15:32:08.233]                         ns <- base::getNamespace("future")
[15:32:08.233]                         version <- ns[[".package"]][["version"]]
[15:32:08.233]                         if (is.null(version)) 
[15:32:08.233]                           version <- utils::packageVersion("future")
[15:32:08.233]                       }
[15:32:08.233]                       else {
[15:32:08.233]                         version <- NULL
[15:32:08.233]                       }
[15:32:08.233]                       if (!has_future || version < "1.8.0") {
[15:32:08.233]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.233]                           "", base::R.version$version.string), 
[15:32:08.233]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:08.233]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.233]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.233]                             "release", "version")], collapse = " "), 
[15:32:08.233]                           hostname = base::Sys.info()[["nodename"]])
[15:32:08.233]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.233]                           info)
[15:32:08.233]                         info <- base::paste(info, collapse = "; ")
[15:32:08.233]                         if (!has_future) {
[15:32:08.233]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.233]                             info)
[15:32:08.233]                         }
[15:32:08.233]                         else {
[15:32:08.233]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.233]                             info, version)
[15:32:08.233]                         }
[15:32:08.233]                         base::stop(msg)
[15:32:08.233]                       }
[15:32:08.233]                     })
[15:32:08.233]                   }
[15:32:08.233]                   ...future.strategy.old <- future::plan("list")
[15:32:08.233]                   options(future.plan = NULL)
[15:32:08.233]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.233]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.233]                 }
[15:32:08.233]                 ...future.workdir <- getwd()
[15:32:08.233]             }
[15:32:08.233]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.233]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.233]         }
[15:32:08.233]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.233]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.233]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.233]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.233]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.233]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.233]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.233]             base::names(...future.oldOptions))
[15:32:08.233]     }
[15:32:08.233]     if (FALSE) {
[15:32:08.233]     }
[15:32:08.233]     else {
[15:32:08.233]         if (TRUE) {
[15:32:08.233]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.233]                 open = "w")
[15:32:08.233]         }
[15:32:08.233]         else {
[15:32:08.233]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.233]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.233]         }
[15:32:08.233]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.233]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.233]             base::sink(type = "output", split = FALSE)
[15:32:08.233]             base::close(...future.stdout)
[15:32:08.233]         }, add = TRUE)
[15:32:08.233]     }
[15:32:08.233]     ...future.frame <- base::sys.nframe()
[15:32:08.233]     ...future.conditions <- base::list()
[15:32:08.233]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.233]     if (FALSE) {
[15:32:08.233]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.233]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.233]     }
[15:32:08.233]     ...future.result <- base::tryCatch({
[15:32:08.233]         base::withCallingHandlers({
[15:32:08.233]             ...future.value <- base::withVisible(base::local({
[15:32:08.233]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.233]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.233]                   ...future.globals.maxSize)) {
[15:32:08.233]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.233]                   on.exit(options(oopts), add = TRUE)
[15:32:08.233]                 }
[15:32:08.233]                 {
[15:32:08.233]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.233]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.233]                     USE.NAMES = FALSE)
[15:32:08.233]                   do.call(mapply, args = args)
[15:32:08.233]                 }
[15:32:08.233]             }))
[15:32:08.233]             future::FutureResult(value = ...future.value$value, 
[15:32:08.233]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.233]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.233]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.233]                     ...future.globalenv.names))
[15:32:08.233]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.233]         }, condition = base::local({
[15:32:08.233]             c <- base::c
[15:32:08.233]             inherits <- base::inherits
[15:32:08.233]             invokeRestart <- base::invokeRestart
[15:32:08.233]             length <- base::length
[15:32:08.233]             list <- base::list
[15:32:08.233]             seq.int <- base::seq.int
[15:32:08.233]             signalCondition <- base::signalCondition
[15:32:08.233]             sys.calls <- base::sys.calls
[15:32:08.233]             `[[` <- base::`[[`
[15:32:08.233]             `+` <- base::`+`
[15:32:08.233]             `<<-` <- base::`<<-`
[15:32:08.233]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.233]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.233]                   3L)]
[15:32:08.233]             }
[15:32:08.233]             function(cond) {
[15:32:08.233]                 is_error <- inherits(cond, "error")
[15:32:08.233]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.233]                   NULL)
[15:32:08.233]                 if (is_error) {
[15:32:08.233]                   sessionInformation <- function() {
[15:32:08.233]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.233]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.233]                       search = base::search(), system = base::Sys.info())
[15:32:08.233]                   }
[15:32:08.233]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.233]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.233]                     cond$call), session = sessionInformation(), 
[15:32:08.233]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.233]                   signalCondition(cond)
[15:32:08.233]                 }
[15:32:08.233]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.233]                 "immediateCondition"))) {
[15:32:08.233]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.233]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.233]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.233]                   if (TRUE && !signal) {
[15:32:08.233]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.233]                     {
[15:32:08.233]                       inherits <- base::inherits
[15:32:08.233]                       invokeRestart <- base::invokeRestart
[15:32:08.233]                       is.null <- base::is.null
[15:32:08.233]                       muffled <- FALSE
[15:32:08.233]                       if (inherits(cond, "message")) {
[15:32:08.233]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.233]                         if (muffled) 
[15:32:08.233]                           invokeRestart("muffleMessage")
[15:32:08.233]                       }
[15:32:08.233]                       else if (inherits(cond, "warning")) {
[15:32:08.233]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.233]                         if (muffled) 
[15:32:08.233]                           invokeRestart("muffleWarning")
[15:32:08.233]                       }
[15:32:08.233]                       else if (inherits(cond, "condition")) {
[15:32:08.233]                         if (!is.null(pattern)) {
[15:32:08.233]                           computeRestarts <- base::computeRestarts
[15:32:08.233]                           grepl <- base::grepl
[15:32:08.233]                           restarts <- computeRestarts(cond)
[15:32:08.233]                           for (restart in restarts) {
[15:32:08.233]                             name <- restart$name
[15:32:08.233]                             if (is.null(name)) 
[15:32:08.233]                               next
[15:32:08.233]                             if (!grepl(pattern, name)) 
[15:32:08.233]                               next
[15:32:08.233]                             invokeRestart(restart)
[15:32:08.233]                             muffled <- TRUE
[15:32:08.233]                             break
[15:32:08.233]                           }
[15:32:08.233]                         }
[15:32:08.233]                       }
[15:32:08.233]                       invisible(muffled)
[15:32:08.233]                     }
[15:32:08.233]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.233]                   }
[15:32:08.233]                 }
[15:32:08.233]                 else {
[15:32:08.233]                   if (TRUE) {
[15:32:08.233]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.233]                     {
[15:32:08.233]                       inherits <- base::inherits
[15:32:08.233]                       invokeRestart <- base::invokeRestart
[15:32:08.233]                       is.null <- base::is.null
[15:32:08.233]                       muffled <- FALSE
[15:32:08.233]                       if (inherits(cond, "message")) {
[15:32:08.233]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.233]                         if (muffled) 
[15:32:08.233]                           invokeRestart("muffleMessage")
[15:32:08.233]                       }
[15:32:08.233]                       else if (inherits(cond, "warning")) {
[15:32:08.233]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.233]                         if (muffled) 
[15:32:08.233]                           invokeRestart("muffleWarning")
[15:32:08.233]                       }
[15:32:08.233]                       else if (inherits(cond, "condition")) {
[15:32:08.233]                         if (!is.null(pattern)) {
[15:32:08.233]                           computeRestarts <- base::computeRestarts
[15:32:08.233]                           grepl <- base::grepl
[15:32:08.233]                           restarts <- computeRestarts(cond)
[15:32:08.233]                           for (restart in restarts) {
[15:32:08.233]                             name <- restart$name
[15:32:08.233]                             if (is.null(name)) 
[15:32:08.233]                               next
[15:32:08.233]                             if (!grepl(pattern, name)) 
[15:32:08.233]                               next
[15:32:08.233]                             invokeRestart(restart)
[15:32:08.233]                             muffled <- TRUE
[15:32:08.233]                             break
[15:32:08.233]                           }
[15:32:08.233]                         }
[15:32:08.233]                       }
[15:32:08.233]                       invisible(muffled)
[15:32:08.233]                     }
[15:32:08.233]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.233]                   }
[15:32:08.233]                 }
[15:32:08.233]             }
[15:32:08.233]         }))
[15:32:08.233]     }, error = function(ex) {
[15:32:08.233]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.233]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.233]                 ...future.rng), started = ...future.startTime, 
[15:32:08.233]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.233]             version = "1.8"), class = "FutureResult")
[15:32:08.233]     }, finally = {
[15:32:08.233]         if (!identical(...future.workdir, getwd())) 
[15:32:08.233]             setwd(...future.workdir)
[15:32:08.233]         {
[15:32:08.233]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.233]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.233]             }
[15:32:08.233]             base::options(...future.oldOptions)
[15:32:08.233]             if (.Platform$OS.type == "windows") {
[15:32:08.233]                 old_names <- names(...future.oldEnvVars)
[15:32:08.233]                 envs <- base::Sys.getenv()
[15:32:08.233]                 names <- names(envs)
[15:32:08.233]                 common <- intersect(names, old_names)
[15:32:08.233]                 added <- setdiff(names, old_names)
[15:32:08.233]                 removed <- setdiff(old_names, names)
[15:32:08.233]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.233]                   envs[common]]
[15:32:08.233]                 NAMES <- toupper(changed)
[15:32:08.233]                 args <- list()
[15:32:08.233]                 for (kk in seq_along(NAMES)) {
[15:32:08.233]                   name <- changed[[kk]]
[15:32:08.233]                   NAME <- NAMES[[kk]]
[15:32:08.233]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.233]                     next
[15:32:08.233]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.233]                 }
[15:32:08.233]                 NAMES <- toupper(added)
[15:32:08.233]                 for (kk in seq_along(NAMES)) {
[15:32:08.233]                   name <- added[[kk]]
[15:32:08.233]                   NAME <- NAMES[[kk]]
[15:32:08.233]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.233]                     next
[15:32:08.233]                   args[[name]] <- ""
[15:32:08.233]                 }
[15:32:08.233]                 NAMES <- toupper(removed)
[15:32:08.233]                 for (kk in seq_along(NAMES)) {
[15:32:08.233]                   name <- removed[[kk]]
[15:32:08.233]                   NAME <- NAMES[[kk]]
[15:32:08.233]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.233]                     next
[15:32:08.233]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.233]                 }
[15:32:08.233]                 if (length(args) > 0) 
[15:32:08.233]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.233]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.233]             }
[15:32:08.233]             else {
[15:32:08.233]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.233]             }
[15:32:08.233]             {
[15:32:08.233]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.233]                   0L) {
[15:32:08.233]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.233]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.233]                   base::options(opts)
[15:32:08.233]                 }
[15:32:08.233]                 {
[15:32:08.233]                   {
[15:32:08.233]                     base::assign(".Random.seed", c(10407L, 511393082L, 
[15:32:08.233]                     -1854767632L, 240297729L, -253660479L, 602526664L, 
[15:32:08.233]                     344058409L), envir = base::globalenv(), inherits = FALSE)
[15:32:08.233]                     NULL
[15:32:08.233]                   }
[15:32:08.233]                   options(future.plan = NULL)
[15:32:08.233]                   if (is.na(NA_character_)) 
[15:32:08.233]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.233]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.233]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.233]                     .init = FALSE)
[15:32:08.233]                 }
[15:32:08.233]             }
[15:32:08.233]         }
[15:32:08.233]     })
[15:32:08.233]     if (TRUE) {
[15:32:08.233]         base::sink(type = "output", split = FALSE)
[15:32:08.233]         if (TRUE) {
[15:32:08.233]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.233]         }
[15:32:08.233]         else {
[15:32:08.233]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.233]         }
[15:32:08.233]         base::close(...future.stdout)
[15:32:08.233]         ...future.stdout <- NULL
[15:32:08.233]     }
[15:32:08.233]     ...future.result$conditions <- ...future.conditions
[15:32:08.233]     ...future.result$finished <- base::Sys.time()
[15:32:08.233]     ...future.result
[15:32:08.233] }
[15:32:08.240] assign_globals() ...
[15:32:08.240] List of 5
[15:32:08.240]  $ ...future.FUN            :function (x, y)  
[15:32:08.240]  $ MoreArgs                 :List of 1
[15:32:08.240]   ..$ y: int [1:2] 3 4
[15:32:08.240]  $ ...future.elements_ii    :List of 1
[15:32:08.240]   ..$ x:List of 2
[15:32:08.240]   .. ..$ : int 1
[15:32:08.240]   .. ..$ : int 2
[15:32:08.240]  $ ...future.seeds_ii       : NULL
[15:32:08.240]  $ ...future.globals.maxSize: NULL
[15:32:08.240]  - attr(*, "where")=List of 5
[15:32:08.240]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.240]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.240]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.240]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.240]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.240]  - attr(*, "resolved")= logi FALSE
[15:32:08.240]  - attr(*, "total_size")= num 1872
[15:32:08.240]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.240]  - attr(*, "already-done")= logi TRUE
[15:32:08.258] - reassign environment for '...future.FUN'
[15:32:08.259] - copied '...future.FUN' to environment
[15:32:08.259] - copied 'MoreArgs' to environment
[15:32:08.259] - copied '...future.elements_ii' to environment
[15:32:08.260] - copied '...future.seeds_ii' to environment
[15:32:08.260] - copied '...future.globals.maxSize' to environment
[15:32:08.260] assign_globals() ... done
[15:32:08.261] plan(): Setting new future strategy stack:
[15:32:08.261] List of future strategies:
[15:32:08.261] 1. sequential:
[15:32:08.261]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.261]    - tweaked: FALSE
[15:32:08.261]    - call: NULL
[15:32:08.262] plan(): nbrOfWorkers() = 1
[15:32:08.265] plan(): Setting new future strategy stack:
[15:32:08.265] List of future strategies:
[15:32:08.265] 1. sequential:
[15:32:08.265]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.265]    - tweaked: FALSE
[15:32:08.265]    - call: plan(strategy)
[15:32:08.266] plan(): nbrOfWorkers() = 1
[15:32:08.267] SequentialFuture started (and completed)
[15:32:08.267] - Launch lazy future ... done
[15:32:08.267] run() for 'SequentialFuture' ... done
[15:32:08.268] Created future:
[15:32:08.268] SequentialFuture:
[15:32:08.268] Label: 'future_.mapply-1'
[15:32:08.268] Expression:
[15:32:08.268] {
[15:32:08.268]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.268]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.268]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.268]         on.exit(options(oopts), add = TRUE)
[15:32:08.268]     }
[15:32:08.268]     {
[15:32:08.268]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.268]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.268]         do.call(mapply, args = args)
[15:32:08.268]     }
[15:32:08.268] }
[15:32:08.268] Lazy evaluation: FALSE
[15:32:08.268] Asynchronous evaluation: FALSE
[15:32:08.268] Local evaluation: TRUE
[15:32:08.268] Environment: R_GlobalEnv
[15:32:08.268] Capture standard output: TRUE
[15:32:08.268] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.268] Globals: 5 objects totaling 1.83 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.268] Packages: <none>
[15:32:08.268] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.268] Resolved: TRUE
[15:32:08.268] Value: 112 bytes of class 'list'
[15:32:08.268] Early signaling: FALSE
[15:32:08.268] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.268] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.270] Chunk #1 of 1 ... DONE
[15:32:08.270] Launching 1 futures (chunks) ... DONE
[15:32:08.271] Resolving 1 futures (chunks) ...
[15:32:08.271] resolve() on list ...
[15:32:08.271]  recursive: 0
[15:32:08.272]  length: 1
[15:32:08.272] 
[15:32:08.272] resolved() for 'SequentialFuture' ...
[15:32:08.273] - state: 'finished'
[15:32:08.273] - run: TRUE
[15:32:08.273] - result: 'FutureResult'
[15:32:08.274] resolved() for 'SequentialFuture' ... done
[15:32:08.274] Future #1
[15:32:08.274] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.275] - nx: 1
[15:32:08.275] - relay: TRUE
[15:32:08.275] - stdout: TRUE
[15:32:08.276] - signal: TRUE
[15:32:08.276] - resignal: FALSE
[15:32:08.276] - force: TRUE
[15:32:08.276] - relayed: [n=1] FALSE
[15:32:08.277] - queued futures: [n=1] FALSE
[15:32:08.277]  - until=1
[15:32:08.277]  - relaying element #1
[15:32:08.278] - relayed: [n=1] TRUE
[15:32:08.278] - queued futures: [n=1] TRUE
[15:32:08.278] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.279]  length: 0 (resolved future 1)
[15:32:08.279] Relaying remaining futures
[15:32:08.279] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.279] - nx: 1
[15:32:08.280] - relay: TRUE
[15:32:08.280] - stdout: TRUE
[15:32:08.280] - signal: TRUE
[15:32:08.280] - resignal: FALSE
[15:32:08.281] - force: TRUE
[15:32:08.281] - relayed: [n=1] TRUE
[15:32:08.281] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.281] - relayed: [n=1] TRUE
[15:32:08.282] - queued futures: [n=1] TRUE
[15:32:08.282] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.282] resolve() on list ... DONE
[15:32:08.283]  - Number of value chunks collected: 1
[15:32:08.283] Resolving 1 futures (chunks) ... DONE
[15:32:08.283] Reducing values from 1 chunks ...
[15:32:08.284]  - Number of values collected after concatenation: 2
[15:32:08.284]  - Number of values expected: 2
[15:32:08.284] Reducing values from 1 chunks ... DONE
[15:32:08.285] future_mapply() ... DONE
- Recycle arguments to same length ...
[15:32:08.285] future_mapply() ...
[15:32:08.286] Number of chunks: 1
[15:32:08.286] getGlobalsAndPackagesXApply() ...
[15:32:08.286]  - future.globals: TRUE
[15:32:08.286] getGlobalsAndPackages() ...
[15:32:08.287] Searching for globals...
[15:32:08.288] - globals found: [1] 'FUN'
[15:32:08.288] Searching for globals ... DONE
[15:32:08.289] Resolving globals: FALSE
[15:32:08.289] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:08.290] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:08.290] - globals: [1] 'FUN'
[15:32:08.291] 
[15:32:08.291] getGlobalsAndPackages() ... DONE
[15:32:08.291]  - globals found/used: [n=1] 'FUN'
[15:32:08.291]  - needed namespaces: [n=0] 
[15:32:08.292] Finding globals ... DONE
[15:32:08.292] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.292] List of 2
[15:32:08.292]  $ ...future.FUN:function (x, ...)  
[15:32:08.292]  $ MoreArgs     : NULL
[15:32:08.292]  - attr(*, "where")=List of 2
[15:32:08.292]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.292]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.292]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.292]  - attr(*, "resolved")= logi FALSE
[15:32:08.292]  - attr(*, "total_size")= num NA
[15:32:08.302] Packages to be attached in all futures: [n=0] 
[15:32:08.303] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.303] Number of futures (= number of chunks): 1
[15:32:08.304] Launching 1 futures (chunks) ...
[15:32:08.304] Chunk #1 of 1 ...
[15:32:08.304]  - Finding globals in '...' for chunk #1 ...
[15:32:08.305] getGlobalsAndPackages() ...
[15:32:08.305] Searching for globals...
[15:32:08.306] 
[15:32:08.306] Searching for globals ... DONE
[15:32:08.307] - globals: [0] <none>
[15:32:08.307] getGlobalsAndPackages() ... DONE
[15:32:08.307]    + additional globals found: [n=0] 
[15:32:08.307]    + additional namespaces needed: [n=0] 
[15:32:08.308]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.308]  - seeds: <none>
[15:32:08.308]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.309] getGlobalsAndPackages() ...
[15:32:08.309] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.309] Resolving globals: FALSE
[15:32:08.310] The total size of the 5 globals is 504 bytes (504 bytes)
[15:32:08.311] 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 504 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (448 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:08.312] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.312] 
[15:32:08.312] getGlobalsAndPackages() ... DONE
[15:32:08.313] run() for 'Future' ...
[15:32:08.313] - state: 'created'
[15:32:08.314] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.314] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.315] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.315]   - Field: 'label'
[15:32:08.315]   - Field: 'local'
[15:32:08.315]   - Field: 'owner'
[15:32:08.316]   - Field: 'envir'
[15:32:08.316]   - Field: 'packages'
[15:32:08.316]   - Field: 'gc'
[15:32:08.317]   - Field: 'conditions'
[15:32:08.317]   - Field: 'expr'
[15:32:08.317]   - Field: 'uuid'
[15:32:08.318]   - Field: 'seed'
[15:32:08.318]   - Field: 'version'
[15:32:08.318]   - Field: 'result'
[15:32:08.318]   - Field: 'asynchronous'
[15:32:08.319]   - Field: 'calls'
[15:32:08.319]   - Field: 'globals'
[15:32:08.319]   - Field: 'stdout'
[15:32:08.320]   - Field: 'earlySignal'
[15:32:08.320]   - Field: 'lazy'
[15:32:08.320]   - Field: 'state'
[15:32:08.320] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.321] - Launch lazy future ...
[15:32:08.321] Packages needed by the future expression (n = 0): <none>
[15:32:08.322] Packages needed by future strategies (n = 0): <none>
[15:32:08.323] {
[15:32:08.323]     {
[15:32:08.323]         {
[15:32:08.323]             ...future.startTime <- base::Sys.time()
[15:32:08.323]             {
[15:32:08.323]                 {
[15:32:08.323]                   {
[15:32:08.323]                     base::local({
[15:32:08.323]                       has_future <- base::requireNamespace("future", 
[15:32:08.323]                         quietly = TRUE)
[15:32:08.323]                       if (has_future) {
[15:32:08.323]                         ns <- base::getNamespace("future")
[15:32:08.323]                         version <- ns[[".package"]][["version"]]
[15:32:08.323]                         if (is.null(version)) 
[15:32:08.323]                           version <- utils::packageVersion("future")
[15:32:08.323]                       }
[15:32:08.323]                       else {
[15:32:08.323]                         version <- NULL
[15:32:08.323]                       }
[15:32:08.323]                       if (!has_future || version < "1.8.0") {
[15:32:08.323]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.323]                           "", base::R.version$version.string), 
[15:32:08.323]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:08.323]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.323]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.323]                             "release", "version")], collapse = " "), 
[15:32:08.323]                           hostname = base::Sys.info()[["nodename"]])
[15:32:08.323]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.323]                           info)
[15:32:08.323]                         info <- base::paste(info, collapse = "; ")
[15:32:08.323]                         if (!has_future) {
[15:32:08.323]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.323]                             info)
[15:32:08.323]                         }
[15:32:08.323]                         else {
[15:32:08.323]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.323]                             info, version)
[15:32:08.323]                         }
[15:32:08.323]                         base::stop(msg)
[15:32:08.323]                       }
[15:32:08.323]                     })
[15:32:08.323]                   }
[15:32:08.323]                   ...future.strategy.old <- future::plan("list")
[15:32:08.323]                   options(future.plan = NULL)
[15:32:08.323]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.323]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.323]                 }
[15:32:08.323]                 ...future.workdir <- getwd()
[15:32:08.323]             }
[15:32:08.323]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.323]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.323]         }
[15:32:08.323]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.323]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.323]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.323]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.323]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.323]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.323]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.323]             base::names(...future.oldOptions))
[15:32:08.323]     }
[15:32:08.323]     if (FALSE) {
[15:32:08.323]     }
[15:32:08.323]     else {
[15:32:08.323]         if (TRUE) {
[15:32:08.323]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.323]                 open = "w")
[15:32:08.323]         }
[15:32:08.323]         else {
[15:32:08.323]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.323]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.323]         }
[15:32:08.323]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.323]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.323]             base::sink(type = "output", split = FALSE)
[15:32:08.323]             base::close(...future.stdout)
[15:32:08.323]         }, add = TRUE)
[15:32:08.323]     }
[15:32:08.323]     ...future.frame <- base::sys.nframe()
[15:32:08.323]     ...future.conditions <- base::list()
[15:32:08.323]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.323]     if (FALSE) {
[15:32:08.323]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.323]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.323]     }
[15:32:08.323]     ...future.result <- base::tryCatch({
[15:32:08.323]         base::withCallingHandlers({
[15:32:08.323]             ...future.value <- base::withVisible(base::local({
[15:32:08.323]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.323]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.323]                   ...future.globals.maxSize)) {
[15:32:08.323]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.323]                   on.exit(options(oopts), add = TRUE)
[15:32:08.323]                 }
[15:32:08.323]                 {
[15:32:08.323]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.323]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.323]                     USE.NAMES = FALSE)
[15:32:08.323]                   do.call(mapply, args = args)
[15:32:08.323]                 }
[15:32:08.323]             }))
[15:32:08.323]             future::FutureResult(value = ...future.value$value, 
[15:32:08.323]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.323]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.323]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.323]                     ...future.globalenv.names))
[15:32:08.323]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.323]         }, condition = base::local({
[15:32:08.323]             c <- base::c
[15:32:08.323]             inherits <- base::inherits
[15:32:08.323]             invokeRestart <- base::invokeRestart
[15:32:08.323]             length <- base::length
[15:32:08.323]             list <- base::list
[15:32:08.323]             seq.int <- base::seq.int
[15:32:08.323]             signalCondition <- base::signalCondition
[15:32:08.323]             sys.calls <- base::sys.calls
[15:32:08.323]             `[[` <- base::`[[`
[15:32:08.323]             `+` <- base::`+`
[15:32:08.323]             `<<-` <- base::`<<-`
[15:32:08.323]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.323]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.323]                   3L)]
[15:32:08.323]             }
[15:32:08.323]             function(cond) {
[15:32:08.323]                 is_error <- inherits(cond, "error")
[15:32:08.323]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.323]                   NULL)
[15:32:08.323]                 if (is_error) {
[15:32:08.323]                   sessionInformation <- function() {
[15:32:08.323]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.323]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.323]                       search = base::search(), system = base::Sys.info())
[15:32:08.323]                   }
[15:32:08.323]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.323]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.323]                     cond$call), session = sessionInformation(), 
[15:32:08.323]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.323]                   signalCondition(cond)
[15:32:08.323]                 }
[15:32:08.323]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.323]                 "immediateCondition"))) {
[15:32:08.323]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.323]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.323]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.323]                   if (TRUE && !signal) {
[15:32:08.323]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.323]                     {
[15:32:08.323]                       inherits <- base::inherits
[15:32:08.323]                       invokeRestart <- base::invokeRestart
[15:32:08.323]                       is.null <- base::is.null
[15:32:08.323]                       muffled <- FALSE
[15:32:08.323]                       if (inherits(cond, "message")) {
[15:32:08.323]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.323]                         if (muffled) 
[15:32:08.323]                           invokeRestart("muffleMessage")
[15:32:08.323]                       }
[15:32:08.323]                       else if (inherits(cond, "warning")) {
[15:32:08.323]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.323]                         if (muffled) 
[15:32:08.323]                           invokeRestart("muffleWarning")
[15:32:08.323]                       }
[15:32:08.323]                       else if (inherits(cond, "condition")) {
[15:32:08.323]                         if (!is.null(pattern)) {
[15:32:08.323]                           computeRestarts <- base::computeRestarts
[15:32:08.323]                           grepl <- base::grepl
[15:32:08.323]                           restarts <- computeRestarts(cond)
[15:32:08.323]                           for (restart in restarts) {
[15:32:08.323]                             name <- restart$name
[15:32:08.323]                             if (is.null(name)) 
[15:32:08.323]                               next
[15:32:08.323]                             if (!grepl(pattern, name)) 
[15:32:08.323]                               next
[15:32:08.323]                             invokeRestart(restart)
[15:32:08.323]                             muffled <- TRUE
[15:32:08.323]                             break
[15:32:08.323]                           }
[15:32:08.323]                         }
[15:32:08.323]                       }
[15:32:08.323]                       invisible(muffled)
[15:32:08.323]                     }
[15:32:08.323]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.323]                   }
[15:32:08.323]                 }
[15:32:08.323]                 else {
[15:32:08.323]                   if (TRUE) {
[15:32:08.323]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.323]                     {
[15:32:08.323]                       inherits <- base::inherits
[15:32:08.323]                       invokeRestart <- base::invokeRestart
[15:32:08.323]                       is.null <- base::is.null
[15:32:08.323]                       muffled <- FALSE
[15:32:08.323]                       if (inherits(cond, "message")) {
[15:32:08.323]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.323]                         if (muffled) 
[15:32:08.323]                           invokeRestart("muffleMessage")
[15:32:08.323]                       }
[15:32:08.323]                       else if (inherits(cond, "warning")) {
[15:32:08.323]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.323]                         if (muffled) 
[15:32:08.323]                           invokeRestart("muffleWarning")
[15:32:08.323]                       }
[15:32:08.323]                       else if (inherits(cond, "condition")) {
[15:32:08.323]                         if (!is.null(pattern)) {
[15:32:08.323]                           computeRestarts <- base::computeRestarts
[15:32:08.323]                           grepl <- base::grepl
[15:32:08.323]                           restarts <- computeRestarts(cond)
[15:32:08.323]                           for (restart in restarts) {
[15:32:08.323]                             name <- restart$name
[15:32:08.323]                             if (is.null(name)) 
[15:32:08.323]                               next
[15:32:08.323]                             if (!grepl(pattern, name)) 
[15:32:08.323]                               next
[15:32:08.323]                             invokeRestart(restart)
[15:32:08.323]                             muffled <- TRUE
[15:32:08.323]                             break
[15:32:08.323]                           }
[15:32:08.323]                         }
[15:32:08.323]                       }
[15:32:08.323]                       invisible(muffled)
[15:32:08.323]                     }
[15:32:08.323]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.323]                   }
[15:32:08.323]                 }
[15:32:08.323]             }
[15:32:08.323]         }))
[15:32:08.323]     }, error = function(ex) {
[15:32:08.323]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.323]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.323]                 ...future.rng), started = ...future.startTime, 
[15:32:08.323]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.323]             version = "1.8"), class = "FutureResult")
[15:32:08.323]     }, finally = {
[15:32:08.323]         if (!identical(...future.workdir, getwd())) 
[15:32:08.323]             setwd(...future.workdir)
[15:32:08.323]         {
[15:32:08.323]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.323]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.323]             }
[15:32:08.323]             base::options(...future.oldOptions)
[15:32:08.323]             if (.Platform$OS.type == "windows") {
[15:32:08.323]                 old_names <- names(...future.oldEnvVars)
[15:32:08.323]                 envs <- base::Sys.getenv()
[15:32:08.323]                 names <- names(envs)
[15:32:08.323]                 common <- intersect(names, old_names)
[15:32:08.323]                 added <- setdiff(names, old_names)
[15:32:08.323]                 removed <- setdiff(old_names, names)
[15:32:08.323]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.323]                   envs[common]]
[15:32:08.323]                 NAMES <- toupper(changed)
[15:32:08.323]                 args <- list()
[15:32:08.323]                 for (kk in seq_along(NAMES)) {
[15:32:08.323]                   name <- changed[[kk]]
[15:32:08.323]                   NAME <- NAMES[[kk]]
[15:32:08.323]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.323]                     next
[15:32:08.323]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.323]                 }
[15:32:08.323]                 NAMES <- toupper(added)
[15:32:08.323]                 for (kk in seq_along(NAMES)) {
[15:32:08.323]                   name <- added[[kk]]
[15:32:08.323]                   NAME <- NAMES[[kk]]
[15:32:08.323]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.323]                     next
[15:32:08.323]                   args[[name]] <- ""
[15:32:08.323]                 }
[15:32:08.323]                 NAMES <- toupper(removed)
[15:32:08.323]                 for (kk in seq_along(NAMES)) {
[15:32:08.323]                   name <- removed[[kk]]
[15:32:08.323]                   NAME <- NAMES[[kk]]
[15:32:08.323]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.323]                     next
[15:32:08.323]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.323]                 }
[15:32:08.323]                 if (length(args) > 0) 
[15:32:08.323]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.323]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.323]             }
[15:32:08.323]             else {
[15:32:08.323]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.323]             }
[15:32:08.323]             {
[15:32:08.323]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.323]                   0L) {
[15:32:08.323]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.323]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.323]                   base::options(opts)
[15:32:08.323]                 }
[15:32:08.323]                 {
[15:32:08.323]                   {
[15:32:08.323]                     base::assign(".Random.seed", c(10407L, 511393082L, 
[15:32:08.323]                     -1854767632L, 240297729L, -253660479L, 602526664L, 
[15:32:08.323]                     344058409L), envir = base::globalenv(), inherits = FALSE)
[15:32:08.323]                     NULL
[15:32:08.323]                   }
[15:32:08.323]                   options(future.plan = NULL)
[15:32:08.323]                   if (is.na(NA_character_)) 
[15:32:08.323]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.323]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.323]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.323]                     .init = FALSE)
[15:32:08.323]                 }
[15:32:08.323]             }
[15:32:08.323]         }
[15:32:08.323]     })
[15:32:08.323]     if (TRUE) {
[15:32:08.323]         base::sink(type = "output", split = FALSE)
[15:32:08.323]         if (TRUE) {
[15:32:08.323]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.323]         }
[15:32:08.323]         else {
[15:32:08.323]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.323]         }
[15:32:08.323]         base::close(...future.stdout)
[15:32:08.323]         ...future.stdout <- NULL
[15:32:08.323]     }
[15:32:08.323]     ...future.result$conditions <- ...future.conditions
[15:32:08.323]     ...future.result$finished <- base::Sys.time()
[15:32:08.323]     ...future.result
[15:32:08.323] }
[15:32:08.329] assign_globals() ...
[15:32:08.330] List of 5
[15:32:08.330]  $ ...future.FUN            :function (x, ...)  
[15:32:08.330]  $ MoreArgs                 : NULL
[15:32:08.330]  $ ...future.elements_ii    :List of 2
[15:32:08.330]   ..$ :List of 4
[15:32:08.330]   .. ..$ : int 1
[15:32:08.330]   .. ..$ : int 2
[15:32:08.330]   .. ..$ : int 3
[15:32:08.330]   .. ..$ : int 4
[15:32:08.330]   ..$ :List of 4
[15:32:08.330]   .. ..$ : int 2
[15:32:08.330]   .. ..$ : int 1
[15:32:08.330]   .. ..$ : int 2
[15:32:08.330]   .. ..$ : int 1
[15:32:08.330]  $ ...future.seeds_ii       : NULL
[15:32:08.330]  $ ...future.globals.maxSize: NULL
[15:32:08.330]  - attr(*, "where")=List of 5
[15:32:08.330]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.330]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.330]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.330]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.330]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.330]  - attr(*, "resolved")= logi FALSE
[15:32:08.330]  - attr(*, "total_size")= num 504
[15:32:08.330]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.330]  - attr(*, "already-done")= logi TRUE
[15:32:08.351] - copied '...future.FUN' to environment
[15:32:08.351] - copied 'MoreArgs' to environment
[15:32:08.352] - copied '...future.elements_ii' to environment
[15:32:08.352] - copied '...future.seeds_ii' to environment
[15:32:08.353] - copied '...future.globals.maxSize' to environment
[15:32:08.353] assign_globals() ... done
[15:32:08.354] plan(): Setting new future strategy stack:
[15:32:08.354] List of future strategies:
[15:32:08.354] 1. sequential:
[15:32:08.354]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.354]    - tweaked: FALSE
[15:32:08.354]    - call: NULL
[15:32:08.356] plan(): nbrOfWorkers() = 1
[15:32:08.359] plan(): Setting new future strategy stack:
[15:32:08.360] List of future strategies:
[15:32:08.360] 1. sequential:
[15:32:08.360]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.360]    - tweaked: FALSE
[15:32:08.360]    - call: plan(strategy)
[15:32:08.361] plan(): nbrOfWorkers() = 1
[15:32:08.362] SequentialFuture started (and completed)
[15:32:08.362] - Launch lazy future ... done
[15:32:08.363] run() for 'SequentialFuture' ... done
[15:32:08.363] Created future:
[15:32:08.363] SequentialFuture:
[15:32:08.363] Label: 'future_mapply-1'
[15:32:08.363] Expression:
[15:32:08.363] {
[15:32:08.363]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.363]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.363]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.363]         on.exit(options(oopts), add = TRUE)
[15:32:08.363]     }
[15:32:08.363]     {
[15:32:08.363]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.363]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.363]         do.call(mapply, args = args)
[15:32:08.363]     }
[15:32:08.363] }
[15:32:08.363] Lazy evaluation: FALSE
[15:32:08.363] Asynchronous evaluation: FALSE
[15:32:08.363] Local evaluation: TRUE
[15:32:08.363] Environment: R_GlobalEnv
[15:32:08.363] Capture standard output: TRUE
[15:32:08.363] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.363] Globals: 5 objects totaling 504 bytes (function '...future.FUN' of 56 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 448 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.363] Packages: <none>
[15:32:08.363] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.363] Resolved: TRUE
[15:32:08.363] Value: 224 bytes of class 'list'
[15:32:08.363] Early signaling: FALSE
[15:32:08.363] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.363] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.366] Chunk #1 of 1 ... DONE
[15:32:08.367] Launching 1 futures (chunks) ... DONE
[15:32:08.367] Resolving 1 futures (chunks) ...
[15:32:08.367] resolve() on list ...
[15:32:08.368]  recursive: 0
[15:32:08.368]  length: 1
[15:32:08.368] 
[15:32:08.369] resolved() for 'SequentialFuture' ...
[15:32:08.369] - state: 'finished'
[15:32:08.370] - run: TRUE
[15:32:08.370] - result: 'FutureResult'
[15:32:08.370] resolved() for 'SequentialFuture' ... done
[15:32:08.371] Future #1
[15:32:08.371] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.372] - nx: 1
[15:32:08.372] - relay: TRUE
[15:32:08.372] - stdout: TRUE
[15:32:08.372] - signal: TRUE
[15:32:08.373] - resignal: FALSE
[15:32:08.373] - force: TRUE
[15:32:08.373] - relayed: [n=1] FALSE
[15:32:08.374] - queued futures: [n=1] FALSE
[15:32:08.374]  - until=1
[15:32:08.374]  - relaying element #1
[15:32:08.375] - relayed: [n=1] TRUE
[15:32:08.375] - queued futures: [n=1] TRUE
[15:32:08.376] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.376]  length: 0 (resolved future 1)
[15:32:08.376] Relaying remaining futures
[15:32:08.377] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.377] - nx: 1
[15:32:08.377] - relay: TRUE
[15:32:08.378] - stdout: TRUE
[15:32:08.378] - signal: TRUE
[15:32:08.378] - resignal: FALSE
[15:32:08.378] - force: TRUE
[15:32:08.379] - relayed: [n=1] TRUE
[15:32:08.379] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.380] - relayed: [n=1] TRUE
[15:32:08.380] - queued futures: [n=1] TRUE
[15:32:08.380] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.380] resolve() on list ... DONE
[15:32:08.381]  - Number of value chunks collected: 1
[15:32:08.381] Resolving 1 futures (chunks) ... DONE
[15:32:08.382] Reducing values from 1 chunks ...
[15:32:08.382]  - Number of values collected after concatenation: 4
[15:32:08.382]  - Number of values expected: 4
[15:32:08.382] Reducing values from 1 chunks ... DONE
[15:32:08.383] future_mapply() ... DONE
- Parallel RNG ...
[15:32:08.383] future_mapply() ...
[15:32:08.384] Generating random seeds ...
[15:32:08.384] Generating random seed streams for 4 elements ...
[15:32:08.384] Generating random seed streams for 4 elements ... DONE
[15:32:08.385] Generating random seeds ... DONE
[15:32:08.385] Will set RNG state on exit: 10407, 240297729, -691905564, -1427421038, 344058409, -639596089, 1295586807
[15:32:08.386] Number of chunks: 1
[15:32:08.386] getGlobalsAndPackagesXApply() ...
[15:32:08.386]  - future.globals: TRUE
[15:32:08.386] getGlobalsAndPackages() ...
[15:32:08.387] Searching for globals...
[15:32:08.390] - globals found: [3] 'FUN', '.Call', 'C_runif'
[15:32:08.391] Searching for globals ... DONE
[15:32:08.391] Resolving globals: FALSE
[15:32:08.392] The total size of the 1 globals is 2.04 KiB (2088 bytes)
[15:32:08.393] The total size of the 1 globals exported for future expression ('FUN(min = 1)') is 2.04 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (2.04 KiB of class 'function')
[15:32:08.394] - globals: [1] 'FUN'
[15:32:08.394] - packages: [1] 'stats'
[15:32:08.395] getGlobalsAndPackages() ... DONE
[15:32:08.395]  - globals found/used: [n=1] 'FUN'
[15:32:08.395]  - needed namespaces: [n=1] 'stats'
[15:32:08.395] Finding globals ... DONE
[15:32:08.396] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.396] List of 2
[15:32:08.396]  $ ...future.FUN:function (n, min = 0, max = 1)  
[15:32:08.396]  $ MoreArgs     :List of 1
[15:32:08.396]   ..$ min: num 1
[15:32:08.396]  - attr(*, "where")=List of 2
[15:32:08.396]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.396]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.396]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.396]  - attr(*, "resolved")= logi FALSE
[15:32:08.396]  - attr(*, "total_size")= num NA
[15:32:08.408] Packages to be attached in all futures: [n=1] 'stats'
[15:32:08.409] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.409] Number of futures (= number of chunks): 1
[15:32:08.410] Launching 1 futures (chunks) ...
[15:32:08.410] Chunk #1 of 1 ...
[15:32:08.411]  - Finding globals in '...' for chunk #1 ...
[15:32:08.411] getGlobalsAndPackages() ...
[15:32:08.411] Searching for globals...
[15:32:08.412] 
[15:32:08.413] Searching for globals ... DONE
[15:32:08.413] - globals: [0] <none>
[15:32:08.413] getGlobalsAndPackages() ... DONE
[15:32:08.414]    + additional globals found: [n=0] 
[15:32:08.414]    + additional namespaces needed: [n=0] 
[15:32:08.414]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.415]  - seeds: [4] <seeds>
[15:32:08.415]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.415] getGlobalsAndPackages() ...
[15:32:08.416] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.416] Resolving globals: FALSE
[15:32:08.418] The total size of the 5 globals is 2.84 KiB (2912 bytes)
[15:32:08.419] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 2.84 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (2.04 KiB of class 'function'), '...future.elements_ii' (448 bytes of class 'list') and '...future.seeds_ii' (320 bytes of class 'list')
[15:32:08.420] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.420] - packages: [1] 'stats'
[15:32:08.421] getGlobalsAndPackages() ... DONE
[15:32:08.421] run() for 'Future' ...
[15:32:08.422] - state: 'created'
[15:32:08.422] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.423] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.423] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.424]   - Field: 'label'
[15:32:08.424]   - Field: 'local'
[15:32:08.425]   - Field: 'owner'
[15:32:08.425]   - Field: 'envir'
[15:32:08.425]   - Field: 'packages'
[15:32:08.426]   - Field: 'gc'
[15:32:08.426]   - Field: 'conditions'
[15:32:08.426]   - Field: 'expr'
[15:32:08.427]   - Field: 'uuid'
[15:32:08.427]   - Field: 'seed'
[15:32:08.428]   - Field: 'version'
[15:32:08.428]   - Field: 'result'
[15:32:08.428]   - Field: 'asynchronous'
[15:32:08.429]   - Field: 'calls'
[15:32:08.429]   - Field: 'globals'
[15:32:08.429]   - Field: 'stdout'
[15:32:08.430]   - Field: 'earlySignal'
[15:32:08.430]   - Field: 'lazy'
[15:32:08.431]   - Field: 'state'
[15:32:08.431] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.431] - Launch lazy future ...
[15:32:08.432] Packages needed by the future expression (n = 1): 'stats'
[15:32:08.432] Packages needed by future strategies (n = 0): <none>
[15:32:08.434] {
[15:32:08.434]     {
[15:32:08.434]         {
[15:32:08.434]             ...future.startTime <- base::Sys.time()
[15:32:08.434]             {
[15:32:08.434]                 {
[15:32:08.434]                   {
[15:32:08.434]                     {
[15:32:08.434]                       base::local({
[15:32:08.434]                         has_future <- base::requireNamespace("future", 
[15:32:08.434]                           quietly = TRUE)
[15:32:08.434]                         if (has_future) {
[15:32:08.434]                           ns <- base::getNamespace("future")
[15:32:08.434]                           version <- ns[[".package"]][["version"]]
[15:32:08.434]                           if (is.null(version)) 
[15:32:08.434]                             version <- utils::packageVersion("future")
[15:32:08.434]                         }
[15:32:08.434]                         else {
[15:32:08.434]                           version <- NULL
[15:32:08.434]                         }
[15:32:08.434]                         if (!has_future || version < "1.8.0") {
[15:32:08.434]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.434]                             "", base::R.version$version.string), 
[15:32:08.434]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:08.434]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.434]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.434]                               "release", "version")], collapse = " "), 
[15:32:08.434]                             hostname = base::Sys.info()[["nodename"]])
[15:32:08.434]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.434]                             info)
[15:32:08.434]                           info <- base::paste(info, collapse = "; ")
[15:32:08.434]                           if (!has_future) {
[15:32:08.434]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.434]                               info)
[15:32:08.434]                           }
[15:32:08.434]                           else {
[15:32:08.434]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.434]                               info, version)
[15:32:08.434]                           }
[15:32:08.434]                           base::stop(msg)
[15:32:08.434]                         }
[15:32:08.434]                       })
[15:32:08.434]                     }
[15:32:08.434]                     base::local({
[15:32:08.434]                       for (pkg in "stats") {
[15:32:08.434]                         base::loadNamespace(pkg)
[15:32:08.434]                         base::library(pkg, character.only = TRUE)
[15:32:08.434]                       }
[15:32:08.434]                     })
[15:32:08.434]                   }
[15:32:08.434]                   ...future.strategy.old <- future::plan("list")
[15:32:08.434]                   options(future.plan = NULL)
[15:32:08.434]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.434]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.434]                 }
[15:32:08.434]                 ...future.workdir <- getwd()
[15:32:08.434]             }
[15:32:08.434]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.434]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.434]         }
[15:32:08.434]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.434]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.434]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.434]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.434]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.434]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.434]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.434]             base::names(...future.oldOptions))
[15:32:08.434]     }
[15:32:08.434]     if (FALSE) {
[15:32:08.434]     }
[15:32:08.434]     else {
[15:32:08.434]         if (TRUE) {
[15:32:08.434]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.434]                 open = "w")
[15:32:08.434]         }
[15:32:08.434]         else {
[15:32:08.434]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.434]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.434]         }
[15:32:08.434]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.434]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.434]             base::sink(type = "output", split = FALSE)
[15:32:08.434]             base::close(...future.stdout)
[15:32:08.434]         }, add = TRUE)
[15:32:08.434]     }
[15:32:08.434]     ...future.frame <- base::sys.nframe()
[15:32:08.434]     ...future.conditions <- base::list()
[15:32:08.434]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.434]     if (FALSE) {
[15:32:08.434]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.434]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.434]     }
[15:32:08.434]     ...future.result <- base::tryCatch({
[15:32:08.434]         base::withCallingHandlers({
[15:32:08.434]             ...future.value <- base::withVisible(base::local({
[15:32:08.434]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.434]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.434]                   ...future.globals.maxSize)) {
[15:32:08.434]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.434]                   on.exit(options(oopts), add = TRUE)
[15:32:08.434]                 }
[15:32:08.434]                 {
[15:32:08.434]                   ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:08.434]                     assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:08.434]                       envir = globalenv(), inherits = FALSE)
[15:32:08.434]                     ...future.FUN(...)
[15:32:08.434]                   }
[15:32:08.434]                   args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:08.434]                     list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:08.434]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.434]                     USE.NAMES = FALSE)
[15:32:08.434]                   do.call(mapply, args = args)
[15:32:08.434]                 }
[15:32:08.434]             }))
[15:32:08.434]             future::FutureResult(value = ...future.value$value, 
[15:32:08.434]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.434]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.434]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.434]                     ...future.globalenv.names))
[15:32:08.434]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.434]         }, condition = base::local({
[15:32:08.434]             c <- base::c
[15:32:08.434]             inherits <- base::inherits
[15:32:08.434]             invokeRestart <- base::invokeRestart
[15:32:08.434]             length <- base::length
[15:32:08.434]             list <- base::list
[15:32:08.434]             seq.int <- base::seq.int
[15:32:08.434]             signalCondition <- base::signalCondition
[15:32:08.434]             sys.calls <- base::sys.calls
[15:32:08.434]             `[[` <- base::`[[`
[15:32:08.434]             `+` <- base::`+`
[15:32:08.434]             `<<-` <- base::`<<-`
[15:32:08.434]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.434]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.434]                   3L)]
[15:32:08.434]             }
[15:32:08.434]             function(cond) {
[15:32:08.434]                 is_error <- inherits(cond, "error")
[15:32:08.434]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.434]                   NULL)
[15:32:08.434]                 if (is_error) {
[15:32:08.434]                   sessionInformation <- function() {
[15:32:08.434]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.434]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.434]                       search = base::search(), system = base::Sys.info())
[15:32:08.434]                   }
[15:32:08.434]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.434]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.434]                     cond$call), session = sessionInformation(), 
[15:32:08.434]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.434]                   signalCondition(cond)
[15:32:08.434]                 }
[15:32:08.434]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.434]                 "immediateCondition"))) {
[15:32:08.434]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.434]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.434]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.434]                   if (TRUE && !signal) {
[15:32:08.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.434]                     {
[15:32:08.434]                       inherits <- base::inherits
[15:32:08.434]                       invokeRestart <- base::invokeRestart
[15:32:08.434]                       is.null <- base::is.null
[15:32:08.434]                       muffled <- FALSE
[15:32:08.434]                       if (inherits(cond, "message")) {
[15:32:08.434]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.434]                         if (muffled) 
[15:32:08.434]                           invokeRestart("muffleMessage")
[15:32:08.434]                       }
[15:32:08.434]                       else if (inherits(cond, "warning")) {
[15:32:08.434]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.434]                         if (muffled) 
[15:32:08.434]                           invokeRestart("muffleWarning")
[15:32:08.434]                       }
[15:32:08.434]                       else if (inherits(cond, "condition")) {
[15:32:08.434]                         if (!is.null(pattern)) {
[15:32:08.434]                           computeRestarts <- base::computeRestarts
[15:32:08.434]                           grepl <- base::grepl
[15:32:08.434]                           restarts <- computeRestarts(cond)
[15:32:08.434]                           for (restart in restarts) {
[15:32:08.434]                             name <- restart$name
[15:32:08.434]                             if (is.null(name)) 
[15:32:08.434]                               next
[15:32:08.434]                             if (!grepl(pattern, name)) 
[15:32:08.434]                               next
[15:32:08.434]                             invokeRestart(restart)
[15:32:08.434]                             muffled <- TRUE
[15:32:08.434]                             break
[15:32:08.434]                           }
[15:32:08.434]                         }
[15:32:08.434]                       }
[15:32:08.434]                       invisible(muffled)
[15:32:08.434]                     }
[15:32:08.434]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.434]                   }
[15:32:08.434]                 }
[15:32:08.434]                 else {
[15:32:08.434]                   if (TRUE) {
[15:32:08.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.434]                     {
[15:32:08.434]                       inherits <- base::inherits
[15:32:08.434]                       invokeRestart <- base::invokeRestart
[15:32:08.434]                       is.null <- base::is.null
[15:32:08.434]                       muffled <- FALSE
[15:32:08.434]                       if (inherits(cond, "message")) {
[15:32:08.434]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.434]                         if (muffled) 
[15:32:08.434]                           invokeRestart("muffleMessage")
[15:32:08.434]                       }
[15:32:08.434]                       else if (inherits(cond, "warning")) {
[15:32:08.434]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.434]                         if (muffled) 
[15:32:08.434]                           invokeRestart("muffleWarning")
[15:32:08.434]                       }
[15:32:08.434]                       else if (inherits(cond, "condition")) {
[15:32:08.434]                         if (!is.null(pattern)) {
[15:32:08.434]                           computeRestarts <- base::computeRestarts
[15:32:08.434]                           grepl <- base::grepl
[15:32:08.434]                           restarts <- computeRestarts(cond)
[15:32:08.434]                           for (restart in restarts) {
[15:32:08.434]                             name <- restart$name
[15:32:08.434]                             if (is.null(name)) 
[15:32:08.434]                               next
[15:32:08.434]                             if (!grepl(pattern, name)) 
[15:32:08.434]                               next
[15:32:08.434]                             invokeRestart(restart)
[15:32:08.434]                             muffled <- TRUE
[15:32:08.434]                             break
[15:32:08.434]                           }
[15:32:08.434]                         }
[15:32:08.434]                       }
[15:32:08.434]                       invisible(muffled)
[15:32:08.434]                     }
[15:32:08.434]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.434]                   }
[15:32:08.434]                 }
[15:32:08.434]             }
[15:32:08.434]         }))
[15:32:08.434]     }, error = function(ex) {
[15:32:08.434]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.434]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.434]                 ...future.rng), started = ...future.startTime, 
[15:32:08.434]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.434]             version = "1.8"), class = "FutureResult")
[15:32:08.434]     }, finally = {
[15:32:08.434]         if (!identical(...future.workdir, getwd())) 
[15:32:08.434]             setwd(...future.workdir)
[15:32:08.434]         {
[15:32:08.434]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.434]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.434]             }
[15:32:08.434]             base::options(...future.oldOptions)
[15:32:08.434]             if (.Platform$OS.type == "windows") {
[15:32:08.434]                 old_names <- names(...future.oldEnvVars)
[15:32:08.434]                 envs <- base::Sys.getenv()
[15:32:08.434]                 names <- names(envs)
[15:32:08.434]                 common <- intersect(names, old_names)
[15:32:08.434]                 added <- setdiff(names, old_names)
[15:32:08.434]                 removed <- setdiff(old_names, names)
[15:32:08.434]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.434]                   envs[common]]
[15:32:08.434]                 NAMES <- toupper(changed)
[15:32:08.434]                 args <- list()
[15:32:08.434]                 for (kk in seq_along(NAMES)) {
[15:32:08.434]                   name <- changed[[kk]]
[15:32:08.434]                   NAME <- NAMES[[kk]]
[15:32:08.434]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.434]                     next
[15:32:08.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.434]                 }
[15:32:08.434]                 NAMES <- toupper(added)
[15:32:08.434]                 for (kk in seq_along(NAMES)) {
[15:32:08.434]                   name <- added[[kk]]
[15:32:08.434]                   NAME <- NAMES[[kk]]
[15:32:08.434]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.434]                     next
[15:32:08.434]                   args[[name]] <- ""
[15:32:08.434]                 }
[15:32:08.434]                 NAMES <- toupper(removed)
[15:32:08.434]                 for (kk in seq_along(NAMES)) {
[15:32:08.434]                   name <- removed[[kk]]
[15:32:08.434]                   NAME <- NAMES[[kk]]
[15:32:08.434]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.434]                     next
[15:32:08.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.434]                 }
[15:32:08.434]                 if (length(args) > 0) 
[15:32:08.434]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.434]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.434]             }
[15:32:08.434]             else {
[15:32:08.434]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.434]             }
[15:32:08.434]             {
[15:32:08.434]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.434]                   0L) {
[15:32:08.434]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.434]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.434]                   base::options(opts)
[15:32:08.434]                 }
[15:32:08.434]                 {
[15:32:08.434]                   {
[15:32:08.434]                     base::assign(".Random.seed", c(10407L, 240297729L, 
[15:32:08.434]                     -691905564L, -1427421038L, 344058409L, -639596089L, 
[15:32:08.434]                     1295586807L), envir = base::globalenv(), 
[15:32:08.434]                       inherits = FALSE)
[15:32:08.434]                     NULL
[15:32:08.434]                   }
[15:32:08.434]                   options(future.plan = NULL)
[15:32:08.434]                   if (is.na(NA_character_)) 
[15:32:08.434]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.434]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.434]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.434]                     .init = FALSE)
[15:32:08.434]                 }
[15:32:08.434]             }
[15:32:08.434]         }
[15:32:08.434]     })
[15:32:08.434]     if (TRUE) {
[15:32:08.434]         base::sink(type = "output", split = FALSE)
[15:32:08.434]         if (TRUE) {
[15:32:08.434]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.434]         }
[15:32:08.434]         else {
[15:32:08.434]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.434]         }
[15:32:08.434]         base::close(...future.stdout)
[15:32:08.434]         ...future.stdout <- NULL
[15:32:08.434]     }
[15:32:08.434]     ...future.result$conditions <- ...future.conditions
[15:32:08.434]     ...future.result$finished <- base::Sys.time()
[15:32:08.434]     ...future.result
[15:32:08.434] }
[15:32:08.443] assign_globals() ...
[15:32:08.443] List of 5
[15:32:08.443]  $ ...future.FUN            :function (n, min = 0, max = 1)  
[15:32:08.443]  $ MoreArgs                 :List of 1
[15:32:08.443]   ..$ min: num 1
[15:32:08.443]  $ ...future.elements_ii    :List of 2
[15:32:08.443]   ..$ n  :List of 4
[15:32:08.443]   .. ..$ : int 1
[15:32:08.443]   .. ..$ : int 2
[15:32:08.443]   .. ..$ : int 3
[15:32:08.443]   .. ..$ : int 4
[15:32:08.443]   ..$ max:List of 4
[15:32:08.443]   .. ..$ : int 2
[15:32:08.443]   .. ..$ : int 3
[15:32:08.443]   .. ..$ : int 4
[15:32:08.443]   .. ..$ : int 5
[15:32:08.443]  $ ...future.seeds_ii       :List of 4
[15:32:08.443]   ..$ : int [1:7] 10407 1242173061 -1150840343 -834448425 701050094 -1369558043 -650964284
[15:32:08.443]   ..$ : int [1:7] 10407 859061261 1088872332 -1371790091 -942478768 -889560561 1393381402
[15:32:08.443]   ..$ : int [1:7] 10407 -1977952646 362645338 -1927542548 -742448269 -2030870718 1472975712
[15:32:08.443]   ..$ : int [1:7] 10407 -781199300 -1470244364 -1435938985 -1154922760 795337516 2089908040
[15:32:08.443]  $ ...future.globals.maxSize: NULL
[15:32:08.443]  - attr(*, "where")=List of 5
[15:32:08.443]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.443]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.443]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.443]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.443]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.443]  - attr(*, "resolved")= logi FALSE
[15:32:08.443]  - attr(*, "total_size")= num 2912
[15:32:08.443]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.443]  - attr(*, "already-done")= logi TRUE
[15:32:08.469] - copied '...future.FUN' to environment
[15:32:08.470] - copied 'MoreArgs' to environment
[15:32:08.470] - copied '...future.elements_ii' to environment
[15:32:08.470] - copied '...future.seeds_ii' to environment
[15:32:08.471] - copied '...future.globals.maxSize' to environment
[15:32:08.471] assign_globals() ... done
[15:32:08.472] plan(): Setting new future strategy stack:
[15:32:08.472] List of future strategies:
[15:32:08.472] 1. sequential:
[15:32:08.472]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.472]    - tweaked: FALSE
[15:32:08.472]    - call: NULL
[15:32:08.474] plan(): nbrOfWorkers() = 1
[15:32:08.476] plan(): Setting new future strategy stack:
[15:32:08.476] List of future strategies:
[15:32:08.476] 1. sequential:
[15:32:08.476]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.476]    - tweaked: FALSE
[15:32:08.476]    - call: plan(strategy)
[15:32:08.477] plan(): nbrOfWorkers() = 1
[15:32:08.478] SequentialFuture started (and completed)
[15:32:08.478] - Launch lazy future ... done
[15:32:08.478] run() for 'SequentialFuture' ... done
[15:32:08.479] Created future:
[15:32:08.479] SequentialFuture:
[15:32:08.479] Label: 'future_mapply-1'
[15:32:08.479] Expression:
[15:32:08.479] {
[15:32:08.479]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.479]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.479]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.479]         on.exit(options(oopts), add = TRUE)
[15:32:08.479]     }
[15:32:08.479]     {
[15:32:08.479]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:08.479]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:08.479]                 inherits = FALSE)
[15:32:08.479]             ...future.FUN(...)
[15:32:08.479]         }
[15:32:08.479]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:08.479]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:08.479]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.479]         do.call(mapply, args = args)
[15:32:08.479]     }
[15:32:08.479] }
[15:32:08.479] Lazy evaluation: FALSE
[15:32:08.479] Asynchronous evaluation: FALSE
[15:32:08.479] Local evaluation: TRUE
[15:32:08.479] Environment: R_GlobalEnv
[15:32:08.479] Capture standard output: TRUE
[15:32:08.479] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.479] Globals: 5 objects totaling 2.84 KiB (function '...future.FUN' of 2.04 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 448 bytes, list '...future.seeds_ii' of 320 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.479] Packages: 1 packages ('stats')
[15:32:08.479] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:08.479] Resolved: TRUE
[15:32:08.479] Value: 280 bytes of class 'list'
[15:32:08.479] Early signaling: FALSE
[15:32:08.479] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.479] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.481] Chunk #1 of 1 ... DONE
[15:32:08.482] Launching 1 futures (chunks) ... DONE
[15:32:08.482] Resolving 1 futures (chunks) ...
[15:32:08.482] resolve() on list ...
[15:32:08.482]  recursive: 0
[15:32:08.483]  length: 1
[15:32:08.483] 
[15:32:08.483] resolved() for 'SequentialFuture' ...
[15:32:08.484] - state: 'finished'
[15:32:08.484] - run: TRUE
[15:32:08.484] - result: 'FutureResult'
[15:32:08.485] resolved() for 'SequentialFuture' ... done
[15:32:08.485] Future #1
[15:32:08.485] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.486] - nx: 1
[15:32:08.486] - relay: TRUE
[15:32:08.486] - stdout: TRUE
[15:32:08.486] - signal: TRUE
[15:32:08.487] - resignal: FALSE
[15:32:08.487] - force: TRUE
[15:32:08.487] - relayed: [n=1] FALSE
[15:32:08.487] - queued futures: [n=1] FALSE
[15:32:08.488]  - until=1
[15:32:08.488]  - relaying element #1
[15:32:08.488] - relayed: [n=1] TRUE
[15:32:08.489] - queued futures: [n=1] TRUE
[15:32:08.489] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.489]  length: 0 (resolved future 1)
[15:32:08.490] Relaying remaining futures
[15:32:08.490] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.490] - nx: 1
[15:32:08.490] - relay: TRUE
[15:32:08.491] - stdout: TRUE
[15:32:08.491] - signal: TRUE
[15:32:08.491] - resignal: FALSE
[15:32:08.491] - force: TRUE
[15:32:08.492] - relayed: [n=1] TRUE
[15:32:08.492] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.492] - relayed: [n=1] TRUE
[15:32:08.493] - queued futures: [n=1] TRUE
[15:32:08.493] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.493] resolve() on list ... DONE
[15:32:08.494]  - Number of value chunks collected: 1
[15:32:08.494] Resolving 1 futures (chunks) ... DONE
[15:32:08.494] Reducing values from 1 chunks ...
[15:32:08.494]  - Number of values collected after concatenation: 4
[15:32:08.495]  - Number of values expected: 4
[15:32:08.495] Reducing values from 1 chunks ... DONE
[15:32:08.495] future_mapply() ... DONE
[[1]]
[1] 1.752502

[[2]]
[1] 2.765950 2.044156

[[3]]
[1] 1.419503 3.529684 1.023802

[[4]]
[1] 4.494280 3.546145 1.402837 4.295444

- future_Map() ...
[15:32:08.500] future_mapply() ...
[15:32:08.501] Number of chunks: 1
[15:32:08.501] getGlobalsAndPackagesXApply() ...
[15:32:08.501]  - future.globals: TRUE
[15:32:08.502] getGlobalsAndPackages() ...
[15:32:08.502] Searching for globals...
[15:32:08.504] - globals found: [2] 'FUN', 'UseMethod'
[15:32:08.505] Searching for globals ... DONE
[15:32:08.505] Resolving globals: FALSE
[15:32:08.506] The total size of the 1 globals is 1.38 KiB (1416 bytes)
[15:32:08.507] The total size of the 1 globals exported for future expression ('FUN()') is 1.38 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.38 KiB of class 'function')
[15:32:08.507] - globals: [1] 'FUN'
[15:32:08.507] - packages: [1] 'stats'
[15:32:08.508] getGlobalsAndPackages() ... DONE
[15:32:08.508]  - globals found/used: [n=1] 'FUN'
[15:32:08.508]  - needed namespaces: [n=1] 'stats'
[15:32:08.509] Finding globals ... DONE
[15:32:08.509] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.509] List of 2
[15:32:08.509]  $ ...future.FUN:function (x, w, ...)  
[15:32:08.509]  $ MoreArgs     : NULL
[15:32:08.509]  - attr(*, "where")=List of 2
[15:32:08.509]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.509]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.509]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.509]  - attr(*, "resolved")= logi FALSE
[15:32:08.509]  - attr(*, "total_size")= num NA
[15:32:08.520] Packages to be attached in all futures: [n=1] 'stats'
[15:32:08.520] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.521] Number of futures (= number of chunks): 1
[15:32:08.521] Launching 1 futures (chunks) ...
[15:32:08.522] Chunk #1 of 1 ...
[15:32:08.522]  - Finding globals in '...' for chunk #1 ...
[15:32:08.522] getGlobalsAndPackages() ...
[15:32:08.523] Searching for globals...
[15:32:08.523] 
[15:32:08.524] Searching for globals ... DONE
[15:32:08.524] - globals: [0] <none>
[15:32:08.524] getGlobalsAndPackages() ... DONE
[15:32:08.525]    + additional globals found: [n=0] 
[15:32:08.525]    + additional namespaces needed: [n=0] 
[15:32:08.525]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.525]  - seeds: <none>
[15:32:08.526]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.526] getGlobalsAndPackages() ...
[15:32:08.526] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.527] Resolving globals: FALSE
[15:32:08.528] The total size of the 5 globals is 3.10 KiB (3176 bytes)
[15:32:08.529] 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 3.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (1.72 KiB of class 'list'), '...future.FUN' (1.38 KiB of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:08.529] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.530] - packages: [1] 'stats'
[15:32:08.530] getGlobalsAndPackages() ... DONE
[15:32:08.531] run() for 'Future' ...
[15:32:08.531] - state: 'created'
[15:32:08.532] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.532] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.533] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.533]   - Field: 'label'
[15:32:08.533]   - Field: 'local'
[15:32:08.534]   - Field: 'owner'
[15:32:08.534]   - Field: 'envir'
[15:32:08.534]   - Field: 'packages'
[15:32:08.534]   - Field: 'gc'
[15:32:08.535]   - Field: 'conditions'
[15:32:08.535]   - Field: 'expr'
[15:32:08.535]   - Field: 'uuid'
[15:32:08.536]   - Field: 'seed'
[15:32:08.536]   - Field: 'version'
[15:32:08.536]   - Field: 'result'
[15:32:08.537]   - Field: 'asynchronous'
[15:32:08.537]   - Field: 'calls'
[15:32:08.537]   - Field: 'globals'
[15:32:08.538]   - Field: 'stdout'
[15:32:08.538]   - Field: 'earlySignal'
[15:32:08.538]   - Field: 'lazy'
[15:32:08.538]   - Field: 'state'
[15:32:08.539] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.539] - Launch lazy future ...
[15:32:08.539] Packages needed by the future expression (n = 1): 'stats'
[15:32:08.540] Packages needed by future strategies (n = 0): <none>
[15:32:08.541] {
[15:32:08.541]     {
[15:32:08.541]         {
[15:32:08.541]             ...future.startTime <- base::Sys.time()
[15:32:08.541]             {
[15:32:08.541]                 {
[15:32:08.541]                   {
[15:32:08.541]                     {
[15:32:08.541]                       base::local({
[15:32:08.541]                         has_future <- base::requireNamespace("future", 
[15:32:08.541]                           quietly = TRUE)
[15:32:08.541]                         if (has_future) {
[15:32:08.541]                           ns <- base::getNamespace("future")
[15:32:08.541]                           version <- ns[[".package"]][["version"]]
[15:32:08.541]                           if (is.null(version)) 
[15:32:08.541]                             version <- utils::packageVersion("future")
[15:32:08.541]                         }
[15:32:08.541]                         else {
[15:32:08.541]                           version <- NULL
[15:32:08.541]                         }
[15:32:08.541]                         if (!has_future || version < "1.8.0") {
[15:32:08.541]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.541]                             "", base::R.version$version.string), 
[15:32:08.541]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:08.541]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.541]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.541]                               "release", "version")], collapse = " "), 
[15:32:08.541]                             hostname = base::Sys.info()[["nodename"]])
[15:32:08.541]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.541]                             info)
[15:32:08.541]                           info <- base::paste(info, collapse = "; ")
[15:32:08.541]                           if (!has_future) {
[15:32:08.541]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.541]                               info)
[15:32:08.541]                           }
[15:32:08.541]                           else {
[15:32:08.541]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.541]                               info, version)
[15:32:08.541]                           }
[15:32:08.541]                           base::stop(msg)
[15:32:08.541]                         }
[15:32:08.541]                       })
[15:32:08.541]                     }
[15:32:08.541]                     base::local({
[15:32:08.541]                       for (pkg in "stats") {
[15:32:08.541]                         base::loadNamespace(pkg)
[15:32:08.541]                         base::library(pkg, character.only = TRUE)
[15:32:08.541]                       }
[15:32:08.541]                     })
[15:32:08.541]                   }
[15:32:08.541]                   ...future.strategy.old <- future::plan("list")
[15:32:08.541]                   options(future.plan = NULL)
[15:32:08.541]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.541]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.541]                 }
[15:32:08.541]                 ...future.workdir <- getwd()
[15:32:08.541]             }
[15:32:08.541]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.541]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.541]         }
[15:32:08.541]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.541]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.541]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.541]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.541]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.541]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.541]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.541]             base::names(...future.oldOptions))
[15:32:08.541]     }
[15:32:08.541]     if (FALSE) {
[15:32:08.541]     }
[15:32:08.541]     else {
[15:32:08.541]         if (TRUE) {
[15:32:08.541]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.541]                 open = "w")
[15:32:08.541]         }
[15:32:08.541]         else {
[15:32:08.541]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.541]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.541]         }
[15:32:08.541]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.541]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.541]             base::sink(type = "output", split = FALSE)
[15:32:08.541]             base::close(...future.stdout)
[15:32:08.541]         }, add = TRUE)
[15:32:08.541]     }
[15:32:08.541]     ...future.frame <- base::sys.nframe()
[15:32:08.541]     ...future.conditions <- base::list()
[15:32:08.541]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.541]     if (FALSE) {
[15:32:08.541]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.541]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.541]     }
[15:32:08.541]     ...future.result <- base::tryCatch({
[15:32:08.541]         base::withCallingHandlers({
[15:32:08.541]             ...future.value <- base::withVisible(base::local({
[15:32:08.541]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.541]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.541]                   ...future.globals.maxSize)) {
[15:32:08.541]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.541]                   on.exit(options(oopts), add = TRUE)
[15:32:08.541]                 }
[15:32:08.541]                 {
[15:32:08.541]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.541]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.541]                     USE.NAMES = FALSE)
[15:32:08.541]                   do.call(mapply, args = args)
[15:32:08.541]                 }
[15:32:08.541]             }))
[15:32:08.541]             future::FutureResult(value = ...future.value$value, 
[15:32:08.541]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.541]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.541]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.541]                     ...future.globalenv.names))
[15:32:08.541]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.541]         }, condition = base::local({
[15:32:08.541]             c <- base::c
[15:32:08.541]             inherits <- base::inherits
[15:32:08.541]             invokeRestart <- base::invokeRestart
[15:32:08.541]             length <- base::length
[15:32:08.541]             list <- base::list
[15:32:08.541]             seq.int <- base::seq.int
[15:32:08.541]             signalCondition <- base::signalCondition
[15:32:08.541]             sys.calls <- base::sys.calls
[15:32:08.541]             `[[` <- base::`[[`
[15:32:08.541]             `+` <- base::`+`
[15:32:08.541]             `<<-` <- base::`<<-`
[15:32:08.541]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.541]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.541]                   3L)]
[15:32:08.541]             }
[15:32:08.541]             function(cond) {
[15:32:08.541]                 is_error <- inherits(cond, "error")
[15:32:08.541]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.541]                   NULL)
[15:32:08.541]                 if (is_error) {
[15:32:08.541]                   sessionInformation <- function() {
[15:32:08.541]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.541]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.541]                       search = base::search(), system = base::Sys.info())
[15:32:08.541]                   }
[15:32:08.541]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.541]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.541]                     cond$call), session = sessionInformation(), 
[15:32:08.541]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.541]                   signalCondition(cond)
[15:32:08.541]                 }
[15:32:08.541]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.541]                 "immediateCondition"))) {
[15:32:08.541]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.541]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.541]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.541]                   if (TRUE && !signal) {
[15:32:08.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.541]                     {
[15:32:08.541]                       inherits <- base::inherits
[15:32:08.541]                       invokeRestart <- base::invokeRestart
[15:32:08.541]                       is.null <- base::is.null
[15:32:08.541]                       muffled <- FALSE
[15:32:08.541]                       if (inherits(cond, "message")) {
[15:32:08.541]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.541]                         if (muffled) 
[15:32:08.541]                           invokeRestart("muffleMessage")
[15:32:08.541]                       }
[15:32:08.541]                       else if (inherits(cond, "warning")) {
[15:32:08.541]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.541]                         if (muffled) 
[15:32:08.541]                           invokeRestart("muffleWarning")
[15:32:08.541]                       }
[15:32:08.541]                       else if (inherits(cond, "condition")) {
[15:32:08.541]                         if (!is.null(pattern)) {
[15:32:08.541]                           computeRestarts <- base::computeRestarts
[15:32:08.541]                           grepl <- base::grepl
[15:32:08.541]                           restarts <- computeRestarts(cond)
[15:32:08.541]                           for (restart in restarts) {
[15:32:08.541]                             name <- restart$name
[15:32:08.541]                             if (is.null(name)) 
[15:32:08.541]                               next
[15:32:08.541]                             if (!grepl(pattern, name)) 
[15:32:08.541]                               next
[15:32:08.541]                             invokeRestart(restart)
[15:32:08.541]                             muffled <- TRUE
[15:32:08.541]                             break
[15:32:08.541]                           }
[15:32:08.541]                         }
[15:32:08.541]                       }
[15:32:08.541]                       invisible(muffled)
[15:32:08.541]                     }
[15:32:08.541]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.541]                   }
[15:32:08.541]                 }
[15:32:08.541]                 else {
[15:32:08.541]                   if (TRUE) {
[15:32:08.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.541]                     {
[15:32:08.541]                       inherits <- base::inherits
[15:32:08.541]                       invokeRestart <- base::invokeRestart
[15:32:08.541]                       is.null <- base::is.null
[15:32:08.541]                       muffled <- FALSE
[15:32:08.541]                       if (inherits(cond, "message")) {
[15:32:08.541]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.541]                         if (muffled) 
[15:32:08.541]                           invokeRestart("muffleMessage")
[15:32:08.541]                       }
[15:32:08.541]                       else if (inherits(cond, "warning")) {
[15:32:08.541]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.541]                         if (muffled) 
[15:32:08.541]                           invokeRestart("muffleWarning")
[15:32:08.541]                       }
[15:32:08.541]                       else if (inherits(cond, "condition")) {
[15:32:08.541]                         if (!is.null(pattern)) {
[15:32:08.541]                           computeRestarts <- base::computeRestarts
[15:32:08.541]                           grepl <- base::grepl
[15:32:08.541]                           restarts <- computeRestarts(cond)
[15:32:08.541]                           for (restart in restarts) {
[15:32:08.541]                             name <- restart$name
[15:32:08.541]                             if (is.null(name)) 
[15:32:08.541]                               next
[15:32:08.541]                             if (!grepl(pattern, name)) 
[15:32:08.541]                               next
[15:32:08.541]                             invokeRestart(restart)
[15:32:08.541]                             muffled <- TRUE
[15:32:08.541]                             break
[15:32:08.541]                           }
[15:32:08.541]                         }
[15:32:08.541]                       }
[15:32:08.541]                       invisible(muffled)
[15:32:08.541]                     }
[15:32:08.541]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.541]                   }
[15:32:08.541]                 }
[15:32:08.541]             }
[15:32:08.541]         }))
[15:32:08.541]     }, error = function(ex) {
[15:32:08.541]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.541]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.541]                 ...future.rng), started = ...future.startTime, 
[15:32:08.541]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.541]             version = "1.8"), class = "FutureResult")
[15:32:08.541]     }, finally = {
[15:32:08.541]         if (!identical(...future.workdir, getwd())) 
[15:32:08.541]             setwd(...future.workdir)
[15:32:08.541]         {
[15:32:08.541]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.541]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.541]             }
[15:32:08.541]             base::options(...future.oldOptions)
[15:32:08.541]             if (.Platform$OS.type == "windows") {
[15:32:08.541]                 old_names <- names(...future.oldEnvVars)
[15:32:08.541]                 envs <- base::Sys.getenv()
[15:32:08.541]                 names <- names(envs)
[15:32:08.541]                 common <- intersect(names, old_names)
[15:32:08.541]                 added <- setdiff(names, old_names)
[15:32:08.541]                 removed <- setdiff(old_names, names)
[15:32:08.541]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.541]                   envs[common]]
[15:32:08.541]                 NAMES <- toupper(changed)
[15:32:08.541]                 args <- list()
[15:32:08.541]                 for (kk in seq_along(NAMES)) {
[15:32:08.541]                   name <- changed[[kk]]
[15:32:08.541]                   NAME <- NAMES[[kk]]
[15:32:08.541]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.541]                     next
[15:32:08.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.541]                 }
[15:32:08.541]                 NAMES <- toupper(added)
[15:32:08.541]                 for (kk in seq_along(NAMES)) {
[15:32:08.541]                   name <- added[[kk]]
[15:32:08.541]                   NAME <- NAMES[[kk]]
[15:32:08.541]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.541]                     next
[15:32:08.541]                   args[[name]] <- ""
[15:32:08.541]                 }
[15:32:08.541]                 NAMES <- toupper(removed)
[15:32:08.541]                 for (kk in seq_along(NAMES)) {
[15:32:08.541]                   name <- removed[[kk]]
[15:32:08.541]                   NAME <- NAMES[[kk]]
[15:32:08.541]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.541]                     next
[15:32:08.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.541]                 }
[15:32:08.541]                 if (length(args) > 0) 
[15:32:08.541]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.541]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.541]             }
[15:32:08.541]             else {
[15:32:08.541]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.541]             }
[15:32:08.541]             {
[15:32:08.541]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.541]                   0L) {
[15:32:08.541]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.541]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.541]                   base::options(opts)
[15:32:08.541]                 }
[15:32:08.541]                 {
[15:32:08.541]                   {
[15:32:08.541]                     base::assign(".Random.seed", c(10407L, 1022819329L, 
[15:32:08.541]                     -493630975L, -521941550L, -1110110993L, -813666423L, 
[15:32:08.541]                     -1504908237L), envir = base::globalenv(), 
[15:32:08.541]                       inherits = FALSE)
[15:32:08.541]                     NULL
[15:32:08.541]                   }
[15:32:08.541]                   options(future.plan = NULL)
[15:32:08.541]                   if (is.na(NA_character_)) 
[15:32:08.541]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.541]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.541]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.541]                     .init = FALSE)
[15:32:08.541]                 }
[15:32:08.541]             }
[15:32:08.541]         }
[15:32:08.541]     })
[15:32:08.541]     if (TRUE) {
[15:32:08.541]         base::sink(type = "output", split = FALSE)
[15:32:08.541]         if (TRUE) {
[15:32:08.541]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.541]         }
[15:32:08.541]         else {
[15:32:08.541]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.541]         }
[15:32:08.541]         base::close(...future.stdout)
[15:32:08.541]         ...future.stdout <- NULL
[15:32:08.541]     }
[15:32:08.541]     ...future.result$conditions <- ...future.conditions
[15:32:08.541]     ...future.result$finished <- base::Sys.time()
[15:32:08.541]     ...future.result
[15:32:08.541] }
[15:32:08.548] assign_globals() ...
[15:32:08.549] List of 5
[15:32:08.549]  $ ...future.FUN            :function (x, w, ...)  
[15:32:08.549]  $ MoreArgs                 : NULL
[15:32:08.549]  $ ...future.elements_ii    :List of 2
[15:32:08.549]   ..$ :List of 5
[15:32:08.549]   .. ..$ : num [1:10] 0.2251 0.4619 0.8397 0.9968 0.0754 ...
[15:32:08.549]   .. ..$ : num [1:10] 0.452 0.535 0.164 0.57 0.86 ...
[15:32:08.549]   .. ..$ : num [1:10] 0.0449 0.2662 0.1264 0.5253 0.3798 ...
[15:32:08.549]   .. ..$ : num [1:10] 0.321 0.888 0.622 0.775 0.422 ...
[15:32:08.549]   .. ..$ : num [1:10] 0.8559 0.7313 0.2139 0.2379 0.0942 ...
[15:32:08.549]   ..$ :List of 5
[15:32:08.549]   .. ..$ : num [1:10] 3 4 6 7 6 8 14 4 4 4
[15:32:08.549]   .. ..$ : num [1:10] 5 4 8 4 10 8 4 5 5 11
[15:32:08.549]   .. ..$ : num [1:10] 7 7 9 6 3 9 2 10 5 5
[15:32:08.549]   .. ..$ : num [1:10] 7 4 4 4 10 5 6 3 3 9
[15:32:08.549]   .. ..$ : num [1:10] 8 7 9 4 6 6 3 6 3 4
[15:32:08.549]  $ ...future.seeds_ii       : NULL
[15:32:08.549]  $ ...future.globals.maxSize: NULL
[15:32:08.549]  - attr(*, "where")=List of 5
[15:32:08.549]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.549]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.549]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.549]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.549]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.549]  - attr(*, "resolved")= logi FALSE
[15:32:08.549]  - attr(*, "total_size")= num 3176
[15:32:08.549]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.549]  - attr(*, "already-done")= logi TRUE
[15:32:08.573] - copied '...future.FUN' to environment
[15:32:08.573] - copied 'MoreArgs' to environment
[15:32:08.573] - copied '...future.elements_ii' to environment
[15:32:08.574] - copied '...future.seeds_ii' to environment
[15:32:08.574] - copied '...future.globals.maxSize' to environment
[15:32:08.574] assign_globals() ... done
[15:32:08.576] plan(): Setting new future strategy stack:
[15:32:08.576] List of future strategies:
[15:32:08.576] 1. sequential:
[15:32:08.576]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.576]    - tweaked: FALSE
[15:32:08.576]    - call: NULL
[15:32:08.577] plan(): nbrOfWorkers() = 1
[15:32:08.579] plan(): Setting new future strategy stack:
[15:32:08.579] List of future strategies:
[15:32:08.579] 1. sequential:
[15:32:08.579]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.579]    - tweaked: FALSE
[15:32:08.579]    - call: plan(strategy)
[15:32:08.580] plan(): nbrOfWorkers() = 1
[15:32:08.581] SequentialFuture started (and completed)
[15:32:08.581] - Launch lazy future ... done
[15:32:08.581] run() for 'SequentialFuture' ... done
[15:32:08.582] Created future:
[15:32:08.582] SequentialFuture:
[15:32:08.582] Label: 'future_Map-1'
[15:32:08.582] Expression:
[15:32:08.582] {
[15:32:08.582]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.582]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.582]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.582]         on.exit(options(oopts), add = TRUE)
[15:32:08.582]     }
[15:32:08.582]     {
[15:32:08.582]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.582]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.582]         do.call(mapply, args = args)
[15:32:08.582]     }
[15:32:08.582] }
[15:32:08.582] Lazy evaluation: FALSE
[15:32:08.582] Asynchronous evaluation: FALSE
[15:32:08.582] Local evaluation: TRUE
[15:32:08.582] Environment: R_GlobalEnv
[15:32:08.582] Capture standard output: TRUE
[15:32:08.582] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.582] Globals: 5 objects totaling 3.10 KiB (function '...future.FUN' of 1.38 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 1.72 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.582] Packages: 1 packages ('stats')
[15:32:08.582] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.582] Resolved: TRUE
[15:32:08.582] Value: 280 bytes of class 'list'
[15:32:08.582] Early signaling: FALSE
[15:32:08.582] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.582] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.584] Chunk #1 of 1 ... DONE
[15:32:08.585] Launching 1 futures (chunks) ... DONE
[15:32:08.585] Resolving 1 futures (chunks) ...
[15:32:08.585] resolve() on list ...
[15:32:08.585]  recursive: 0
[15:32:08.586]  length: 1
[15:32:08.586] 
[15:32:08.586] resolved() for 'SequentialFuture' ...
[15:32:08.587] - state: 'finished'
[15:32:08.587] - run: TRUE
[15:32:08.587] - result: 'FutureResult'
[15:32:08.587] resolved() for 'SequentialFuture' ... done
[15:32:08.588] Future #1
[15:32:08.588] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.588] - nx: 1
[15:32:08.589] - relay: TRUE
[15:32:08.589] - stdout: TRUE
[15:32:08.589] - signal: TRUE
[15:32:08.590] - resignal: FALSE
[15:32:08.590] - force: TRUE
[15:32:08.590] - relayed: [n=1] FALSE
[15:32:08.590] - queued futures: [n=1] FALSE
[15:32:08.591]  - until=1
[15:32:08.591]  - relaying element #1
[15:32:08.591] - relayed: [n=1] TRUE
[15:32:08.592] - queued futures: [n=1] TRUE
[15:32:08.592] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.592]  length: 0 (resolved future 1)
[15:32:08.593] Relaying remaining futures
[15:32:08.593] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.593] - nx: 1
[15:32:08.593] - relay: TRUE
[15:32:08.594] - stdout: TRUE
[15:32:08.594] - signal: TRUE
[15:32:08.594] - resignal: FALSE
[15:32:08.594] - force: TRUE
[15:32:08.595] - relayed: [n=1] TRUE
[15:32:08.595] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.595] - relayed: [n=1] TRUE
[15:32:08.596] - queued futures: [n=1] TRUE
[15:32:08.596] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.596] resolve() on list ... DONE
[15:32:08.597]  - Number of value chunks collected: 1
[15:32:08.597] Resolving 1 futures (chunks) ... DONE
[15:32:08.597] Reducing values from 1 chunks ...
[15:32:08.597]  - Number of values collected after concatenation: 5
[15:32:08.598]  - Number of values expected: 5
[15:32:08.598] Reducing values from 1 chunks ... DONE
[15:32:08.598] future_mapply() ... DONE
- future_mapply() - 'max-or-0-if' recycling rule ...
[15:32:08.603] future_mapply() ...
[15:32:08.603] Number of chunks: 1
[15:32:08.603] getGlobalsAndPackagesXApply() ...
[15:32:08.604]  - future.globals: TRUE
[15:32:08.604] getGlobalsAndPackages() ...
[15:32:08.604] Searching for globals...
[15:32:08.606] - globals found: [1] 'FUN'
[15:32:08.606] Searching for globals ... DONE
[15:32:08.606] Resolving globals: FALSE
[15:32:08.607] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:08.608] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:08.608] - globals: [1] 'FUN'
[15:32:08.608] 
[15:32:08.609] getGlobalsAndPackages() ... DONE
[15:32:08.609]  - globals found/used: [n=1] 'FUN'
[15:32:08.609]  - needed namespaces: [n=0] 
[15:32:08.609] Finding globals ... DONE
[15:32:08.610] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.610] List of 2
[15:32:08.610]  $ ...future.FUN:function (e1, e2)  
[15:32:08.610]  $ MoreArgs     : NULL
[15:32:08.610]  - attr(*, "where")=List of 2
[15:32:08.610]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.610]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.610]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.610]  - attr(*, "resolved")= logi FALSE
[15:32:08.610]  - attr(*, "total_size")= num NA
[15:32:08.621] Packages to be attached in all futures: [n=0] 
[15:32:08.621] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.622] Number of futures (= number of chunks): 1
[15:32:08.622] Launching 1 futures (chunks) ...
[15:32:08.622] Chunk #1 of 1 ...
[15:32:08.623]  - Finding globals in '...' for chunk #1 ...
[15:32:08.623] getGlobalsAndPackages() ...
[15:32:08.623] Searching for globals...
[15:32:08.624] 
[15:32:08.625] Searching for globals ... DONE
[15:32:08.625] - globals: [0] <none>
[15:32:08.625] getGlobalsAndPackages() ... DONE
[15:32:08.625]    + additional globals found: [n=0] 
[15:32:08.626]    + additional namespaces needed: [n=0] 
[15:32:08.626]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.626]  - seeds: <none>
[15:32:08.627]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.627] getGlobalsAndPackages() ...
[15:32:08.627] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.627] Resolving globals: FALSE
[15:32:08.629] The total size of the 5 globals is 392 bytes (392 bytes)
[15:32:08.630] 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 392 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (336 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:08.630] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.630] 
[15:32:08.631] getGlobalsAndPackages() ... DONE
[15:32:08.631] run() for 'Future' ...
[15:32:08.632] - state: 'created'
[15:32:08.632] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.633] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.633] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.633]   - Field: 'label'
[15:32:08.634]   - Field: 'local'
[15:32:08.634]   - Field: 'owner'
[15:32:08.634]   - Field: 'envir'
[15:32:08.635]   - Field: 'packages'
[15:32:08.635]   - Field: 'gc'
[15:32:08.635]   - Field: 'conditions'
[15:32:08.636]   - Field: 'expr'
[15:32:08.636]   - Field: 'uuid'
[15:32:08.636]   - Field: 'seed'
[15:32:08.636]   - Field: 'version'
[15:32:08.637]   - Field: 'result'
[15:32:08.637]   - Field: 'asynchronous'
[15:32:08.637]   - Field: 'calls'
[15:32:08.638]   - Field: 'globals'
[15:32:08.638]   - Field: 'stdout'
[15:32:08.638]   - Field: 'earlySignal'
[15:32:08.638]   - Field: 'lazy'
[15:32:08.639]   - Field: 'state'
[15:32:08.639] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.639] - Launch lazy future ...
[15:32:08.640] Packages needed by the future expression (n = 0): <none>
[15:32:08.640] Packages needed by future strategies (n = 0): <none>
[15:32:08.641] {
[15:32:08.641]     {
[15:32:08.641]         {
[15:32:08.641]             ...future.startTime <- base::Sys.time()
[15:32:08.641]             {
[15:32:08.641]                 {
[15:32:08.641]                   {
[15:32:08.641]                     base::local({
[15:32:08.641]                       has_future <- base::requireNamespace("future", 
[15:32:08.641]                         quietly = TRUE)
[15:32:08.641]                       if (has_future) {
[15:32:08.641]                         ns <- base::getNamespace("future")
[15:32:08.641]                         version <- ns[[".package"]][["version"]]
[15:32:08.641]                         if (is.null(version)) 
[15:32:08.641]                           version <- utils::packageVersion("future")
[15:32:08.641]                       }
[15:32:08.641]                       else {
[15:32:08.641]                         version <- NULL
[15:32:08.641]                       }
[15:32:08.641]                       if (!has_future || version < "1.8.0") {
[15:32:08.641]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.641]                           "", base::R.version$version.string), 
[15:32:08.641]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:08.641]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.641]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.641]                             "release", "version")], collapse = " "), 
[15:32:08.641]                           hostname = base::Sys.info()[["nodename"]])
[15:32:08.641]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.641]                           info)
[15:32:08.641]                         info <- base::paste(info, collapse = "; ")
[15:32:08.641]                         if (!has_future) {
[15:32:08.641]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.641]                             info)
[15:32:08.641]                         }
[15:32:08.641]                         else {
[15:32:08.641]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.641]                             info, version)
[15:32:08.641]                         }
[15:32:08.641]                         base::stop(msg)
[15:32:08.641]                       }
[15:32:08.641]                     })
[15:32:08.641]                   }
[15:32:08.641]                   ...future.strategy.old <- future::plan("list")
[15:32:08.641]                   options(future.plan = NULL)
[15:32:08.641]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.641]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.641]                 }
[15:32:08.641]                 ...future.workdir <- getwd()
[15:32:08.641]             }
[15:32:08.641]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.641]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.641]         }
[15:32:08.641]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.641]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.641]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.641]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.641]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.641]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.641]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.641]             base::names(...future.oldOptions))
[15:32:08.641]     }
[15:32:08.641]     if (FALSE) {
[15:32:08.641]     }
[15:32:08.641]     else {
[15:32:08.641]         if (TRUE) {
[15:32:08.641]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.641]                 open = "w")
[15:32:08.641]         }
[15:32:08.641]         else {
[15:32:08.641]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.641]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.641]         }
[15:32:08.641]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.641]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.641]             base::sink(type = "output", split = FALSE)
[15:32:08.641]             base::close(...future.stdout)
[15:32:08.641]         }, add = TRUE)
[15:32:08.641]     }
[15:32:08.641]     ...future.frame <- base::sys.nframe()
[15:32:08.641]     ...future.conditions <- base::list()
[15:32:08.641]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.641]     if (FALSE) {
[15:32:08.641]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.641]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.641]     }
[15:32:08.641]     ...future.result <- base::tryCatch({
[15:32:08.641]         base::withCallingHandlers({
[15:32:08.641]             ...future.value <- base::withVisible(base::local({
[15:32:08.641]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.641]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.641]                   ...future.globals.maxSize)) {
[15:32:08.641]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.641]                   on.exit(options(oopts), add = TRUE)
[15:32:08.641]                 }
[15:32:08.641]                 {
[15:32:08.641]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.641]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.641]                     USE.NAMES = FALSE)
[15:32:08.641]                   do.call(mapply, args = args)
[15:32:08.641]                 }
[15:32:08.641]             }))
[15:32:08.641]             future::FutureResult(value = ...future.value$value, 
[15:32:08.641]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.641]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.641]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.641]                     ...future.globalenv.names))
[15:32:08.641]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.641]         }, condition = base::local({
[15:32:08.641]             c <- base::c
[15:32:08.641]             inherits <- base::inherits
[15:32:08.641]             invokeRestart <- base::invokeRestart
[15:32:08.641]             length <- base::length
[15:32:08.641]             list <- base::list
[15:32:08.641]             seq.int <- base::seq.int
[15:32:08.641]             signalCondition <- base::signalCondition
[15:32:08.641]             sys.calls <- base::sys.calls
[15:32:08.641]             `[[` <- base::`[[`
[15:32:08.641]             `+` <- base::`+`
[15:32:08.641]             `<<-` <- base::`<<-`
[15:32:08.641]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.641]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.641]                   3L)]
[15:32:08.641]             }
[15:32:08.641]             function(cond) {
[15:32:08.641]                 is_error <- inherits(cond, "error")
[15:32:08.641]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.641]                   NULL)
[15:32:08.641]                 if (is_error) {
[15:32:08.641]                   sessionInformation <- function() {
[15:32:08.641]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.641]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.641]                       search = base::search(), system = base::Sys.info())
[15:32:08.641]                   }
[15:32:08.641]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.641]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.641]                     cond$call), session = sessionInformation(), 
[15:32:08.641]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.641]                   signalCondition(cond)
[15:32:08.641]                 }
[15:32:08.641]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.641]                 "immediateCondition"))) {
[15:32:08.641]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.641]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.641]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.641]                   if (TRUE && !signal) {
[15:32:08.641]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.641]                     {
[15:32:08.641]                       inherits <- base::inherits
[15:32:08.641]                       invokeRestart <- base::invokeRestart
[15:32:08.641]                       is.null <- base::is.null
[15:32:08.641]                       muffled <- FALSE
[15:32:08.641]                       if (inherits(cond, "message")) {
[15:32:08.641]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.641]                         if (muffled) 
[15:32:08.641]                           invokeRestart("muffleMessage")
[15:32:08.641]                       }
[15:32:08.641]                       else if (inherits(cond, "warning")) {
[15:32:08.641]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.641]                         if (muffled) 
[15:32:08.641]                           invokeRestart("muffleWarning")
[15:32:08.641]                       }
[15:32:08.641]                       else if (inherits(cond, "condition")) {
[15:32:08.641]                         if (!is.null(pattern)) {
[15:32:08.641]                           computeRestarts <- base::computeRestarts
[15:32:08.641]                           grepl <- base::grepl
[15:32:08.641]                           restarts <- computeRestarts(cond)
[15:32:08.641]                           for (restart in restarts) {
[15:32:08.641]                             name <- restart$name
[15:32:08.641]                             if (is.null(name)) 
[15:32:08.641]                               next
[15:32:08.641]                             if (!grepl(pattern, name)) 
[15:32:08.641]                               next
[15:32:08.641]                             invokeRestart(restart)
[15:32:08.641]                             muffled <- TRUE
[15:32:08.641]                             break
[15:32:08.641]                           }
[15:32:08.641]                         }
[15:32:08.641]                       }
[15:32:08.641]                       invisible(muffled)
[15:32:08.641]                     }
[15:32:08.641]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.641]                   }
[15:32:08.641]                 }
[15:32:08.641]                 else {
[15:32:08.641]                   if (TRUE) {
[15:32:08.641]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.641]                     {
[15:32:08.641]                       inherits <- base::inherits
[15:32:08.641]                       invokeRestart <- base::invokeRestart
[15:32:08.641]                       is.null <- base::is.null
[15:32:08.641]                       muffled <- FALSE
[15:32:08.641]                       if (inherits(cond, "message")) {
[15:32:08.641]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.641]                         if (muffled) 
[15:32:08.641]                           invokeRestart("muffleMessage")
[15:32:08.641]                       }
[15:32:08.641]                       else if (inherits(cond, "warning")) {
[15:32:08.641]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.641]                         if (muffled) 
[15:32:08.641]                           invokeRestart("muffleWarning")
[15:32:08.641]                       }
[15:32:08.641]                       else if (inherits(cond, "condition")) {
[15:32:08.641]                         if (!is.null(pattern)) {
[15:32:08.641]                           computeRestarts <- base::computeRestarts
[15:32:08.641]                           grepl <- base::grepl
[15:32:08.641]                           restarts <- computeRestarts(cond)
[15:32:08.641]                           for (restart in restarts) {
[15:32:08.641]                             name <- restart$name
[15:32:08.641]                             if (is.null(name)) 
[15:32:08.641]                               next
[15:32:08.641]                             if (!grepl(pattern, name)) 
[15:32:08.641]                               next
[15:32:08.641]                             invokeRestart(restart)
[15:32:08.641]                             muffled <- TRUE
[15:32:08.641]                             break
[15:32:08.641]                           }
[15:32:08.641]                         }
[15:32:08.641]                       }
[15:32:08.641]                       invisible(muffled)
[15:32:08.641]                     }
[15:32:08.641]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.641]                   }
[15:32:08.641]                 }
[15:32:08.641]             }
[15:32:08.641]         }))
[15:32:08.641]     }, error = function(ex) {
[15:32:08.641]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.641]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.641]                 ...future.rng), started = ...future.startTime, 
[15:32:08.641]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.641]             version = "1.8"), class = "FutureResult")
[15:32:08.641]     }, finally = {
[15:32:08.641]         if (!identical(...future.workdir, getwd())) 
[15:32:08.641]             setwd(...future.workdir)
[15:32:08.641]         {
[15:32:08.641]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.641]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.641]             }
[15:32:08.641]             base::options(...future.oldOptions)
[15:32:08.641]             if (.Platform$OS.type == "windows") {
[15:32:08.641]                 old_names <- names(...future.oldEnvVars)
[15:32:08.641]                 envs <- base::Sys.getenv()
[15:32:08.641]                 names <- names(envs)
[15:32:08.641]                 common <- intersect(names, old_names)
[15:32:08.641]                 added <- setdiff(names, old_names)
[15:32:08.641]                 removed <- setdiff(old_names, names)
[15:32:08.641]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.641]                   envs[common]]
[15:32:08.641]                 NAMES <- toupper(changed)
[15:32:08.641]                 args <- list()
[15:32:08.641]                 for (kk in seq_along(NAMES)) {
[15:32:08.641]                   name <- changed[[kk]]
[15:32:08.641]                   NAME <- NAMES[[kk]]
[15:32:08.641]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.641]                     next
[15:32:08.641]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.641]                 }
[15:32:08.641]                 NAMES <- toupper(added)
[15:32:08.641]                 for (kk in seq_along(NAMES)) {
[15:32:08.641]                   name <- added[[kk]]
[15:32:08.641]                   NAME <- NAMES[[kk]]
[15:32:08.641]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.641]                     next
[15:32:08.641]                   args[[name]] <- ""
[15:32:08.641]                 }
[15:32:08.641]                 NAMES <- toupper(removed)
[15:32:08.641]                 for (kk in seq_along(NAMES)) {
[15:32:08.641]                   name <- removed[[kk]]
[15:32:08.641]                   NAME <- NAMES[[kk]]
[15:32:08.641]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.641]                     next
[15:32:08.641]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.641]                 }
[15:32:08.641]                 if (length(args) > 0) 
[15:32:08.641]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.641]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.641]             }
[15:32:08.641]             else {
[15:32:08.641]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.641]             }
[15:32:08.641]             {
[15:32:08.641]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.641]                   0L) {
[15:32:08.641]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.641]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.641]                   base::options(opts)
[15:32:08.641]                 }
[15:32:08.641]                 {
[15:32:08.641]                   {
[15:32:08.641]                     base::assign(".Random.seed", c(10407L, 1022819329L, 
[15:32:08.641]                     -493630975L, -521941550L, -1110110993L, -813666423L, 
[15:32:08.641]                     -1504908237L), envir = base::globalenv(), 
[15:32:08.641]                       inherits = FALSE)
[15:32:08.641]                     NULL
[15:32:08.641]                   }
[15:32:08.641]                   options(future.plan = NULL)
[15:32:08.641]                   if (is.na(NA_character_)) 
[15:32:08.641]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.641]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.641]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.641]                     .init = FALSE)
[15:32:08.641]                 }
[15:32:08.641]             }
[15:32:08.641]         }
[15:32:08.641]     })
[15:32:08.641]     if (TRUE) {
[15:32:08.641]         base::sink(type = "output", split = FALSE)
[15:32:08.641]         if (TRUE) {
[15:32:08.641]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.641]         }
[15:32:08.641]         else {
[15:32:08.641]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.641]         }
[15:32:08.641]         base::close(...future.stdout)
[15:32:08.641]         ...future.stdout <- NULL
[15:32:08.641]     }
[15:32:08.641]     ...future.result$conditions <- ...future.conditions
[15:32:08.641]     ...future.result$finished <- base::Sys.time()
[15:32:08.641]     ...future.result
[15:32:08.641] }
[15:32:08.648] assign_globals() ...
[15:32:08.648] List of 5
[15:32:08.648]  $ ...future.FUN            :function (e1, e2)  
[15:32:08.648]  $ MoreArgs                 : NULL
[15:32:08.648]  $ ...future.elements_ii    :List of 2
[15:32:08.648]   ..$ :List of 3
[15:32:08.648]   .. ..$ : num 1
[15:32:08.648]   .. ..$ : num 1
[15:32:08.648]   .. ..$ : num 1
[15:32:08.648]   ..$ :List of 3
[15:32:08.648]   .. ..$ : int 1
[15:32:08.648]   .. ..$ : int 2
[15:32:08.648]   .. ..$ : int 3
[15:32:08.648]  $ ...future.seeds_ii       : NULL
[15:32:08.648]  $ ...future.globals.maxSize: NULL
[15:32:08.648]  - attr(*, "where")=List of 5
[15:32:08.648]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.648]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.648]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.648]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.648]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.648]  - attr(*, "resolved")= logi FALSE
[15:32:08.648]  - attr(*, "total_size")= num 392
[15:32:08.648]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.648]  - attr(*, "already-done")= logi TRUE
[15:32:08.666] - copied '...future.FUN' to environment
[15:32:08.666] - copied 'MoreArgs' to environment
[15:32:08.666] - copied '...future.elements_ii' to environment
[15:32:08.667] - copied '...future.seeds_ii' to environment
[15:32:08.667] - copied '...future.globals.maxSize' to environment
[15:32:08.667] assign_globals() ... done
[15:32:08.668] plan(): Setting new future strategy stack:
[15:32:08.668] List of future strategies:
[15:32:08.668] 1. sequential:
[15:32:08.668]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.668]    - tweaked: FALSE
[15:32:08.668]    - call: NULL
[15:32:08.670] plan(): nbrOfWorkers() = 1
[15:32:08.672] plan(): Setting new future strategy stack:
[15:32:08.672] List of future strategies:
[15:32:08.672] 1. sequential:
[15:32:08.672]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.672]    - tweaked: FALSE
[15:32:08.672]    - call: plan(strategy)
[15:32:08.673] plan(): nbrOfWorkers() = 1
[15:32:08.674] SequentialFuture started (and completed)
[15:32:08.674] - Launch lazy future ... done
[15:32:08.675] run() for 'SequentialFuture' ... done
[15:32:08.675] Created future:
[15:32:08.675] SequentialFuture:
[15:32:08.675] Label: 'future_Map-1'
[15:32:08.675] Expression:
[15:32:08.675] {
[15:32:08.675]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.675]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.675]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.675]         on.exit(options(oopts), add = TRUE)
[15:32:08.675]     }
[15:32:08.675]     {
[15:32:08.675]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.675]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.675]         do.call(mapply, args = args)
[15:32:08.675]     }
[15:32:08.675] }
[15:32:08.675] Lazy evaluation: FALSE
[15:32:08.675] Asynchronous evaluation: FALSE
[15:32:08.675] Local evaluation: TRUE
[15:32:08.675] Environment: R_GlobalEnv
[15:32:08.675] Capture standard output: TRUE
[15:32:08.675] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.675] Globals: 5 objects totaling 392 bytes (function '...future.FUN' of 56 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:08.675] Packages: <none>
[15:32:08.675] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.675] Resolved: TRUE
[15:32:08.675] Value: 168 bytes of class 'list'
[15:32:08.675] Early signaling: FALSE
[15:32:08.675] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.675] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.678] Chunk #1 of 1 ... DONE
[15:32:08.678] Launching 1 futures (chunks) ... DONE
[15:32:08.678] Resolving 1 futures (chunks) ...
[15:32:08.678] resolve() on list ...
[15:32:08.679]  recursive: 0
[15:32:08.679]  length: 1
[15:32:08.679] 
[15:32:08.679] resolved() for 'SequentialFuture' ...
[15:32:08.680] - state: 'finished'
[15:32:08.680] - run: TRUE
[15:32:08.680] - result: 'FutureResult'
[15:32:08.681] resolved() for 'SequentialFuture' ... done
[15:32:08.681] Future #1
[15:32:08.681] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.682] - nx: 1
[15:32:08.682] - relay: TRUE
[15:32:08.682] - stdout: TRUE
[15:32:08.682] - signal: TRUE
[15:32:08.683] - resignal: FALSE
[15:32:08.683] - force: TRUE
[15:32:08.683] - relayed: [n=1] FALSE
[15:32:08.683] - queued futures: [n=1] FALSE
[15:32:08.684]  - until=1
[15:32:08.684]  - relaying element #1
[15:32:08.684] - relayed: [n=1] TRUE
[15:32:08.685] - queued futures: [n=1] TRUE
[15:32:08.685] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.685]  length: 0 (resolved future 1)
[15:32:08.686] Relaying remaining futures
[15:32:08.686] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.686] - nx: 1
[15:32:08.686] - relay: TRUE
[15:32:08.687] - stdout: TRUE
[15:32:08.687] - signal: TRUE
[15:32:08.687] - resignal: FALSE
[15:32:08.687] - force: TRUE
[15:32:08.688] - relayed: [n=1] TRUE
[15:32:08.688] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.688] - relayed: [n=1] TRUE
[15:32:08.689] - queued futures: [n=1] TRUE
[15:32:08.689] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.689] resolve() on list ... DONE
[15:32:08.690]  - Number of value chunks collected: 1
[15:32:08.690] Resolving 1 futures (chunks) ... DONE
[15:32:08.690] Reducing values from 1 chunks ...
[15:32:08.691]  - Number of values collected after concatenation: 3
[15:32:08.691]  - Number of values expected: 3
[15:32:08.691] Reducing values from 1 chunks ... DONE
[15:32:08.691] future_mapply() ... DONE
- future_mapply(x, ...) where x[[i]] subsets via S3 method ...
[15:32:08.692] future_mapply() ...
[15:32:08.693] Number of chunks: 1
[15:32:08.693] getGlobalsAndPackagesXApply() ...
[15:32:08.694]  - future.globals: TRUE
[15:32:08.694] getGlobalsAndPackages() ...
[15:32:08.694] Searching for globals...
[15:32:08.696] - globals found: [1] 'FUN'
[15:32:08.696] Searching for globals ... DONE
[15:32:08.697] Resolving globals: FALSE
[15:32:08.697] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:08.698] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:08.698] - globals: [1] 'FUN'
[15:32:08.699] 
[15:32:08.699] getGlobalsAndPackages() ... DONE
[15:32:08.699]  - globals found/used: [n=1] 'FUN'
[15:32:08.699]  - needed namespaces: [n=0] 
[15:32:08.700] Finding globals ... DONE
[15:32:08.700] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:08.700] List of 2
[15:32:08.700]  $ ...future.FUN:function (x)  
[15:32:08.700]  $ MoreArgs     : NULL
[15:32:08.700]  - attr(*, "where")=List of 2
[15:32:08.700]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:08.700]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:08.700]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.700]  - attr(*, "resolved")= logi FALSE
[15:32:08.700]  - attr(*, "total_size")= num NA
[15:32:08.705] Packages to be attached in all futures: [n=0] 
[15:32:08.711] getGlobalsAndPackagesXApply() ... DONE
[15:32:08.711] Number of futures (= number of chunks): 1
[15:32:08.712] Launching 1 futures (chunks) ...
[15:32:08.712] Chunk #1 of 1 ...
[15:32:08.713]  - Finding globals in '...' for chunk #1 ...
[15:32:08.713] getGlobalsAndPackages() ...
[15:32:08.713] Searching for globals...
[15:32:08.714] 
[15:32:08.714] Searching for globals ... DONE
[15:32:08.715] - globals: [0] <none>
[15:32:08.715] getGlobalsAndPackages() ... DONE
[15:32:08.715]    + additional globals found: [n=0] 
[15:32:08.716]    + additional namespaces needed: [n=0] 
[15:32:08.716]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:08.716]  - seeds: <none>
[15:32:08.716]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.717] getGlobalsAndPackages() ...
[15:32:08.717] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.718] Resolving globals: FALSE
[15:32:08.719] The total size of the 5 globals is 960 bytes (960 bytes)
[15:32:08.720] 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 960 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:08.720] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:08.721] 
[15:32:08.721] getGlobalsAndPackages() ... DONE
[15:32:08.722] run() for 'Future' ...
[15:32:08.722] - state: 'created'
[15:32:08.723] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:08.723] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.724] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:08.724]   - Field: 'label'
[15:32:08.724]   - Field: 'local'
[15:32:08.725]   - Field: 'owner'
[15:32:08.725]   - Field: 'envir'
[15:32:08.725]   - Field: 'packages'
[15:32:08.725]   - Field: 'gc'
[15:32:08.726]   - Field: 'conditions'
[15:32:08.726]   - Field: 'expr'
[15:32:08.726]   - Field: 'uuid'
[15:32:08.727]   - Field: 'seed'
[15:32:08.727]   - Field: 'version'
[15:32:08.727]   - Field: 'result'
[15:32:08.728]   - Field: 'asynchronous'
[15:32:08.728]   - Field: 'calls'
[15:32:08.728]   - Field: 'globals'
[15:32:08.729]   - Field: 'stdout'
[15:32:08.729]   - Field: 'earlySignal'
[15:32:08.729]   - Field: 'lazy'
[15:32:08.729]   - Field: 'state'
[15:32:08.730] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:08.730] - Launch lazy future ...
[15:32:08.731] Packages needed by the future expression (n = 0): <none>
[15:32:08.731] Packages needed by future strategies (n = 0): <none>
[15:32:08.732] {
[15:32:08.732]     {
[15:32:08.732]         {
[15:32:08.732]             ...future.startTime <- base::Sys.time()
[15:32:08.732]             {
[15:32:08.732]                 {
[15:32:08.732]                   {
[15:32:08.732]                     base::local({
[15:32:08.732]                       has_future <- base::requireNamespace("future", 
[15:32:08.732]                         quietly = TRUE)
[15:32:08.732]                       if (has_future) {
[15:32:08.732]                         ns <- base::getNamespace("future")
[15:32:08.732]                         version <- ns[[".package"]][["version"]]
[15:32:08.732]                         if (is.null(version)) 
[15:32:08.732]                           version <- utils::packageVersion("future")
[15:32:08.732]                       }
[15:32:08.732]                       else {
[15:32:08.732]                         version <- NULL
[15:32:08.732]                       }
[15:32:08.732]                       if (!has_future || version < "1.8.0") {
[15:32:08.732]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:08.732]                           "", base::R.version$version.string), 
[15:32:08.732]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:08.732]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:08.732]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:08.732]                             "release", "version")], collapse = " "), 
[15:32:08.732]                           hostname = base::Sys.info()[["nodename"]])
[15:32:08.732]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:08.732]                           info)
[15:32:08.732]                         info <- base::paste(info, collapse = "; ")
[15:32:08.732]                         if (!has_future) {
[15:32:08.732]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:08.732]                             info)
[15:32:08.732]                         }
[15:32:08.732]                         else {
[15:32:08.732]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:08.732]                             info, version)
[15:32:08.732]                         }
[15:32:08.732]                         base::stop(msg)
[15:32:08.732]                       }
[15:32:08.732]                     })
[15:32:08.732]                   }
[15:32:08.732]                   ...future.strategy.old <- future::plan("list")
[15:32:08.732]                   options(future.plan = NULL)
[15:32:08.732]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.732]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:08.732]                 }
[15:32:08.732]                 ...future.workdir <- getwd()
[15:32:08.732]             }
[15:32:08.732]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:08.732]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:08.732]         }
[15:32:08.732]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:08.732]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:08.732]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:08.732]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:08.732]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:08.732]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:08.732]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:08.732]             base::names(...future.oldOptions))
[15:32:08.732]     }
[15:32:08.732]     if (FALSE) {
[15:32:08.732]     }
[15:32:08.732]     else {
[15:32:08.732]         if (TRUE) {
[15:32:08.732]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:08.732]                 open = "w")
[15:32:08.732]         }
[15:32:08.732]         else {
[15:32:08.732]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:08.732]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:08.732]         }
[15:32:08.732]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:08.732]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:08.732]             base::sink(type = "output", split = FALSE)
[15:32:08.732]             base::close(...future.stdout)
[15:32:08.732]         }, add = TRUE)
[15:32:08.732]     }
[15:32:08.732]     ...future.frame <- base::sys.nframe()
[15:32:08.732]     ...future.conditions <- base::list()
[15:32:08.732]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:08.732]     if (FALSE) {
[15:32:08.732]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:08.732]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:08.732]     }
[15:32:08.732]     ...future.result <- base::tryCatch({
[15:32:08.732]         base::withCallingHandlers({
[15:32:08.732]             ...future.value <- base::withVisible(base::local({
[15:32:08.732]                 ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.732]                 if (!identical(...future.globals.maxSize.org, 
[15:32:08.732]                   ...future.globals.maxSize)) {
[15:32:08.732]                   oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.732]                   on.exit(options(oopts), add = TRUE)
[15:32:08.732]                 }
[15:32:08.732]                 {
[15:32:08.732]                   args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.732]                     MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:08.732]                     USE.NAMES = FALSE)
[15:32:08.732]                   do.call(mapply, args = args)
[15:32:08.732]                 }
[15:32:08.732]             }))
[15:32:08.732]             future::FutureResult(value = ...future.value$value, 
[15:32:08.732]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.732]                   ...future.rng), globalenv = if (FALSE) 
[15:32:08.732]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:08.732]                     ...future.globalenv.names))
[15:32:08.732]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:08.732]         }, condition = base::local({
[15:32:08.732]             c <- base::c
[15:32:08.732]             inherits <- base::inherits
[15:32:08.732]             invokeRestart <- base::invokeRestart
[15:32:08.732]             length <- base::length
[15:32:08.732]             list <- base::list
[15:32:08.732]             seq.int <- base::seq.int
[15:32:08.732]             signalCondition <- base::signalCondition
[15:32:08.732]             sys.calls <- base::sys.calls
[15:32:08.732]             `[[` <- base::`[[`
[15:32:08.732]             `+` <- base::`+`
[15:32:08.732]             `<<-` <- base::`<<-`
[15:32:08.732]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:08.732]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:08.732]                   3L)]
[15:32:08.732]             }
[15:32:08.732]             function(cond) {
[15:32:08.732]                 is_error <- inherits(cond, "error")
[15:32:08.732]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:08.732]                   NULL)
[15:32:08.732]                 if (is_error) {
[15:32:08.732]                   sessionInformation <- function() {
[15:32:08.732]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:08.732]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:08.732]                       search = base::search(), system = base::Sys.info())
[15:32:08.732]                   }
[15:32:08.732]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.732]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:08.732]                     cond$call), session = sessionInformation(), 
[15:32:08.732]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:08.732]                   signalCondition(cond)
[15:32:08.732]                 }
[15:32:08.732]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:08.732]                 "immediateCondition"))) {
[15:32:08.732]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:08.732]                   ...future.conditions[[length(...future.conditions) + 
[15:32:08.732]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:08.732]                   if (TRUE && !signal) {
[15:32:08.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.732]                     {
[15:32:08.732]                       inherits <- base::inherits
[15:32:08.732]                       invokeRestart <- base::invokeRestart
[15:32:08.732]                       is.null <- base::is.null
[15:32:08.732]                       muffled <- FALSE
[15:32:08.732]                       if (inherits(cond, "message")) {
[15:32:08.732]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.732]                         if (muffled) 
[15:32:08.732]                           invokeRestart("muffleMessage")
[15:32:08.732]                       }
[15:32:08.732]                       else if (inherits(cond, "warning")) {
[15:32:08.732]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.732]                         if (muffled) 
[15:32:08.732]                           invokeRestart("muffleWarning")
[15:32:08.732]                       }
[15:32:08.732]                       else if (inherits(cond, "condition")) {
[15:32:08.732]                         if (!is.null(pattern)) {
[15:32:08.732]                           computeRestarts <- base::computeRestarts
[15:32:08.732]                           grepl <- base::grepl
[15:32:08.732]                           restarts <- computeRestarts(cond)
[15:32:08.732]                           for (restart in restarts) {
[15:32:08.732]                             name <- restart$name
[15:32:08.732]                             if (is.null(name)) 
[15:32:08.732]                               next
[15:32:08.732]                             if (!grepl(pattern, name)) 
[15:32:08.732]                               next
[15:32:08.732]                             invokeRestart(restart)
[15:32:08.732]                             muffled <- TRUE
[15:32:08.732]                             break
[15:32:08.732]                           }
[15:32:08.732]                         }
[15:32:08.732]                       }
[15:32:08.732]                       invisible(muffled)
[15:32:08.732]                     }
[15:32:08.732]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.732]                   }
[15:32:08.732]                 }
[15:32:08.732]                 else {
[15:32:08.732]                   if (TRUE) {
[15:32:08.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:08.732]                     {
[15:32:08.732]                       inherits <- base::inherits
[15:32:08.732]                       invokeRestart <- base::invokeRestart
[15:32:08.732]                       is.null <- base::is.null
[15:32:08.732]                       muffled <- FALSE
[15:32:08.732]                       if (inherits(cond, "message")) {
[15:32:08.732]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:08.732]                         if (muffled) 
[15:32:08.732]                           invokeRestart("muffleMessage")
[15:32:08.732]                       }
[15:32:08.732]                       else if (inherits(cond, "warning")) {
[15:32:08.732]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:08.732]                         if (muffled) 
[15:32:08.732]                           invokeRestart("muffleWarning")
[15:32:08.732]                       }
[15:32:08.732]                       else if (inherits(cond, "condition")) {
[15:32:08.732]                         if (!is.null(pattern)) {
[15:32:08.732]                           computeRestarts <- base::computeRestarts
[15:32:08.732]                           grepl <- base::grepl
[15:32:08.732]                           restarts <- computeRestarts(cond)
[15:32:08.732]                           for (restart in restarts) {
[15:32:08.732]                             name <- restart$name
[15:32:08.732]                             if (is.null(name)) 
[15:32:08.732]                               next
[15:32:08.732]                             if (!grepl(pattern, name)) 
[15:32:08.732]                               next
[15:32:08.732]                             invokeRestart(restart)
[15:32:08.732]                             muffled <- TRUE
[15:32:08.732]                             break
[15:32:08.732]                           }
[15:32:08.732]                         }
[15:32:08.732]                       }
[15:32:08.732]                       invisible(muffled)
[15:32:08.732]                     }
[15:32:08.732]                     muffleCondition(cond, pattern = "^muffle")
[15:32:08.732]                   }
[15:32:08.732]                 }
[15:32:08.732]             }
[15:32:08.732]         }))
[15:32:08.732]     }, error = function(ex) {
[15:32:08.732]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:08.732]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:08.732]                 ...future.rng), started = ...future.startTime, 
[15:32:08.732]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:08.732]             version = "1.8"), class = "FutureResult")
[15:32:08.732]     }, finally = {
[15:32:08.732]         if (!identical(...future.workdir, getwd())) 
[15:32:08.732]             setwd(...future.workdir)
[15:32:08.732]         {
[15:32:08.732]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:08.732]                 ...future.oldOptions$nwarnings <- NULL
[15:32:08.732]             }
[15:32:08.732]             base::options(...future.oldOptions)
[15:32:08.732]             if (.Platform$OS.type == "windows") {
[15:32:08.732]                 old_names <- names(...future.oldEnvVars)
[15:32:08.732]                 envs <- base::Sys.getenv()
[15:32:08.732]                 names <- names(envs)
[15:32:08.732]                 common <- intersect(names, old_names)
[15:32:08.732]                 added <- setdiff(names, old_names)
[15:32:08.732]                 removed <- setdiff(old_names, names)
[15:32:08.732]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:08.732]                   envs[common]]
[15:32:08.732]                 NAMES <- toupper(changed)
[15:32:08.732]                 args <- list()
[15:32:08.732]                 for (kk in seq_along(NAMES)) {
[15:32:08.732]                   name <- changed[[kk]]
[15:32:08.732]                   NAME <- NAMES[[kk]]
[15:32:08.732]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.732]                     next
[15:32:08.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.732]                 }
[15:32:08.732]                 NAMES <- toupper(added)
[15:32:08.732]                 for (kk in seq_along(NAMES)) {
[15:32:08.732]                   name <- added[[kk]]
[15:32:08.732]                   NAME <- NAMES[[kk]]
[15:32:08.732]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.732]                     next
[15:32:08.732]                   args[[name]] <- ""
[15:32:08.732]                 }
[15:32:08.732]                 NAMES <- toupper(removed)
[15:32:08.732]                 for (kk in seq_along(NAMES)) {
[15:32:08.732]                   name <- removed[[kk]]
[15:32:08.732]                   NAME <- NAMES[[kk]]
[15:32:08.732]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:08.732]                     next
[15:32:08.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:08.732]                 }
[15:32:08.732]                 if (length(args) > 0) 
[15:32:08.732]                   base::do.call(base::Sys.setenv, args = args)
[15:32:08.732]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:08.732]             }
[15:32:08.732]             else {
[15:32:08.732]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:08.732]             }
[15:32:08.732]             {
[15:32:08.732]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:08.732]                   0L) {
[15:32:08.732]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:08.732]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:08.732]                   base::options(opts)
[15:32:08.732]                 }
[15:32:08.732]                 {
[15:32:08.732]                   {
[15:32:08.732]                     base::assign(".Random.seed", c(10407L, 1022819329L, 
[15:32:08.732]                     -493630975L, -521941550L, -1110110993L, -813666423L, 
[15:32:08.732]                     -1504908237L), envir = base::globalenv(), 
[15:32:08.732]                       inherits = FALSE)
[15:32:08.732]                     NULL
[15:32:08.732]                   }
[15:32:08.732]                   options(future.plan = NULL)
[15:32:08.732]                   if (is.na(NA_character_)) 
[15:32:08.732]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:08.732]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:08.732]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:08.732]                     .init = FALSE)
[15:32:08.732]                 }
[15:32:08.732]             }
[15:32:08.732]         }
[15:32:08.732]     })
[15:32:08.732]     if (TRUE) {
[15:32:08.732]         base::sink(type = "output", split = FALSE)
[15:32:08.732]         if (TRUE) {
[15:32:08.732]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:08.732]         }
[15:32:08.732]         else {
[15:32:08.732]             ...future.result["stdout"] <- base::list(NULL)
[15:32:08.732]         }
[15:32:08.732]         base::close(...future.stdout)
[15:32:08.732]         ...future.stdout <- NULL
[15:32:08.732]     }
[15:32:08.732]     ...future.result$conditions <- ...future.conditions
[15:32:08.732]     ...future.result$finished <- base::Sys.time()
[15:32:08.732]     ...future.result
[15:32:08.732] }
[15:32:08.738] assign_globals() ...
[15:32:08.739] List of 5
[15:32:08.739]  $ ...future.FUN            :function (x)  
[15:32:08.739]  $ MoreArgs                 : NULL
[15:32:08.739]  $ ...future.elements_ii    :List of 1
[15:32:08.739]   ..$ :List of 2
[15:32:08.739]   .. ..$ a: num 0
[15:32:08.739]   .. ..$ b: num 0
[15:32:08.739]  $ ...future.seeds_ii       : NULL
[15:32:08.739]  $ ...future.globals.maxSize: NULL
[15:32:08.739]  - attr(*, "where")=List of 5
[15:32:08.739]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:08.739]   ..$ MoreArgs                 :<environment: R_EmptyEnv> 
[15:32:08.739]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:08.739]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:08.739]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:08.739]  - attr(*, "resolved")= logi FALSE
[15:32:08.739]  - attr(*, "total_size")= num 960
[15:32:08.739]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:08.739]  - attr(*, "already-done")= logi TRUE
[15:32:08.749] - copied '...future.FUN' to environment
[15:32:08.750] - copied 'MoreArgs' to environment
[15:32:08.750] - copied '...future.elements_ii' to environment
[15:32:08.750] - copied '...future.seeds_ii' to environment
[15:32:08.751] - copied '...future.globals.maxSize' to environment
[15:32:08.751] assign_globals() ... done
[15:32:08.752] plan(): Setting new future strategy stack:
[15:32:08.752] List of future strategies:
[15:32:08.752] 1. sequential:
[15:32:08.752]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.752]    - tweaked: FALSE
[15:32:08.752]    - call: NULL
[15:32:08.753] plan(): nbrOfWorkers() = 1
[15:32:08.755] plan(): Setting new future strategy stack:
[15:32:08.756] List of future strategies:
[15:32:08.756] 1. sequential:
[15:32:08.756]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.756]    - tweaked: FALSE
[15:32:08.756]    - call: plan(strategy)
[15:32:08.757] plan(): nbrOfWorkers() = 1
[15:32:08.757] SequentialFuture started (and completed)
[15:32:08.758] - Launch lazy future ... done
[15:32:08.758] run() for 'SequentialFuture' ... done
[15:32:08.758] Created future:
[15:32:08.759] SequentialFuture:
[15:32:08.759] Label: 'future_mapply-1'
[15:32:08.759] Expression:
[15:32:08.759] {
[15:32:08.759]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:08.759]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:08.759]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:08.759]         on.exit(options(oopts), add = TRUE)
[15:32:08.759]     }
[15:32:08.759]     {
[15:32:08.759]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:08.759]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:08.759]         do.call(mapply, args = args)
[15:32:08.759]     }
[15:32:08.759] }
[15:32:08.759] Lazy evaluation: FALSE
[15:32:08.759] Asynchronous evaluation: FALSE
[15:32:08.759] Local evaluation: TRUE
[15:32:08.759] Environment: R_GlobalEnv
[15:32:08.759] Capture standard output: TRUE
[15:32:08.759] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:08.759] Globals: 5 objects totaling 960 bytes (function '...future.FUN' of 848 bytes, 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:32:08.759] Packages: <none>
[15:32:08.759] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:08.759] Resolved: TRUE
[15:32:08.759] Value: 112 bytes of class 'list'
[15:32:08.759] Early signaling: FALSE
[15:32:08.759] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:08.759] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:08.766] Chunk #1 of 1 ... DONE
[15:32:08.766] Launching 1 futures (chunks) ... DONE
[15:32:08.766] Resolving 1 futures (chunks) ...
[15:32:08.767] resolve() on list ...
[15:32:08.767]  recursive: 0
[15:32:08.767]  length: 1
[15:32:08.768] 
[15:32:08.768] resolved() for 'SequentialFuture' ...
[15:32:08.768] - state: 'finished'
[15:32:08.769] - run: TRUE
[15:32:08.769] - result: 'FutureResult'
[15:32:08.769] resolved() for 'SequentialFuture' ... done
[15:32:08.770] Future #1
[15:32:08.770] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:08.771] - nx: 1
[15:32:08.771] - relay: TRUE
[15:32:08.771] - stdout: TRUE
[15:32:08.771] - signal: TRUE
[15:32:08.772] - resignal: FALSE
[15:32:08.772] - force: TRUE
[15:32:08.772] - relayed: [n=1] FALSE
[15:32:08.773] - queued futures: [n=1] FALSE
[15:32:08.773]  - until=1
[15:32:08.773]  - relaying element #1
[15:32:08.774] - relayed: [n=1] TRUE
[15:32:08.774] - queued futures: [n=1] TRUE
[15:32:08.775] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:08.775]  length: 0 (resolved future 1)
[15:32:08.775] Relaying remaining futures
[15:32:08.776] signalConditionsASAP(NULL, pos=0) ...
[15:32:08.776] - nx: 1
[15:32:08.776] - relay: TRUE
[15:32:08.776] - stdout: TRUE
[15:32:08.777] - signal: TRUE
[15:32:08.777] - resignal: FALSE
[15:32:08.777] - force: TRUE
[15:32:08.778] - relayed: [n=1] TRUE
[15:32:08.778] - queued futures: [n=1] TRUE
 - flush all
[15:32:08.779] - relayed: [n=1] TRUE
[15:32:08.779] - queued futures: [n=1] TRUE
[15:32:08.779] signalConditionsASAP(NULL, pos=0) ... done
[15:32:08.779] resolve() on list ... DONE
[15:32:08.780]  - Number of value chunks collected: 1
[15:32:08.780] Resolving 1 futures (chunks) ... DONE
[15:32:08.780] Reducing values from 1 chunks ...
[15:32:08.781]  - Number of values collected after concatenation: 2
[15:32:08.781]  - Number of values expected: 2
[15:32:08.781] Reducing values from 1 chunks ... DONE
[15:32:08.782] future_mapply() ... DONE
[15:32:08.782] plan(): Setting new future strategy stack:
[15:32:08.782] List of future strategies:
[15:32:08.782] 1. sequential:
[15:32:08.782]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:08.782]    - tweaked: FALSE
[15:32:08.782]    - call: plan(sequential)
[15:32:08.784] plan(): nbrOfWorkers() = 1
*** strategy = 'sequential' ... done
*** strategy = 'multisession' ...
[15:32:08.785] plan(): Setting new future strategy stack:
[15:32:08.785] List of future strategies:
[15:32:08.785] 1. multisession:
[15:32:08.785]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:32:08.785]    - tweaked: FALSE
[15:32:08.785]    - call: plan(strategy)
[15:32:08.786] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:32:08.786] multisession:
[15:32:08.786] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:32:08.786] - tweaked: FALSE
[15:32:08.786] - call: plan(strategy)
[15:32:08.794] getGlobalsAndPackages() ...
[15:32:08.795] Not searching for globals
[15:32:08.795] - globals: [0] <none>
[15:32:08.796] getGlobalsAndPackages() ... DONE
[15:32:08.797] [local output] makeClusterPSOCK() ...
[15:32:08.863] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:32:08.873] [local output] Base port: 21634
[15:32:08.873] [local output] Getting setup options for 2 cluster nodes ...
[15:32:08.874] [local output]  - Node 1 of 2 ...
[15:32:08.875] [local output] localMachine=TRUE => revtunnel=FALSE

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

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

[15:32:09.331] [local output] Rscript port: 21634

[15:32:09.331] [local output] Getting setup options for 2 cluster nodes ... done
[15:32:09.332] [local output]  - Parallel setup requested for some PSOCK nodes
[15:32:09.333] [local output] Setting up PSOCK nodes in parallel
[15:32:09.333] List of 36
[15:32:09.333]  $ worker          : chr "localhost"
[15:32:09.333]   ..- attr(*, "localhost")= logi TRUE
[15:32:09.333]  $ master          : chr "localhost"
[15:32:09.333]  $ port            : int 21634
[15:32:09.333]  $ connectTimeout  : num 120
[15:32:09.333]  $ timeout         : num 120
[15:32:09.333]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:32:09.333]  $ homogeneous     : logi TRUE
[15:32:09.333]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_mapply.R:29128:CRANWIN3:C"| __truncated__
[15:32:09.333]  $ rscript_envs    : NULL
[15:32:09.333]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:32:09.333]  $ rscript_startup : NULL
[15:32:09.333]  $ rscript_sh      : chr "cmd"
[15:32:09.333]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:32:09.333]  $ methods         : logi TRUE
[15:32:09.333]  $ socketOptions   : chr "no-delay"
[15:32:09.333]  $ useXDR          : logi FALSE
[15:32:09.333]  $ outfile         : chr "/dev/null"
[15:32:09.333]  $ renice          : int NA
[15:32:09.333]  $ rshcmd          : NULL
[15:32:09.333]  $ user            : chr(0) 
[15:32:09.333]  $ revtunnel       : logi FALSE
[15:32:09.333]  $ rshlogfile      : NULL
[15:32:09.333]  $ rshopts         : chr(0) 
[15:32:09.333]  $ rank            : int 1
[15:32:09.333]  $ manual          : logi FALSE
[15:32:09.333]  $ dryrun          : logi FALSE
[15:32:09.333]  $ quiet           : logi FALSE
[15:32:09.333]  $ setup_strategy  : chr "parallel"
[15:32:09.333]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:32:09.333]  $ pidfile         : chr "D:/temp/RtmpEzFknr/worker.rank=1.parallelly.parent=29128.71c84e4c2f55.pid"
[15:32:09.333]  $ rshcmd_label    : NULL
[15:32:09.333]  $ rsh_call        : NULL
[15:32:09.333]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:32:09.333]  $ localMachine    : logi TRUE
[15:32:09.333]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:32:09.333]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:32:09.333]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:32:09.333]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:32:09.333]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:32:09.333]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:32:09.333]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:32:09.333]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:32:09.333]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:32:09.333]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:32:09.333]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:32:09.333]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:32:09.333]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:32:09.333]  $ arguments       :List of 28
[15:32:09.333]   ..$ worker          : chr "localhost"
[15:32:09.333]   ..$ master          : NULL
[15:32:09.333]   ..$ port            : int 21634
[15:32:09.333]   ..$ connectTimeout  : num 120
[15:32:09.333]   ..$ timeout         : num 120
[15:32:09.333]   ..$ rscript         : NULL
[15:32:09.333]   ..$ homogeneous     : NULL
[15:32:09.333]   ..$ rscript_args    : NULL
[15:32:09.333]   ..$ rscript_envs    : NULL
[15:32:09.333]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:32:09.333]   ..$ rscript_startup : NULL
[15:32:09.333]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:32:09.333]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:32:09.333]   ..$ methods         : logi TRUE
[15:32:09.333]   ..$ socketOptions   : chr "no-delay"
[15:32:09.333]   ..$ useXDR          : logi FALSE
[15:32:09.333]   ..$ outfile         : chr "/dev/null"
[15:32:09.333]   ..$ renice          : int NA
[15:32:09.333]   ..$ rshcmd          : NULL
[15:32:09.333]   ..$ user            : NULL
[15:32:09.333]   ..$ revtunnel       : logi NA
[15:32:09.333]   ..$ rshlogfile      : NULL
[15:32:09.333]   ..$ rshopts         : NULL
[15:32:09.333]   ..$ rank            : int 1
[15:32:09.333]   ..$ manual          : logi FALSE
[15:32:09.333]   ..$ dryrun          : logi FALSE
[15:32:09.333]   ..$ quiet           : logi FALSE
[15:32:09.333]   ..$ setup_strategy  : chr "parallel"
[15:32:09.333]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:32:09.368] [local output] System call to launch all workers:
[15:32:09.368] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_mapply.R:29128:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpEzFknr/worker.rank=1.parallelly.parent=29128.71c84e4c2f55.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=21634 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:32:09.368] [local output] Starting PSOCK main server
[15:32:09.377] [local output] Workers launched
[15:32:09.377] [local output] Waiting for workers to connect back
[15:32:09.378]  - [local output] 0 workers out of 2 ready
[15:32:09.644]  - [local output] 0 workers out of 2 ready
[15:32:09.646]  - [local output] 1 workers out of 2 ready
[15:32:09.647]  - [local output] 2 workers out of 2 ready
[15:32:09.648] [local output] Launching of workers completed
[15:32:09.648] [local output] Collecting session information from workers
[15:32:09.649] [local output]  - Worker #1 of 2
[15:32:09.650] [local output]  - Worker #2 of 2
[15:32:09.651] [local output] makeClusterPSOCK() ... done
[15:32:09.666] Packages needed by the future expression (n = 0): <none>
[15:32:09.667] Packages needed by future strategies (n = 0): <none>
[15:32:09.668] {
[15:32:09.668]     {
[15:32:09.668]         {
[15:32:09.668]             ...future.startTime <- base::Sys.time()
[15:32:09.668]             {
[15:32:09.668]                 {
[15:32:09.668]                   {
[15:32:09.668]                     {
[15:32:09.668]                       base::local({
[15:32:09.668]                         has_future <- base::requireNamespace("future", 
[15:32:09.668]                           quietly = TRUE)
[15:32:09.668]                         if (has_future) {
[15:32:09.668]                           ns <- base::getNamespace("future")
[15:32:09.668]                           version <- ns[[".package"]][["version"]]
[15:32:09.668]                           if (is.null(version)) 
[15:32:09.668]                             version <- utils::packageVersion("future")
[15:32:09.668]                         }
[15:32:09.668]                         else {
[15:32:09.668]                           version <- NULL
[15:32:09.668]                         }
[15:32:09.668]                         if (!has_future || version < "1.8.0") {
[15:32:09.668]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:09.668]                             "", base::R.version$version.string), 
[15:32:09.668]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:09.668]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:09.668]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:09.668]                               "release", "version")], collapse = " "), 
[15:32:09.668]                             hostname = base::Sys.info()[["nodename"]])
[15:32:09.668]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:09.668]                             info)
[15:32:09.668]                           info <- base::paste(info, collapse = "; ")
[15:32:09.668]                           if (!has_future) {
[15:32:09.668]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:09.668]                               info)
[15:32:09.668]                           }
[15:32:09.668]                           else {
[15:32:09.668]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:09.668]                               info, version)
[15:32:09.668]                           }
[15:32:09.668]                           base::stop(msg)
[15:32:09.668]                         }
[15:32:09.668]                       })
[15:32:09.668]                     }
[15:32:09.668]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:09.668]                     base::options(mc.cores = 1L)
[15:32:09.668]                   }
[15:32:09.668]                   ...future.strategy.old <- future::plan("list")
[15:32:09.668]                   options(future.plan = NULL)
[15:32:09.668]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:09.668]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:09.668]                 }
[15:32:09.668]                 ...future.workdir <- getwd()
[15:32:09.668]             }
[15:32:09.668]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:09.668]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:09.668]         }
[15:32:09.668]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:09.668]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:09.668]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:09.668]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:09.668]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:09.668]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:09.668]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:09.668]             base::names(...future.oldOptions))
[15:32:09.668]     }
[15:32:09.668]     if (FALSE) {
[15:32:09.668]     }
[15:32:09.668]     else {
[15:32:09.668]         if (TRUE) {
[15:32:09.668]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:09.668]                 open = "w")
[15:32:09.668]         }
[15:32:09.668]         else {
[15:32:09.668]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:09.668]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:09.668]         }
[15:32:09.668]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:09.668]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:09.668]             base::sink(type = "output", split = FALSE)
[15:32:09.668]             base::close(...future.stdout)
[15:32:09.668]         }, add = TRUE)
[15:32:09.668]     }
[15:32:09.668]     ...future.frame <- base::sys.nframe()
[15:32:09.668]     ...future.conditions <- base::list()
[15:32:09.668]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:09.668]     if (FALSE) {
[15:32:09.668]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:09.668]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:09.668]     }
[15:32:09.668]     ...future.result <- base::tryCatch({
[15:32:09.668]         base::withCallingHandlers({
[15:32:09.668]             ...future.value <- base::withVisible(base::local({
[15:32:09.668]                 ...future.makeSendCondition <- base::local({
[15:32:09.668]                   sendCondition <- NULL
[15:32:09.668]                   function(frame = 1L) {
[15:32:09.668]                     if (is.function(sendCondition)) 
[15:32:09.668]                       return(sendCondition)
[15:32:09.668]                     ns <- getNamespace("parallel")
[15:32:09.668]                     if (exists("sendData", mode = "function", 
[15:32:09.668]                       envir = ns)) {
[15:32:09.668]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:09.668]                         envir = ns)
[15:32:09.668]                       envir <- sys.frame(frame)
[15:32:09.668]                       master <- NULL
[15:32:09.668]                       while (!identical(envir, .GlobalEnv) && 
[15:32:09.668]                         !identical(envir, emptyenv())) {
[15:32:09.668]                         if (exists("master", mode = "list", envir = envir, 
[15:32:09.668]                           inherits = FALSE)) {
[15:32:09.668]                           master <- get("master", mode = "list", 
[15:32:09.668]                             envir = envir, inherits = FALSE)
[15:32:09.668]                           if (inherits(master, c("SOCKnode", 
[15:32:09.668]                             "SOCK0node"))) {
[15:32:09.668]                             sendCondition <<- function(cond) {
[15:32:09.668]                               data <- list(type = "VALUE", value = cond, 
[15:32:09.668]                                 success = TRUE)
[15:32:09.668]                               parallel_sendData(master, data)
[15:32:09.668]                             }
[15:32:09.668]                             return(sendCondition)
[15:32:09.668]                           }
[15:32:09.668]                         }
[15:32:09.668]                         frame <- frame + 1L
[15:32:09.668]                         envir <- sys.frame(frame)
[15:32:09.668]                       }
[15:32:09.668]                     }
[15:32:09.668]                     sendCondition <<- function(cond) NULL
[15:32:09.668]                   }
[15:32:09.668]                 })
[15:32:09.668]                 withCallingHandlers({
[15:32:09.668]                   NA
[15:32:09.668]                 }, immediateCondition = function(cond) {
[15:32:09.668]                   sendCondition <- ...future.makeSendCondition()
[15:32:09.668]                   sendCondition(cond)
[15:32:09.668]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:09.668]                   {
[15:32:09.668]                     inherits <- base::inherits
[15:32:09.668]                     invokeRestart <- base::invokeRestart
[15:32:09.668]                     is.null <- base::is.null
[15:32:09.668]                     muffled <- FALSE
[15:32:09.668]                     if (inherits(cond, "message")) {
[15:32:09.668]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:09.668]                       if (muffled) 
[15:32:09.668]                         invokeRestart("muffleMessage")
[15:32:09.668]                     }
[15:32:09.668]                     else if (inherits(cond, "warning")) {
[15:32:09.668]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:09.668]                       if (muffled) 
[15:32:09.668]                         invokeRestart("muffleWarning")
[15:32:09.668]                     }
[15:32:09.668]                     else if (inherits(cond, "condition")) {
[15:32:09.668]                       if (!is.null(pattern)) {
[15:32:09.668]                         computeRestarts <- base::computeRestarts
[15:32:09.668]                         grepl <- base::grepl
[15:32:09.668]                         restarts <- computeRestarts(cond)
[15:32:09.668]                         for (restart in restarts) {
[15:32:09.668]                           name <- restart$name
[15:32:09.668]                           if (is.null(name)) 
[15:32:09.668]                             next
[15:32:09.668]                           if (!grepl(pattern, name)) 
[15:32:09.668]                             next
[15:32:09.668]                           invokeRestart(restart)
[15:32:09.668]                           muffled <- TRUE
[15:32:09.668]                           break
[15:32:09.668]                         }
[15:32:09.668]                       }
[15:32:09.668]                     }
[15:32:09.668]                     invisible(muffled)
[15:32:09.668]                   }
[15:32:09.668]                   muffleCondition(cond)
[15:32:09.668]                 })
[15:32:09.668]             }))
[15:32:09.668]             future::FutureResult(value = ...future.value$value, 
[15:32:09.668]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:09.668]                   ...future.rng), globalenv = if (FALSE) 
[15:32:09.668]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:09.668]                     ...future.globalenv.names))
[15:32:09.668]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:09.668]         }, condition = base::local({
[15:32:09.668]             c <- base::c
[15:32:09.668]             inherits <- base::inherits
[15:32:09.668]             invokeRestart <- base::invokeRestart
[15:32:09.668]             length <- base::length
[15:32:09.668]             list <- base::list
[15:32:09.668]             seq.int <- base::seq.int
[15:32:09.668]             signalCondition <- base::signalCondition
[15:32:09.668]             sys.calls <- base::sys.calls
[15:32:09.668]             `[[` <- base::`[[`
[15:32:09.668]             `+` <- base::`+`
[15:32:09.668]             `<<-` <- base::`<<-`
[15:32:09.668]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:09.668]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:09.668]                   3L)]
[15:32:09.668]             }
[15:32:09.668]             function(cond) {
[15:32:09.668]                 is_error <- inherits(cond, "error")
[15:32:09.668]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:09.668]                   NULL)
[15:32:09.668]                 if (is_error) {
[15:32:09.668]                   sessionInformation <- function() {
[15:32:09.668]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:09.668]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:09.668]                       search = base::search(), system = base::Sys.info())
[15:32:09.668]                   }
[15:32:09.668]                   ...future.conditions[[length(...future.conditions) + 
[15:32:09.668]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:09.668]                     cond$call), session = sessionInformation(), 
[15:32:09.668]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:09.668]                   signalCondition(cond)
[15:32:09.668]                 }
[15:32:09.668]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:09.668]                 "immediateCondition"))) {
[15:32:09.668]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:09.668]                   ...future.conditions[[length(...future.conditions) + 
[15:32:09.668]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:09.668]                   if (TRUE && !signal) {
[15:32:09.668]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:09.668]                     {
[15:32:09.668]                       inherits <- base::inherits
[15:32:09.668]                       invokeRestart <- base::invokeRestart
[15:32:09.668]                       is.null <- base::is.null
[15:32:09.668]                       muffled <- FALSE
[15:32:09.668]                       if (inherits(cond, "message")) {
[15:32:09.668]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:09.668]                         if (muffled) 
[15:32:09.668]                           invokeRestart("muffleMessage")
[15:32:09.668]                       }
[15:32:09.668]                       else if (inherits(cond, "warning")) {
[15:32:09.668]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:09.668]                         if (muffled) 
[15:32:09.668]                           invokeRestart("muffleWarning")
[15:32:09.668]                       }
[15:32:09.668]                       else if (inherits(cond, "condition")) {
[15:32:09.668]                         if (!is.null(pattern)) {
[15:32:09.668]                           computeRestarts <- base::computeRestarts
[15:32:09.668]                           grepl <- base::grepl
[15:32:09.668]                           restarts <- computeRestarts(cond)
[15:32:09.668]                           for (restart in restarts) {
[15:32:09.668]                             name <- restart$name
[15:32:09.668]                             if (is.null(name)) 
[15:32:09.668]                               next
[15:32:09.668]                             if (!grepl(pattern, name)) 
[15:32:09.668]                               next
[15:32:09.668]                             invokeRestart(restart)
[15:32:09.668]                             muffled <- TRUE
[15:32:09.668]                             break
[15:32:09.668]                           }
[15:32:09.668]                         }
[15:32:09.668]                       }
[15:32:09.668]                       invisible(muffled)
[15:32:09.668]                     }
[15:32:09.668]                     muffleCondition(cond, pattern = "^muffle")
[15:32:09.668]                   }
[15:32:09.668]                 }
[15:32:09.668]                 else {
[15:32:09.668]                   if (TRUE) {
[15:32:09.668]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:09.668]                     {
[15:32:09.668]                       inherits <- base::inherits
[15:32:09.668]                       invokeRestart <- base::invokeRestart
[15:32:09.668]                       is.null <- base::is.null
[15:32:09.668]                       muffled <- FALSE
[15:32:09.668]                       if (inherits(cond, "message")) {
[15:32:09.668]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:09.668]                         if (muffled) 
[15:32:09.668]                           invokeRestart("muffleMessage")
[15:32:09.668]                       }
[15:32:09.668]                       else if (inherits(cond, "warning")) {
[15:32:09.668]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:09.668]                         if (muffled) 
[15:32:09.668]                           invokeRestart("muffleWarning")
[15:32:09.668]                       }
[15:32:09.668]                       else if (inherits(cond, "condition")) {
[15:32:09.668]                         if (!is.null(pattern)) {
[15:32:09.668]                           computeRestarts <- base::computeRestarts
[15:32:09.668]                           grepl <- base::grepl
[15:32:09.668]                           restarts <- computeRestarts(cond)
[15:32:09.668]                           for (restart in restarts) {
[15:32:09.668]                             name <- restart$name
[15:32:09.668]                             if (is.null(name)) 
[15:32:09.668]                               next
[15:32:09.668]                             if (!grepl(pattern, name)) 
[15:32:09.668]                               next
[15:32:09.668]                             invokeRestart(restart)
[15:32:09.668]                             muffled <- TRUE
[15:32:09.668]                             break
[15:32:09.668]                           }
[15:32:09.668]                         }
[15:32:09.668]                       }
[15:32:09.668]                       invisible(muffled)
[15:32:09.668]                     }
[15:32:09.668]                     muffleCondition(cond, pattern = "^muffle")
[15:32:09.668]                   }
[15:32:09.668]                 }
[15:32:09.668]             }
[15:32:09.668]         }))
[15:32:09.668]     }, error = function(ex) {
[15:32:09.668]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:09.668]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:09.668]                 ...future.rng), started = ...future.startTime, 
[15:32:09.668]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:09.668]             version = "1.8"), class = "FutureResult")
[15:32:09.668]     }, finally = {
[15:32:09.668]         if (!identical(...future.workdir, getwd())) 
[15:32:09.668]             setwd(...future.workdir)
[15:32:09.668]         {
[15:32:09.668]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:09.668]                 ...future.oldOptions$nwarnings <- NULL
[15:32:09.668]             }
[15:32:09.668]             base::options(...future.oldOptions)
[15:32:09.668]             if (.Platform$OS.type == "windows") {
[15:32:09.668]                 old_names <- names(...future.oldEnvVars)
[15:32:09.668]                 envs <- base::Sys.getenv()
[15:32:09.668]                 names <- names(envs)
[15:32:09.668]                 common <- intersect(names, old_names)
[15:32:09.668]                 added <- setdiff(names, old_names)
[15:32:09.668]                 removed <- setdiff(old_names, names)
[15:32:09.668]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:09.668]                   envs[common]]
[15:32:09.668]                 NAMES <- toupper(changed)
[15:32:09.668]                 args <- list()
[15:32:09.668]                 for (kk in seq_along(NAMES)) {
[15:32:09.668]                   name <- changed[[kk]]
[15:32:09.668]                   NAME <- NAMES[[kk]]
[15:32:09.668]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:09.668]                     next
[15:32:09.668]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:09.668]                 }
[15:32:09.668]                 NAMES <- toupper(added)
[15:32:09.668]                 for (kk in seq_along(NAMES)) {
[15:32:09.668]                   name <- added[[kk]]
[15:32:09.668]                   NAME <- NAMES[[kk]]
[15:32:09.668]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:09.668]                     next
[15:32:09.668]                   args[[name]] <- ""
[15:32:09.668]                 }
[15:32:09.668]                 NAMES <- toupper(removed)
[15:32:09.668]                 for (kk in seq_along(NAMES)) {
[15:32:09.668]                   name <- removed[[kk]]
[15:32:09.668]                   NAME <- NAMES[[kk]]
[15:32:09.668]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:09.668]                     next
[15:32:09.668]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:09.668]                 }
[15:32:09.668]                 if (length(args) > 0) 
[15:32:09.668]                   base::do.call(base::Sys.setenv, args = args)
[15:32:09.668]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:09.668]             }
[15:32:09.668]             else {
[15:32:09.668]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:09.668]             }
[15:32:09.668]             {
[15:32:09.668]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:09.668]                   0L) {
[15:32:09.668]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:09.668]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:09.668]                   base::options(opts)
[15:32:09.668]                 }
[15:32:09.668]                 {
[15:32:09.668]                   {
[15:32:09.668]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:09.668]                     NULL
[15:32:09.668]                   }
[15:32:09.668]                   options(future.plan = NULL)
[15:32:09.668]                   if (is.na(NA_character_)) 
[15:32:09.668]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:09.668]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:09.668]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:09.668]                     .init = FALSE)
[15:32:09.668]                 }
[15:32:09.668]             }
[15:32:09.668]         }
[15:32:09.668]     })
[15:32:09.668]     if (TRUE) {
[15:32:09.668]         base::sink(type = "output", split = FALSE)
[15:32:09.668]         if (TRUE) {
[15:32:09.668]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:09.668]         }
[15:32:09.668]         else {
[15:32:09.668]             ...future.result["stdout"] <- base::list(NULL)
[15:32:09.668]         }
[15:32:09.668]         base::close(...future.stdout)
[15:32:09.668]         ...future.stdout <- NULL
[15:32:09.668]     }
[15:32:09.668]     ...future.result$conditions <- ...future.conditions
[15:32:09.668]     ...future.result$finished <- base::Sys.time()
[15:32:09.668]     ...future.result
[15:32:09.668] }
[15:32:09.810] MultisessionFuture started
[15:32:09.810] result() for ClusterFuture ...
[15:32:09.811] receiveMessageFromWorker() for ClusterFuture ...
[15:32:09.811] - Validating connection of MultisessionFuture
[15:32:09.878] - received message: FutureResult
[15:32:09.878] - Received FutureResult
[15:32:09.884] - Erased future from FutureRegistry
[15:32:09.884] result() for ClusterFuture ...
[15:32:09.884] - result already collected: FutureResult
[15:32:09.885] result() for ClusterFuture ... done
[15:32:09.885] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:09.885] result() for ClusterFuture ... done
[15:32:09.886] result() for ClusterFuture ...
[15:32:09.886] - result already collected: FutureResult
[15:32:09.886] result() for ClusterFuture ... done
[15:32:09.887] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:32:09.891] plan(): nbrOfWorkers() = 2
- From example(mapply) ...
[15:32:09.892] future_mapply() ...
[15:32:09.897] Number of chunks: 2
[15:32:09.898] getGlobalsAndPackagesXApply() ...
[15:32:09.898]  - future.globals: TRUE
[15:32:09.898] getGlobalsAndPackages() ...
[15:32:09.899] Searching for globals...
[15:32:09.900] - globals found: [1] 'FUN'
[15:32:09.901] Searching for globals ... DONE
[15:32:09.901] Resolving globals: FALSE
[15:32:09.902] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:09.903] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:09.903] - globals: [1] 'FUN'
[15:32:09.903] 
[15:32:09.904] getGlobalsAndPackages() ... DONE
[15:32:09.904]  - globals found/used: [n=1] 'FUN'
[15:32:09.904]  - needed namespaces: [n=0] 
[15:32:09.905] Finding globals ... DONE
[15:32:09.905] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:09.906] List of 2
[15:32:09.906]  $ ...future.FUN:function (x, ...)  
[15:32:09.906]  $ MoreArgs     : NULL
[15:32:09.906]  - attr(*, "where")=List of 2
[15:32:09.906]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:09.906]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:09.906]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:09.906]  - attr(*, "resolved")= logi FALSE
[15:32:09.906]  - attr(*, "total_size")= num NA
[15:32:09.912] Packages to be attached in all futures: [n=0] 
[15:32:09.912] getGlobalsAndPackagesXApply() ... DONE
[15:32:09.913] Number of futures (= number of chunks): 2
[15:32:09.913] Launching 2 futures (chunks) ...
[15:32:09.914] Chunk #1 of 2 ...
[15:32:09.914]  - Finding globals in '...' for chunk #1 ...
[15:32:09.914] getGlobalsAndPackages() ...
[15:32:09.915] Searching for globals...
[15:32:09.915] 
[15:32:09.916] Searching for globals ... DONE
[15:32:09.916] - globals: [0] <none>
[15:32:09.916] getGlobalsAndPackages() ... DONE
[15:32:09.917]    + additional globals found: [n=0] 
[15:32:09.917]    + additional namespaces needed: [n=0] 
[15:32:09.917]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:09.918]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:09.918]  - seeds: <none>
[15:32:09.918]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:09.919] getGlobalsAndPackages() ...
[15:32:09.919] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:09.919] Resolving globals: FALSE
[15:32:09.921] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:09.922] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:09.922] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:09.923] 
[15:32:09.923] getGlobalsAndPackages() ... DONE
[15:32:09.924] run() for 'Future' ...
[15:32:09.924] - state: 'created'
[15:32:09.925] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:09.945] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:09.946] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:09.946]   - Field: 'node'
[15:32:09.947]   - Field: 'label'
[15:32:09.947]   - Field: 'local'
[15:32:09.947]   - Field: 'owner'
[15:32:09.948]   - Field: 'envir'
[15:32:09.948]   - Field: 'workers'
[15:32:09.948]   - Field: 'packages'
[15:32:09.949]   - Field: 'gc'
[15:32:09.949]   - Field: 'conditions'
[15:32:09.949]   - Field: 'persistent'
[15:32:09.950]   - Field: 'expr'
[15:32:09.950]   - Field: 'uuid'
[15:32:09.950]   - Field: 'seed'
[15:32:09.951]   - Field: 'version'
[15:32:09.951]   - Field: 'result'
[15:32:09.951]   - Field: 'asynchronous'
[15:32:09.951]   - Field: 'calls'
[15:32:09.952]   - Field: 'globals'
[15:32:09.952]   - Field: 'stdout'
[15:32:09.952]   - Field: 'earlySignal'
[15:32:09.952]   - Field: 'lazy'
[15:32:09.953]   - Field: 'state'
[15:32:09.953] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:09.953] - Launch lazy future ...
[15:32:09.954] Packages needed by the future expression (n = 0): <none>
[15:32:09.954] Packages needed by future strategies (n = 0): <none>
[15:32:09.955] {
[15:32:09.955]     {
[15:32:09.955]         {
[15:32:09.955]             ...future.startTime <- base::Sys.time()
[15:32:09.955]             {
[15:32:09.955]                 {
[15:32:09.955]                   {
[15:32:09.955]                     {
[15:32:09.955]                       base::local({
[15:32:09.955]                         has_future <- base::requireNamespace("future", 
[15:32:09.955]                           quietly = TRUE)
[15:32:09.955]                         if (has_future) {
[15:32:09.955]                           ns <- base::getNamespace("future")
[15:32:09.955]                           version <- ns[[".package"]][["version"]]
[15:32:09.955]                           if (is.null(version)) 
[15:32:09.955]                             version <- utils::packageVersion("future")
[15:32:09.955]                         }
[15:32:09.955]                         else {
[15:32:09.955]                           version <- NULL
[15:32:09.955]                         }
[15:32:09.955]                         if (!has_future || version < "1.8.0") {
[15:32:09.955]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:09.955]                             "", base::R.version$version.string), 
[15:32:09.955]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:09.955]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:09.955]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:09.955]                               "release", "version")], collapse = " "), 
[15:32:09.955]                             hostname = base::Sys.info()[["nodename"]])
[15:32:09.955]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:09.955]                             info)
[15:32:09.955]                           info <- base::paste(info, collapse = "; ")
[15:32:09.955]                           if (!has_future) {
[15:32:09.955]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:09.955]                               info)
[15:32:09.955]                           }
[15:32:09.955]                           else {
[15:32:09.955]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:09.955]                               info, version)
[15:32:09.955]                           }
[15:32:09.955]                           base::stop(msg)
[15:32:09.955]                         }
[15:32:09.955]                       })
[15:32:09.955]                     }
[15:32:09.955]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:09.955]                     base::options(mc.cores = 1L)
[15:32:09.955]                   }
[15:32:09.955]                   ...future.strategy.old <- future::plan("list")
[15:32:09.955]                   options(future.plan = NULL)
[15:32:09.955]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:09.955]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:09.955]                 }
[15:32:09.955]                 ...future.workdir <- getwd()
[15:32:09.955]             }
[15:32:09.955]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:09.955]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:09.955]         }
[15:32:09.955]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:09.955]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:09.955]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:09.955]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:09.955]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:09.955]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:09.955]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:09.955]             base::names(...future.oldOptions))
[15:32:09.955]     }
[15:32:09.955]     if (FALSE) {
[15:32:09.955]     }
[15:32:09.955]     else {
[15:32:09.955]         if (TRUE) {
[15:32:09.955]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:09.955]                 open = "w")
[15:32:09.955]         }
[15:32:09.955]         else {
[15:32:09.955]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:09.955]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:09.955]         }
[15:32:09.955]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:09.955]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:09.955]             base::sink(type = "output", split = FALSE)
[15:32:09.955]             base::close(...future.stdout)
[15:32:09.955]         }, add = TRUE)
[15:32:09.955]     }
[15:32:09.955]     ...future.frame <- base::sys.nframe()
[15:32:09.955]     ...future.conditions <- base::list()
[15:32:09.955]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:09.955]     if (FALSE) {
[15:32:09.955]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:09.955]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:09.955]     }
[15:32:09.955]     ...future.result <- base::tryCatch({
[15:32:09.955]         base::withCallingHandlers({
[15:32:09.955]             ...future.value <- base::withVisible(base::local({
[15:32:09.955]                 ...future.makeSendCondition <- base::local({
[15:32:09.955]                   sendCondition <- NULL
[15:32:09.955]                   function(frame = 1L) {
[15:32:09.955]                     if (is.function(sendCondition)) 
[15:32:09.955]                       return(sendCondition)
[15:32:09.955]                     ns <- getNamespace("parallel")
[15:32:09.955]                     if (exists("sendData", mode = "function", 
[15:32:09.955]                       envir = ns)) {
[15:32:09.955]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:09.955]                         envir = ns)
[15:32:09.955]                       envir <- sys.frame(frame)
[15:32:09.955]                       master <- NULL
[15:32:09.955]                       while (!identical(envir, .GlobalEnv) && 
[15:32:09.955]                         !identical(envir, emptyenv())) {
[15:32:09.955]                         if (exists("master", mode = "list", envir = envir, 
[15:32:09.955]                           inherits = FALSE)) {
[15:32:09.955]                           master <- get("master", mode = "list", 
[15:32:09.955]                             envir = envir, inherits = FALSE)
[15:32:09.955]                           if (inherits(master, c("SOCKnode", 
[15:32:09.955]                             "SOCK0node"))) {
[15:32:09.955]                             sendCondition <<- function(cond) {
[15:32:09.955]                               data <- list(type = "VALUE", value = cond, 
[15:32:09.955]                                 success = TRUE)
[15:32:09.955]                               parallel_sendData(master, data)
[15:32:09.955]                             }
[15:32:09.955]                             return(sendCondition)
[15:32:09.955]                           }
[15:32:09.955]                         }
[15:32:09.955]                         frame <- frame + 1L
[15:32:09.955]                         envir <- sys.frame(frame)
[15:32:09.955]                       }
[15:32:09.955]                     }
[15:32:09.955]                     sendCondition <<- function(cond) NULL
[15:32:09.955]                   }
[15:32:09.955]                 })
[15:32:09.955]                 withCallingHandlers({
[15:32:09.955]                   {
[15:32:09.955]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:09.955]                     if (!identical(...future.globals.maxSize.org, 
[15:32:09.955]                       ...future.globals.maxSize)) {
[15:32:09.955]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:09.955]                       on.exit(options(oopts), add = TRUE)
[15:32:09.955]                     }
[15:32:09.955]                     {
[15:32:09.955]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:09.955]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:09.955]                         USE.NAMES = FALSE)
[15:32:09.955]                       do.call(mapply, args = args)
[15:32:09.955]                     }
[15:32:09.955]                   }
[15:32:09.955]                 }, immediateCondition = function(cond) {
[15:32:09.955]                   sendCondition <- ...future.makeSendCondition()
[15:32:09.955]                   sendCondition(cond)
[15:32:09.955]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:09.955]                   {
[15:32:09.955]                     inherits <- base::inherits
[15:32:09.955]                     invokeRestart <- base::invokeRestart
[15:32:09.955]                     is.null <- base::is.null
[15:32:09.955]                     muffled <- FALSE
[15:32:09.955]                     if (inherits(cond, "message")) {
[15:32:09.955]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:09.955]                       if (muffled) 
[15:32:09.955]                         invokeRestart("muffleMessage")
[15:32:09.955]                     }
[15:32:09.955]                     else if (inherits(cond, "warning")) {
[15:32:09.955]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:09.955]                       if (muffled) 
[15:32:09.955]                         invokeRestart("muffleWarning")
[15:32:09.955]                     }
[15:32:09.955]                     else if (inherits(cond, "condition")) {
[15:32:09.955]                       if (!is.null(pattern)) {
[15:32:09.955]                         computeRestarts <- base::computeRestarts
[15:32:09.955]                         grepl <- base::grepl
[15:32:09.955]                         restarts <- computeRestarts(cond)
[15:32:09.955]                         for (restart in restarts) {
[15:32:09.955]                           name <- restart$name
[15:32:09.955]                           if (is.null(name)) 
[15:32:09.955]                             next
[15:32:09.955]                           if (!grepl(pattern, name)) 
[15:32:09.955]                             next
[15:32:09.955]                           invokeRestart(restart)
[15:32:09.955]                           muffled <- TRUE
[15:32:09.955]                           break
[15:32:09.955]                         }
[15:32:09.955]                       }
[15:32:09.955]                     }
[15:32:09.955]                     invisible(muffled)
[15:32:09.955]                   }
[15:32:09.955]                   muffleCondition(cond)
[15:32:09.955]                 })
[15:32:09.955]             }))
[15:32:09.955]             future::FutureResult(value = ...future.value$value, 
[15:32:09.955]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:09.955]                   ...future.rng), globalenv = if (FALSE) 
[15:32:09.955]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:09.955]                     ...future.globalenv.names))
[15:32:09.955]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:09.955]         }, condition = base::local({
[15:32:09.955]             c <- base::c
[15:32:09.955]             inherits <- base::inherits
[15:32:09.955]             invokeRestart <- base::invokeRestart
[15:32:09.955]             length <- base::length
[15:32:09.955]             list <- base::list
[15:32:09.955]             seq.int <- base::seq.int
[15:32:09.955]             signalCondition <- base::signalCondition
[15:32:09.955]             sys.calls <- base::sys.calls
[15:32:09.955]             `[[` <- base::`[[`
[15:32:09.955]             `+` <- base::`+`
[15:32:09.955]             `<<-` <- base::`<<-`
[15:32:09.955]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:09.955]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:09.955]                   3L)]
[15:32:09.955]             }
[15:32:09.955]             function(cond) {
[15:32:09.955]                 is_error <- inherits(cond, "error")
[15:32:09.955]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:09.955]                   NULL)
[15:32:09.955]                 if (is_error) {
[15:32:09.955]                   sessionInformation <- function() {
[15:32:09.955]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:09.955]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:09.955]                       search = base::search(), system = base::Sys.info())
[15:32:09.955]                   }
[15:32:09.955]                   ...future.conditions[[length(...future.conditions) + 
[15:32:09.955]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:09.955]                     cond$call), session = sessionInformation(), 
[15:32:09.955]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:09.955]                   signalCondition(cond)
[15:32:09.955]                 }
[15:32:09.955]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:09.955]                 "immediateCondition"))) {
[15:32:09.955]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:09.955]                   ...future.conditions[[length(...future.conditions) + 
[15:32:09.955]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:09.955]                   if (TRUE && !signal) {
[15:32:09.955]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:09.955]                     {
[15:32:09.955]                       inherits <- base::inherits
[15:32:09.955]                       invokeRestart <- base::invokeRestart
[15:32:09.955]                       is.null <- base::is.null
[15:32:09.955]                       muffled <- FALSE
[15:32:09.955]                       if (inherits(cond, "message")) {
[15:32:09.955]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:09.955]                         if (muffled) 
[15:32:09.955]                           invokeRestart("muffleMessage")
[15:32:09.955]                       }
[15:32:09.955]                       else if (inherits(cond, "warning")) {
[15:32:09.955]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:09.955]                         if (muffled) 
[15:32:09.955]                           invokeRestart("muffleWarning")
[15:32:09.955]                       }
[15:32:09.955]                       else if (inherits(cond, "condition")) {
[15:32:09.955]                         if (!is.null(pattern)) {
[15:32:09.955]                           computeRestarts <- base::computeRestarts
[15:32:09.955]                           grepl <- base::grepl
[15:32:09.955]                           restarts <- computeRestarts(cond)
[15:32:09.955]                           for (restart in restarts) {
[15:32:09.955]                             name <- restart$name
[15:32:09.955]                             if (is.null(name)) 
[15:32:09.955]                               next
[15:32:09.955]                             if (!grepl(pattern, name)) 
[15:32:09.955]                               next
[15:32:09.955]                             invokeRestart(restart)
[15:32:09.955]                             muffled <- TRUE
[15:32:09.955]                             break
[15:32:09.955]                           }
[15:32:09.955]                         }
[15:32:09.955]                       }
[15:32:09.955]                       invisible(muffled)
[15:32:09.955]                     }
[15:32:09.955]                     muffleCondition(cond, pattern = "^muffle")
[15:32:09.955]                   }
[15:32:09.955]                 }
[15:32:09.955]                 else {
[15:32:09.955]                   if (TRUE) {
[15:32:09.955]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:09.955]                     {
[15:32:09.955]                       inherits <- base::inherits
[15:32:09.955]                       invokeRestart <- base::invokeRestart
[15:32:09.955]                       is.null <- base::is.null
[15:32:09.955]                       muffled <- FALSE
[15:32:09.955]                       if (inherits(cond, "message")) {
[15:32:09.955]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:09.955]                         if (muffled) 
[15:32:09.955]                           invokeRestart("muffleMessage")
[15:32:09.955]                       }
[15:32:09.955]                       else if (inherits(cond, "warning")) {
[15:32:09.955]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:09.955]                         if (muffled) 
[15:32:09.955]                           invokeRestart("muffleWarning")
[15:32:09.955]                       }
[15:32:09.955]                       else if (inherits(cond, "condition")) {
[15:32:09.955]                         if (!is.null(pattern)) {
[15:32:09.955]                           computeRestarts <- base::computeRestarts
[15:32:09.955]                           grepl <- base::grepl
[15:32:09.955]                           restarts <- computeRestarts(cond)
[15:32:09.955]                           for (restart in restarts) {
[15:32:09.955]                             name <- restart$name
[15:32:09.955]                             if (is.null(name)) 
[15:32:09.955]                               next
[15:32:09.955]                             if (!grepl(pattern, name)) 
[15:32:09.955]                               next
[15:32:09.955]                             invokeRestart(restart)
[15:32:09.955]                             muffled <- TRUE
[15:32:09.955]                             break
[15:32:09.955]                           }
[15:32:09.955]                         }
[15:32:09.955]                       }
[15:32:09.955]                       invisible(muffled)
[15:32:09.955]                     }
[15:32:09.955]                     muffleCondition(cond, pattern = "^muffle")
[15:32:09.955]                   }
[15:32:09.955]                 }
[15:32:09.955]             }
[15:32:09.955]         }))
[15:32:09.955]     }, error = function(ex) {
[15:32:09.955]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:09.955]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:09.955]                 ...future.rng), started = ...future.startTime, 
[15:32:09.955]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:09.955]             version = "1.8"), class = "FutureResult")
[15:32:09.955]     }, finally = {
[15:32:09.955]         if (!identical(...future.workdir, getwd())) 
[15:32:09.955]             setwd(...future.workdir)
[15:32:09.955]         {
[15:32:09.955]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:09.955]                 ...future.oldOptions$nwarnings <- NULL
[15:32:09.955]             }
[15:32:09.955]             base::options(...future.oldOptions)
[15:32:09.955]             if (.Platform$OS.type == "windows") {
[15:32:09.955]                 old_names <- names(...future.oldEnvVars)
[15:32:09.955]                 envs <- base::Sys.getenv()
[15:32:09.955]                 names <- names(envs)
[15:32:09.955]                 common <- intersect(names, old_names)
[15:32:09.955]                 added <- setdiff(names, old_names)
[15:32:09.955]                 removed <- setdiff(old_names, names)
[15:32:09.955]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:09.955]                   envs[common]]
[15:32:09.955]                 NAMES <- toupper(changed)
[15:32:09.955]                 args <- list()
[15:32:09.955]                 for (kk in seq_along(NAMES)) {
[15:32:09.955]                   name <- changed[[kk]]
[15:32:09.955]                   NAME <- NAMES[[kk]]
[15:32:09.955]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:09.955]                     next
[15:32:09.955]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:09.955]                 }
[15:32:09.955]                 NAMES <- toupper(added)
[15:32:09.955]                 for (kk in seq_along(NAMES)) {
[15:32:09.955]                   name <- added[[kk]]
[15:32:09.955]                   NAME <- NAMES[[kk]]
[15:32:09.955]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:09.955]                     next
[15:32:09.955]                   args[[name]] <- ""
[15:32:09.955]                 }
[15:32:09.955]                 NAMES <- toupper(removed)
[15:32:09.955]                 for (kk in seq_along(NAMES)) {
[15:32:09.955]                   name <- removed[[kk]]
[15:32:09.955]                   NAME <- NAMES[[kk]]
[15:32:09.955]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:09.955]                     next
[15:32:09.955]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:09.955]                 }
[15:32:09.955]                 if (length(args) > 0) 
[15:32:09.955]                   base::do.call(base::Sys.setenv, args = args)
[15:32:09.955]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:09.955]             }
[15:32:09.955]             else {
[15:32:09.955]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:09.955]             }
[15:32:09.955]             {
[15:32:09.955]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:09.955]                   0L) {
[15:32:09.955]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:09.955]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:09.955]                   base::options(opts)
[15:32:09.955]                 }
[15:32:09.955]                 {
[15:32:09.955]                   {
[15:32:09.955]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:09.955]                     NULL
[15:32:09.955]                   }
[15:32:09.955]                   options(future.plan = NULL)
[15:32:09.955]                   if (is.na(NA_character_)) 
[15:32:09.955]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:09.955]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:09.955]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:09.955]                     .init = FALSE)
[15:32:09.955]                 }
[15:32:09.955]             }
[15:32:09.955]         }
[15:32:09.955]     })
[15:32:09.955]     if (TRUE) {
[15:32:09.955]         base::sink(type = "output", split = FALSE)
[15:32:09.955]         if (TRUE) {
[15:32:09.955]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:09.955]         }
[15:32:09.955]         else {
[15:32:09.955]             ...future.result["stdout"] <- base::list(NULL)
[15:32:09.955]         }
[15:32:09.955]         base::close(...future.stdout)
[15:32:09.955]         ...future.stdout <- NULL
[15:32:09.955]     }
[15:32:09.955]     ...future.result$conditions <- ...future.conditions
[15:32:09.955]     ...future.result$finished <- base::Sys.time()
[15:32:09.955]     ...future.result
[15:32:09.955] }
[15:32:09.962] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:09.963] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:09.964] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:09.964] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:09.965] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:09.965] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:09.966] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:09.967] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:09.968] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:09.968] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:09.969] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:09.970] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:09.971] MultisessionFuture started
[15:32:09.971] - Launch lazy future ... done
[15:32:09.971] run() for 'MultisessionFuture' ... done
[15:32:09.972] Created future:
[15:32:10.001] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.001] - Validating connection of MultisessionFuture
[15:32:10.002] - received message: FutureResult
[15:32:10.002] - Received FutureResult
[15:32:10.003] - Erased future from FutureRegistry
[15:32:10.003] result() for ClusterFuture ...
[15:32:10.003] - result already collected: FutureResult
[15:32:10.004] result() for ClusterFuture ... done
[15:32:10.004] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:09.972] MultisessionFuture:
[15:32:09.972] Label: 'future_mapply-1'
[15:32:09.972] Expression:
[15:32:09.972] {
[15:32:09.972]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:09.972]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:09.972]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:09.972]         on.exit(options(oopts), add = TRUE)
[15:32:09.972]     }
[15:32:09.972]     {
[15:32:09.972]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:09.972]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:09.972]         do.call(mapply, args = args)
[15:32:09.972]     }
[15:32:09.972] }
[15:32:09.972] Lazy evaluation: FALSE
[15:32:09.972] Asynchronous evaluation: TRUE
[15:32:09.972] Local evaluation: TRUE
[15:32:09.972] Environment: R_GlobalEnv
[15:32:09.972] Capture standard output: TRUE
[15:32:09.972] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:09.972] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:09.972] Packages: <none>
[15:32:09.972] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:09.972] Resolved: TRUE
[15:32:09.972] Value: <not collected>
[15:32:09.972] Conditions captured: <none>
[15:32:09.972] Early signaling: FALSE
[15:32:09.972] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:09.972] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.005] Chunk #1 of 2 ... DONE
[15:32:10.005] Chunk #2 of 2 ...
[15:32:10.006]  - Finding globals in '...' for chunk #2 ...
[15:32:10.006] getGlobalsAndPackages() ...
[15:32:10.006] Searching for globals...
[15:32:10.007] 
[15:32:10.008] Searching for globals ... DONE
[15:32:10.008] - globals: [0] <none>
[15:32:10.008] getGlobalsAndPackages() ... DONE
[15:32:10.009]    + additional globals found: [n=0] 
[15:32:10.009]    + additional namespaces needed: [n=0] 
[15:32:10.009]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:10.010]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.010]  - seeds: <none>
[15:32:10.010]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.011] getGlobalsAndPackages() ...
[15:32:10.011] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.011] Resolving globals: FALSE
[15:32:10.012] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:10.014] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.014] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.014] 
[15:32:10.015] getGlobalsAndPackages() ... DONE
[15:32:10.015] run() for 'Future' ...
[15:32:10.016] - state: 'created'
[15:32:10.016] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.037] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.037] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.038]   - Field: 'node'
[15:32:10.038]   - Field: 'label'
[15:32:10.039]   - Field: 'local'
[15:32:10.039]   - Field: 'owner'
[15:32:10.039]   - Field: 'envir'
[15:32:10.040]   - Field: 'workers'
[15:32:10.040]   - Field: 'packages'
[15:32:10.040]   - Field: 'gc'
[15:32:10.040]   - Field: 'conditions'
[15:32:10.041]   - Field: 'persistent'
[15:32:10.041]   - Field: 'expr'
[15:32:10.041]   - Field: 'uuid'
[15:32:10.042]   - Field: 'seed'
[15:32:10.042]   - Field: 'version'
[15:32:10.042]   - Field: 'result'
[15:32:10.043]   - Field: 'asynchronous'
[15:32:10.043]   - Field: 'calls'
[15:32:10.043]   - Field: 'globals'
[15:32:10.044]   - Field: 'stdout'
[15:32:10.044]   - Field: 'earlySignal'
[15:32:10.045]   - Field: 'lazy'
[15:32:10.045]   - Field: 'state'
[15:32:10.045] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.046] - Launch lazy future ...
[15:32:10.047] Packages needed by the future expression (n = 0): <none>
[15:32:10.047] Packages needed by future strategies (n = 0): <none>
[15:32:10.048] {
[15:32:10.048]     {
[15:32:10.048]         {
[15:32:10.048]             ...future.startTime <- base::Sys.time()
[15:32:10.048]             {
[15:32:10.048]                 {
[15:32:10.048]                   {
[15:32:10.048]                     {
[15:32:10.048]                       base::local({
[15:32:10.048]                         has_future <- base::requireNamespace("future", 
[15:32:10.048]                           quietly = TRUE)
[15:32:10.048]                         if (has_future) {
[15:32:10.048]                           ns <- base::getNamespace("future")
[15:32:10.048]                           version <- ns[[".package"]][["version"]]
[15:32:10.048]                           if (is.null(version)) 
[15:32:10.048]                             version <- utils::packageVersion("future")
[15:32:10.048]                         }
[15:32:10.048]                         else {
[15:32:10.048]                           version <- NULL
[15:32:10.048]                         }
[15:32:10.048]                         if (!has_future || version < "1.8.0") {
[15:32:10.048]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.048]                             "", base::R.version$version.string), 
[15:32:10.048]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.048]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.048]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.048]                               "release", "version")], collapse = " "), 
[15:32:10.048]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.048]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.048]                             info)
[15:32:10.048]                           info <- base::paste(info, collapse = "; ")
[15:32:10.048]                           if (!has_future) {
[15:32:10.048]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.048]                               info)
[15:32:10.048]                           }
[15:32:10.048]                           else {
[15:32:10.048]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.048]                               info, version)
[15:32:10.048]                           }
[15:32:10.048]                           base::stop(msg)
[15:32:10.048]                         }
[15:32:10.048]                       })
[15:32:10.048]                     }
[15:32:10.048]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.048]                     base::options(mc.cores = 1L)
[15:32:10.048]                   }
[15:32:10.048]                   ...future.strategy.old <- future::plan("list")
[15:32:10.048]                   options(future.plan = NULL)
[15:32:10.048]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.048]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.048]                 }
[15:32:10.048]                 ...future.workdir <- getwd()
[15:32:10.048]             }
[15:32:10.048]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.048]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.048]         }
[15:32:10.048]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.048]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.048]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.048]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.048]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.048]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.048]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.048]             base::names(...future.oldOptions))
[15:32:10.048]     }
[15:32:10.048]     if (FALSE) {
[15:32:10.048]     }
[15:32:10.048]     else {
[15:32:10.048]         if (TRUE) {
[15:32:10.048]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.048]                 open = "w")
[15:32:10.048]         }
[15:32:10.048]         else {
[15:32:10.048]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.048]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.048]         }
[15:32:10.048]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.048]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.048]             base::sink(type = "output", split = FALSE)
[15:32:10.048]             base::close(...future.stdout)
[15:32:10.048]         }, add = TRUE)
[15:32:10.048]     }
[15:32:10.048]     ...future.frame <- base::sys.nframe()
[15:32:10.048]     ...future.conditions <- base::list()
[15:32:10.048]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.048]     if (FALSE) {
[15:32:10.048]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.048]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.048]     }
[15:32:10.048]     ...future.result <- base::tryCatch({
[15:32:10.048]         base::withCallingHandlers({
[15:32:10.048]             ...future.value <- base::withVisible(base::local({
[15:32:10.048]                 ...future.makeSendCondition <- base::local({
[15:32:10.048]                   sendCondition <- NULL
[15:32:10.048]                   function(frame = 1L) {
[15:32:10.048]                     if (is.function(sendCondition)) 
[15:32:10.048]                       return(sendCondition)
[15:32:10.048]                     ns <- getNamespace("parallel")
[15:32:10.048]                     if (exists("sendData", mode = "function", 
[15:32:10.048]                       envir = ns)) {
[15:32:10.048]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.048]                         envir = ns)
[15:32:10.048]                       envir <- sys.frame(frame)
[15:32:10.048]                       master <- NULL
[15:32:10.048]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.048]                         !identical(envir, emptyenv())) {
[15:32:10.048]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.048]                           inherits = FALSE)) {
[15:32:10.048]                           master <- get("master", mode = "list", 
[15:32:10.048]                             envir = envir, inherits = FALSE)
[15:32:10.048]                           if (inherits(master, c("SOCKnode", 
[15:32:10.048]                             "SOCK0node"))) {
[15:32:10.048]                             sendCondition <<- function(cond) {
[15:32:10.048]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.048]                                 success = TRUE)
[15:32:10.048]                               parallel_sendData(master, data)
[15:32:10.048]                             }
[15:32:10.048]                             return(sendCondition)
[15:32:10.048]                           }
[15:32:10.048]                         }
[15:32:10.048]                         frame <- frame + 1L
[15:32:10.048]                         envir <- sys.frame(frame)
[15:32:10.048]                       }
[15:32:10.048]                     }
[15:32:10.048]                     sendCondition <<- function(cond) NULL
[15:32:10.048]                   }
[15:32:10.048]                 })
[15:32:10.048]                 withCallingHandlers({
[15:32:10.048]                   {
[15:32:10.048]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.048]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.048]                       ...future.globals.maxSize)) {
[15:32:10.048]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.048]                       on.exit(options(oopts), add = TRUE)
[15:32:10.048]                     }
[15:32:10.048]                     {
[15:32:10.048]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.048]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.048]                         USE.NAMES = FALSE)
[15:32:10.048]                       do.call(mapply, args = args)
[15:32:10.048]                     }
[15:32:10.048]                   }
[15:32:10.048]                 }, immediateCondition = function(cond) {
[15:32:10.048]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.048]                   sendCondition(cond)
[15:32:10.048]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.048]                   {
[15:32:10.048]                     inherits <- base::inherits
[15:32:10.048]                     invokeRestart <- base::invokeRestart
[15:32:10.048]                     is.null <- base::is.null
[15:32:10.048]                     muffled <- FALSE
[15:32:10.048]                     if (inherits(cond, "message")) {
[15:32:10.048]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.048]                       if (muffled) 
[15:32:10.048]                         invokeRestart("muffleMessage")
[15:32:10.048]                     }
[15:32:10.048]                     else if (inherits(cond, "warning")) {
[15:32:10.048]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.048]                       if (muffled) 
[15:32:10.048]                         invokeRestart("muffleWarning")
[15:32:10.048]                     }
[15:32:10.048]                     else if (inherits(cond, "condition")) {
[15:32:10.048]                       if (!is.null(pattern)) {
[15:32:10.048]                         computeRestarts <- base::computeRestarts
[15:32:10.048]                         grepl <- base::grepl
[15:32:10.048]                         restarts <- computeRestarts(cond)
[15:32:10.048]                         for (restart in restarts) {
[15:32:10.048]                           name <- restart$name
[15:32:10.048]                           if (is.null(name)) 
[15:32:10.048]                             next
[15:32:10.048]                           if (!grepl(pattern, name)) 
[15:32:10.048]                             next
[15:32:10.048]                           invokeRestart(restart)
[15:32:10.048]                           muffled <- TRUE
[15:32:10.048]                           break
[15:32:10.048]                         }
[15:32:10.048]                       }
[15:32:10.048]                     }
[15:32:10.048]                     invisible(muffled)
[15:32:10.048]                   }
[15:32:10.048]                   muffleCondition(cond)
[15:32:10.048]                 })
[15:32:10.048]             }))
[15:32:10.048]             future::FutureResult(value = ...future.value$value, 
[15:32:10.048]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.048]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.048]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.048]                     ...future.globalenv.names))
[15:32:10.048]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.048]         }, condition = base::local({
[15:32:10.048]             c <- base::c
[15:32:10.048]             inherits <- base::inherits
[15:32:10.048]             invokeRestart <- base::invokeRestart
[15:32:10.048]             length <- base::length
[15:32:10.048]             list <- base::list
[15:32:10.048]             seq.int <- base::seq.int
[15:32:10.048]             signalCondition <- base::signalCondition
[15:32:10.048]             sys.calls <- base::sys.calls
[15:32:10.048]             `[[` <- base::`[[`
[15:32:10.048]             `+` <- base::`+`
[15:32:10.048]             `<<-` <- base::`<<-`
[15:32:10.048]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.048]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.048]                   3L)]
[15:32:10.048]             }
[15:32:10.048]             function(cond) {
[15:32:10.048]                 is_error <- inherits(cond, "error")
[15:32:10.048]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.048]                   NULL)
[15:32:10.048]                 if (is_error) {
[15:32:10.048]                   sessionInformation <- function() {
[15:32:10.048]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.048]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.048]                       search = base::search(), system = base::Sys.info())
[15:32:10.048]                   }
[15:32:10.048]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.048]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.048]                     cond$call), session = sessionInformation(), 
[15:32:10.048]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.048]                   signalCondition(cond)
[15:32:10.048]                 }
[15:32:10.048]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.048]                 "immediateCondition"))) {
[15:32:10.048]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.048]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.048]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.048]                   if (TRUE && !signal) {
[15:32:10.048]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.048]                     {
[15:32:10.048]                       inherits <- base::inherits
[15:32:10.048]                       invokeRestart <- base::invokeRestart
[15:32:10.048]                       is.null <- base::is.null
[15:32:10.048]                       muffled <- FALSE
[15:32:10.048]                       if (inherits(cond, "message")) {
[15:32:10.048]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.048]                         if (muffled) 
[15:32:10.048]                           invokeRestart("muffleMessage")
[15:32:10.048]                       }
[15:32:10.048]                       else if (inherits(cond, "warning")) {
[15:32:10.048]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.048]                         if (muffled) 
[15:32:10.048]                           invokeRestart("muffleWarning")
[15:32:10.048]                       }
[15:32:10.048]                       else if (inherits(cond, "condition")) {
[15:32:10.048]                         if (!is.null(pattern)) {
[15:32:10.048]                           computeRestarts <- base::computeRestarts
[15:32:10.048]                           grepl <- base::grepl
[15:32:10.048]                           restarts <- computeRestarts(cond)
[15:32:10.048]                           for (restart in restarts) {
[15:32:10.048]                             name <- restart$name
[15:32:10.048]                             if (is.null(name)) 
[15:32:10.048]                               next
[15:32:10.048]                             if (!grepl(pattern, name)) 
[15:32:10.048]                               next
[15:32:10.048]                             invokeRestart(restart)
[15:32:10.048]                             muffled <- TRUE
[15:32:10.048]                             break
[15:32:10.048]                           }
[15:32:10.048]                         }
[15:32:10.048]                       }
[15:32:10.048]                       invisible(muffled)
[15:32:10.048]                     }
[15:32:10.048]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.048]                   }
[15:32:10.048]                 }
[15:32:10.048]                 else {
[15:32:10.048]                   if (TRUE) {
[15:32:10.048]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.048]                     {
[15:32:10.048]                       inherits <- base::inherits
[15:32:10.048]                       invokeRestart <- base::invokeRestart
[15:32:10.048]                       is.null <- base::is.null
[15:32:10.048]                       muffled <- FALSE
[15:32:10.048]                       if (inherits(cond, "message")) {
[15:32:10.048]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.048]                         if (muffled) 
[15:32:10.048]                           invokeRestart("muffleMessage")
[15:32:10.048]                       }
[15:32:10.048]                       else if (inherits(cond, "warning")) {
[15:32:10.048]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.048]                         if (muffled) 
[15:32:10.048]                           invokeRestart("muffleWarning")
[15:32:10.048]                       }
[15:32:10.048]                       else if (inherits(cond, "condition")) {
[15:32:10.048]                         if (!is.null(pattern)) {
[15:32:10.048]                           computeRestarts <- base::computeRestarts
[15:32:10.048]                           grepl <- base::grepl
[15:32:10.048]                           restarts <- computeRestarts(cond)
[15:32:10.048]                           for (restart in restarts) {
[15:32:10.048]                             name <- restart$name
[15:32:10.048]                             if (is.null(name)) 
[15:32:10.048]                               next
[15:32:10.048]                             if (!grepl(pattern, name)) 
[15:32:10.048]                               next
[15:32:10.048]                             invokeRestart(restart)
[15:32:10.048]                             muffled <- TRUE
[15:32:10.048]                             break
[15:32:10.048]                           }
[15:32:10.048]                         }
[15:32:10.048]                       }
[15:32:10.048]                       invisible(muffled)
[15:32:10.048]                     }
[15:32:10.048]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.048]                   }
[15:32:10.048]                 }
[15:32:10.048]             }
[15:32:10.048]         }))
[15:32:10.048]     }, error = function(ex) {
[15:32:10.048]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.048]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.048]                 ...future.rng), started = ...future.startTime, 
[15:32:10.048]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.048]             version = "1.8"), class = "FutureResult")
[15:32:10.048]     }, finally = {
[15:32:10.048]         if (!identical(...future.workdir, getwd())) 
[15:32:10.048]             setwd(...future.workdir)
[15:32:10.048]         {
[15:32:10.048]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.048]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.048]             }
[15:32:10.048]             base::options(...future.oldOptions)
[15:32:10.048]             if (.Platform$OS.type == "windows") {
[15:32:10.048]                 old_names <- names(...future.oldEnvVars)
[15:32:10.048]                 envs <- base::Sys.getenv()
[15:32:10.048]                 names <- names(envs)
[15:32:10.048]                 common <- intersect(names, old_names)
[15:32:10.048]                 added <- setdiff(names, old_names)
[15:32:10.048]                 removed <- setdiff(old_names, names)
[15:32:10.048]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.048]                   envs[common]]
[15:32:10.048]                 NAMES <- toupper(changed)
[15:32:10.048]                 args <- list()
[15:32:10.048]                 for (kk in seq_along(NAMES)) {
[15:32:10.048]                   name <- changed[[kk]]
[15:32:10.048]                   NAME <- NAMES[[kk]]
[15:32:10.048]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.048]                     next
[15:32:10.048]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.048]                 }
[15:32:10.048]                 NAMES <- toupper(added)
[15:32:10.048]                 for (kk in seq_along(NAMES)) {
[15:32:10.048]                   name <- added[[kk]]
[15:32:10.048]                   NAME <- NAMES[[kk]]
[15:32:10.048]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.048]                     next
[15:32:10.048]                   args[[name]] <- ""
[15:32:10.048]                 }
[15:32:10.048]                 NAMES <- toupper(removed)
[15:32:10.048]                 for (kk in seq_along(NAMES)) {
[15:32:10.048]                   name <- removed[[kk]]
[15:32:10.048]                   NAME <- NAMES[[kk]]
[15:32:10.048]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.048]                     next
[15:32:10.048]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.048]                 }
[15:32:10.048]                 if (length(args) > 0) 
[15:32:10.048]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.048]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.048]             }
[15:32:10.048]             else {
[15:32:10.048]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.048]             }
[15:32:10.048]             {
[15:32:10.048]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.048]                   0L) {
[15:32:10.048]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.048]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.048]                   base::options(opts)
[15:32:10.048]                 }
[15:32:10.048]                 {
[15:32:10.048]                   {
[15:32:10.048]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.048]                     NULL
[15:32:10.048]                   }
[15:32:10.048]                   options(future.plan = NULL)
[15:32:10.048]                   if (is.na(NA_character_)) 
[15:32:10.048]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.048]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.048]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.048]                     .init = FALSE)
[15:32:10.048]                 }
[15:32:10.048]             }
[15:32:10.048]         }
[15:32:10.048]     })
[15:32:10.048]     if (TRUE) {
[15:32:10.048]         base::sink(type = "output", split = FALSE)
[15:32:10.048]         if (TRUE) {
[15:32:10.048]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.048]         }
[15:32:10.048]         else {
[15:32:10.048]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.048]         }
[15:32:10.048]         base::close(...future.stdout)
[15:32:10.048]         ...future.stdout <- NULL
[15:32:10.048]     }
[15:32:10.048]     ...future.result$conditions <- ...future.conditions
[15:32:10.048]     ...future.result$finished <- base::Sys.time()
[15:32:10.048]     ...future.result
[15:32:10.048] }
[15:32:10.058] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:10.059] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.060] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.060] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.061] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.061] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:10.062] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:10.063] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.063] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.064] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.064] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.065] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:10.066] MultisessionFuture started
[15:32:10.066] - Launch lazy future ... done
[15:32:10.067] run() for 'MultisessionFuture' ... done
[15:32:10.067] Created future:
[15:32:10.092] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.093] - Validating connection of MultisessionFuture
[15:32:10.094] - received message: FutureResult
[15:32:10.094] - Received FutureResult
[15:32:10.094] - Erased future from FutureRegistry
[15:32:10.095] result() for ClusterFuture ...
[15:32:10.095] - result already collected: FutureResult
[15:32:10.095] result() for ClusterFuture ... done
[15:32:10.096] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.067] MultisessionFuture:
[15:32:10.067] Label: 'future_mapply-2'
[15:32:10.067] Expression:
[15:32:10.067] {
[15:32:10.067]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.067]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.067]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.067]         on.exit(options(oopts), add = TRUE)
[15:32:10.067]     }
[15:32:10.067]     {
[15:32:10.067]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.067]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.067]         do.call(mapply, args = args)
[15:32:10.067]     }
[15:32:10.067] }
[15:32:10.067] Lazy evaluation: FALSE
[15:32:10.067] Asynchronous evaluation: TRUE
[15:32:10.067] Local evaluation: TRUE
[15:32:10.067] Environment: R_GlobalEnv
[15:32:10.067] Capture standard output: TRUE
[15:32:10.067] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.067] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:10.067] Packages: <none>
[15:32:10.067] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.067] Resolved: TRUE
[15:32:10.067] Value: <not collected>
[15:32:10.067] Conditions captured: <none>
[15:32:10.067] Early signaling: FALSE
[15:32:10.067] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.067] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.096] Chunk #2 of 2 ... DONE
[15:32:10.097] Launching 2 futures (chunks) ... DONE
[15:32:10.097] Resolving 2 futures (chunks) ...
[15:32:10.097] resolve() on list ...
[15:32:10.098]  recursive: 0
[15:32:10.098]  length: 2
[15:32:10.098] 
[15:32:10.099] Future #1
[15:32:10.099] result() for ClusterFuture ...
[15:32:10.099] - result already collected: FutureResult
[15:32:10.100] result() for ClusterFuture ... done
[15:32:10.100] result() for ClusterFuture ...
[15:32:10.100] - result already collected: FutureResult
[15:32:10.100] result() for ClusterFuture ... done
[15:32:10.101] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:10.101] - nx: 2
[15:32:10.101] - relay: TRUE
[15:32:10.102] - stdout: TRUE
[15:32:10.102] - signal: TRUE
[15:32:10.102] - resignal: FALSE
[15:32:10.102] - force: TRUE
[15:32:10.103] - relayed: [n=2] FALSE, FALSE
[15:32:10.103] - queued futures: [n=2] FALSE, FALSE
[15:32:10.103]  - until=1
[15:32:10.104]  - relaying element #1
[15:32:10.104] result() for ClusterFuture ...
[15:32:10.104] - result already collected: FutureResult
[15:32:10.104] result() for ClusterFuture ... done
[15:32:10.105] result() for ClusterFuture ...
[15:32:10.105] - result already collected: FutureResult
[15:32:10.105] result() for ClusterFuture ... done
[15:32:10.106] result() for ClusterFuture ...
[15:32:10.106] - result already collected: FutureResult
[15:32:10.106] result() for ClusterFuture ... done
[15:32:10.107] result() for ClusterFuture ...
[15:32:10.107] - result already collected: FutureResult
[15:32:10.107] result() for ClusterFuture ... done
[15:32:10.107] - relayed: [n=2] TRUE, FALSE
[15:32:10.108] - queued futures: [n=2] TRUE, FALSE
[15:32:10.108] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:10.108]  length: 1 (resolved future 1)
[15:32:10.109] Future #2
[15:32:10.109] result() for ClusterFuture ...
[15:32:10.109] - result already collected: FutureResult
[15:32:10.110] result() for ClusterFuture ... done
[15:32:10.110] result() for ClusterFuture ...
[15:32:10.110] - result already collected: FutureResult
[15:32:10.115] result() for ClusterFuture ... done
[15:32:10.115] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:10.116] - nx: 2
[15:32:10.116] - relay: TRUE
[15:32:10.116] - stdout: TRUE
[15:32:10.116] - signal: TRUE
[15:32:10.117] - resignal: FALSE
[15:32:10.117] - force: TRUE
[15:32:10.117] - relayed: [n=2] TRUE, FALSE
[15:32:10.118] - queued futures: [n=2] TRUE, FALSE
[15:32:10.118]  - until=2
[15:32:10.118]  - relaying element #2
[15:32:10.119] result() for ClusterFuture ...
[15:32:10.119] - result already collected: FutureResult
[15:32:10.119] result() for ClusterFuture ... done
[15:32:10.119] result() for ClusterFuture ...
[15:32:10.120] - result already collected: FutureResult
[15:32:10.120] result() for ClusterFuture ... done
[15:32:10.120] result() for ClusterFuture ...
[15:32:10.121] - result already collected: FutureResult
[15:32:10.121] result() for ClusterFuture ... done
[15:32:10.121] result() for ClusterFuture ...
[15:32:10.122] - result already collected: FutureResult
[15:32:10.122] result() for ClusterFuture ... done
[15:32:10.122] - relayed: [n=2] TRUE, TRUE
[15:32:10.122] - queued futures: [n=2] TRUE, TRUE
[15:32:10.123] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:10.123]  length: 0 (resolved future 2)
[15:32:10.123] Relaying remaining futures
[15:32:10.124] signalConditionsASAP(NULL, pos=0) ...
[15:32:10.124] - nx: 2
[15:32:10.124] - relay: TRUE
[15:32:10.125] - stdout: TRUE
[15:32:10.125] - signal: TRUE
[15:32:10.125] - resignal: FALSE
[15:32:10.125] - force: TRUE
[15:32:10.126] - relayed: [n=2] TRUE, TRUE
[15:32:10.126] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:10.127] - relayed: [n=2] TRUE, TRUE
[15:32:10.127] - queued futures: [n=2] TRUE, TRUE
[15:32:10.127] signalConditionsASAP(NULL, pos=0) ... done
[15:32:10.127] resolve() on list ... DONE
[15:32:10.128] result() for ClusterFuture ...
[15:32:10.128] - result already collected: FutureResult
[15:32:10.128] result() for ClusterFuture ... done
[15:32:10.129] result() for ClusterFuture ...
[15:32:10.129] - result already collected: FutureResult
[15:32:10.129] result() for ClusterFuture ... done
[15:32:10.130] result() for ClusterFuture ...
[15:32:10.130] - result already collected: FutureResult
[15:32:10.130] result() for ClusterFuture ... done
[15:32:10.131] result() for ClusterFuture ...
[15:32:10.131] - result already collected: FutureResult
[15:32:10.131] result() for ClusterFuture ... done
[15:32:10.132]  - Number of value chunks collected: 2
[15:32:10.132] Resolving 2 futures (chunks) ... DONE
[15:32:10.132] Reducing values from 2 chunks ...
[15:32:10.132]  - Number of values collected after concatenation: 4
[15:32:10.133]  - Number of values expected: 4
[15:32:10.133] Reducing values from 2 chunks ... DONE
[15:32:10.133] future_mapply() ... DONE
[15:32:10.134] future_mapply() ...
[15:32:10.139] Number of chunks: 2
[15:32:10.139] getGlobalsAndPackagesXApply() ...
[15:32:10.139]  - future.globals: TRUE
[15:32:10.140] getGlobalsAndPackages() ...
[15:32:10.140] Searching for globals...
[15:32:10.142] - globals found: [1] 'FUN'
[15:32:10.142] Searching for globals ... DONE
[15:32:10.142] Resolving globals: FALSE
[15:32:10.143] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:10.144] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:10.144] - globals: [1] 'FUN'
[15:32:10.145] 
[15:32:10.145] getGlobalsAndPackages() ... DONE
[15:32:10.145]  - globals found/used: [n=1] 'FUN'
[15:32:10.146]  - needed namespaces: [n=0] 
[15:32:10.146] Finding globals ... DONE
[15:32:10.146] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:10.147] List of 2
[15:32:10.147]  $ ...future.FUN:function (x, ...)  
[15:32:10.147]  $ MoreArgs     : NULL
[15:32:10.147]  - attr(*, "where")=List of 2
[15:32:10.147]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:10.147]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:10.147]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:10.147]  - attr(*, "resolved")= logi FALSE
[15:32:10.147]  - attr(*, "total_size")= num NA
[15:32:10.153] Packages to be attached in all futures: [n=0] 
[15:32:10.153] getGlobalsAndPackagesXApply() ... DONE
[15:32:10.153] Number of futures (= number of chunks): 2
[15:32:10.154] Launching 2 futures (chunks) ...
[15:32:10.154] Chunk #1 of 2 ...
[15:32:10.154]  - Finding globals in '...' for chunk #1 ...
[15:32:10.155] getGlobalsAndPackages() ...
[15:32:10.155] Searching for globals...
[15:32:10.156] 
[15:32:10.156] Searching for globals ... DONE
[15:32:10.156] - globals: [0] <none>
[15:32:10.157] getGlobalsAndPackages() ... DONE
[15:32:10.157]    + additional globals found: [n=0] 
[15:32:10.157]    + additional namespaces needed: [n=0] 
[15:32:10.158]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:10.158]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.158]  - seeds: <none>
[15:32:10.159]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.159] getGlobalsAndPackages() ...
[15:32:10.159] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.160] Resolving globals: FALSE
[15:32:10.161] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:10.162] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.162] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.163] 
[15:32:10.163] getGlobalsAndPackages() ... DONE
[15:32:10.164] run() for 'Future' ...
[15:32:10.164] - state: 'created'
[15:32:10.165] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.189] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.190] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.190]   - Field: 'node'
[15:32:10.191]   - Field: 'label'
[15:32:10.191]   - Field: 'local'
[15:32:10.191]   - Field: 'owner'
[15:32:10.192]   - Field: 'envir'
[15:32:10.192]   - Field: 'workers'
[15:32:10.192]   - Field: 'packages'
[15:32:10.193]   - Field: 'gc'
[15:32:10.193]   - Field: 'conditions'
[15:32:10.193]   - Field: 'persistent'
[15:32:10.194]   - Field: 'expr'
[15:32:10.194]   - Field: 'uuid'
[15:32:10.194]   - Field: 'seed'
[15:32:10.195]   - Field: 'version'
[15:32:10.195]   - Field: 'result'
[15:32:10.195]   - Field: 'asynchronous'
[15:32:10.196]   - Field: 'calls'
[15:32:10.196]   - Field: 'globals'
[15:32:10.196]   - Field: 'stdout'
[15:32:10.197]   - Field: 'earlySignal'
[15:32:10.197]   - Field: 'lazy'
[15:32:10.197]   - Field: 'state'
[15:32:10.198] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.198] - Launch lazy future ...
[15:32:10.199] Packages needed by the future expression (n = 0): <none>
[15:32:10.199] Packages needed by future strategies (n = 0): <none>
[15:32:10.201] {
[15:32:10.201]     {
[15:32:10.201]         {
[15:32:10.201]             ...future.startTime <- base::Sys.time()
[15:32:10.201]             {
[15:32:10.201]                 {
[15:32:10.201]                   {
[15:32:10.201]                     {
[15:32:10.201]                       base::local({
[15:32:10.201]                         has_future <- base::requireNamespace("future", 
[15:32:10.201]                           quietly = TRUE)
[15:32:10.201]                         if (has_future) {
[15:32:10.201]                           ns <- base::getNamespace("future")
[15:32:10.201]                           version <- ns[[".package"]][["version"]]
[15:32:10.201]                           if (is.null(version)) 
[15:32:10.201]                             version <- utils::packageVersion("future")
[15:32:10.201]                         }
[15:32:10.201]                         else {
[15:32:10.201]                           version <- NULL
[15:32:10.201]                         }
[15:32:10.201]                         if (!has_future || version < "1.8.0") {
[15:32:10.201]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.201]                             "", base::R.version$version.string), 
[15:32:10.201]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.201]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.201]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.201]                               "release", "version")], collapse = " "), 
[15:32:10.201]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.201]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.201]                             info)
[15:32:10.201]                           info <- base::paste(info, collapse = "; ")
[15:32:10.201]                           if (!has_future) {
[15:32:10.201]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.201]                               info)
[15:32:10.201]                           }
[15:32:10.201]                           else {
[15:32:10.201]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.201]                               info, version)
[15:32:10.201]                           }
[15:32:10.201]                           base::stop(msg)
[15:32:10.201]                         }
[15:32:10.201]                       })
[15:32:10.201]                     }
[15:32:10.201]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.201]                     base::options(mc.cores = 1L)
[15:32:10.201]                   }
[15:32:10.201]                   ...future.strategy.old <- future::plan("list")
[15:32:10.201]                   options(future.plan = NULL)
[15:32:10.201]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.201]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.201]                 }
[15:32:10.201]                 ...future.workdir <- getwd()
[15:32:10.201]             }
[15:32:10.201]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.201]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.201]         }
[15:32:10.201]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.201]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.201]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.201]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.201]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.201]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.201]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.201]             base::names(...future.oldOptions))
[15:32:10.201]     }
[15:32:10.201]     if (FALSE) {
[15:32:10.201]     }
[15:32:10.201]     else {
[15:32:10.201]         if (TRUE) {
[15:32:10.201]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.201]                 open = "w")
[15:32:10.201]         }
[15:32:10.201]         else {
[15:32:10.201]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.201]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.201]         }
[15:32:10.201]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.201]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.201]             base::sink(type = "output", split = FALSE)
[15:32:10.201]             base::close(...future.stdout)
[15:32:10.201]         }, add = TRUE)
[15:32:10.201]     }
[15:32:10.201]     ...future.frame <- base::sys.nframe()
[15:32:10.201]     ...future.conditions <- base::list()
[15:32:10.201]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.201]     if (FALSE) {
[15:32:10.201]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.201]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.201]     }
[15:32:10.201]     ...future.result <- base::tryCatch({
[15:32:10.201]         base::withCallingHandlers({
[15:32:10.201]             ...future.value <- base::withVisible(base::local({
[15:32:10.201]                 ...future.makeSendCondition <- base::local({
[15:32:10.201]                   sendCondition <- NULL
[15:32:10.201]                   function(frame = 1L) {
[15:32:10.201]                     if (is.function(sendCondition)) 
[15:32:10.201]                       return(sendCondition)
[15:32:10.201]                     ns <- getNamespace("parallel")
[15:32:10.201]                     if (exists("sendData", mode = "function", 
[15:32:10.201]                       envir = ns)) {
[15:32:10.201]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.201]                         envir = ns)
[15:32:10.201]                       envir <- sys.frame(frame)
[15:32:10.201]                       master <- NULL
[15:32:10.201]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.201]                         !identical(envir, emptyenv())) {
[15:32:10.201]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.201]                           inherits = FALSE)) {
[15:32:10.201]                           master <- get("master", mode = "list", 
[15:32:10.201]                             envir = envir, inherits = FALSE)
[15:32:10.201]                           if (inherits(master, c("SOCKnode", 
[15:32:10.201]                             "SOCK0node"))) {
[15:32:10.201]                             sendCondition <<- function(cond) {
[15:32:10.201]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.201]                                 success = TRUE)
[15:32:10.201]                               parallel_sendData(master, data)
[15:32:10.201]                             }
[15:32:10.201]                             return(sendCondition)
[15:32:10.201]                           }
[15:32:10.201]                         }
[15:32:10.201]                         frame <- frame + 1L
[15:32:10.201]                         envir <- sys.frame(frame)
[15:32:10.201]                       }
[15:32:10.201]                     }
[15:32:10.201]                     sendCondition <<- function(cond) NULL
[15:32:10.201]                   }
[15:32:10.201]                 })
[15:32:10.201]                 withCallingHandlers({
[15:32:10.201]                   {
[15:32:10.201]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.201]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.201]                       ...future.globals.maxSize)) {
[15:32:10.201]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.201]                       on.exit(options(oopts), add = TRUE)
[15:32:10.201]                     }
[15:32:10.201]                     {
[15:32:10.201]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.201]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.201]                         USE.NAMES = FALSE)
[15:32:10.201]                       do.call(mapply, args = args)
[15:32:10.201]                     }
[15:32:10.201]                   }
[15:32:10.201]                 }, immediateCondition = function(cond) {
[15:32:10.201]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.201]                   sendCondition(cond)
[15:32:10.201]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.201]                   {
[15:32:10.201]                     inherits <- base::inherits
[15:32:10.201]                     invokeRestart <- base::invokeRestart
[15:32:10.201]                     is.null <- base::is.null
[15:32:10.201]                     muffled <- FALSE
[15:32:10.201]                     if (inherits(cond, "message")) {
[15:32:10.201]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.201]                       if (muffled) 
[15:32:10.201]                         invokeRestart("muffleMessage")
[15:32:10.201]                     }
[15:32:10.201]                     else if (inherits(cond, "warning")) {
[15:32:10.201]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.201]                       if (muffled) 
[15:32:10.201]                         invokeRestart("muffleWarning")
[15:32:10.201]                     }
[15:32:10.201]                     else if (inherits(cond, "condition")) {
[15:32:10.201]                       if (!is.null(pattern)) {
[15:32:10.201]                         computeRestarts <- base::computeRestarts
[15:32:10.201]                         grepl <- base::grepl
[15:32:10.201]                         restarts <- computeRestarts(cond)
[15:32:10.201]                         for (restart in restarts) {
[15:32:10.201]                           name <- restart$name
[15:32:10.201]                           if (is.null(name)) 
[15:32:10.201]                             next
[15:32:10.201]                           if (!grepl(pattern, name)) 
[15:32:10.201]                             next
[15:32:10.201]                           invokeRestart(restart)
[15:32:10.201]                           muffled <- TRUE
[15:32:10.201]                           break
[15:32:10.201]                         }
[15:32:10.201]                       }
[15:32:10.201]                     }
[15:32:10.201]                     invisible(muffled)
[15:32:10.201]                   }
[15:32:10.201]                   muffleCondition(cond)
[15:32:10.201]                 })
[15:32:10.201]             }))
[15:32:10.201]             future::FutureResult(value = ...future.value$value, 
[15:32:10.201]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.201]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.201]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.201]                     ...future.globalenv.names))
[15:32:10.201]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.201]         }, condition = base::local({
[15:32:10.201]             c <- base::c
[15:32:10.201]             inherits <- base::inherits
[15:32:10.201]             invokeRestart <- base::invokeRestart
[15:32:10.201]             length <- base::length
[15:32:10.201]             list <- base::list
[15:32:10.201]             seq.int <- base::seq.int
[15:32:10.201]             signalCondition <- base::signalCondition
[15:32:10.201]             sys.calls <- base::sys.calls
[15:32:10.201]             `[[` <- base::`[[`
[15:32:10.201]             `+` <- base::`+`
[15:32:10.201]             `<<-` <- base::`<<-`
[15:32:10.201]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.201]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.201]                   3L)]
[15:32:10.201]             }
[15:32:10.201]             function(cond) {
[15:32:10.201]                 is_error <- inherits(cond, "error")
[15:32:10.201]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.201]                   NULL)
[15:32:10.201]                 if (is_error) {
[15:32:10.201]                   sessionInformation <- function() {
[15:32:10.201]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.201]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.201]                       search = base::search(), system = base::Sys.info())
[15:32:10.201]                   }
[15:32:10.201]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.201]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.201]                     cond$call), session = sessionInformation(), 
[15:32:10.201]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.201]                   signalCondition(cond)
[15:32:10.201]                 }
[15:32:10.201]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.201]                 "immediateCondition"))) {
[15:32:10.201]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.201]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.201]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.201]                   if (TRUE && !signal) {
[15:32:10.201]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.201]                     {
[15:32:10.201]                       inherits <- base::inherits
[15:32:10.201]                       invokeRestart <- base::invokeRestart
[15:32:10.201]                       is.null <- base::is.null
[15:32:10.201]                       muffled <- FALSE
[15:32:10.201]                       if (inherits(cond, "message")) {
[15:32:10.201]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.201]                         if (muffled) 
[15:32:10.201]                           invokeRestart("muffleMessage")
[15:32:10.201]                       }
[15:32:10.201]                       else if (inherits(cond, "warning")) {
[15:32:10.201]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.201]                         if (muffled) 
[15:32:10.201]                           invokeRestart("muffleWarning")
[15:32:10.201]                       }
[15:32:10.201]                       else if (inherits(cond, "condition")) {
[15:32:10.201]                         if (!is.null(pattern)) {
[15:32:10.201]                           computeRestarts <- base::computeRestarts
[15:32:10.201]                           grepl <- base::grepl
[15:32:10.201]                           restarts <- computeRestarts(cond)
[15:32:10.201]                           for (restart in restarts) {
[15:32:10.201]                             name <- restart$name
[15:32:10.201]                             if (is.null(name)) 
[15:32:10.201]                               next
[15:32:10.201]                             if (!grepl(pattern, name)) 
[15:32:10.201]                               next
[15:32:10.201]                             invokeRestart(restart)
[15:32:10.201]                             muffled <- TRUE
[15:32:10.201]                             break
[15:32:10.201]                           }
[15:32:10.201]                         }
[15:32:10.201]                       }
[15:32:10.201]                       invisible(muffled)
[15:32:10.201]                     }
[15:32:10.201]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.201]                   }
[15:32:10.201]                 }
[15:32:10.201]                 else {
[15:32:10.201]                   if (TRUE) {
[15:32:10.201]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.201]                     {
[15:32:10.201]                       inherits <- base::inherits
[15:32:10.201]                       invokeRestart <- base::invokeRestart
[15:32:10.201]                       is.null <- base::is.null
[15:32:10.201]                       muffled <- FALSE
[15:32:10.201]                       if (inherits(cond, "message")) {
[15:32:10.201]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.201]                         if (muffled) 
[15:32:10.201]                           invokeRestart("muffleMessage")
[15:32:10.201]                       }
[15:32:10.201]                       else if (inherits(cond, "warning")) {
[15:32:10.201]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.201]                         if (muffled) 
[15:32:10.201]                           invokeRestart("muffleWarning")
[15:32:10.201]                       }
[15:32:10.201]                       else if (inherits(cond, "condition")) {
[15:32:10.201]                         if (!is.null(pattern)) {
[15:32:10.201]                           computeRestarts <- base::computeRestarts
[15:32:10.201]                           grepl <- base::grepl
[15:32:10.201]                           restarts <- computeRestarts(cond)
[15:32:10.201]                           for (restart in restarts) {
[15:32:10.201]                             name <- restart$name
[15:32:10.201]                             if (is.null(name)) 
[15:32:10.201]                               next
[15:32:10.201]                             if (!grepl(pattern, name)) 
[15:32:10.201]                               next
[15:32:10.201]                             invokeRestart(restart)
[15:32:10.201]                             muffled <- TRUE
[15:32:10.201]                             break
[15:32:10.201]                           }
[15:32:10.201]                         }
[15:32:10.201]                       }
[15:32:10.201]                       invisible(muffled)
[15:32:10.201]                     }
[15:32:10.201]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.201]                   }
[15:32:10.201]                 }
[15:32:10.201]             }
[15:32:10.201]         }))
[15:32:10.201]     }, error = function(ex) {
[15:32:10.201]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.201]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.201]                 ...future.rng), started = ...future.startTime, 
[15:32:10.201]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.201]             version = "1.8"), class = "FutureResult")
[15:32:10.201]     }, finally = {
[15:32:10.201]         if (!identical(...future.workdir, getwd())) 
[15:32:10.201]             setwd(...future.workdir)
[15:32:10.201]         {
[15:32:10.201]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.201]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.201]             }
[15:32:10.201]             base::options(...future.oldOptions)
[15:32:10.201]             if (.Platform$OS.type == "windows") {
[15:32:10.201]                 old_names <- names(...future.oldEnvVars)
[15:32:10.201]                 envs <- base::Sys.getenv()
[15:32:10.201]                 names <- names(envs)
[15:32:10.201]                 common <- intersect(names, old_names)
[15:32:10.201]                 added <- setdiff(names, old_names)
[15:32:10.201]                 removed <- setdiff(old_names, names)
[15:32:10.201]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.201]                   envs[common]]
[15:32:10.201]                 NAMES <- toupper(changed)
[15:32:10.201]                 args <- list()
[15:32:10.201]                 for (kk in seq_along(NAMES)) {
[15:32:10.201]                   name <- changed[[kk]]
[15:32:10.201]                   NAME <- NAMES[[kk]]
[15:32:10.201]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.201]                     next
[15:32:10.201]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.201]                 }
[15:32:10.201]                 NAMES <- toupper(added)
[15:32:10.201]                 for (kk in seq_along(NAMES)) {
[15:32:10.201]                   name <- added[[kk]]
[15:32:10.201]                   NAME <- NAMES[[kk]]
[15:32:10.201]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.201]                     next
[15:32:10.201]                   args[[name]] <- ""
[15:32:10.201]                 }
[15:32:10.201]                 NAMES <- toupper(removed)
[15:32:10.201]                 for (kk in seq_along(NAMES)) {
[15:32:10.201]                   name <- removed[[kk]]
[15:32:10.201]                   NAME <- NAMES[[kk]]
[15:32:10.201]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.201]                     next
[15:32:10.201]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.201]                 }
[15:32:10.201]                 if (length(args) > 0) 
[15:32:10.201]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.201]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.201]             }
[15:32:10.201]             else {
[15:32:10.201]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.201]             }
[15:32:10.201]             {
[15:32:10.201]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.201]                   0L) {
[15:32:10.201]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.201]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.201]                   base::options(opts)
[15:32:10.201]                 }
[15:32:10.201]                 {
[15:32:10.201]                   {
[15:32:10.201]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.201]                     NULL
[15:32:10.201]                   }
[15:32:10.201]                   options(future.plan = NULL)
[15:32:10.201]                   if (is.na(NA_character_)) 
[15:32:10.201]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.201]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.201]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.201]                     .init = FALSE)
[15:32:10.201]                 }
[15:32:10.201]             }
[15:32:10.201]         }
[15:32:10.201]     })
[15:32:10.201]     if (TRUE) {
[15:32:10.201]         base::sink(type = "output", split = FALSE)
[15:32:10.201]         if (TRUE) {
[15:32:10.201]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.201]         }
[15:32:10.201]         else {
[15:32:10.201]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.201]         }
[15:32:10.201]         base::close(...future.stdout)
[15:32:10.201]         ...future.stdout <- NULL
[15:32:10.201]     }
[15:32:10.201]     ...future.result$conditions <- ...future.conditions
[15:32:10.201]     ...future.result$finished <- base::Sys.time()
[15:32:10.201]     ...future.result
[15:32:10.201] }
[15:32:10.212] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:10.212] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.213] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.213] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.214] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.215] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:10.216] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:10.216] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.217] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.217] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.218] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.218] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:10.219] MultisessionFuture started
[15:32:10.220] - Launch lazy future ... done
[15:32:10.220] run() for 'MultisessionFuture' ... done
[15:32:10.221] Created future:
[15:32:10.245] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.246] - Validating connection of MultisessionFuture
[15:32:10.246] - received message: FutureResult
[15:32:10.247] - Received FutureResult
[15:32:10.247] - Erased future from FutureRegistry
[15:32:10.247] result() for ClusterFuture ...
[15:32:10.248] - result already collected: FutureResult
[15:32:10.248] result() for ClusterFuture ... done
[15:32:10.248] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.221] MultisessionFuture:
[15:32:10.221] Label: 'future_mapply-1'
[15:32:10.221] Expression:
[15:32:10.221] {
[15:32:10.221]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.221]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.221]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.221]         on.exit(options(oopts), add = TRUE)
[15:32:10.221]     }
[15:32:10.221]     {
[15:32:10.221]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.221]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.221]         do.call(mapply, args = args)
[15:32:10.221]     }
[15:32:10.221] }
[15:32:10.221] Lazy evaluation: FALSE
[15:32:10.221] Asynchronous evaluation: TRUE
[15:32:10.221] Local evaluation: TRUE
[15:32:10.221] Environment: R_GlobalEnv
[15:32:10.221] Capture standard output: TRUE
[15:32:10.221] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.221] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:10.221] Packages: <none>
[15:32:10.221] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.221] Resolved: TRUE
[15:32:10.221] Value: <not collected>
[15:32:10.221] Conditions captured: <none>
[15:32:10.221] Early signaling: FALSE
[15:32:10.221] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.221] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.249] Chunk #1 of 2 ... DONE
[15:32:10.250] Chunk #2 of 2 ...
[15:32:10.250]  - Finding globals in '...' for chunk #2 ...
[15:32:10.250] getGlobalsAndPackages() ...
[15:32:10.251] Searching for globals...
[15:32:10.252] 
[15:32:10.252] Searching for globals ... DONE
[15:32:10.252] - globals: [0] <none>
[15:32:10.252] getGlobalsAndPackages() ... DONE
[15:32:10.253]    + additional globals found: [n=0] 
[15:32:10.253]    + additional namespaces needed: [n=0] 
[15:32:10.253]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:10.254]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.254]  - seeds: <none>
[15:32:10.254]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.255] getGlobalsAndPackages() ...
[15:32:10.255] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.255] Resolving globals: FALSE
[15:32:10.257] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:10.258] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.258] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.259] 
[15:32:10.259] getGlobalsAndPackages() ... DONE
[15:32:10.260] run() for 'Future' ...
[15:32:10.260] - state: 'created'
[15:32:10.260] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.282] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.283]   - Field: 'node'
[15:32:10.284]   - Field: 'label'
[15:32:10.284]   - Field: 'local'
[15:32:10.284]   - Field: 'owner'
[15:32:10.285]   - Field: 'envir'
[15:32:10.285]   - Field: 'workers'
[15:32:10.285]   - Field: 'packages'
[15:32:10.286]   - Field: 'gc'
[15:32:10.286]   - Field: 'conditions'
[15:32:10.286]   - Field: 'persistent'
[15:32:10.287]   - Field: 'expr'
[15:32:10.287]   - Field: 'uuid'
[15:32:10.287]   - Field: 'seed'
[15:32:10.288]   - Field: 'version'
[15:32:10.288]   - Field: 'result'
[15:32:10.288]   - Field: 'asynchronous'
[15:32:10.289]   - Field: 'calls'
[15:32:10.289]   - Field: 'globals'
[15:32:10.289]   - Field: 'stdout'
[15:32:10.290]   - Field: 'earlySignal'
[15:32:10.290]   - Field: 'lazy'
[15:32:10.290]   - Field: 'state'
[15:32:10.291] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.291] - Launch lazy future ...
[15:32:10.292] Packages needed by the future expression (n = 0): <none>
[15:32:10.292] Packages needed by future strategies (n = 0): <none>
[15:32:10.293] {
[15:32:10.293]     {
[15:32:10.293]         {
[15:32:10.293]             ...future.startTime <- base::Sys.time()
[15:32:10.293]             {
[15:32:10.293]                 {
[15:32:10.293]                   {
[15:32:10.293]                     {
[15:32:10.293]                       base::local({
[15:32:10.293]                         has_future <- base::requireNamespace("future", 
[15:32:10.293]                           quietly = TRUE)
[15:32:10.293]                         if (has_future) {
[15:32:10.293]                           ns <- base::getNamespace("future")
[15:32:10.293]                           version <- ns[[".package"]][["version"]]
[15:32:10.293]                           if (is.null(version)) 
[15:32:10.293]                             version <- utils::packageVersion("future")
[15:32:10.293]                         }
[15:32:10.293]                         else {
[15:32:10.293]                           version <- NULL
[15:32:10.293]                         }
[15:32:10.293]                         if (!has_future || version < "1.8.0") {
[15:32:10.293]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.293]                             "", base::R.version$version.string), 
[15:32:10.293]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.293]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.293]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.293]                               "release", "version")], collapse = " "), 
[15:32:10.293]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.293]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.293]                             info)
[15:32:10.293]                           info <- base::paste(info, collapse = "; ")
[15:32:10.293]                           if (!has_future) {
[15:32:10.293]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.293]                               info)
[15:32:10.293]                           }
[15:32:10.293]                           else {
[15:32:10.293]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.293]                               info, version)
[15:32:10.293]                           }
[15:32:10.293]                           base::stop(msg)
[15:32:10.293]                         }
[15:32:10.293]                       })
[15:32:10.293]                     }
[15:32:10.293]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.293]                     base::options(mc.cores = 1L)
[15:32:10.293]                   }
[15:32:10.293]                   ...future.strategy.old <- future::plan("list")
[15:32:10.293]                   options(future.plan = NULL)
[15:32:10.293]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.293]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.293]                 }
[15:32:10.293]                 ...future.workdir <- getwd()
[15:32:10.293]             }
[15:32:10.293]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.293]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.293]         }
[15:32:10.293]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.293]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.293]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.293]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.293]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.293]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.293]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.293]             base::names(...future.oldOptions))
[15:32:10.293]     }
[15:32:10.293]     if (FALSE) {
[15:32:10.293]     }
[15:32:10.293]     else {
[15:32:10.293]         if (TRUE) {
[15:32:10.293]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.293]                 open = "w")
[15:32:10.293]         }
[15:32:10.293]         else {
[15:32:10.293]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.293]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.293]         }
[15:32:10.293]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.293]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.293]             base::sink(type = "output", split = FALSE)
[15:32:10.293]             base::close(...future.stdout)
[15:32:10.293]         }, add = TRUE)
[15:32:10.293]     }
[15:32:10.293]     ...future.frame <- base::sys.nframe()
[15:32:10.293]     ...future.conditions <- base::list()
[15:32:10.293]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.293]     if (FALSE) {
[15:32:10.293]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.293]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.293]     }
[15:32:10.293]     ...future.result <- base::tryCatch({
[15:32:10.293]         base::withCallingHandlers({
[15:32:10.293]             ...future.value <- base::withVisible(base::local({
[15:32:10.293]                 ...future.makeSendCondition <- base::local({
[15:32:10.293]                   sendCondition <- NULL
[15:32:10.293]                   function(frame = 1L) {
[15:32:10.293]                     if (is.function(sendCondition)) 
[15:32:10.293]                       return(sendCondition)
[15:32:10.293]                     ns <- getNamespace("parallel")
[15:32:10.293]                     if (exists("sendData", mode = "function", 
[15:32:10.293]                       envir = ns)) {
[15:32:10.293]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.293]                         envir = ns)
[15:32:10.293]                       envir <- sys.frame(frame)
[15:32:10.293]                       master <- NULL
[15:32:10.293]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.293]                         !identical(envir, emptyenv())) {
[15:32:10.293]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.293]                           inherits = FALSE)) {
[15:32:10.293]                           master <- get("master", mode = "list", 
[15:32:10.293]                             envir = envir, inherits = FALSE)
[15:32:10.293]                           if (inherits(master, c("SOCKnode", 
[15:32:10.293]                             "SOCK0node"))) {
[15:32:10.293]                             sendCondition <<- function(cond) {
[15:32:10.293]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.293]                                 success = TRUE)
[15:32:10.293]                               parallel_sendData(master, data)
[15:32:10.293]                             }
[15:32:10.293]                             return(sendCondition)
[15:32:10.293]                           }
[15:32:10.293]                         }
[15:32:10.293]                         frame <- frame + 1L
[15:32:10.293]                         envir <- sys.frame(frame)
[15:32:10.293]                       }
[15:32:10.293]                     }
[15:32:10.293]                     sendCondition <<- function(cond) NULL
[15:32:10.293]                   }
[15:32:10.293]                 })
[15:32:10.293]                 withCallingHandlers({
[15:32:10.293]                   {
[15:32:10.293]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.293]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.293]                       ...future.globals.maxSize)) {
[15:32:10.293]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.293]                       on.exit(options(oopts), add = TRUE)
[15:32:10.293]                     }
[15:32:10.293]                     {
[15:32:10.293]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.293]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.293]                         USE.NAMES = FALSE)
[15:32:10.293]                       do.call(mapply, args = args)
[15:32:10.293]                     }
[15:32:10.293]                   }
[15:32:10.293]                 }, immediateCondition = function(cond) {
[15:32:10.293]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.293]                   sendCondition(cond)
[15:32:10.293]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.293]                   {
[15:32:10.293]                     inherits <- base::inherits
[15:32:10.293]                     invokeRestart <- base::invokeRestart
[15:32:10.293]                     is.null <- base::is.null
[15:32:10.293]                     muffled <- FALSE
[15:32:10.293]                     if (inherits(cond, "message")) {
[15:32:10.293]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.293]                       if (muffled) 
[15:32:10.293]                         invokeRestart("muffleMessage")
[15:32:10.293]                     }
[15:32:10.293]                     else if (inherits(cond, "warning")) {
[15:32:10.293]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.293]                       if (muffled) 
[15:32:10.293]                         invokeRestart("muffleWarning")
[15:32:10.293]                     }
[15:32:10.293]                     else if (inherits(cond, "condition")) {
[15:32:10.293]                       if (!is.null(pattern)) {
[15:32:10.293]                         computeRestarts <- base::computeRestarts
[15:32:10.293]                         grepl <- base::grepl
[15:32:10.293]                         restarts <- computeRestarts(cond)
[15:32:10.293]                         for (restart in restarts) {
[15:32:10.293]                           name <- restart$name
[15:32:10.293]                           if (is.null(name)) 
[15:32:10.293]                             next
[15:32:10.293]                           if (!grepl(pattern, name)) 
[15:32:10.293]                             next
[15:32:10.293]                           invokeRestart(restart)
[15:32:10.293]                           muffled <- TRUE
[15:32:10.293]                           break
[15:32:10.293]                         }
[15:32:10.293]                       }
[15:32:10.293]                     }
[15:32:10.293]                     invisible(muffled)
[15:32:10.293]                   }
[15:32:10.293]                   muffleCondition(cond)
[15:32:10.293]                 })
[15:32:10.293]             }))
[15:32:10.293]             future::FutureResult(value = ...future.value$value, 
[15:32:10.293]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.293]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.293]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.293]                     ...future.globalenv.names))
[15:32:10.293]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.293]         }, condition = base::local({
[15:32:10.293]             c <- base::c
[15:32:10.293]             inherits <- base::inherits
[15:32:10.293]             invokeRestart <- base::invokeRestart
[15:32:10.293]             length <- base::length
[15:32:10.293]             list <- base::list
[15:32:10.293]             seq.int <- base::seq.int
[15:32:10.293]             signalCondition <- base::signalCondition
[15:32:10.293]             sys.calls <- base::sys.calls
[15:32:10.293]             `[[` <- base::`[[`
[15:32:10.293]             `+` <- base::`+`
[15:32:10.293]             `<<-` <- base::`<<-`
[15:32:10.293]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.293]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.293]                   3L)]
[15:32:10.293]             }
[15:32:10.293]             function(cond) {
[15:32:10.293]                 is_error <- inherits(cond, "error")
[15:32:10.293]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.293]                   NULL)
[15:32:10.293]                 if (is_error) {
[15:32:10.293]                   sessionInformation <- function() {
[15:32:10.293]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.293]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.293]                       search = base::search(), system = base::Sys.info())
[15:32:10.293]                   }
[15:32:10.293]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.293]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.293]                     cond$call), session = sessionInformation(), 
[15:32:10.293]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.293]                   signalCondition(cond)
[15:32:10.293]                 }
[15:32:10.293]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.293]                 "immediateCondition"))) {
[15:32:10.293]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.293]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.293]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.293]                   if (TRUE && !signal) {
[15:32:10.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.293]                     {
[15:32:10.293]                       inherits <- base::inherits
[15:32:10.293]                       invokeRestart <- base::invokeRestart
[15:32:10.293]                       is.null <- base::is.null
[15:32:10.293]                       muffled <- FALSE
[15:32:10.293]                       if (inherits(cond, "message")) {
[15:32:10.293]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.293]                         if (muffled) 
[15:32:10.293]                           invokeRestart("muffleMessage")
[15:32:10.293]                       }
[15:32:10.293]                       else if (inherits(cond, "warning")) {
[15:32:10.293]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.293]                         if (muffled) 
[15:32:10.293]                           invokeRestart("muffleWarning")
[15:32:10.293]                       }
[15:32:10.293]                       else if (inherits(cond, "condition")) {
[15:32:10.293]                         if (!is.null(pattern)) {
[15:32:10.293]                           computeRestarts <- base::computeRestarts
[15:32:10.293]                           grepl <- base::grepl
[15:32:10.293]                           restarts <- computeRestarts(cond)
[15:32:10.293]                           for (restart in restarts) {
[15:32:10.293]                             name <- restart$name
[15:32:10.293]                             if (is.null(name)) 
[15:32:10.293]                               next
[15:32:10.293]                             if (!grepl(pattern, name)) 
[15:32:10.293]                               next
[15:32:10.293]                             invokeRestart(restart)
[15:32:10.293]                             muffled <- TRUE
[15:32:10.293]                             break
[15:32:10.293]                           }
[15:32:10.293]                         }
[15:32:10.293]                       }
[15:32:10.293]                       invisible(muffled)
[15:32:10.293]                     }
[15:32:10.293]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.293]                   }
[15:32:10.293]                 }
[15:32:10.293]                 else {
[15:32:10.293]                   if (TRUE) {
[15:32:10.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.293]                     {
[15:32:10.293]                       inherits <- base::inherits
[15:32:10.293]                       invokeRestart <- base::invokeRestart
[15:32:10.293]                       is.null <- base::is.null
[15:32:10.293]                       muffled <- FALSE
[15:32:10.293]                       if (inherits(cond, "message")) {
[15:32:10.293]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.293]                         if (muffled) 
[15:32:10.293]                           invokeRestart("muffleMessage")
[15:32:10.293]                       }
[15:32:10.293]                       else if (inherits(cond, "warning")) {
[15:32:10.293]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.293]                         if (muffled) 
[15:32:10.293]                           invokeRestart("muffleWarning")
[15:32:10.293]                       }
[15:32:10.293]                       else if (inherits(cond, "condition")) {
[15:32:10.293]                         if (!is.null(pattern)) {
[15:32:10.293]                           computeRestarts <- base::computeRestarts
[15:32:10.293]                           grepl <- base::grepl
[15:32:10.293]                           restarts <- computeRestarts(cond)
[15:32:10.293]                           for (restart in restarts) {
[15:32:10.293]                             name <- restart$name
[15:32:10.293]                             if (is.null(name)) 
[15:32:10.293]                               next
[15:32:10.293]                             if (!grepl(pattern, name)) 
[15:32:10.293]                               next
[15:32:10.293]                             invokeRestart(restart)
[15:32:10.293]                             muffled <- TRUE
[15:32:10.293]                             break
[15:32:10.293]                           }
[15:32:10.293]                         }
[15:32:10.293]                       }
[15:32:10.293]                       invisible(muffled)
[15:32:10.293]                     }
[15:32:10.293]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.293]                   }
[15:32:10.293]                 }
[15:32:10.293]             }
[15:32:10.293]         }))
[15:32:10.293]     }, error = function(ex) {
[15:32:10.293]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.293]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.293]                 ...future.rng), started = ...future.startTime, 
[15:32:10.293]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.293]             version = "1.8"), class = "FutureResult")
[15:32:10.293]     }, finally = {
[15:32:10.293]         if (!identical(...future.workdir, getwd())) 
[15:32:10.293]             setwd(...future.workdir)
[15:32:10.293]         {
[15:32:10.293]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.293]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.293]             }
[15:32:10.293]             base::options(...future.oldOptions)
[15:32:10.293]             if (.Platform$OS.type == "windows") {
[15:32:10.293]                 old_names <- names(...future.oldEnvVars)
[15:32:10.293]                 envs <- base::Sys.getenv()
[15:32:10.293]                 names <- names(envs)
[15:32:10.293]                 common <- intersect(names, old_names)
[15:32:10.293]                 added <- setdiff(names, old_names)
[15:32:10.293]                 removed <- setdiff(old_names, names)
[15:32:10.293]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.293]                   envs[common]]
[15:32:10.293]                 NAMES <- toupper(changed)
[15:32:10.293]                 args <- list()
[15:32:10.293]                 for (kk in seq_along(NAMES)) {
[15:32:10.293]                   name <- changed[[kk]]
[15:32:10.293]                   NAME <- NAMES[[kk]]
[15:32:10.293]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.293]                     next
[15:32:10.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.293]                 }
[15:32:10.293]                 NAMES <- toupper(added)
[15:32:10.293]                 for (kk in seq_along(NAMES)) {
[15:32:10.293]                   name <- added[[kk]]
[15:32:10.293]                   NAME <- NAMES[[kk]]
[15:32:10.293]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.293]                     next
[15:32:10.293]                   args[[name]] <- ""
[15:32:10.293]                 }
[15:32:10.293]                 NAMES <- toupper(removed)
[15:32:10.293]                 for (kk in seq_along(NAMES)) {
[15:32:10.293]                   name <- removed[[kk]]
[15:32:10.293]                   NAME <- NAMES[[kk]]
[15:32:10.293]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.293]                     next
[15:32:10.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.293]                 }
[15:32:10.293]                 if (length(args) > 0) 
[15:32:10.293]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.293]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.293]             }
[15:32:10.293]             else {
[15:32:10.293]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.293]             }
[15:32:10.293]             {
[15:32:10.293]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.293]                   0L) {
[15:32:10.293]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.293]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.293]                   base::options(opts)
[15:32:10.293]                 }
[15:32:10.293]                 {
[15:32:10.293]                   {
[15:32:10.293]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.293]                     NULL
[15:32:10.293]                   }
[15:32:10.293]                   options(future.plan = NULL)
[15:32:10.293]                   if (is.na(NA_character_)) 
[15:32:10.293]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.293]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.293]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.293]                     .init = FALSE)
[15:32:10.293]                 }
[15:32:10.293]             }
[15:32:10.293]         }
[15:32:10.293]     })
[15:32:10.293]     if (TRUE) {
[15:32:10.293]         base::sink(type = "output", split = FALSE)
[15:32:10.293]         if (TRUE) {
[15:32:10.293]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.293]         }
[15:32:10.293]         else {
[15:32:10.293]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.293]         }
[15:32:10.293]         base::close(...future.stdout)
[15:32:10.293]         ...future.stdout <- NULL
[15:32:10.293]     }
[15:32:10.293]     ...future.result$conditions <- ...future.conditions
[15:32:10.293]     ...future.result$finished <- base::Sys.time()
[15:32:10.293]     ...future.result
[15:32:10.293] }
[15:32:10.304] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:10.305] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.306] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.306] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.307] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.307] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:10.308] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:10.308] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.309] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.309] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.310] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.310] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:10.312] MultisessionFuture started
[15:32:10.312] - Launch lazy future ... done
[15:32:10.312] run() for 'MultisessionFuture' ... done
[15:32:10.313] Created future:
[15:32:10.339] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.340] - Validating connection of MultisessionFuture
[15:32:10.341] - received message: FutureResult
[15:32:10.341] - Received FutureResult
[15:32:10.341] - Erased future from FutureRegistry
[15:32:10.342] result() for ClusterFuture ...
[15:32:10.342] - result already collected: FutureResult
[15:32:10.342] result() for ClusterFuture ... done
[15:32:10.343] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.313] MultisessionFuture:
[15:32:10.313] Label: 'future_mapply-2'
[15:32:10.313] Expression:
[15:32:10.313] {
[15:32:10.313]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.313]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.313]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.313]         on.exit(options(oopts), add = TRUE)
[15:32:10.313]     }
[15:32:10.313]     {
[15:32:10.313]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.313]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.313]         do.call(mapply, args = args)
[15:32:10.313]     }
[15:32:10.313] }
[15:32:10.313] Lazy evaluation: FALSE
[15:32:10.313] Asynchronous evaluation: TRUE
[15:32:10.313] Local evaluation: TRUE
[15:32:10.313] Environment: R_GlobalEnv
[15:32:10.313] Capture standard output: TRUE
[15:32:10.313] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.313] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:10.313] Packages: <none>
[15:32:10.313] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.313] Resolved: TRUE
[15:32:10.313] Value: <not collected>
[15:32:10.313] Conditions captured: <none>
[15:32:10.313] Early signaling: FALSE
[15:32:10.313] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.313] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.343] Chunk #2 of 2 ... DONE
[15:32:10.344] Launching 2 futures (chunks) ... DONE
[15:32:10.344] Resolving 2 futures (chunks) ...
[15:32:10.344] resolve() on list ...
[15:32:10.345]  recursive: 0
[15:32:10.345]  length: 2
[15:32:10.345] 
[15:32:10.346] Future #1
[15:32:10.346] result() for ClusterFuture ...
[15:32:10.346] - result already collected: FutureResult
[15:32:10.347] result() for ClusterFuture ... done
[15:32:10.347] result() for ClusterFuture ...
[15:32:10.347] - result already collected: FutureResult
[15:32:10.347] result() for ClusterFuture ... done
[15:32:10.348] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:10.348] - nx: 2
[15:32:10.348] - relay: TRUE
[15:32:10.349] - stdout: TRUE
[15:32:10.349] - signal: TRUE
[15:32:10.349] - resignal: FALSE
[15:32:10.349] - force: TRUE
[15:32:10.350] - relayed: [n=2] FALSE, FALSE
[15:32:10.350] - queued futures: [n=2] FALSE, FALSE
[15:32:10.350]  - until=1
[15:32:10.351]  - relaying element #1
[15:32:10.351] result() for ClusterFuture ...
[15:32:10.351] - result already collected: FutureResult
[15:32:10.351] result() for ClusterFuture ... done
[15:32:10.352] result() for ClusterFuture ...
[15:32:10.352] - result already collected: FutureResult
[15:32:10.352] result() for ClusterFuture ... done
[15:32:10.353] result() for ClusterFuture ...
[15:32:10.353] - result already collected: FutureResult
[15:32:10.354] result() for ClusterFuture ... done
[15:32:10.354] result() for ClusterFuture ...
[15:32:10.354] - result already collected: FutureResult
[15:32:10.355] result() for ClusterFuture ... done
[15:32:10.355] - relayed: [n=2] TRUE, FALSE
[15:32:10.355] - queued futures: [n=2] TRUE, FALSE
[15:32:10.355] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:10.356]  length: 1 (resolved future 1)
[15:32:10.356] Future #2
[15:32:10.356] result() for ClusterFuture ...
[15:32:10.357] - result already collected: FutureResult
[15:32:10.357] result() for ClusterFuture ... done
[15:32:10.358] result() for ClusterFuture ...
[15:32:10.358] - result already collected: FutureResult
[15:32:10.358] result() for ClusterFuture ... done
[15:32:10.359] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:10.359] - nx: 2
[15:32:10.359] - relay: TRUE
[15:32:10.360] - stdout: TRUE
[15:32:10.360] - signal: TRUE
[15:32:10.360] - resignal: FALSE
[15:32:10.360] - force: TRUE
[15:32:10.361] - relayed: [n=2] TRUE, FALSE
[15:32:10.361] - queued futures: [n=2] TRUE, FALSE
[15:32:10.361]  - until=2
[15:32:10.362]  - relaying element #2
[15:32:10.362] result() for ClusterFuture ...
[15:32:10.362] - result already collected: FutureResult
[15:32:10.363] result() for ClusterFuture ... done
[15:32:10.363] result() for ClusterFuture ...
[15:32:10.363] - result already collected: FutureResult
[15:32:10.364] result() for ClusterFuture ... done
[15:32:10.364] result() for ClusterFuture ...
[15:32:10.364] - result already collected: FutureResult
[15:32:10.365] result() for ClusterFuture ... done
[15:32:10.365] result() for ClusterFuture ...
[15:32:10.365] - result already collected: FutureResult
[15:32:10.366] result() for ClusterFuture ... done
[15:32:10.366] - relayed: [n=2] TRUE, TRUE
[15:32:10.366] - queued futures: [n=2] TRUE, TRUE
[15:32:10.366] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:10.367]  length: 0 (resolved future 2)
[15:32:10.367] Relaying remaining futures
[15:32:10.367] signalConditionsASAP(NULL, pos=0) ...
[15:32:10.368] - nx: 2
[15:32:10.368] - relay: TRUE
[15:32:10.368] - stdout: TRUE
[15:32:10.369] - signal: TRUE
[15:32:10.369] - resignal: FALSE
[15:32:10.369] - force: TRUE
[15:32:10.369] - relayed: [n=2] TRUE, TRUE
[15:32:10.370] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:10.370] - relayed: [n=2] TRUE, TRUE
[15:32:10.370] - queued futures: [n=2] TRUE, TRUE
[15:32:10.371] signalConditionsASAP(NULL, pos=0) ... done
[15:32:10.371] resolve() on list ... DONE
[15:32:10.371] result() for ClusterFuture ...
[15:32:10.372] - result already collected: FutureResult
[15:32:10.372] result() for ClusterFuture ... done
[15:32:10.372] result() for ClusterFuture ...
[15:32:10.373] - result already collected: FutureResult
[15:32:10.373] result() for ClusterFuture ... done
[15:32:10.373] result() for ClusterFuture ...
[15:32:10.374] - result already collected: FutureResult
[15:32:10.374] result() for ClusterFuture ... done
[15:32:10.374] result() for ClusterFuture ...
[15:32:10.374] - result already collected: FutureResult
[15:32:10.375] result() for ClusterFuture ... done
[15:32:10.375]  - Number of value chunks collected: 2
[15:32:10.375] Resolving 2 futures (chunks) ... DONE
[15:32:10.376] Reducing values from 2 chunks ...
[15:32:10.376]  - Number of values collected after concatenation: 4
[15:32:10.376]  - Number of values expected: 4
[15:32:10.377] Reducing values from 2 chunks ... DONE
[15:32:10.377] future_mapply() ... DONE
[15:32:10.377] future_mapply() ...
[15:32:10.382] Number of chunks: 2
[15:32:10.383] getGlobalsAndPackagesXApply() ...
[15:32:10.383]  - future.globals: TRUE
[15:32:10.383] getGlobalsAndPackages() ...
[15:32:10.384] Searching for globals...
[15:32:10.385] - globals found: [1] 'FUN'
[15:32:10.385] Searching for globals ... DONE
[15:32:10.386] Resolving globals: FALSE
[15:32:10.386] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:10.387] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:10.388] - globals: [1] 'FUN'
[15:32:10.388] 
[15:32:10.389] getGlobalsAndPackages() ... DONE
[15:32:10.389]  - globals found/used: [n=1] 'FUN'
[15:32:10.389]  - needed namespaces: [n=0] 
[15:32:10.390] Finding globals ... DONE
[15:32:10.390] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:10.390] List of 2
[15:32:10.390]  $ ...future.FUN:function (x, ...)  
[15:32:10.390]  $ MoreArgs     : NULL
[15:32:10.390]  - attr(*, "where")=List of 2
[15:32:10.390]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:10.390]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:10.390]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:10.390]  - attr(*, "resolved")= logi FALSE
[15:32:10.390]  - attr(*, "total_size")= num NA
[15:32:10.396] Packages to be attached in all futures: [n=0] 
[15:32:10.396] getGlobalsAndPackagesXApply() ... DONE
[15:32:10.397] Number of futures (= number of chunks): 2
[15:32:10.397] Launching 2 futures (chunks) ...
[15:32:10.398] Chunk #1 of 2 ...
[15:32:10.398]  - Finding globals in '...' for chunk #1 ...
[15:32:10.398] getGlobalsAndPackages() ...
[15:32:10.398] Searching for globals...
[15:32:10.399] 
[15:32:10.400] Searching for globals ... DONE
[15:32:10.400] - globals: [0] <none>
[15:32:10.400] getGlobalsAndPackages() ... DONE
[15:32:10.400]    + additional globals found: [n=0] 
[15:32:10.401]    + additional namespaces needed: [n=0] 
[15:32:10.401]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:10.401]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.402]  - seeds: <none>
[15:32:10.402]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.402] getGlobalsAndPackages() ...
[15:32:10.403] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.403] Resolving globals: FALSE
[15:32:10.404] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:10.406] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.406] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.406] 
[15:32:10.407] getGlobalsAndPackages() ... DONE
[15:32:10.407] run() for 'Future' ...
[15:32:10.408] - state: 'created'
[15:32:10.408] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.429] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.430] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.430]   - Field: 'node'
[15:32:10.430]   - Field: 'label'
[15:32:10.431]   - Field: 'local'
[15:32:10.431]   - Field: 'owner'
[15:32:10.431]   - Field: 'envir'
[15:32:10.432]   - Field: 'workers'
[15:32:10.432]   - Field: 'packages'
[15:32:10.432]   - Field: 'gc'
[15:32:10.433]   - Field: 'conditions'
[15:32:10.433]   - Field: 'persistent'
[15:32:10.433]   - Field: 'expr'
[15:32:10.434]   - Field: 'uuid'
[15:32:10.434]   - Field: 'seed'
[15:32:10.434]   - Field: 'version'
[15:32:10.435]   - Field: 'result'
[15:32:10.435]   - Field: 'asynchronous'
[15:32:10.435]   - Field: 'calls'
[15:32:10.435]   - Field: 'globals'
[15:32:10.436]   - Field: 'stdout'
[15:32:10.436]   - Field: 'earlySignal'
[15:32:10.436]   - Field: 'lazy'
[15:32:10.437]   - Field: 'state'
[15:32:10.437] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.437] - Launch lazy future ...
[15:32:10.438] Packages needed by the future expression (n = 0): <none>
[15:32:10.438] Packages needed by future strategies (n = 0): <none>
[15:32:10.439] {
[15:32:10.439]     {
[15:32:10.439]         {
[15:32:10.439]             ...future.startTime <- base::Sys.time()
[15:32:10.439]             {
[15:32:10.439]                 {
[15:32:10.439]                   {
[15:32:10.439]                     {
[15:32:10.439]                       base::local({
[15:32:10.439]                         has_future <- base::requireNamespace("future", 
[15:32:10.439]                           quietly = TRUE)
[15:32:10.439]                         if (has_future) {
[15:32:10.439]                           ns <- base::getNamespace("future")
[15:32:10.439]                           version <- ns[[".package"]][["version"]]
[15:32:10.439]                           if (is.null(version)) 
[15:32:10.439]                             version <- utils::packageVersion("future")
[15:32:10.439]                         }
[15:32:10.439]                         else {
[15:32:10.439]                           version <- NULL
[15:32:10.439]                         }
[15:32:10.439]                         if (!has_future || version < "1.8.0") {
[15:32:10.439]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.439]                             "", base::R.version$version.string), 
[15:32:10.439]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.439]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.439]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.439]                               "release", "version")], collapse = " "), 
[15:32:10.439]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.439]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.439]                             info)
[15:32:10.439]                           info <- base::paste(info, collapse = "; ")
[15:32:10.439]                           if (!has_future) {
[15:32:10.439]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.439]                               info)
[15:32:10.439]                           }
[15:32:10.439]                           else {
[15:32:10.439]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.439]                               info, version)
[15:32:10.439]                           }
[15:32:10.439]                           base::stop(msg)
[15:32:10.439]                         }
[15:32:10.439]                       })
[15:32:10.439]                     }
[15:32:10.439]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.439]                     base::options(mc.cores = 1L)
[15:32:10.439]                   }
[15:32:10.439]                   ...future.strategy.old <- future::plan("list")
[15:32:10.439]                   options(future.plan = NULL)
[15:32:10.439]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.439]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.439]                 }
[15:32:10.439]                 ...future.workdir <- getwd()
[15:32:10.439]             }
[15:32:10.439]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.439]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.439]         }
[15:32:10.439]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.439]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.439]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.439]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.439]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.439]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.439]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.439]             base::names(...future.oldOptions))
[15:32:10.439]     }
[15:32:10.439]     if (FALSE) {
[15:32:10.439]     }
[15:32:10.439]     else {
[15:32:10.439]         if (TRUE) {
[15:32:10.439]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.439]                 open = "w")
[15:32:10.439]         }
[15:32:10.439]         else {
[15:32:10.439]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.439]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.439]         }
[15:32:10.439]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.439]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.439]             base::sink(type = "output", split = FALSE)
[15:32:10.439]             base::close(...future.stdout)
[15:32:10.439]         }, add = TRUE)
[15:32:10.439]     }
[15:32:10.439]     ...future.frame <- base::sys.nframe()
[15:32:10.439]     ...future.conditions <- base::list()
[15:32:10.439]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.439]     if (FALSE) {
[15:32:10.439]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.439]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.439]     }
[15:32:10.439]     ...future.result <- base::tryCatch({
[15:32:10.439]         base::withCallingHandlers({
[15:32:10.439]             ...future.value <- base::withVisible(base::local({
[15:32:10.439]                 ...future.makeSendCondition <- base::local({
[15:32:10.439]                   sendCondition <- NULL
[15:32:10.439]                   function(frame = 1L) {
[15:32:10.439]                     if (is.function(sendCondition)) 
[15:32:10.439]                       return(sendCondition)
[15:32:10.439]                     ns <- getNamespace("parallel")
[15:32:10.439]                     if (exists("sendData", mode = "function", 
[15:32:10.439]                       envir = ns)) {
[15:32:10.439]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.439]                         envir = ns)
[15:32:10.439]                       envir <- sys.frame(frame)
[15:32:10.439]                       master <- NULL
[15:32:10.439]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.439]                         !identical(envir, emptyenv())) {
[15:32:10.439]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.439]                           inherits = FALSE)) {
[15:32:10.439]                           master <- get("master", mode = "list", 
[15:32:10.439]                             envir = envir, inherits = FALSE)
[15:32:10.439]                           if (inherits(master, c("SOCKnode", 
[15:32:10.439]                             "SOCK0node"))) {
[15:32:10.439]                             sendCondition <<- function(cond) {
[15:32:10.439]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.439]                                 success = TRUE)
[15:32:10.439]                               parallel_sendData(master, data)
[15:32:10.439]                             }
[15:32:10.439]                             return(sendCondition)
[15:32:10.439]                           }
[15:32:10.439]                         }
[15:32:10.439]                         frame <- frame + 1L
[15:32:10.439]                         envir <- sys.frame(frame)
[15:32:10.439]                       }
[15:32:10.439]                     }
[15:32:10.439]                     sendCondition <<- function(cond) NULL
[15:32:10.439]                   }
[15:32:10.439]                 })
[15:32:10.439]                 withCallingHandlers({
[15:32:10.439]                   {
[15:32:10.439]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.439]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.439]                       ...future.globals.maxSize)) {
[15:32:10.439]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.439]                       on.exit(options(oopts), add = TRUE)
[15:32:10.439]                     }
[15:32:10.439]                     {
[15:32:10.439]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.439]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.439]                         USE.NAMES = FALSE)
[15:32:10.439]                       do.call(mapply, args = args)
[15:32:10.439]                     }
[15:32:10.439]                   }
[15:32:10.439]                 }, immediateCondition = function(cond) {
[15:32:10.439]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.439]                   sendCondition(cond)
[15:32:10.439]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.439]                   {
[15:32:10.439]                     inherits <- base::inherits
[15:32:10.439]                     invokeRestart <- base::invokeRestart
[15:32:10.439]                     is.null <- base::is.null
[15:32:10.439]                     muffled <- FALSE
[15:32:10.439]                     if (inherits(cond, "message")) {
[15:32:10.439]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.439]                       if (muffled) 
[15:32:10.439]                         invokeRestart("muffleMessage")
[15:32:10.439]                     }
[15:32:10.439]                     else if (inherits(cond, "warning")) {
[15:32:10.439]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.439]                       if (muffled) 
[15:32:10.439]                         invokeRestart("muffleWarning")
[15:32:10.439]                     }
[15:32:10.439]                     else if (inherits(cond, "condition")) {
[15:32:10.439]                       if (!is.null(pattern)) {
[15:32:10.439]                         computeRestarts <- base::computeRestarts
[15:32:10.439]                         grepl <- base::grepl
[15:32:10.439]                         restarts <- computeRestarts(cond)
[15:32:10.439]                         for (restart in restarts) {
[15:32:10.439]                           name <- restart$name
[15:32:10.439]                           if (is.null(name)) 
[15:32:10.439]                             next
[15:32:10.439]                           if (!grepl(pattern, name)) 
[15:32:10.439]                             next
[15:32:10.439]                           invokeRestart(restart)
[15:32:10.439]                           muffled <- TRUE
[15:32:10.439]                           break
[15:32:10.439]                         }
[15:32:10.439]                       }
[15:32:10.439]                     }
[15:32:10.439]                     invisible(muffled)
[15:32:10.439]                   }
[15:32:10.439]                   muffleCondition(cond)
[15:32:10.439]                 })
[15:32:10.439]             }))
[15:32:10.439]             future::FutureResult(value = ...future.value$value, 
[15:32:10.439]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.439]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.439]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.439]                     ...future.globalenv.names))
[15:32:10.439]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.439]         }, condition = base::local({
[15:32:10.439]             c <- base::c
[15:32:10.439]             inherits <- base::inherits
[15:32:10.439]             invokeRestart <- base::invokeRestart
[15:32:10.439]             length <- base::length
[15:32:10.439]             list <- base::list
[15:32:10.439]             seq.int <- base::seq.int
[15:32:10.439]             signalCondition <- base::signalCondition
[15:32:10.439]             sys.calls <- base::sys.calls
[15:32:10.439]             `[[` <- base::`[[`
[15:32:10.439]             `+` <- base::`+`
[15:32:10.439]             `<<-` <- base::`<<-`
[15:32:10.439]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.439]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.439]                   3L)]
[15:32:10.439]             }
[15:32:10.439]             function(cond) {
[15:32:10.439]                 is_error <- inherits(cond, "error")
[15:32:10.439]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.439]                   NULL)
[15:32:10.439]                 if (is_error) {
[15:32:10.439]                   sessionInformation <- function() {
[15:32:10.439]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.439]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.439]                       search = base::search(), system = base::Sys.info())
[15:32:10.439]                   }
[15:32:10.439]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.439]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.439]                     cond$call), session = sessionInformation(), 
[15:32:10.439]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.439]                   signalCondition(cond)
[15:32:10.439]                 }
[15:32:10.439]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.439]                 "immediateCondition"))) {
[15:32:10.439]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.439]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.439]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.439]                   if (TRUE && !signal) {
[15:32:10.439]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.439]                     {
[15:32:10.439]                       inherits <- base::inherits
[15:32:10.439]                       invokeRestart <- base::invokeRestart
[15:32:10.439]                       is.null <- base::is.null
[15:32:10.439]                       muffled <- FALSE
[15:32:10.439]                       if (inherits(cond, "message")) {
[15:32:10.439]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.439]                         if (muffled) 
[15:32:10.439]                           invokeRestart("muffleMessage")
[15:32:10.439]                       }
[15:32:10.439]                       else if (inherits(cond, "warning")) {
[15:32:10.439]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.439]                         if (muffled) 
[15:32:10.439]                           invokeRestart("muffleWarning")
[15:32:10.439]                       }
[15:32:10.439]                       else if (inherits(cond, "condition")) {
[15:32:10.439]                         if (!is.null(pattern)) {
[15:32:10.439]                           computeRestarts <- base::computeRestarts
[15:32:10.439]                           grepl <- base::grepl
[15:32:10.439]                           restarts <- computeRestarts(cond)
[15:32:10.439]                           for (restart in restarts) {
[15:32:10.439]                             name <- restart$name
[15:32:10.439]                             if (is.null(name)) 
[15:32:10.439]                               next
[15:32:10.439]                             if (!grepl(pattern, name)) 
[15:32:10.439]                               next
[15:32:10.439]                             invokeRestart(restart)
[15:32:10.439]                             muffled <- TRUE
[15:32:10.439]                             break
[15:32:10.439]                           }
[15:32:10.439]                         }
[15:32:10.439]                       }
[15:32:10.439]                       invisible(muffled)
[15:32:10.439]                     }
[15:32:10.439]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.439]                   }
[15:32:10.439]                 }
[15:32:10.439]                 else {
[15:32:10.439]                   if (TRUE) {
[15:32:10.439]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.439]                     {
[15:32:10.439]                       inherits <- base::inherits
[15:32:10.439]                       invokeRestart <- base::invokeRestart
[15:32:10.439]                       is.null <- base::is.null
[15:32:10.439]                       muffled <- FALSE
[15:32:10.439]                       if (inherits(cond, "message")) {
[15:32:10.439]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.439]                         if (muffled) 
[15:32:10.439]                           invokeRestart("muffleMessage")
[15:32:10.439]                       }
[15:32:10.439]                       else if (inherits(cond, "warning")) {
[15:32:10.439]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.439]                         if (muffled) 
[15:32:10.439]                           invokeRestart("muffleWarning")
[15:32:10.439]                       }
[15:32:10.439]                       else if (inherits(cond, "condition")) {
[15:32:10.439]                         if (!is.null(pattern)) {
[15:32:10.439]                           computeRestarts <- base::computeRestarts
[15:32:10.439]                           grepl <- base::grepl
[15:32:10.439]                           restarts <- computeRestarts(cond)
[15:32:10.439]                           for (restart in restarts) {
[15:32:10.439]                             name <- restart$name
[15:32:10.439]                             if (is.null(name)) 
[15:32:10.439]                               next
[15:32:10.439]                             if (!grepl(pattern, name)) 
[15:32:10.439]                               next
[15:32:10.439]                             invokeRestart(restart)
[15:32:10.439]                             muffled <- TRUE
[15:32:10.439]                             break
[15:32:10.439]                           }
[15:32:10.439]                         }
[15:32:10.439]                       }
[15:32:10.439]                       invisible(muffled)
[15:32:10.439]                     }
[15:32:10.439]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.439]                   }
[15:32:10.439]                 }
[15:32:10.439]             }
[15:32:10.439]         }))
[15:32:10.439]     }, error = function(ex) {
[15:32:10.439]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.439]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.439]                 ...future.rng), started = ...future.startTime, 
[15:32:10.439]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.439]             version = "1.8"), class = "FutureResult")
[15:32:10.439]     }, finally = {
[15:32:10.439]         if (!identical(...future.workdir, getwd())) 
[15:32:10.439]             setwd(...future.workdir)
[15:32:10.439]         {
[15:32:10.439]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.439]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.439]             }
[15:32:10.439]             base::options(...future.oldOptions)
[15:32:10.439]             if (.Platform$OS.type == "windows") {
[15:32:10.439]                 old_names <- names(...future.oldEnvVars)
[15:32:10.439]                 envs <- base::Sys.getenv()
[15:32:10.439]                 names <- names(envs)
[15:32:10.439]                 common <- intersect(names, old_names)
[15:32:10.439]                 added <- setdiff(names, old_names)
[15:32:10.439]                 removed <- setdiff(old_names, names)
[15:32:10.439]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.439]                   envs[common]]
[15:32:10.439]                 NAMES <- toupper(changed)
[15:32:10.439]                 args <- list()
[15:32:10.439]                 for (kk in seq_along(NAMES)) {
[15:32:10.439]                   name <- changed[[kk]]
[15:32:10.439]                   NAME <- NAMES[[kk]]
[15:32:10.439]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.439]                     next
[15:32:10.439]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.439]                 }
[15:32:10.439]                 NAMES <- toupper(added)
[15:32:10.439]                 for (kk in seq_along(NAMES)) {
[15:32:10.439]                   name <- added[[kk]]
[15:32:10.439]                   NAME <- NAMES[[kk]]
[15:32:10.439]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.439]                     next
[15:32:10.439]                   args[[name]] <- ""
[15:32:10.439]                 }
[15:32:10.439]                 NAMES <- toupper(removed)
[15:32:10.439]                 for (kk in seq_along(NAMES)) {
[15:32:10.439]                   name <- removed[[kk]]
[15:32:10.439]                   NAME <- NAMES[[kk]]
[15:32:10.439]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.439]                     next
[15:32:10.439]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.439]                 }
[15:32:10.439]                 if (length(args) > 0) 
[15:32:10.439]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.439]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.439]             }
[15:32:10.439]             else {
[15:32:10.439]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.439]             }
[15:32:10.439]             {
[15:32:10.439]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.439]                   0L) {
[15:32:10.439]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.439]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.439]                   base::options(opts)
[15:32:10.439]                 }
[15:32:10.439]                 {
[15:32:10.439]                   {
[15:32:10.439]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.439]                     NULL
[15:32:10.439]                   }
[15:32:10.439]                   options(future.plan = NULL)
[15:32:10.439]                   if (is.na(NA_character_)) 
[15:32:10.439]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.439]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.439]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.439]                     .init = FALSE)
[15:32:10.439]                 }
[15:32:10.439]             }
[15:32:10.439]         }
[15:32:10.439]     })
[15:32:10.439]     if (TRUE) {
[15:32:10.439]         base::sink(type = "output", split = FALSE)
[15:32:10.439]         if (TRUE) {
[15:32:10.439]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.439]         }
[15:32:10.439]         else {
[15:32:10.439]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.439]         }
[15:32:10.439]         base::close(...future.stdout)
[15:32:10.439]         ...future.stdout <- NULL
[15:32:10.439]     }
[15:32:10.439]     ...future.result$conditions <- ...future.conditions
[15:32:10.439]     ...future.result$finished <- base::Sys.time()
[15:32:10.439]     ...future.result
[15:32:10.439] }
[15:32:10.448] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:10.449] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.449] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.450] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.451] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.451] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:10.452] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:10.452] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.453] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.453] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.454] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.455] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:10.456] MultisessionFuture started
[15:32:10.456] - Launch lazy future ... done
[15:32:10.456] run() for 'MultisessionFuture' ... done
[15:32:10.457] Created future:
[15:32:10.483] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.484] - Validating connection of MultisessionFuture
[15:32:10.485] - received message: FutureResult
[15:32:10.485] - Received FutureResult
[15:32:10.486] - Erased future from FutureRegistry
[15:32:10.486] result() for ClusterFuture ...
[15:32:10.486] - result already collected: FutureResult
[15:32:10.487] result() for ClusterFuture ... done
[15:32:10.487] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.457] MultisessionFuture:
[15:32:10.457] Label: 'future_mapply-1'
[15:32:10.457] Expression:
[15:32:10.457] {
[15:32:10.457]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.457]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.457]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.457]         on.exit(options(oopts), add = TRUE)
[15:32:10.457]     }
[15:32:10.457]     {
[15:32:10.457]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.457]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.457]         do.call(mapply, args = args)
[15:32:10.457]     }
[15:32:10.457] }
[15:32:10.457] Lazy evaluation: FALSE
[15:32:10.457] Asynchronous evaluation: TRUE
[15:32:10.457] Local evaluation: TRUE
[15:32:10.457] Environment: R_GlobalEnv
[15:32:10.457] Capture standard output: TRUE
[15:32:10.457] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.457] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:10.457] Packages: <none>
[15:32:10.457] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.457] Resolved: TRUE
[15:32:10.457] Value: <not collected>
[15:32:10.457] Conditions captured: <none>
[15:32:10.457] Early signaling: FALSE
[15:32:10.457] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.457] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.488] Chunk #1 of 2 ... DONE
[15:32:10.488] Chunk #2 of 2 ...
[15:32:10.489]  - Finding globals in '...' for chunk #2 ...
[15:32:10.489] getGlobalsAndPackages() ...
[15:32:10.490] Searching for globals...
[15:32:10.491] 
[15:32:10.491] Searching for globals ... DONE
[15:32:10.491] - globals: [0] <none>
[15:32:10.492] getGlobalsAndPackages() ... DONE
[15:32:10.492]    + additional globals found: [n=0] 
[15:32:10.493]    + additional namespaces needed: [n=0] 
[15:32:10.493]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:10.493]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.493]  - seeds: <none>
[15:32:10.494]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.494] getGlobalsAndPackages() ...
[15:32:10.494] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.494] Resolving globals: FALSE
[15:32:10.500] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:10.501] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.501] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.502] 
[15:32:10.502] getGlobalsAndPackages() ... DONE
[15:32:10.503] run() for 'Future' ...
[15:32:10.503] - state: 'created'
[15:32:10.503] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.520] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.521] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.521]   - Field: 'node'
[15:32:10.521]   - Field: 'label'
[15:32:10.522]   - Field: 'local'
[15:32:10.522]   - Field: 'owner'
[15:32:10.522]   - Field: 'envir'
[15:32:10.522]   - Field: 'workers'
[15:32:10.523]   - Field: 'packages'
[15:32:10.523]   - Field: 'gc'
[15:32:10.523]   - Field: 'conditions'
[15:32:10.523]   - Field: 'persistent'
[15:32:10.523]   - Field: 'expr'
[15:32:10.523]   - Field: 'uuid'
[15:32:10.524]   - Field: 'seed'
[15:32:10.524]   - Field: 'version'
[15:32:10.524]   - Field: 'result'
[15:32:10.524]   - Field: 'asynchronous'
[15:32:10.524]   - Field: 'calls'
[15:32:10.525]   - Field: 'globals'
[15:32:10.525]   - Field: 'stdout'
[15:32:10.525]   - Field: 'earlySignal'
[15:32:10.525]   - Field: 'lazy'
[15:32:10.525]   - Field: 'state'
[15:32:10.526] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.526] - Launch lazy future ...
[15:32:10.526] Packages needed by the future expression (n = 0): <none>
[15:32:10.527] Packages needed by future strategies (n = 0): <none>
[15:32:10.527] {
[15:32:10.527]     {
[15:32:10.527]         {
[15:32:10.527]             ...future.startTime <- base::Sys.time()
[15:32:10.527]             {
[15:32:10.527]                 {
[15:32:10.527]                   {
[15:32:10.527]                     {
[15:32:10.527]                       base::local({
[15:32:10.527]                         has_future <- base::requireNamespace("future", 
[15:32:10.527]                           quietly = TRUE)
[15:32:10.527]                         if (has_future) {
[15:32:10.527]                           ns <- base::getNamespace("future")
[15:32:10.527]                           version <- ns[[".package"]][["version"]]
[15:32:10.527]                           if (is.null(version)) 
[15:32:10.527]                             version <- utils::packageVersion("future")
[15:32:10.527]                         }
[15:32:10.527]                         else {
[15:32:10.527]                           version <- NULL
[15:32:10.527]                         }
[15:32:10.527]                         if (!has_future || version < "1.8.0") {
[15:32:10.527]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.527]                             "", base::R.version$version.string), 
[15:32:10.527]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.527]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.527]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.527]                               "release", "version")], collapse = " "), 
[15:32:10.527]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.527]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.527]                             info)
[15:32:10.527]                           info <- base::paste(info, collapse = "; ")
[15:32:10.527]                           if (!has_future) {
[15:32:10.527]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.527]                               info)
[15:32:10.527]                           }
[15:32:10.527]                           else {
[15:32:10.527]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.527]                               info, version)
[15:32:10.527]                           }
[15:32:10.527]                           base::stop(msg)
[15:32:10.527]                         }
[15:32:10.527]                       })
[15:32:10.527]                     }
[15:32:10.527]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.527]                     base::options(mc.cores = 1L)
[15:32:10.527]                   }
[15:32:10.527]                   ...future.strategy.old <- future::plan("list")
[15:32:10.527]                   options(future.plan = NULL)
[15:32:10.527]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.527]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.527]                 }
[15:32:10.527]                 ...future.workdir <- getwd()
[15:32:10.527]             }
[15:32:10.527]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.527]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.527]         }
[15:32:10.527]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.527]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.527]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.527]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.527]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.527]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.527]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.527]             base::names(...future.oldOptions))
[15:32:10.527]     }
[15:32:10.527]     if (FALSE) {
[15:32:10.527]     }
[15:32:10.527]     else {
[15:32:10.527]         if (TRUE) {
[15:32:10.527]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.527]                 open = "w")
[15:32:10.527]         }
[15:32:10.527]         else {
[15:32:10.527]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.527]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.527]         }
[15:32:10.527]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.527]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.527]             base::sink(type = "output", split = FALSE)
[15:32:10.527]             base::close(...future.stdout)
[15:32:10.527]         }, add = TRUE)
[15:32:10.527]     }
[15:32:10.527]     ...future.frame <- base::sys.nframe()
[15:32:10.527]     ...future.conditions <- base::list()
[15:32:10.527]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.527]     if (FALSE) {
[15:32:10.527]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.527]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.527]     }
[15:32:10.527]     ...future.result <- base::tryCatch({
[15:32:10.527]         base::withCallingHandlers({
[15:32:10.527]             ...future.value <- base::withVisible(base::local({
[15:32:10.527]                 ...future.makeSendCondition <- base::local({
[15:32:10.527]                   sendCondition <- NULL
[15:32:10.527]                   function(frame = 1L) {
[15:32:10.527]                     if (is.function(sendCondition)) 
[15:32:10.527]                       return(sendCondition)
[15:32:10.527]                     ns <- getNamespace("parallel")
[15:32:10.527]                     if (exists("sendData", mode = "function", 
[15:32:10.527]                       envir = ns)) {
[15:32:10.527]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.527]                         envir = ns)
[15:32:10.527]                       envir <- sys.frame(frame)
[15:32:10.527]                       master <- NULL
[15:32:10.527]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.527]                         !identical(envir, emptyenv())) {
[15:32:10.527]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.527]                           inherits = FALSE)) {
[15:32:10.527]                           master <- get("master", mode = "list", 
[15:32:10.527]                             envir = envir, inherits = FALSE)
[15:32:10.527]                           if (inherits(master, c("SOCKnode", 
[15:32:10.527]                             "SOCK0node"))) {
[15:32:10.527]                             sendCondition <<- function(cond) {
[15:32:10.527]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.527]                                 success = TRUE)
[15:32:10.527]                               parallel_sendData(master, data)
[15:32:10.527]                             }
[15:32:10.527]                             return(sendCondition)
[15:32:10.527]                           }
[15:32:10.527]                         }
[15:32:10.527]                         frame <- frame + 1L
[15:32:10.527]                         envir <- sys.frame(frame)
[15:32:10.527]                       }
[15:32:10.527]                     }
[15:32:10.527]                     sendCondition <<- function(cond) NULL
[15:32:10.527]                   }
[15:32:10.527]                 })
[15:32:10.527]                 withCallingHandlers({
[15:32:10.527]                   {
[15:32:10.527]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.527]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.527]                       ...future.globals.maxSize)) {
[15:32:10.527]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.527]                       on.exit(options(oopts), add = TRUE)
[15:32:10.527]                     }
[15:32:10.527]                     {
[15:32:10.527]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.527]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.527]                         USE.NAMES = FALSE)
[15:32:10.527]                       do.call(mapply, args = args)
[15:32:10.527]                     }
[15:32:10.527]                   }
[15:32:10.527]                 }, immediateCondition = function(cond) {
[15:32:10.527]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.527]                   sendCondition(cond)
[15:32:10.527]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.527]                   {
[15:32:10.527]                     inherits <- base::inherits
[15:32:10.527]                     invokeRestart <- base::invokeRestart
[15:32:10.527]                     is.null <- base::is.null
[15:32:10.527]                     muffled <- FALSE
[15:32:10.527]                     if (inherits(cond, "message")) {
[15:32:10.527]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.527]                       if (muffled) 
[15:32:10.527]                         invokeRestart("muffleMessage")
[15:32:10.527]                     }
[15:32:10.527]                     else if (inherits(cond, "warning")) {
[15:32:10.527]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.527]                       if (muffled) 
[15:32:10.527]                         invokeRestart("muffleWarning")
[15:32:10.527]                     }
[15:32:10.527]                     else if (inherits(cond, "condition")) {
[15:32:10.527]                       if (!is.null(pattern)) {
[15:32:10.527]                         computeRestarts <- base::computeRestarts
[15:32:10.527]                         grepl <- base::grepl
[15:32:10.527]                         restarts <- computeRestarts(cond)
[15:32:10.527]                         for (restart in restarts) {
[15:32:10.527]                           name <- restart$name
[15:32:10.527]                           if (is.null(name)) 
[15:32:10.527]                             next
[15:32:10.527]                           if (!grepl(pattern, name)) 
[15:32:10.527]                             next
[15:32:10.527]                           invokeRestart(restart)
[15:32:10.527]                           muffled <- TRUE
[15:32:10.527]                           break
[15:32:10.527]                         }
[15:32:10.527]                       }
[15:32:10.527]                     }
[15:32:10.527]                     invisible(muffled)
[15:32:10.527]                   }
[15:32:10.527]                   muffleCondition(cond)
[15:32:10.527]                 })
[15:32:10.527]             }))
[15:32:10.527]             future::FutureResult(value = ...future.value$value, 
[15:32:10.527]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.527]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.527]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.527]                     ...future.globalenv.names))
[15:32:10.527]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.527]         }, condition = base::local({
[15:32:10.527]             c <- base::c
[15:32:10.527]             inherits <- base::inherits
[15:32:10.527]             invokeRestart <- base::invokeRestart
[15:32:10.527]             length <- base::length
[15:32:10.527]             list <- base::list
[15:32:10.527]             seq.int <- base::seq.int
[15:32:10.527]             signalCondition <- base::signalCondition
[15:32:10.527]             sys.calls <- base::sys.calls
[15:32:10.527]             `[[` <- base::`[[`
[15:32:10.527]             `+` <- base::`+`
[15:32:10.527]             `<<-` <- base::`<<-`
[15:32:10.527]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.527]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.527]                   3L)]
[15:32:10.527]             }
[15:32:10.527]             function(cond) {
[15:32:10.527]                 is_error <- inherits(cond, "error")
[15:32:10.527]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.527]                   NULL)
[15:32:10.527]                 if (is_error) {
[15:32:10.527]                   sessionInformation <- function() {
[15:32:10.527]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.527]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.527]                       search = base::search(), system = base::Sys.info())
[15:32:10.527]                   }
[15:32:10.527]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.527]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.527]                     cond$call), session = sessionInformation(), 
[15:32:10.527]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.527]                   signalCondition(cond)
[15:32:10.527]                 }
[15:32:10.527]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.527]                 "immediateCondition"))) {
[15:32:10.527]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.527]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.527]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.527]                   if (TRUE && !signal) {
[15:32:10.527]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.527]                     {
[15:32:10.527]                       inherits <- base::inherits
[15:32:10.527]                       invokeRestart <- base::invokeRestart
[15:32:10.527]                       is.null <- base::is.null
[15:32:10.527]                       muffled <- FALSE
[15:32:10.527]                       if (inherits(cond, "message")) {
[15:32:10.527]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.527]                         if (muffled) 
[15:32:10.527]                           invokeRestart("muffleMessage")
[15:32:10.527]                       }
[15:32:10.527]                       else if (inherits(cond, "warning")) {
[15:32:10.527]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.527]                         if (muffled) 
[15:32:10.527]                           invokeRestart("muffleWarning")
[15:32:10.527]                       }
[15:32:10.527]                       else if (inherits(cond, "condition")) {
[15:32:10.527]                         if (!is.null(pattern)) {
[15:32:10.527]                           computeRestarts <- base::computeRestarts
[15:32:10.527]                           grepl <- base::grepl
[15:32:10.527]                           restarts <- computeRestarts(cond)
[15:32:10.527]                           for (restart in restarts) {
[15:32:10.527]                             name <- restart$name
[15:32:10.527]                             if (is.null(name)) 
[15:32:10.527]                               next
[15:32:10.527]                             if (!grepl(pattern, name)) 
[15:32:10.527]                               next
[15:32:10.527]                             invokeRestart(restart)
[15:32:10.527]                             muffled <- TRUE
[15:32:10.527]                             break
[15:32:10.527]                           }
[15:32:10.527]                         }
[15:32:10.527]                       }
[15:32:10.527]                       invisible(muffled)
[15:32:10.527]                     }
[15:32:10.527]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.527]                   }
[15:32:10.527]                 }
[15:32:10.527]                 else {
[15:32:10.527]                   if (TRUE) {
[15:32:10.527]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.527]                     {
[15:32:10.527]                       inherits <- base::inherits
[15:32:10.527]                       invokeRestart <- base::invokeRestart
[15:32:10.527]                       is.null <- base::is.null
[15:32:10.527]                       muffled <- FALSE
[15:32:10.527]                       if (inherits(cond, "message")) {
[15:32:10.527]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.527]                         if (muffled) 
[15:32:10.527]                           invokeRestart("muffleMessage")
[15:32:10.527]                       }
[15:32:10.527]                       else if (inherits(cond, "warning")) {
[15:32:10.527]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.527]                         if (muffled) 
[15:32:10.527]                           invokeRestart("muffleWarning")
[15:32:10.527]                       }
[15:32:10.527]                       else if (inherits(cond, "condition")) {
[15:32:10.527]                         if (!is.null(pattern)) {
[15:32:10.527]                           computeRestarts <- base::computeRestarts
[15:32:10.527]                           grepl <- base::grepl
[15:32:10.527]                           restarts <- computeRestarts(cond)
[15:32:10.527]                           for (restart in restarts) {
[15:32:10.527]                             name <- restart$name
[15:32:10.527]                             if (is.null(name)) 
[15:32:10.527]                               next
[15:32:10.527]                             if (!grepl(pattern, name)) 
[15:32:10.527]                               next
[15:32:10.527]                             invokeRestart(restart)
[15:32:10.527]                             muffled <- TRUE
[15:32:10.527]                             break
[15:32:10.527]                           }
[15:32:10.527]                         }
[15:32:10.527]                       }
[15:32:10.527]                       invisible(muffled)
[15:32:10.527]                     }
[15:32:10.527]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.527]                   }
[15:32:10.527]                 }
[15:32:10.527]             }
[15:32:10.527]         }))
[15:32:10.527]     }, error = function(ex) {
[15:32:10.527]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.527]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.527]                 ...future.rng), started = ...future.startTime, 
[15:32:10.527]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.527]             version = "1.8"), class = "FutureResult")
[15:32:10.527]     }, finally = {
[15:32:10.527]         if (!identical(...future.workdir, getwd())) 
[15:32:10.527]             setwd(...future.workdir)
[15:32:10.527]         {
[15:32:10.527]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.527]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.527]             }
[15:32:10.527]             base::options(...future.oldOptions)
[15:32:10.527]             if (.Platform$OS.type == "windows") {
[15:32:10.527]                 old_names <- names(...future.oldEnvVars)
[15:32:10.527]                 envs <- base::Sys.getenv()
[15:32:10.527]                 names <- names(envs)
[15:32:10.527]                 common <- intersect(names, old_names)
[15:32:10.527]                 added <- setdiff(names, old_names)
[15:32:10.527]                 removed <- setdiff(old_names, names)
[15:32:10.527]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.527]                   envs[common]]
[15:32:10.527]                 NAMES <- toupper(changed)
[15:32:10.527]                 args <- list()
[15:32:10.527]                 for (kk in seq_along(NAMES)) {
[15:32:10.527]                   name <- changed[[kk]]
[15:32:10.527]                   NAME <- NAMES[[kk]]
[15:32:10.527]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.527]                     next
[15:32:10.527]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.527]                 }
[15:32:10.527]                 NAMES <- toupper(added)
[15:32:10.527]                 for (kk in seq_along(NAMES)) {
[15:32:10.527]                   name <- added[[kk]]
[15:32:10.527]                   NAME <- NAMES[[kk]]
[15:32:10.527]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.527]                     next
[15:32:10.527]                   args[[name]] <- ""
[15:32:10.527]                 }
[15:32:10.527]                 NAMES <- toupper(removed)
[15:32:10.527]                 for (kk in seq_along(NAMES)) {
[15:32:10.527]                   name <- removed[[kk]]
[15:32:10.527]                   NAME <- NAMES[[kk]]
[15:32:10.527]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.527]                     next
[15:32:10.527]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.527]                 }
[15:32:10.527]                 if (length(args) > 0) 
[15:32:10.527]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.527]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.527]             }
[15:32:10.527]             else {
[15:32:10.527]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.527]             }
[15:32:10.527]             {
[15:32:10.527]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.527]                   0L) {
[15:32:10.527]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.527]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.527]                   base::options(opts)
[15:32:10.527]                 }
[15:32:10.527]                 {
[15:32:10.527]                   {
[15:32:10.527]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.527]                     NULL
[15:32:10.527]                   }
[15:32:10.527]                   options(future.plan = NULL)
[15:32:10.527]                   if (is.na(NA_character_)) 
[15:32:10.527]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.527]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.527]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.527]                     .init = FALSE)
[15:32:10.527]                 }
[15:32:10.527]             }
[15:32:10.527]         }
[15:32:10.527]     })
[15:32:10.527]     if (TRUE) {
[15:32:10.527]         base::sink(type = "output", split = FALSE)
[15:32:10.527]         if (TRUE) {
[15:32:10.527]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.527]         }
[15:32:10.527]         else {
[15:32:10.527]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.527]         }
[15:32:10.527]         base::close(...future.stdout)
[15:32:10.527]         ...future.stdout <- NULL
[15:32:10.527]     }
[15:32:10.527]     ...future.result$conditions <- ...future.conditions
[15:32:10.527]     ...future.result$finished <- base::Sys.time()
[15:32:10.527]     ...future.result
[15:32:10.527] }
[15:32:10.535] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:10.535] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.536] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.536] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.537] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.538] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:10.538] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:10.539] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.540] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.540] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.541] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.541] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:10.543] MultisessionFuture started
[15:32:10.543] - Launch lazy future ... done
[15:32:10.543] run() for 'MultisessionFuture' ... done
[15:32:10.544] Created future:
[15:32:10.570] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.571] - Validating connection of MultisessionFuture
[15:32:10.571] - received message: FutureResult
[15:32:10.572] - Received FutureResult
[15:32:10.572] - Erased future from FutureRegistry
[15:32:10.573] result() for ClusterFuture ...
[15:32:10.573] - result already collected: FutureResult
[15:32:10.574] result() for ClusterFuture ... done
[15:32:10.574] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.544] MultisessionFuture:
[15:32:10.544] Label: 'future_mapply-2'
[15:32:10.544] Expression:
[15:32:10.544] {
[15:32:10.544]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.544]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.544]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.544]         on.exit(options(oopts), add = TRUE)
[15:32:10.544]     }
[15:32:10.544]     {
[15:32:10.544]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.544]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.544]         do.call(mapply, args = args)
[15:32:10.544]     }
[15:32:10.544] }
[15:32:10.544] Lazy evaluation: FALSE
[15:32:10.544] Asynchronous evaluation: TRUE
[15:32:10.544] Local evaluation: TRUE
[15:32:10.544] Environment: R_GlobalEnv
[15:32:10.544] Capture standard output: TRUE
[15:32:10.544] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.544] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:10.544] Packages: <none>
[15:32:10.544] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.544] Resolved: TRUE
[15:32:10.544] Value: <not collected>
[15:32:10.544] Conditions captured: <none>
[15:32:10.544] Early signaling: FALSE
[15:32:10.544] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.544] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.575] Chunk #2 of 2 ... DONE
[15:32:10.575] Launching 2 futures (chunks) ... DONE
[15:32:10.576] Resolving 2 futures (chunks) ...
[15:32:10.576] resolve() on list ...
[15:32:10.576]  recursive: 0
[15:32:10.577]  length: 2
[15:32:10.577] 
[15:32:10.577] Future #1
[15:32:10.578] result() for ClusterFuture ...
[15:32:10.578] - result already collected: FutureResult
[15:32:10.578] result() for ClusterFuture ... done
[15:32:10.579] result() for ClusterFuture ...
[15:32:10.579] - result already collected: FutureResult
[15:32:10.579] result() for ClusterFuture ... done
[15:32:10.580] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:10.580] - nx: 2
[15:32:10.581] - relay: TRUE
[15:32:10.581] - stdout: TRUE
[15:32:10.581] - signal: TRUE
[15:32:10.582] - resignal: FALSE
[15:32:10.582] - force: TRUE
[15:32:10.582] - relayed: [n=2] FALSE, FALSE
[15:32:10.582] - queued futures: [n=2] FALSE, FALSE
[15:32:10.583]  - until=1
[15:32:10.583]  - relaying element #1
[15:32:10.583] result() for ClusterFuture ...
[15:32:10.584] - result already collected: FutureResult
[15:32:10.584] result() for ClusterFuture ... done
[15:32:10.584] result() for ClusterFuture ...
[15:32:10.585] - result already collected: FutureResult
[15:32:10.585] result() for ClusterFuture ... done
[15:32:10.586] result() for ClusterFuture ...
[15:32:10.586] - result already collected: FutureResult
[15:32:10.586] result() for ClusterFuture ... done
[15:32:10.587] result() for ClusterFuture ...
[15:32:10.587] - result already collected: FutureResult
[15:32:10.587] result() for ClusterFuture ... done
[15:32:10.588] - relayed: [n=2] TRUE, FALSE
[15:32:10.588] - queued futures: [n=2] TRUE, FALSE
[15:32:10.588] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:10.589]  length: 1 (resolved future 1)
[15:32:10.589] Future #2
[15:32:10.590] result() for ClusterFuture ...
[15:32:10.590] - result already collected: FutureResult
[15:32:10.590] result() for ClusterFuture ... done
[15:32:10.591] result() for ClusterFuture ...
[15:32:10.591] - result already collected: FutureResult
[15:32:10.591] result() for ClusterFuture ... done
[15:32:10.592] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:10.592] - nx: 2
[15:32:10.592] - relay: TRUE
[15:32:10.593] - stdout: TRUE
[15:32:10.593] - signal: TRUE
[15:32:10.593] - resignal: FALSE
[15:32:10.594] - force: TRUE
[15:32:10.594] - relayed: [n=2] TRUE, FALSE
[15:32:10.594] - queued futures: [n=2] TRUE, FALSE
[15:32:10.595]  - until=2
[15:32:10.595]  - relaying element #2
[15:32:10.595] result() for ClusterFuture ...
[15:32:10.596] - result already collected: FutureResult
[15:32:10.596] result() for ClusterFuture ... done
[15:32:10.596] result() for ClusterFuture ...
[15:32:10.597] - result already collected: FutureResult
[15:32:10.597] result() for ClusterFuture ... done
[15:32:10.597] result() for ClusterFuture ...
[15:32:10.598] - result already collected: FutureResult
[15:32:10.598] result() for ClusterFuture ... done
[15:32:10.598] result() for ClusterFuture ...
[15:32:10.599] - result already collected: FutureResult
[15:32:10.599] result() for ClusterFuture ... done
[15:32:10.599] - relayed: [n=2] TRUE, TRUE
[15:32:10.600] - queued futures: [n=2] TRUE, TRUE
[15:32:10.600] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:10.601]  length: 0 (resolved future 2)
[15:32:10.601] Relaying remaining futures
[15:32:10.601] signalConditionsASAP(NULL, pos=0) ...
[15:32:10.602] - nx: 2
[15:32:10.602] - relay: TRUE
[15:32:10.602] - stdout: TRUE
[15:32:10.603] - signal: TRUE
[15:32:10.603] - resignal: FALSE
[15:32:10.603] - force: TRUE
[15:32:10.604] - relayed: [n=2] TRUE, TRUE
[15:32:10.604] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:10.605] - relayed: [n=2] TRUE, TRUE
[15:32:10.605] - queued futures: [n=2] TRUE, TRUE
[15:32:10.605] signalConditionsASAP(NULL, pos=0) ... done
[15:32:10.606] resolve() on list ... DONE
[15:32:10.606] result() for ClusterFuture ...
[15:32:10.606] - result already collected: FutureResult
[15:32:10.607] result() for ClusterFuture ... done
[15:32:10.607] result() for ClusterFuture ...
[15:32:10.607] - result already collected: FutureResult
[15:32:10.608] result() for ClusterFuture ... done
[15:32:10.608] result() for ClusterFuture ...
[15:32:10.608] - result already collected: FutureResult
[15:32:10.609] result() for ClusterFuture ... done
[15:32:10.609] result() for ClusterFuture ...
[15:32:10.609] - result already collected: FutureResult
[15:32:10.610] result() for ClusterFuture ... done
[15:32:10.610]  - Number of value chunks collected: 2
[15:32:10.610] Resolving 2 futures (chunks) ... DONE
[15:32:10.611] Reducing values from 2 chunks ...
[15:32:10.611]  - Number of values collected after concatenation: 4
[15:32:10.611]  - Number of values expected: 4
[15:32:10.612] Reducing values from 2 chunks ... DONE
[15:32:10.612] future_mapply() ... DONE
[15:32:10.613] future_mapply() ...
[15:32:10.618] Number of chunks: 2
[15:32:10.618] getGlobalsAndPackagesXApply() ...
[15:32:10.618]  - future.globals: TRUE
[15:32:10.619] getGlobalsAndPackages() ...
[15:32:10.619] Searching for globals...
[15:32:10.621] - globals found: [1] 'FUN'
[15:32:10.621] Searching for globals ... DONE
[15:32:10.621] Resolving globals: FALSE
[15:32:10.622] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:10.623] The total size of the 1 globals exported for future expression ('FUN(x = 42)') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:10.623] - globals: [1] 'FUN'
[15:32:10.624] 
[15:32:10.624] getGlobalsAndPackages() ... DONE
[15:32:10.624]  - globals found/used: [n=1] 'FUN'
[15:32:10.625]  - needed namespaces: [n=0] 
[15:32:10.625] Finding globals ... DONE
[15:32:10.625] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:10.626] List of 2
[15:32:10.626]  $ ...future.FUN:function (x, ...)  
[15:32:10.626]  $ MoreArgs     :List of 1
[15:32:10.626]   ..$ x: num 42
[15:32:10.626]  - attr(*, "where")=List of 2
[15:32:10.626]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:10.626]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:10.626]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:10.626]  - attr(*, "resolved")= logi FALSE
[15:32:10.626]  - attr(*, "total_size")= num NA
[15:32:10.632] Packages to be attached in all futures: [n=0] 
[15:32:10.632] getGlobalsAndPackagesXApply() ... DONE
[15:32:10.632] Number of futures (= number of chunks): 2
[15:32:10.633] Launching 2 futures (chunks) ...
[15:32:10.633] Chunk #1 of 2 ...
[15:32:10.633]  - Finding globals in '...' for chunk #1 ...
[15:32:10.633] getGlobalsAndPackages() ...
[15:32:10.634] Searching for globals...
[15:32:10.634] 
[15:32:10.634] Searching for globals ... DONE
[15:32:10.635] - globals: [0] <none>
[15:32:10.635] getGlobalsAndPackages() ... DONE
[15:32:10.635]    + additional globals found: [n=0] 
[15:32:10.636]    + additional namespaces needed: [n=0] 
[15:32:10.636]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:10.636]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.637]  - seeds: <none>
[15:32:10.637]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.638] getGlobalsAndPackages() ...
[15:32:10.638] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.638] Resolving globals: FALSE
[15:32:10.640] The total size of the 5 globals is 224 bytes (224 bytes)
[15:32:10.641] 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 224 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (112 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (56 bytes of class 'list')
[15:32:10.642] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.642] 
[15:32:10.642] getGlobalsAndPackages() ... DONE
[15:32:10.643] run() for 'Future' ...
[15:32:10.643] - state: 'created'
[15:32:10.644] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.666] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.666] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.667]   - Field: 'node'
[15:32:10.667]   - Field: 'label'
[15:32:10.667]   - Field: 'local'
[15:32:10.667]   - Field: 'owner'
[15:32:10.668]   - Field: 'envir'
[15:32:10.668]   - Field: 'workers'
[15:32:10.668]   - Field: 'packages'
[15:32:10.668]   - Field: 'gc'
[15:32:10.669]   - Field: 'conditions'
[15:32:10.669]   - Field: 'persistent'
[15:32:10.669]   - Field: 'expr'
[15:32:10.670]   - Field: 'uuid'
[15:32:10.670]   - Field: 'seed'
[15:32:10.670]   - Field: 'version'
[15:32:10.670]   - Field: 'result'
[15:32:10.670]   - Field: 'asynchronous'
[15:32:10.671]   - Field: 'calls'
[15:32:10.671]   - Field: 'globals'
[15:32:10.672]   - Field: 'stdout'
[15:32:10.672]   - Field: 'earlySignal'
[15:32:10.672]   - Field: 'lazy'
[15:32:10.673]   - Field: 'state'
[15:32:10.673] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.673] - Launch lazy future ...
[15:32:10.674] Packages needed by the future expression (n = 0): <none>
[15:32:10.675] Packages needed by future strategies (n = 0): <none>
[15:32:10.676] {
[15:32:10.676]     {
[15:32:10.676]         {
[15:32:10.676]             ...future.startTime <- base::Sys.time()
[15:32:10.676]             {
[15:32:10.676]                 {
[15:32:10.676]                   {
[15:32:10.676]                     {
[15:32:10.676]                       base::local({
[15:32:10.676]                         has_future <- base::requireNamespace("future", 
[15:32:10.676]                           quietly = TRUE)
[15:32:10.676]                         if (has_future) {
[15:32:10.676]                           ns <- base::getNamespace("future")
[15:32:10.676]                           version <- ns[[".package"]][["version"]]
[15:32:10.676]                           if (is.null(version)) 
[15:32:10.676]                             version <- utils::packageVersion("future")
[15:32:10.676]                         }
[15:32:10.676]                         else {
[15:32:10.676]                           version <- NULL
[15:32:10.676]                         }
[15:32:10.676]                         if (!has_future || version < "1.8.0") {
[15:32:10.676]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.676]                             "", base::R.version$version.string), 
[15:32:10.676]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.676]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.676]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.676]                               "release", "version")], collapse = " "), 
[15:32:10.676]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.676]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.676]                             info)
[15:32:10.676]                           info <- base::paste(info, collapse = "; ")
[15:32:10.676]                           if (!has_future) {
[15:32:10.676]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.676]                               info)
[15:32:10.676]                           }
[15:32:10.676]                           else {
[15:32:10.676]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.676]                               info, version)
[15:32:10.676]                           }
[15:32:10.676]                           base::stop(msg)
[15:32:10.676]                         }
[15:32:10.676]                       })
[15:32:10.676]                     }
[15:32:10.676]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.676]                     base::options(mc.cores = 1L)
[15:32:10.676]                   }
[15:32:10.676]                   ...future.strategy.old <- future::plan("list")
[15:32:10.676]                   options(future.plan = NULL)
[15:32:10.676]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.676]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.676]                 }
[15:32:10.676]                 ...future.workdir <- getwd()
[15:32:10.676]             }
[15:32:10.676]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.676]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.676]         }
[15:32:10.676]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.676]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.676]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.676]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.676]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.676]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.676]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.676]             base::names(...future.oldOptions))
[15:32:10.676]     }
[15:32:10.676]     if (FALSE) {
[15:32:10.676]     }
[15:32:10.676]     else {
[15:32:10.676]         if (TRUE) {
[15:32:10.676]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.676]                 open = "w")
[15:32:10.676]         }
[15:32:10.676]         else {
[15:32:10.676]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.676]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.676]         }
[15:32:10.676]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.676]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.676]             base::sink(type = "output", split = FALSE)
[15:32:10.676]             base::close(...future.stdout)
[15:32:10.676]         }, add = TRUE)
[15:32:10.676]     }
[15:32:10.676]     ...future.frame <- base::sys.nframe()
[15:32:10.676]     ...future.conditions <- base::list()
[15:32:10.676]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.676]     if (FALSE) {
[15:32:10.676]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.676]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.676]     }
[15:32:10.676]     ...future.result <- base::tryCatch({
[15:32:10.676]         base::withCallingHandlers({
[15:32:10.676]             ...future.value <- base::withVisible(base::local({
[15:32:10.676]                 ...future.makeSendCondition <- base::local({
[15:32:10.676]                   sendCondition <- NULL
[15:32:10.676]                   function(frame = 1L) {
[15:32:10.676]                     if (is.function(sendCondition)) 
[15:32:10.676]                       return(sendCondition)
[15:32:10.676]                     ns <- getNamespace("parallel")
[15:32:10.676]                     if (exists("sendData", mode = "function", 
[15:32:10.676]                       envir = ns)) {
[15:32:10.676]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.676]                         envir = ns)
[15:32:10.676]                       envir <- sys.frame(frame)
[15:32:10.676]                       master <- NULL
[15:32:10.676]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.676]                         !identical(envir, emptyenv())) {
[15:32:10.676]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.676]                           inherits = FALSE)) {
[15:32:10.676]                           master <- get("master", mode = "list", 
[15:32:10.676]                             envir = envir, inherits = FALSE)
[15:32:10.676]                           if (inherits(master, c("SOCKnode", 
[15:32:10.676]                             "SOCK0node"))) {
[15:32:10.676]                             sendCondition <<- function(cond) {
[15:32:10.676]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.676]                                 success = TRUE)
[15:32:10.676]                               parallel_sendData(master, data)
[15:32:10.676]                             }
[15:32:10.676]                             return(sendCondition)
[15:32:10.676]                           }
[15:32:10.676]                         }
[15:32:10.676]                         frame <- frame + 1L
[15:32:10.676]                         envir <- sys.frame(frame)
[15:32:10.676]                       }
[15:32:10.676]                     }
[15:32:10.676]                     sendCondition <<- function(cond) NULL
[15:32:10.676]                   }
[15:32:10.676]                 })
[15:32:10.676]                 withCallingHandlers({
[15:32:10.676]                   {
[15:32:10.676]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.676]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.676]                       ...future.globals.maxSize)) {
[15:32:10.676]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.676]                       on.exit(options(oopts), add = TRUE)
[15:32:10.676]                     }
[15:32:10.676]                     {
[15:32:10.676]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.676]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.676]                         USE.NAMES = FALSE)
[15:32:10.676]                       do.call(mapply, args = args)
[15:32:10.676]                     }
[15:32:10.676]                   }
[15:32:10.676]                 }, immediateCondition = function(cond) {
[15:32:10.676]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.676]                   sendCondition(cond)
[15:32:10.676]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.676]                   {
[15:32:10.676]                     inherits <- base::inherits
[15:32:10.676]                     invokeRestart <- base::invokeRestart
[15:32:10.676]                     is.null <- base::is.null
[15:32:10.676]                     muffled <- FALSE
[15:32:10.676]                     if (inherits(cond, "message")) {
[15:32:10.676]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.676]                       if (muffled) 
[15:32:10.676]                         invokeRestart("muffleMessage")
[15:32:10.676]                     }
[15:32:10.676]                     else if (inherits(cond, "warning")) {
[15:32:10.676]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.676]                       if (muffled) 
[15:32:10.676]                         invokeRestart("muffleWarning")
[15:32:10.676]                     }
[15:32:10.676]                     else if (inherits(cond, "condition")) {
[15:32:10.676]                       if (!is.null(pattern)) {
[15:32:10.676]                         computeRestarts <- base::computeRestarts
[15:32:10.676]                         grepl <- base::grepl
[15:32:10.676]                         restarts <- computeRestarts(cond)
[15:32:10.676]                         for (restart in restarts) {
[15:32:10.676]                           name <- restart$name
[15:32:10.676]                           if (is.null(name)) 
[15:32:10.676]                             next
[15:32:10.676]                           if (!grepl(pattern, name)) 
[15:32:10.676]                             next
[15:32:10.676]                           invokeRestart(restart)
[15:32:10.676]                           muffled <- TRUE
[15:32:10.676]                           break
[15:32:10.676]                         }
[15:32:10.676]                       }
[15:32:10.676]                     }
[15:32:10.676]                     invisible(muffled)
[15:32:10.676]                   }
[15:32:10.676]                   muffleCondition(cond)
[15:32:10.676]                 })
[15:32:10.676]             }))
[15:32:10.676]             future::FutureResult(value = ...future.value$value, 
[15:32:10.676]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.676]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.676]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.676]                     ...future.globalenv.names))
[15:32:10.676]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.676]         }, condition = base::local({
[15:32:10.676]             c <- base::c
[15:32:10.676]             inherits <- base::inherits
[15:32:10.676]             invokeRestart <- base::invokeRestart
[15:32:10.676]             length <- base::length
[15:32:10.676]             list <- base::list
[15:32:10.676]             seq.int <- base::seq.int
[15:32:10.676]             signalCondition <- base::signalCondition
[15:32:10.676]             sys.calls <- base::sys.calls
[15:32:10.676]             `[[` <- base::`[[`
[15:32:10.676]             `+` <- base::`+`
[15:32:10.676]             `<<-` <- base::`<<-`
[15:32:10.676]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.676]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.676]                   3L)]
[15:32:10.676]             }
[15:32:10.676]             function(cond) {
[15:32:10.676]                 is_error <- inherits(cond, "error")
[15:32:10.676]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.676]                   NULL)
[15:32:10.676]                 if (is_error) {
[15:32:10.676]                   sessionInformation <- function() {
[15:32:10.676]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.676]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.676]                       search = base::search(), system = base::Sys.info())
[15:32:10.676]                   }
[15:32:10.676]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.676]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.676]                     cond$call), session = sessionInformation(), 
[15:32:10.676]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.676]                   signalCondition(cond)
[15:32:10.676]                 }
[15:32:10.676]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.676]                 "immediateCondition"))) {
[15:32:10.676]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.676]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.676]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.676]                   if (TRUE && !signal) {
[15:32:10.676]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.676]                     {
[15:32:10.676]                       inherits <- base::inherits
[15:32:10.676]                       invokeRestart <- base::invokeRestart
[15:32:10.676]                       is.null <- base::is.null
[15:32:10.676]                       muffled <- FALSE
[15:32:10.676]                       if (inherits(cond, "message")) {
[15:32:10.676]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.676]                         if (muffled) 
[15:32:10.676]                           invokeRestart("muffleMessage")
[15:32:10.676]                       }
[15:32:10.676]                       else if (inherits(cond, "warning")) {
[15:32:10.676]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.676]                         if (muffled) 
[15:32:10.676]                           invokeRestart("muffleWarning")
[15:32:10.676]                       }
[15:32:10.676]                       else if (inherits(cond, "condition")) {
[15:32:10.676]                         if (!is.null(pattern)) {
[15:32:10.676]                           computeRestarts <- base::computeRestarts
[15:32:10.676]                           grepl <- base::grepl
[15:32:10.676]                           restarts <- computeRestarts(cond)
[15:32:10.676]                           for (restart in restarts) {
[15:32:10.676]                             name <- restart$name
[15:32:10.676]                             if (is.null(name)) 
[15:32:10.676]                               next
[15:32:10.676]                             if (!grepl(pattern, name)) 
[15:32:10.676]                               next
[15:32:10.676]                             invokeRestart(restart)
[15:32:10.676]                             muffled <- TRUE
[15:32:10.676]                             break
[15:32:10.676]                           }
[15:32:10.676]                         }
[15:32:10.676]                       }
[15:32:10.676]                       invisible(muffled)
[15:32:10.676]                     }
[15:32:10.676]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.676]                   }
[15:32:10.676]                 }
[15:32:10.676]                 else {
[15:32:10.676]                   if (TRUE) {
[15:32:10.676]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.676]                     {
[15:32:10.676]                       inherits <- base::inherits
[15:32:10.676]                       invokeRestart <- base::invokeRestart
[15:32:10.676]                       is.null <- base::is.null
[15:32:10.676]                       muffled <- FALSE
[15:32:10.676]                       if (inherits(cond, "message")) {
[15:32:10.676]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.676]                         if (muffled) 
[15:32:10.676]                           invokeRestart("muffleMessage")
[15:32:10.676]                       }
[15:32:10.676]                       else if (inherits(cond, "warning")) {
[15:32:10.676]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.676]                         if (muffled) 
[15:32:10.676]                           invokeRestart("muffleWarning")
[15:32:10.676]                       }
[15:32:10.676]                       else if (inherits(cond, "condition")) {
[15:32:10.676]                         if (!is.null(pattern)) {
[15:32:10.676]                           computeRestarts <- base::computeRestarts
[15:32:10.676]                           grepl <- base::grepl
[15:32:10.676]                           restarts <- computeRestarts(cond)
[15:32:10.676]                           for (restart in restarts) {
[15:32:10.676]                             name <- restart$name
[15:32:10.676]                             if (is.null(name)) 
[15:32:10.676]                               next
[15:32:10.676]                             if (!grepl(pattern, name)) 
[15:32:10.676]                               next
[15:32:10.676]                             invokeRestart(restart)
[15:32:10.676]                             muffled <- TRUE
[15:32:10.676]                             break
[15:32:10.676]                           }
[15:32:10.676]                         }
[15:32:10.676]                       }
[15:32:10.676]                       invisible(muffled)
[15:32:10.676]                     }
[15:32:10.676]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.676]                   }
[15:32:10.676]                 }
[15:32:10.676]             }
[15:32:10.676]         }))
[15:32:10.676]     }, error = function(ex) {
[15:32:10.676]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.676]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.676]                 ...future.rng), started = ...future.startTime, 
[15:32:10.676]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.676]             version = "1.8"), class = "FutureResult")
[15:32:10.676]     }, finally = {
[15:32:10.676]         if (!identical(...future.workdir, getwd())) 
[15:32:10.676]             setwd(...future.workdir)
[15:32:10.676]         {
[15:32:10.676]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.676]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.676]             }
[15:32:10.676]             base::options(...future.oldOptions)
[15:32:10.676]             if (.Platform$OS.type == "windows") {
[15:32:10.676]                 old_names <- names(...future.oldEnvVars)
[15:32:10.676]                 envs <- base::Sys.getenv()
[15:32:10.676]                 names <- names(envs)
[15:32:10.676]                 common <- intersect(names, old_names)
[15:32:10.676]                 added <- setdiff(names, old_names)
[15:32:10.676]                 removed <- setdiff(old_names, names)
[15:32:10.676]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.676]                   envs[common]]
[15:32:10.676]                 NAMES <- toupper(changed)
[15:32:10.676]                 args <- list()
[15:32:10.676]                 for (kk in seq_along(NAMES)) {
[15:32:10.676]                   name <- changed[[kk]]
[15:32:10.676]                   NAME <- NAMES[[kk]]
[15:32:10.676]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.676]                     next
[15:32:10.676]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.676]                 }
[15:32:10.676]                 NAMES <- toupper(added)
[15:32:10.676]                 for (kk in seq_along(NAMES)) {
[15:32:10.676]                   name <- added[[kk]]
[15:32:10.676]                   NAME <- NAMES[[kk]]
[15:32:10.676]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.676]                     next
[15:32:10.676]                   args[[name]] <- ""
[15:32:10.676]                 }
[15:32:10.676]                 NAMES <- toupper(removed)
[15:32:10.676]                 for (kk in seq_along(NAMES)) {
[15:32:10.676]                   name <- removed[[kk]]
[15:32:10.676]                   NAME <- NAMES[[kk]]
[15:32:10.676]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.676]                     next
[15:32:10.676]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.676]                 }
[15:32:10.676]                 if (length(args) > 0) 
[15:32:10.676]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.676]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.676]             }
[15:32:10.676]             else {
[15:32:10.676]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.676]             }
[15:32:10.676]             {
[15:32:10.676]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.676]                   0L) {
[15:32:10.676]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.676]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.676]                   base::options(opts)
[15:32:10.676]                 }
[15:32:10.676]                 {
[15:32:10.676]                   {
[15:32:10.676]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.676]                     NULL
[15:32:10.676]                   }
[15:32:10.676]                   options(future.plan = NULL)
[15:32:10.676]                   if (is.na(NA_character_)) 
[15:32:10.676]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.676]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.676]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.676]                     .init = FALSE)
[15:32:10.676]                 }
[15:32:10.676]             }
[15:32:10.676]         }
[15:32:10.676]     })
[15:32:10.676]     if (TRUE) {
[15:32:10.676]         base::sink(type = "output", split = FALSE)
[15:32:10.676]         if (TRUE) {
[15:32:10.676]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.676]         }
[15:32:10.676]         else {
[15:32:10.676]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.676]         }
[15:32:10.676]         base::close(...future.stdout)
[15:32:10.676]         ...future.stdout <- NULL
[15:32:10.676]     }
[15:32:10.676]     ...future.result$conditions <- ...future.conditions
[15:32:10.676]     ...future.result$finished <- base::Sys.time()
[15:32:10.676]     ...future.result
[15:32:10.676] }
[15:32:10.686] Exporting 5 global objects (224 bytes) to cluster node #1 ...
[15:32:10.686] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.687] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.688] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:10.689] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:10.689] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:10.690] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:10.690] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.691] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.692] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.692] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.693] Exporting 5 global objects (224 bytes) to cluster node #1 ... DONE
[15:32:10.694] MultisessionFuture started
[15:32:10.694] - Launch lazy future ... done
[15:32:10.695] run() for 'MultisessionFuture' ... done
[15:32:10.695] Created future:
[15:32:10.719] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.720] - Validating connection of MultisessionFuture
[15:32:10.720] - received message: FutureResult
[15:32:10.720] - Received FutureResult
[15:32:10.721] - Erased future from FutureRegistry
[15:32:10.721] result() for ClusterFuture ...
[15:32:10.721] - result already collected: FutureResult
[15:32:10.721] result() for ClusterFuture ... done
[15:32:10.721] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.696] MultisessionFuture:
[15:32:10.696] Label: 'future_mapply-1'
[15:32:10.696] Expression:
[15:32:10.696] {
[15:32:10.696]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.696]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.696]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.696]         on.exit(options(oopts), add = TRUE)
[15:32:10.696]     }
[15:32:10.696]     {
[15:32:10.696]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.696]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.696]         do.call(mapply, args = args)
[15:32:10.696]     }
[15:32:10.696] }
[15:32:10.696] Lazy evaluation: FALSE
[15:32:10.696] Asynchronous evaluation: TRUE
[15:32:10.696] Local evaluation: TRUE
[15:32:10.696] Environment: R_GlobalEnv
[15:32:10.696] Capture standard output: TRUE
[15:32:10.696] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.696] Globals: 5 objects totaling 224 bytes (function '...future.FUN' of 56 bytes, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:10.696] Packages: <none>
[15:32:10.696] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.696] Resolved: TRUE
[15:32:10.696] Value: <not collected>
[15:32:10.696] Conditions captured: <none>
[15:32:10.696] Early signaling: FALSE
[15:32:10.696] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.696] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.722] Chunk #1 of 2 ... DONE
[15:32:10.722] Chunk #2 of 2 ...
[15:32:10.722]  - Finding globals in '...' for chunk #2 ...
[15:32:10.722] getGlobalsAndPackages() ...
[15:32:10.723] Searching for globals...
[15:32:10.723] 
[15:32:10.723] Searching for globals ... DONE
[15:32:10.723] - globals: [0] <none>
[15:32:10.724] getGlobalsAndPackages() ... DONE
[15:32:10.724]    + additional globals found: [n=0] 
[15:32:10.724]    + additional namespaces needed: [n=0] 
[15:32:10.724]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:10.724]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.725]  - seeds: <none>
[15:32:10.725]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.725] getGlobalsAndPackages() ...
[15:32:10.725] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.725] Resolving globals: FALSE
[15:32:10.726] The total size of the 5 globals is 224 bytes (224 bytes)
[15:32:10.727] 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 224 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (112 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (56 bytes of class 'list')
[15:32:10.727] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.728] 
[15:32:10.728] getGlobalsAndPackages() ... DONE
[15:32:10.728] run() for 'Future' ...
[15:32:10.728] - state: 'created'
[15:32:10.729] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.747] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.747] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.748]   - Field: 'node'
[15:32:10.748]   - Field: 'label'
[15:32:10.748]   - Field: 'local'
[15:32:10.749]   - Field: 'owner'
[15:32:10.749]   - Field: 'envir'
[15:32:10.749]   - Field: 'workers'
[15:32:10.750]   - Field: 'packages'
[15:32:10.750]   - Field: 'gc'
[15:32:10.750]   - Field: 'conditions'
[15:32:10.751]   - Field: 'persistent'
[15:32:10.751]   - Field: 'expr'
[15:32:10.751]   - Field: 'uuid'
[15:32:10.751]   - Field: 'seed'
[15:32:10.752]   - Field: 'version'
[15:32:10.752]   - Field: 'result'
[15:32:10.752]   - Field: 'asynchronous'
[15:32:10.753]   - Field: 'calls'
[15:32:10.753]   - Field: 'globals'
[15:32:10.753]   - Field: 'stdout'
[15:32:10.753]   - Field: 'earlySignal'
[15:32:10.754]   - Field: 'lazy'
[15:32:10.754]   - Field: 'state'
[15:32:10.754] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.755] - Launch lazy future ...
[15:32:10.755] Packages needed by the future expression (n = 0): <none>
[15:32:10.756] Packages needed by future strategies (n = 0): <none>
[15:32:10.757] {
[15:32:10.757]     {
[15:32:10.757]         {
[15:32:10.757]             ...future.startTime <- base::Sys.time()
[15:32:10.757]             {
[15:32:10.757]                 {
[15:32:10.757]                   {
[15:32:10.757]                     {
[15:32:10.757]                       base::local({
[15:32:10.757]                         has_future <- base::requireNamespace("future", 
[15:32:10.757]                           quietly = TRUE)
[15:32:10.757]                         if (has_future) {
[15:32:10.757]                           ns <- base::getNamespace("future")
[15:32:10.757]                           version <- ns[[".package"]][["version"]]
[15:32:10.757]                           if (is.null(version)) 
[15:32:10.757]                             version <- utils::packageVersion("future")
[15:32:10.757]                         }
[15:32:10.757]                         else {
[15:32:10.757]                           version <- NULL
[15:32:10.757]                         }
[15:32:10.757]                         if (!has_future || version < "1.8.0") {
[15:32:10.757]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.757]                             "", base::R.version$version.string), 
[15:32:10.757]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.757]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.757]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.757]                               "release", "version")], collapse = " "), 
[15:32:10.757]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.757]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.757]                             info)
[15:32:10.757]                           info <- base::paste(info, collapse = "; ")
[15:32:10.757]                           if (!has_future) {
[15:32:10.757]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.757]                               info)
[15:32:10.757]                           }
[15:32:10.757]                           else {
[15:32:10.757]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.757]                               info, version)
[15:32:10.757]                           }
[15:32:10.757]                           base::stop(msg)
[15:32:10.757]                         }
[15:32:10.757]                       })
[15:32:10.757]                     }
[15:32:10.757]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.757]                     base::options(mc.cores = 1L)
[15:32:10.757]                   }
[15:32:10.757]                   ...future.strategy.old <- future::plan("list")
[15:32:10.757]                   options(future.plan = NULL)
[15:32:10.757]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.757]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.757]                 }
[15:32:10.757]                 ...future.workdir <- getwd()
[15:32:10.757]             }
[15:32:10.757]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.757]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.757]         }
[15:32:10.757]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.757]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.757]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.757]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.757]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.757]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.757]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.757]             base::names(...future.oldOptions))
[15:32:10.757]     }
[15:32:10.757]     if (FALSE) {
[15:32:10.757]     }
[15:32:10.757]     else {
[15:32:10.757]         if (TRUE) {
[15:32:10.757]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.757]                 open = "w")
[15:32:10.757]         }
[15:32:10.757]         else {
[15:32:10.757]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.757]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.757]         }
[15:32:10.757]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.757]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.757]             base::sink(type = "output", split = FALSE)
[15:32:10.757]             base::close(...future.stdout)
[15:32:10.757]         }, add = TRUE)
[15:32:10.757]     }
[15:32:10.757]     ...future.frame <- base::sys.nframe()
[15:32:10.757]     ...future.conditions <- base::list()
[15:32:10.757]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.757]     if (FALSE) {
[15:32:10.757]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.757]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.757]     }
[15:32:10.757]     ...future.result <- base::tryCatch({
[15:32:10.757]         base::withCallingHandlers({
[15:32:10.757]             ...future.value <- base::withVisible(base::local({
[15:32:10.757]                 ...future.makeSendCondition <- base::local({
[15:32:10.757]                   sendCondition <- NULL
[15:32:10.757]                   function(frame = 1L) {
[15:32:10.757]                     if (is.function(sendCondition)) 
[15:32:10.757]                       return(sendCondition)
[15:32:10.757]                     ns <- getNamespace("parallel")
[15:32:10.757]                     if (exists("sendData", mode = "function", 
[15:32:10.757]                       envir = ns)) {
[15:32:10.757]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.757]                         envir = ns)
[15:32:10.757]                       envir <- sys.frame(frame)
[15:32:10.757]                       master <- NULL
[15:32:10.757]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.757]                         !identical(envir, emptyenv())) {
[15:32:10.757]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.757]                           inherits = FALSE)) {
[15:32:10.757]                           master <- get("master", mode = "list", 
[15:32:10.757]                             envir = envir, inherits = FALSE)
[15:32:10.757]                           if (inherits(master, c("SOCKnode", 
[15:32:10.757]                             "SOCK0node"))) {
[15:32:10.757]                             sendCondition <<- function(cond) {
[15:32:10.757]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.757]                                 success = TRUE)
[15:32:10.757]                               parallel_sendData(master, data)
[15:32:10.757]                             }
[15:32:10.757]                             return(sendCondition)
[15:32:10.757]                           }
[15:32:10.757]                         }
[15:32:10.757]                         frame <- frame + 1L
[15:32:10.757]                         envir <- sys.frame(frame)
[15:32:10.757]                       }
[15:32:10.757]                     }
[15:32:10.757]                     sendCondition <<- function(cond) NULL
[15:32:10.757]                   }
[15:32:10.757]                 })
[15:32:10.757]                 withCallingHandlers({
[15:32:10.757]                   {
[15:32:10.757]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.757]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.757]                       ...future.globals.maxSize)) {
[15:32:10.757]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.757]                       on.exit(options(oopts), add = TRUE)
[15:32:10.757]                     }
[15:32:10.757]                     {
[15:32:10.757]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.757]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.757]                         USE.NAMES = FALSE)
[15:32:10.757]                       do.call(mapply, args = args)
[15:32:10.757]                     }
[15:32:10.757]                   }
[15:32:10.757]                 }, immediateCondition = function(cond) {
[15:32:10.757]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.757]                   sendCondition(cond)
[15:32:10.757]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.757]                   {
[15:32:10.757]                     inherits <- base::inherits
[15:32:10.757]                     invokeRestart <- base::invokeRestart
[15:32:10.757]                     is.null <- base::is.null
[15:32:10.757]                     muffled <- FALSE
[15:32:10.757]                     if (inherits(cond, "message")) {
[15:32:10.757]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.757]                       if (muffled) 
[15:32:10.757]                         invokeRestart("muffleMessage")
[15:32:10.757]                     }
[15:32:10.757]                     else if (inherits(cond, "warning")) {
[15:32:10.757]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.757]                       if (muffled) 
[15:32:10.757]                         invokeRestart("muffleWarning")
[15:32:10.757]                     }
[15:32:10.757]                     else if (inherits(cond, "condition")) {
[15:32:10.757]                       if (!is.null(pattern)) {
[15:32:10.757]                         computeRestarts <- base::computeRestarts
[15:32:10.757]                         grepl <- base::grepl
[15:32:10.757]                         restarts <- computeRestarts(cond)
[15:32:10.757]                         for (restart in restarts) {
[15:32:10.757]                           name <- restart$name
[15:32:10.757]                           if (is.null(name)) 
[15:32:10.757]                             next
[15:32:10.757]                           if (!grepl(pattern, name)) 
[15:32:10.757]                             next
[15:32:10.757]                           invokeRestart(restart)
[15:32:10.757]                           muffled <- TRUE
[15:32:10.757]                           break
[15:32:10.757]                         }
[15:32:10.757]                       }
[15:32:10.757]                     }
[15:32:10.757]                     invisible(muffled)
[15:32:10.757]                   }
[15:32:10.757]                   muffleCondition(cond)
[15:32:10.757]                 })
[15:32:10.757]             }))
[15:32:10.757]             future::FutureResult(value = ...future.value$value, 
[15:32:10.757]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.757]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.757]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.757]                     ...future.globalenv.names))
[15:32:10.757]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.757]         }, condition = base::local({
[15:32:10.757]             c <- base::c
[15:32:10.757]             inherits <- base::inherits
[15:32:10.757]             invokeRestart <- base::invokeRestart
[15:32:10.757]             length <- base::length
[15:32:10.757]             list <- base::list
[15:32:10.757]             seq.int <- base::seq.int
[15:32:10.757]             signalCondition <- base::signalCondition
[15:32:10.757]             sys.calls <- base::sys.calls
[15:32:10.757]             `[[` <- base::`[[`
[15:32:10.757]             `+` <- base::`+`
[15:32:10.757]             `<<-` <- base::`<<-`
[15:32:10.757]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.757]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.757]                   3L)]
[15:32:10.757]             }
[15:32:10.757]             function(cond) {
[15:32:10.757]                 is_error <- inherits(cond, "error")
[15:32:10.757]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.757]                   NULL)
[15:32:10.757]                 if (is_error) {
[15:32:10.757]                   sessionInformation <- function() {
[15:32:10.757]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.757]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.757]                       search = base::search(), system = base::Sys.info())
[15:32:10.757]                   }
[15:32:10.757]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.757]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.757]                     cond$call), session = sessionInformation(), 
[15:32:10.757]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.757]                   signalCondition(cond)
[15:32:10.757]                 }
[15:32:10.757]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.757]                 "immediateCondition"))) {
[15:32:10.757]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.757]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.757]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.757]                   if (TRUE && !signal) {
[15:32:10.757]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.757]                     {
[15:32:10.757]                       inherits <- base::inherits
[15:32:10.757]                       invokeRestart <- base::invokeRestart
[15:32:10.757]                       is.null <- base::is.null
[15:32:10.757]                       muffled <- FALSE
[15:32:10.757]                       if (inherits(cond, "message")) {
[15:32:10.757]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.757]                         if (muffled) 
[15:32:10.757]                           invokeRestart("muffleMessage")
[15:32:10.757]                       }
[15:32:10.757]                       else if (inherits(cond, "warning")) {
[15:32:10.757]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.757]                         if (muffled) 
[15:32:10.757]                           invokeRestart("muffleWarning")
[15:32:10.757]                       }
[15:32:10.757]                       else if (inherits(cond, "condition")) {
[15:32:10.757]                         if (!is.null(pattern)) {
[15:32:10.757]                           computeRestarts <- base::computeRestarts
[15:32:10.757]                           grepl <- base::grepl
[15:32:10.757]                           restarts <- computeRestarts(cond)
[15:32:10.757]                           for (restart in restarts) {
[15:32:10.757]                             name <- restart$name
[15:32:10.757]                             if (is.null(name)) 
[15:32:10.757]                               next
[15:32:10.757]                             if (!grepl(pattern, name)) 
[15:32:10.757]                               next
[15:32:10.757]                             invokeRestart(restart)
[15:32:10.757]                             muffled <- TRUE
[15:32:10.757]                             break
[15:32:10.757]                           }
[15:32:10.757]                         }
[15:32:10.757]                       }
[15:32:10.757]                       invisible(muffled)
[15:32:10.757]                     }
[15:32:10.757]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.757]                   }
[15:32:10.757]                 }
[15:32:10.757]                 else {
[15:32:10.757]                   if (TRUE) {
[15:32:10.757]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.757]                     {
[15:32:10.757]                       inherits <- base::inherits
[15:32:10.757]                       invokeRestart <- base::invokeRestart
[15:32:10.757]                       is.null <- base::is.null
[15:32:10.757]                       muffled <- FALSE
[15:32:10.757]                       if (inherits(cond, "message")) {
[15:32:10.757]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.757]                         if (muffled) 
[15:32:10.757]                           invokeRestart("muffleMessage")
[15:32:10.757]                       }
[15:32:10.757]                       else if (inherits(cond, "warning")) {
[15:32:10.757]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.757]                         if (muffled) 
[15:32:10.757]                           invokeRestart("muffleWarning")
[15:32:10.757]                       }
[15:32:10.757]                       else if (inherits(cond, "condition")) {
[15:32:10.757]                         if (!is.null(pattern)) {
[15:32:10.757]                           computeRestarts <- base::computeRestarts
[15:32:10.757]                           grepl <- base::grepl
[15:32:10.757]                           restarts <- computeRestarts(cond)
[15:32:10.757]                           for (restart in restarts) {
[15:32:10.757]                             name <- restart$name
[15:32:10.757]                             if (is.null(name)) 
[15:32:10.757]                               next
[15:32:10.757]                             if (!grepl(pattern, name)) 
[15:32:10.757]                               next
[15:32:10.757]                             invokeRestart(restart)
[15:32:10.757]                             muffled <- TRUE
[15:32:10.757]                             break
[15:32:10.757]                           }
[15:32:10.757]                         }
[15:32:10.757]                       }
[15:32:10.757]                       invisible(muffled)
[15:32:10.757]                     }
[15:32:10.757]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.757]                   }
[15:32:10.757]                 }
[15:32:10.757]             }
[15:32:10.757]         }))
[15:32:10.757]     }, error = function(ex) {
[15:32:10.757]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.757]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.757]                 ...future.rng), started = ...future.startTime, 
[15:32:10.757]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.757]             version = "1.8"), class = "FutureResult")
[15:32:10.757]     }, finally = {
[15:32:10.757]         if (!identical(...future.workdir, getwd())) 
[15:32:10.757]             setwd(...future.workdir)
[15:32:10.757]         {
[15:32:10.757]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.757]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.757]             }
[15:32:10.757]             base::options(...future.oldOptions)
[15:32:10.757]             if (.Platform$OS.type == "windows") {
[15:32:10.757]                 old_names <- names(...future.oldEnvVars)
[15:32:10.757]                 envs <- base::Sys.getenv()
[15:32:10.757]                 names <- names(envs)
[15:32:10.757]                 common <- intersect(names, old_names)
[15:32:10.757]                 added <- setdiff(names, old_names)
[15:32:10.757]                 removed <- setdiff(old_names, names)
[15:32:10.757]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.757]                   envs[common]]
[15:32:10.757]                 NAMES <- toupper(changed)
[15:32:10.757]                 args <- list()
[15:32:10.757]                 for (kk in seq_along(NAMES)) {
[15:32:10.757]                   name <- changed[[kk]]
[15:32:10.757]                   NAME <- NAMES[[kk]]
[15:32:10.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.757]                     next
[15:32:10.757]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.757]                 }
[15:32:10.757]                 NAMES <- toupper(added)
[15:32:10.757]                 for (kk in seq_along(NAMES)) {
[15:32:10.757]                   name <- added[[kk]]
[15:32:10.757]                   NAME <- NAMES[[kk]]
[15:32:10.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.757]                     next
[15:32:10.757]                   args[[name]] <- ""
[15:32:10.757]                 }
[15:32:10.757]                 NAMES <- toupper(removed)
[15:32:10.757]                 for (kk in seq_along(NAMES)) {
[15:32:10.757]                   name <- removed[[kk]]
[15:32:10.757]                   NAME <- NAMES[[kk]]
[15:32:10.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.757]                     next
[15:32:10.757]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.757]                 }
[15:32:10.757]                 if (length(args) > 0) 
[15:32:10.757]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.757]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.757]             }
[15:32:10.757]             else {
[15:32:10.757]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.757]             }
[15:32:10.757]             {
[15:32:10.757]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.757]                   0L) {
[15:32:10.757]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.757]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.757]                   base::options(opts)
[15:32:10.757]                 }
[15:32:10.757]                 {
[15:32:10.757]                   {
[15:32:10.757]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.757]                     NULL
[15:32:10.757]                   }
[15:32:10.757]                   options(future.plan = NULL)
[15:32:10.757]                   if (is.na(NA_character_)) 
[15:32:10.757]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.757]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.757]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.757]                     .init = FALSE)
[15:32:10.757]                 }
[15:32:10.757]             }
[15:32:10.757]         }
[15:32:10.757]     })
[15:32:10.757]     if (TRUE) {
[15:32:10.757]         base::sink(type = "output", split = FALSE)
[15:32:10.757]         if (TRUE) {
[15:32:10.757]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.757]         }
[15:32:10.757]         else {
[15:32:10.757]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.757]         }
[15:32:10.757]         base::close(...future.stdout)
[15:32:10.757]         ...future.stdout <- NULL
[15:32:10.757]     }
[15:32:10.757]     ...future.result$conditions <- ...future.conditions
[15:32:10.757]     ...future.result$finished <- base::Sys.time()
[15:32:10.757]     ...future.result
[15:32:10.757] }
[15:32:10.766] Exporting 5 global objects (224 bytes) to cluster node #1 ...
[15:32:10.767] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:10.767] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:10.768] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:10.768] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:10.769] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:10.769] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:10.770] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.770] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.770] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.771] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.771] Exporting 5 global objects (224 bytes) to cluster node #1 ... DONE
[15:32:10.772] MultisessionFuture started
[15:32:10.773] - Launch lazy future ... done
[15:32:10.773] run() for 'MultisessionFuture' ... done
[15:32:10.773] Created future:
[15:32:10.795] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.795] - Validating connection of MultisessionFuture
[15:32:10.796] - received message: FutureResult
[15:32:10.796] - Received FutureResult
[15:32:10.797] - Erased future from FutureRegistry
[15:32:10.797] result() for ClusterFuture ...
[15:32:10.797] - result already collected: FutureResult
[15:32:10.797] result() for ClusterFuture ... done
[15:32:10.798] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.774] MultisessionFuture:
[15:32:10.774] Label: 'future_mapply-2'
[15:32:10.774] Expression:
[15:32:10.774] {
[15:32:10.774]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.774]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.774]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.774]         on.exit(options(oopts), add = TRUE)
[15:32:10.774]     }
[15:32:10.774]     {
[15:32:10.774]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.774]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.774]         do.call(mapply, args = args)
[15:32:10.774]     }
[15:32:10.774] }
[15:32:10.774] Lazy evaluation: FALSE
[15:32:10.774] Asynchronous evaluation: TRUE
[15:32:10.774] Local evaluation: TRUE
[15:32:10.774] Environment: R_GlobalEnv
[15:32:10.774] Capture standard output: TRUE
[15:32:10.774] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.774] Globals: 5 objects totaling 224 bytes (function '...future.FUN' of 56 bytes, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:10.774] Packages: <none>
[15:32:10.774] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.774] Resolved: TRUE
[15:32:10.774] Value: <not collected>
[15:32:10.774] Conditions captured: <none>
[15:32:10.774] Early signaling: FALSE
[15:32:10.774] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.774] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.798] Chunk #2 of 2 ... DONE
[15:32:10.799] Launching 2 futures (chunks) ... DONE
[15:32:10.799] Resolving 2 futures (chunks) ...
[15:32:10.799] resolve() on list ...
[15:32:10.799]  recursive: 0
[15:32:10.800]  length: 2
[15:32:10.800] 
[15:32:10.800] Future #1
[15:32:10.800] result() for ClusterFuture ...
[15:32:10.801] - result already collected: FutureResult
[15:32:10.801] result() for ClusterFuture ... done
[15:32:10.801] result() for ClusterFuture ...
[15:32:10.802] - result already collected: FutureResult
[15:32:10.802] result() for ClusterFuture ... done
[15:32:10.802] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:10.802] - nx: 2
[15:32:10.803] - relay: TRUE
[15:32:10.803] - stdout: TRUE
[15:32:10.803] - signal: TRUE
[15:32:10.803] - resignal: FALSE
[15:32:10.804] - force: TRUE
[15:32:10.804] - relayed: [n=2] FALSE, FALSE
[15:32:10.804] - queued futures: [n=2] FALSE, FALSE
[15:32:10.804]  - until=1
[15:32:10.805]  - relaying element #1
[15:32:10.805] result() for ClusterFuture ...
[15:32:10.805] - result already collected: FutureResult
[15:32:10.806] result() for ClusterFuture ... done
[15:32:10.806] result() for ClusterFuture ...
[15:32:10.806] - result already collected: FutureResult
[15:32:10.806] result() for ClusterFuture ... done
[15:32:10.807] result() for ClusterFuture ...
[15:32:10.807] - result already collected: FutureResult
[15:32:10.807] result() for ClusterFuture ... done
[15:32:10.808] result() for ClusterFuture ...
[15:32:10.808] - result already collected: FutureResult
[15:32:10.808] result() for ClusterFuture ... done
[15:32:10.808] - relayed: [n=2] TRUE, FALSE
[15:32:10.809] - queued futures: [n=2] TRUE, FALSE
[15:32:10.809] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:10.809]  length: 1 (resolved future 1)
[15:32:10.809] Future #2
[15:32:10.810] result() for ClusterFuture ...
[15:32:10.810] - result already collected: FutureResult
[15:32:10.810] result() for ClusterFuture ... done
[15:32:10.810] result() for ClusterFuture ...
[15:32:10.811] - result already collected: FutureResult
[15:32:10.811] result() for ClusterFuture ... done
[15:32:10.811] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:10.811] - nx: 2
[15:32:10.812] - relay: TRUE
[15:32:10.812] - stdout: TRUE
[15:32:10.812] - signal: TRUE
[15:32:10.812] - resignal: FALSE
[15:32:10.813] - force: TRUE
[15:32:10.813] - relayed: [n=2] TRUE, FALSE
[15:32:10.813] - queued futures: [n=2] TRUE, FALSE
[15:32:10.813]  - until=2
[15:32:10.814]  - relaying element #2
[15:32:10.814] result() for ClusterFuture ...
[15:32:10.814] - result already collected: FutureResult
[15:32:10.815] result() for ClusterFuture ... done
[15:32:10.815] result() for ClusterFuture ...
[15:32:10.815] - result already collected: FutureResult
[15:32:10.816] result() for ClusterFuture ... done
[15:32:10.816] result() for ClusterFuture ...
[15:32:10.816] - result already collected: FutureResult
[15:32:10.816] result() for ClusterFuture ... done
[15:32:10.817] result() for ClusterFuture ...
[15:32:10.817] - result already collected: FutureResult
[15:32:10.817] result() for ClusterFuture ... done
[15:32:10.817] - relayed: [n=2] TRUE, TRUE
[15:32:10.818] - queued futures: [n=2] TRUE, TRUE
[15:32:10.818] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:10.818]  length: 0 (resolved future 2)
[15:32:10.819] Relaying remaining futures
[15:32:10.819] signalConditionsASAP(NULL, pos=0) ...
[15:32:10.819] - nx: 2
[15:32:10.819] - relay: TRUE
[15:32:10.820] - stdout: TRUE
[15:32:10.820] - signal: TRUE
[15:32:10.820] - resignal: FALSE
[15:32:10.820] - force: TRUE
[15:32:10.821] - relayed: [n=2] TRUE, TRUE
[15:32:10.821] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:10.821] - relayed: [n=2] TRUE, TRUE
[15:32:10.821] - queued futures: [n=2] TRUE, TRUE
[15:32:10.822] signalConditionsASAP(NULL, pos=0) ... done
[15:32:10.822] resolve() on list ... DONE
[15:32:10.822] result() for ClusterFuture ...
[15:32:10.822] - result already collected: FutureResult
[15:32:10.823] result() for ClusterFuture ... done
[15:32:10.823] result() for ClusterFuture ...
[15:32:10.823] - result already collected: FutureResult
[15:32:10.823] result() for ClusterFuture ... done
[15:32:10.824] result() for ClusterFuture ...
[15:32:10.824] - result already collected: FutureResult
[15:32:10.824] result() for ClusterFuture ... done
[15:32:10.824] result() for ClusterFuture ...
[15:32:10.825] - result already collected: FutureResult
[15:32:10.825] result() for ClusterFuture ... done
[15:32:10.825]  - Number of value chunks collected: 2
[15:32:10.825] Resolving 2 futures (chunks) ... DONE
[15:32:10.826] Reducing values from 2 chunks ...
[15:32:10.826]  - Number of values collected after concatenation: 4
[15:32:10.826]  - Number of values expected: 4
[15:32:10.826] Reducing values from 2 chunks ... DONE
[15:32:10.827] future_mapply() ... DONE
[15:32:10.827] future_mapply() ...
[15:32:10.831] Number of chunks: 2
[15:32:10.831] getGlobalsAndPackagesXApply() ...
[15:32:10.832]  - future.globals: TRUE
[15:32:10.832] getGlobalsAndPackages() ...
[15:32:10.832] Searching for globals...
[15:32:10.835] - globals found: [3] 'FUN', '+', 'seq_len'
[15:32:10.835] Searching for globals ... DONE
[15:32:10.835] Resolving globals: FALSE
[15:32:10.836] The total size of the 1 globals is 1.93 KiB (1976 bytes)
[15:32:10.837] The total size of the 1 globals exported for future expression ('FUN()') is 1.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.93 KiB of class 'function')
[15:32:10.837] - globals: [1] 'FUN'
[15:32:10.837] 
[15:32:10.838] getGlobalsAndPackages() ... DONE
[15:32:10.838]  - globals found/used: [n=1] 'FUN'
[15:32:10.838]  - needed namespaces: [n=0] 
[15:32:10.838] Finding globals ... DONE
[15:32:10.839] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:10.839] List of 2
[15:32:10.839]  $ ...future.FUN:function (x, y)  
[15:32:10.839]  $ MoreArgs     : NULL
[15:32:10.839]  - attr(*, "where")=List of 2
[15:32:10.839]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:10.839]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:10.839]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:10.839]  - attr(*, "resolved")= logi FALSE
[15:32:10.839]  - attr(*, "total_size")= num NA
[15:32:10.848] Packages to be attached in all futures: [n=0] 
[15:32:10.848] getGlobalsAndPackagesXApply() ... DONE
[15:32:10.849] Number of futures (= number of chunks): 2
[15:32:10.849] Launching 2 futures (chunks) ...
[15:32:10.850] Chunk #1 of 2 ...
[15:32:10.850]  - Finding globals in '...' for chunk #1 ...
[15:32:10.850] getGlobalsAndPackages() ...
[15:32:10.850] Searching for globals...
[15:32:10.851] 
[15:32:10.851] Searching for globals ... DONE
[15:32:10.852] - globals: [0] <none>
[15:32:10.852] getGlobalsAndPackages() ... DONE
[15:32:10.852]    + additional globals found: [n=0] 
[15:32:10.853]    + additional namespaces needed: [n=0] 
[15:32:10.853]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:10.853]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.853]  - seeds: <none>
[15:32:10.854]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.854] getGlobalsAndPackages() ...
[15:32:10.854] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.855] Resolving globals: FALSE
[15:32:10.856] The total size of the 5 globals is 2.04 KiB (2088 bytes)
[15:32:10.857] 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 2.04 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.93 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.857] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.858] 
[15:32:10.858] getGlobalsAndPackages() ... DONE
[15:32:10.858] run() for 'Future' ...
[15:32:10.859] - state: 'created'
[15:32:10.859] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.878] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.879] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.879]   - Field: 'node'
[15:32:10.880]   - Field: 'label'
[15:32:10.880]   - Field: 'local'
[15:32:10.880]   - Field: 'owner'
[15:32:10.881]   - Field: 'envir'
[15:32:10.881]   - Field: 'workers'
[15:32:10.881]   - Field: 'packages'
[15:32:10.881]   - Field: 'gc'
[15:32:10.882]   - Field: 'conditions'
[15:32:10.882]   - Field: 'persistent'
[15:32:10.882]   - Field: 'expr'
[15:32:10.883]   - Field: 'uuid'
[15:32:10.883]   - Field: 'seed'
[15:32:10.883]   - Field: 'version'
[15:32:10.884]   - Field: 'result'
[15:32:10.884]   - Field: 'asynchronous'
[15:32:10.884]   - Field: 'calls'
[15:32:10.884]   - Field: 'globals'
[15:32:10.885]   - Field: 'stdout'
[15:32:10.885]   - Field: 'earlySignal'
[15:32:10.885]   - Field: 'lazy'
[15:32:10.886]   - Field: 'state'
[15:32:10.886] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.886] - Launch lazy future ...
[15:32:10.887] Packages needed by the future expression (n = 0): <none>
[15:32:10.887] Packages needed by future strategies (n = 0): <none>
[15:32:10.888] {
[15:32:10.888]     {
[15:32:10.888]         {
[15:32:10.888]             ...future.startTime <- base::Sys.time()
[15:32:10.888]             {
[15:32:10.888]                 {
[15:32:10.888]                   {
[15:32:10.888]                     {
[15:32:10.888]                       base::local({
[15:32:10.888]                         has_future <- base::requireNamespace("future", 
[15:32:10.888]                           quietly = TRUE)
[15:32:10.888]                         if (has_future) {
[15:32:10.888]                           ns <- base::getNamespace("future")
[15:32:10.888]                           version <- ns[[".package"]][["version"]]
[15:32:10.888]                           if (is.null(version)) 
[15:32:10.888]                             version <- utils::packageVersion("future")
[15:32:10.888]                         }
[15:32:10.888]                         else {
[15:32:10.888]                           version <- NULL
[15:32:10.888]                         }
[15:32:10.888]                         if (!has_future || version < "1.8.0") {
[15:32:10.888]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.888]                             "", base::R.version$version.string), 
[15:32:10.888]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.888]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.888]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.888]                               "release", "version")], collapse = " "), 
[15:32:10.888]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.888]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.888]                             info)
[15:32:10.888]                           info <- base::paste(info, collapse = "; ")
[15:32:10.888]                           if (!has_future) {
[15:32:10.888]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.888]                               info)
[15:32:10.888]                           }
[15:32:10.888]                           else {
[15:32:10.888]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.888]                               info, version)
[15:32:10.888]                           }
[15:32:10.888]                           base::stop(msg)
[15:32:10.888]                         }
[15:32:10.888]                       })
[15:32:10.888]                     }
[15:32:10.888]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.888]                     base::options(mc.cores = 1L)
[15:32:10.888]                   }
[15:32:10.888]                   ...future.strategy.old <- future::plan("list")
[15:32:10.888]                   options(future.plan = NULL)
[15:32:10.888]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.888]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.888]                 }
[15:32:10.888]                 ...future.workdir <- getwd()
[15:32:10.888]             }
[15:32:10.888]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.888]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.888]         }
[15:32:10.888]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.888]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.888]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.888]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.888]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.888]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.888]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.888]             base::names(...future.oldOptions))
[15:32:10.888]     }
[15:32:10.888]     if (FALSE) {
[15:32:10.888]     }
[15:32:10.888]     else {
[15:32:10.888]         if (TRUE) {
[15:32:10.888]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.888]                 open = "w")
[15:32:10.888]         }
[15:32:10.888]         else {
[15:32:10.888]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.888]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.888]         }
[15:32:10.888]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.888]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.888]             base::sink(type = "output", split = FALSE)
[15:32:10.888]             base::close(...future.stdout)
[15:32:10.888]         }, add = TRUE)
[15:32:10.888]     }
[15:32:10.888]     ...future.frame <- base::sys.nframe()
[15:32:10.888]     ...future.conditions <- base::list()
[15:32:10.888]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.888]     if (FALSE) {
[15:32:10.888]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.888]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.888]     }
[15:32:10.888]     ...future.result <- base::tryCatch({
[15:32:10.888]         base::withCallingHandlers({
[15:32:10.888]             ...future.value <- base::withVisible(base::local({
[15:32:10.888]                 ...future.makeSendCondition <- base::local({
[15:32:10.888]                   sendCondition <- NULL
[15:32:10.888]                   function(frame = 1L) {
[15:32:10.888]                     if (is.function(sendCondition)) 
[15:32:10.888]                       return(sendCondition)
[15:32:10.888]                     ns <- getNamespace("parallel")
[15:32:10.888]                     if (exists("sendData", mode = "function", 
[15:32:10.888]                       envir = ns)) {
[15:32:10.888]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.888]                         envir = ns)
[15:32:10.888]                       envir <- sys.frame(frame)
[15:32:10.888]                       master <- NULL
[15:32:10.888]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.888]                         !identical(envir, emptyenv())) {
[15:32:10.888]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.888]                           inherits = FALSE)) {
[15:32:10.888]                           master <- get("master", mode = "list", 
[15:32:10.888]                             envir = envir, inherits = FALSE)
[15:32:10.888]                           if (inherits(master, c("SOCKnode", 
[15:32:10.888]                             "SOCK0node"))) {
[15:32:10.888]                             sendCondition <<- function(cond) {
[15:32:10.888]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.888]                                 success = TRUE)
[15:32:10.888]                               parallel_sendData(master, data)
[15:32:10.888]                             }
[15:32:10.888]                             return(sendCondition)
[15:32:10.888]                           }
[15:32:10.888]                         }
[15:32:10.888]                         frame <- frame + 1L
[15:32:10.888]                         envir <- sys.frame(frame)
[15:32:10.888]                       }
[15:32:10.888]                     }
[15:32:10.888]                     sendCondition <<- function(cond) NULL
[15:32:10.888]                   }
[15:32:10.888]                 })
[15:32:10.888]                 withCallingHandlers({
[15:32:10.888]                   {
[15:32:10.888]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.888]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.888]                       ...future.globals.maxSize)) {
[15:32:10.888]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.888]                       on.exit(options(oopts), add = TRUE)
[15:32:10.888]                     }
[15:32:10.888]                     {
[15:32:10.888]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.888]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.888]                         USE.NAMES = FALSE)
[15:32:10.888]                       do.call(mapply, args = args)
[15:32:10.888]                     }
[15:32:10.888]                   }
[15:32:10.888]                 }, immediateCondition = function(cond) {
[15:32:10.888]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.888]                   sendCondition(cond)
[15:32:10.888]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.888]                   {
[15:32:10.888]                     inherits <- base::inherits
[15:32:10.888]                     invokeRestart <- base::invokeRestart
[15:32:10.888]                     is.null <- base::is.null
[15:32:10.888]                     muffled <- FALSE
[15:32:10.888]                     if (inherits(cond, "message")) {
[15:32:10.888]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.888]                       if (muffled) 
[15:32:10.888]                         invokeRestart("muffleMessage")
[15:32:10.888]                     }
[15:32:10.888]                     else if (inherits(cond, "warning")) {
[15:32:10.888]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.888]                       if (muffled) 
[15:32:10.888]                         invokeRestart("muffleWarning")
[15:32:10.888]                     }
[15:32:10.888]                     else if (inherits(cond, "condition")) {
[15:32:10.888]                       if (!is.null(pattern)) {
[15:32:10.888]                         computeRestarts <- base::computeRestarts
[15:32:10.888]                         grepl <- base::grepl
[15:32:10.888]                         restarts <- computeRestarts(cond)
[15:32:10.888]                         for (restart in restarts) {
[15:32:10.888]                           name <- restart$name
[15:32:10.888]                           if (is.null(name)) 
[15:32:10.888]                             next
[15:32:10.888]                           if (!grepl(pattern, name)) 
[15:32:10.888]                             next
[15:32:10.888]                           invokeRestart(restart)
[15:32:10.888]                           muffled <- TRUE
[15:32:10.888]                           break
[15:32:10.888]                         }
[15:32:10.888]                       }
[15:32:10.888]                     }
[15:32:10.888]                     invisible(muffled)
[15:32:10.888]                   }
[15:32:10.888]                   muffleCondition(cond)
[15:32:10.888]                 })
[15:32:10.888]             }))
[15:32:10.888]             future::FutureResult(value = ...future.value$value, 
[15:32:10.888]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.888]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.888]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.888]                     ...future.globalenv.names))
[15:32:10.888]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.888]         }, condition = base::local({
[15:32:10.888]             c <- base::c
[15:32:10.888]             inherits <- base::inherits
[15:32:10.888]             invokeRestart <- base::invokeRestart
[15:32:10.888]             length <- base::length
[15:32:10.888]             list <- base::list
[15:32:10.888]             seq.int <- base::seq.int
[15:32:10.888]             signalCondition <- base::signalCondition
[15:32:10.888]             sys.calls <- base::sys.calls
[15:32:10.888]             `[[` <- base::`[[`
[15:32:10.888]             `+` <- base::`+`
[15:32:10.888]             `<<-` <- base::`<<-`
[15:32:10.888]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.888]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.888]                   3L)]
[15:32:10.888]             }
[15:32:10.888]             function(cond) {
[15:32:10.888]                 is_error <- inherits(cond, "error")
[15:32:10.888]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.888]                   NULL)
[15:32:10.888]                 if (is_error) {
[15:32:10.888]                   sessionInformation <- function() {
[15:32:10.888]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.888]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.888]                       search = base::search(), system = base::Sys.info())
[15:32:10.888]                   }
[15:32:10.888]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.888]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.888]                     cond$call), session = sessionInformation(), 
[15:32:10.888]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.888]                   signalCondition(cond)
[15:32:10.888]                 }
[15:32:10.888]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.888]                 "immediateCondition"))) {
[15:32:10.888]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.888]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.888]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.888]                   if (TRUE && !signal) {
[15:32:10.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.888]                     {
[15:32:10.888]                       inherits <- base::inherits
[15:32:10.888]                       invokeRestart <- base::invokeRestart
[15:32:10.888]                       is.null <- base::is.null
[15:32:10.888]                       muffled <- FALSE
[15:32:10.888]                       if (inherits(cond, "message")) {
[15:32:10.888]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.888]                         if (muffled) 
[15:32:10.888]                           invokeRestart("muffleMessage")
[15:32:10.888]                       }
[15:32:10.888]                       else if (inherits(cond, "warning")) {
[15:32:10.888]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.888]                         if (muffled) 
[15:32:10.888]                           invokeRestart("muffleWarning")
[15:32:10.888]                       }
[15:32:10.888]                       else if (inherits(cond, "condition")) {
[15:32:10.888]                         if (!is.null(pattern)) {
[15:32:10.888]                           computeRestarts <- base::computeRestarts
[15:32:10.888]                           grepl <- base::grepl
[15:32:10.888]                           restarts <- computeRestarts(cond)
[15:32:10.888]                           for (restart in restarts) {
[15:32:10.888]                             name <- restart$name
[15:32:10.888]                             if (is.null(name)) 
[15:32:10.888]                               next
[15:32:10.888]                             if (!grepl(pattern, name)) 
[15:32:10.888]                               next
[15:32:10.888]                             invokeRestart(restart)
[15:32:10.888]                             muffled <- TRUE
[15:32:10.888]                             break
[15:32:10.888]                           }
[15:32:10.888]                         }
[15:32:10.888]                       }
[15:32:10.888]                       invisible(muffled)
[15:32:10.888]                     }
[15:32:10.888]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.888]                   }
[15:32:10.888]                 }
[15:32:10.888]                 else {
[15:32:10.888]                   if (TRUE) {
[15:32:10.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.888]                     {
[15:32:10.888]                       inherits <- base::inherits
[15:32:10.888]                       invokeRestart <- base::invokeRestart
[15:32:10.888]                       is.null <- base::is.null
[15:32:10.888]                       muffled <- FALSE
[15:32:10.888]                       if (inherits(cond, "message")) {
[15:32:10.888]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.888]                         if (muffled) 
[15:32:10.888]                           invokeRestart("muffleMessage")
[15:32:10.888]                       }
[15:32:10.888]                       else if (inherits(cond, "warning")) {
[15:32:10.888]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.888]                         if (muffled) 
[15:32:10.888]                           invokeRestart("muffleWarning")
[15:32:10.888]                       }
[15:32:10.888]                       else if (inherits(cond, "condition")) {
[15:32:10.888]                         if (!is.null(pattern)) {
[15:32:10.888]                           computeRestarts <- base::computeRestarts
[15:32:10.888]                           grepl <- base::grepl
[15:32:10.888]                           restarts <- computeRestarts(cond)
[15:32:10.888]                           for (restart in restarts) {
[15:32:10.888]                             name <- restart$name
[15:32:10.888]                             if (is.null(name)) 
[15:32:10.888]                               next
[15:32:10.888]                             if (!grepl(pattern, name)) 
[15:32:10.888]                               next
[15:32:10.888]                             invokeRestart(restart)
[15:32:10.888]                             muffled <- TRUE
[15:32:10.888]                             break
[15:32:10.888]                           }
[15:32:10.888]                         }
[15:32:10.888]                       }
[15:32:10.888]                       invisible(muffled)
[15:32:10.888]                     }
[15:32:10.888]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.888]                   }
[15:32:10.888]                 }
[15:32:10.888]             }
[15:32:10.888]         }))
[15:32:10.888]     }, error = function(ex) {
[15:32:10.888]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.888]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.888]                 ...future.rng), started = ...future.startTime, 
[15:32:10.888]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.888]             version = "1.8"), class = "FutureResult")
[15:32:10.888]     }, finally = {
[15:32:10.888]         if (!identical(...future.workdir, getwd())) 
[15:32:10.888]             setwd(...future.workdir)
[15:32:10.888]         {
[15:32:10.888]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.888]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.888]             }
[15:32:10.888]             base::options(...future.oldOptions)
[15:32:10.888]             if (.Platform$OS.type == "windows") {
[15:32:10.888]                 old_names <- names(...future.oldEnvVars)
[15:32:10.888]                 envs <- base::Sys.getenv()
[15:32:10.888]                 names <- names(envs)
[15:32:10.888]                 common <- intersect(names, old_names)
[15:32:10.888]                 added <- setdiff(names, old_names)
[15:32:10.888]                 removed <- setdiff(old_names, names)
[15:32:10.888]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.888]                   envs[common]]
[15:32:10.888]                 NAMES <- toupper(changed)
[15:32:10.888]                 args <- list()
[15:32:10.888]                 for (kk in seq_along(NAMES)) {
[15:32:10.888]                   name <- changed[[kk]]
[15:32:10.888]                   NAME <- NAMES[[kk]]
[15:32:10.888]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.888]                     next
[15:32:10.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.888]                 }
[15:32:10.888]                 NAMES <- toupper(added)
[15:32:10.888]                 for (kk in seq_along(NAMES)) {
[15:32:10.888]                   name <- added[[kk]]
[15:32:10.888]                   NAME <- NAMES[[kk]]
[15:32:10.888]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.888]                     next
[15:32:10.888]                   args[[name]] <- ""
[15:32:10.888]                 }
[15:32:10.888]                 NAMES <- toupper(removed)
[15:32:10.888]                 for (kk in seq_along(NAMES)) {
[15:32:10.888]                   name <- removed[[kk]]
[15:32:10.888]                   NAME <- NAMES[[kk]]
[15:32:10.888]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.888]                     next
[15:32:10.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.888]                 }
[15:32:10.888]                 if (length(args) > 0) 
[15:32:10.888]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.888]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.888]             }
[15:32:10.888]             else {
[15:32:10.888]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.888]             }
[15:32:10.888]             {
[15:32:10.888]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.888]                   0L) {
[15:32:10.888]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.888]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.888]                   base::options(opts)
[15:32:10.888]                 }
[15:32:10.888]                 {
[15:32:10.888]                   {
[15:32:10.888]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.888]                     NULL
[15:32:10.888]                   }
[15:32:10.888]                   options(future.plan = NULL)
[15:32:10.888]                   if (is.na(NA_character_)) 
[15:32:10.888]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.888]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.888]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.888]                     .init = FALSE)
[15:32:10.888]                 }
[15:32:10.888]             }
[15:32:10.888]         }
[15:32:10.888]     })
[15:32:10.888]     if (TRUE) {
[15:32:10.888]         base::sink(type = "output", split = FALSE)
[15:32:10.888]         if (TRUE) {
[15:32:10.888]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.888]         }
[15:32:10.888]         else {
[15:32:10.888]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.888]         }
[15:32:10.888]         base::close(...future.stdout)
[15:32:10.888]         ...future.stdout <- NULL
[15:32:10.888]     }
[15:32:10.888]     ...future.result$conditions <- ...future.conditions
[15:32:10.888]     ...future.result$finished <- base::Sys.time()
[15:32:10.888]     ...future.result
[15:32:10.888] }
[15:32:10.898] Exporting 5 global objects (2.04 KiB) to cluster node #1 ...
[15:32:10.898] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ...
[15:32:10.899] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ... DONE
[15:32:10.899] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.900] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.900] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:10.901] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:10.901] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.902] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.902] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.902] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.902] Exporting 5 global objects (2.04 KiB) to cluster node #1 ... DONE
[15:32:10.903] MultisessionFuture started
[15:32:10.903] - Launch lazy future ... done
[15:32:10.904] run() for 'MultisessionFuture' ... done
[15:32:10.904] Created future:
[15:32:10.931] receiveMessageFromWorker() for ClusterFuture ...
[15:32:10.932] - Validating connection of MultisessionFuture
[15:32:10.932] - received message: FutureResult
[15:32:10.933] - Received FutureResult
[15:32:10.933] - Erased future from FutureRegistry
[15:32:10.933] result() for ClusterFuture ...
[15:32:10.933] - result already collected: FutureResult
[15:32:10.934] result() for ClusterFuture ... done
[15:32:10.934] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.904] MultisessionFuture:
[15:32:10.904] Label: 'future_mapply-1'
[15:32:10.904] Expression:
[15:32:10.904] {
[15:32:10.904]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.904]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.904]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.904]         on.exit(options(oopts), add = TRUE)
[15:32:10.904]     }
[15:32:10.904]     {
[15:32:10.904]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.904]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.904]         do.call(mapply, args = args)
[15:32:10.904]     }
[15:32:10.904] }
[15:32:10.904] Lazy evaluation: FALSE
[15:32:10.904] Asynchronous evaluation: TRUE
[15:32:10.904] Local evaluation: TRUE
[15:32:10.904] Environment: R_GlobalEnv
[15:32:10.904] Capture standard output: TRUE
[15:32:10.904] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.904] Globals: 5 objects totaling 2.04 KiB (function '...future.FUN' of 1.93 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:32:10.904] Packages: <none>
[15:32:10.904] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.904] Resolved: TRUE
[15:32:10.904] Value: <not collected>
[15:32:10.904] Conditions captured: <none>
[15:32:10.904] Early signaling: FALSE
[15:32:10.904] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.904] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.935] Chunk #1 of 2 ... DONE
[15:32:10.935] Chunk #2 of 2 ...
[15:32:10.935]  - Finding globals in '...' for chunk #2 ...
[15:32:10.936] getGlobalsAndPackages() ...
[15:32:10.936] Searching for globals...
[15:32:10.937] 
[15:32:10.937] Searching for globals ... DONE
[15:32:10.937] - globals: [0] <none>
[15:32:10.937] getGlobalsAndPackages() ... DONE
[15:32:10.937]    + additional globals found: [n=0] 
[15:32:10.937]    + additional namespaces needed: [n=0] 
[15:32:10.938]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:10.938]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:10.938]  - seeds: <none>
[15:32:10.938]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.938] getGlobalsAndPackages() ...
[15:32:10.939] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.939] Resolving globals: FALSE
[15:32:10.940] The total size of the 5 globals is 2.15 KiB (2200 bytes)
[15:32:10.940] 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 2.15 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.93 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:10.941] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:10.941] 
[15:32:10.941] getGlobalsAndPackages() ... DONE
[15:32:10.942] run() for 'Future' ...
[15:32:10.942] - state: 'created'
[15:32:10.942] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:10.961] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:10.961] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:10.961]   - Field: 'node'
[15:32:10.962]   - Field: 'label'
[15:32:10.962]   - Field: 'local'
[15:32:10.962]   - Field: 'owner'
[15:32:10.963]   - Field: 'envir'
[15:32:10.963]   - Field: 'workers'
[15:32:10.963]   - Field: 'packages'
[15:32:10.964]   - Field: 'gc'
[15:32:10.964]   - Field: 'conditions'
[15:32:10.964]   - Field: 'persistent'
[15:32:10.965]   - Field: 'expr'
[15:32:10.965]   - Field: 'uuid'
[15:32:10.966]   - Field: 'seed'
[15:32:10.966]   - Field: 'version'
[15:32:10.966]   - Field: 'result'
[15:32:10.967]   - Field: 'asynchronous'
[15:32:10.967]   - Field: 'calls'
[15:32:10.967]   - Field: 'globals'
[15:32:10.968]   - Field: 'stdout'
[15:32:10.968]   - Field: 'earlySignal'
[15:32:10.969]   - Field: 'lazy'
[15:32:10.969]   - Field: 'state'
[15:32:10.969] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:10.970] - Launch lazy future ...
[15:32:10.970] Packages needed by the future expression (n = 0): <none>
[15:32:10.971] Packages needed by future strategies (n = 0): <none>
[15:32:10.972] {
[15:32:10.972]     {
[15:32:10.972]         {
[15:32:10.972]             ...future.startTime <- base::Sys.time()
[15:32:10.972]             {
[15:32:10.972]                 {
[15:32:10.972]                   {
[15:32:10.972]                     {
[15:32:10.972]                       base::local({
[15:32:10.972]                         has_future <- base::requireNamespace("future", 
[15:32:10.972]                           quietly = TRUE)
[15:32:10.972]                         if (has_future) {
[15:32:10.972]                           ns <- base::getNamespace("future")
[15:32:10.972]                           version <- ns[[".package"]][["version"]]
[15:32:10.972]                           if (is.null(version)) 
[15:32:10.972]                             version <- utils::packageVersion("future")
[15:32:10.972]                         }
[15:32:10.972]                         else {
[15:32:10.972]                           version <- NULL
[15:32:10.972]                         }
[15:32:10.972]                         if (!has_future || version < "1.8.0") {
[15:32:10.972]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:10.972]                             "", base::R.version$version.string), 
[15:32:10.972]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:10.972]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:10.972]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:10.972]                               "release", "version")], collapse = " "), 
[15:32:10.972]                             hostname = base::Sys.info()[["nodename"]])
[15:32:10.972]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:10.972]                             info)
[15:32:10.972]                           info <- base::paste(info, collapse = "; ")
[15:32:10.972]                           if (!has_future) {
[15:32:10.972]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:10.972]                               info)
[15:32:10.972]                           }
[15:32:10.972]                           else {
[15:32:10.972]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:10.972]                               info, version)
[15:32:10.972]                           }
[15:32:10.972]                           base::stop(msg)
[15:32:10.972]                         }
[15:32:10.972]                       })
[15:32:10.972]                     }
[15:32:10.972]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:10.972]                     base::options(mc.cores = 1L)
[15:32:10.972]                   }
[15:32:10.972]                   ...future.strategy.old <- future::plan("list")
[15:32:10.972]                   options(future.plan = NULL)
[15:32:10.972]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.972]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:10.972]                 }
[15:32:10.972]                 ...future.workdir <- getwd()
[15:32:10.972]             }
[15:32:10.972]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:10.972]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:10.972]         }
[15:32:10.972]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:10.972]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:10.972]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:10.972]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:10.972]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:10.972]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:10.972]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:10.972]             base::names(...future.oldOptions))
[15:32:10.972]     }
[15:32:10.972]     if (FALSE) {
[15:32:10.972]     }
[15:32:10.972]     else {
[15:32:10.972]         if (TRUE) {
[15:32:10.972]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:10.972]                 open = "w")
[15:32:10.972]         }
[15:32:10.972]         else {
[15:32:10.972]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:10.972]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:10.972]         }
[15:32:10.972]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:10.972]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:10.972]             base::sink(type = "output", split = FALSE)
[15:32:10.972]             base::close(...future.stdout)
[15:32:10.972]         }, add = TRUE)
[15:32:10.972]     }
[15:32:10.972]     ...future.frame <- base::sys.nframe()
[15:32:10.972]     ...future.conditions <- base::list()
[15:32:10.972]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:10.972]     if (FALSE) {
[15:32:10.972]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:10.972]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:10.972]     }
[15:32:10.972]     ...future.result <- base::tryCatch({
[15:32:10.972]         base::withCallingHandlers({
[15:32:10.972]             ...future.value <- base::withVisible(base::local({
[15:32:10.972]                 ...future.makeSendCondition <- base::local({
[15:32:10.972]                   sendCondition <- NULL
[15:32:10.972]                   function(frame = 1L) {
[15:32:10.972]                     if (is.function(sendCondition)) 
[15:32:10.972]                       return(sendCondition)
[15:32:10.972]                     ns <- getNamespace("parallel")
[15:32:10.972]                     if (exists("sendData", mode = "function", 
[15:32:10.972]                       envir = ns)) {
[15:32:10.972]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:10.972]                         envir = ns)
[15:32:10.972]                       envir <- sys.frame(frame)
[15:32:10.972]                       master <- NULL
[15:32:10.972]                       while (!identical(envir, .GlobalEnv) && 
[15:32:10.972]                         !identical(envir, emptyenv())) {
[15:32:10.972]                         if (exists("master", mode = "list", envir = envir, 
[15:32:10.972]                           inherits = FALSE)) {
[15:32:10.972]                           master <- get("master", mode = "list", 
[15:32:10.972]                             envir = envir, inherits = FALSE)
[15:32:10.972]                           if (inherits(master, c("SOCKnode", 
[15:32:10.972]                             "SOCK0node"))) {
[15:32:10.972]                             sendCondition <<- function(cond) {
[15:32:10.972]                               data <- list(type = "VALUE", value = cond, 
[15:32:10.972]                                 success = TRUE)
[15:32:10.972]                               parallel_sendData(master, data)
[15:32:10.972]                             }
[15:32:10.972]                             return(sendCondition)
[15:32:10.972]                           }
[15:32:10.972]                         }
[15:32:10.972]                         frame <- frame + 1L
[15:32:10.972]                         envir <- sys.frame(frame)
[15:32:10.972]                       }
[15:32:10.972]                     }
[15:32:10.972]                     sendCondition <<- function(cond) NULL
[15:32:10.972]                   }
[15:32:10.972]                 })
[15:32:10.972]                 withCallingHandlers({
[15:32:10.972]                   {
[15:32:10.972]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.972]                     if (!identical(...future.globals.maxSize.org, 
[15:32:10.972]                       ...future.globals.maxSize)) {
[15:32:10.972]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.972]                       on.exit(options(oopts), add = TRUE)
[15:32:10.972]                     }
[15:32:10.972]                     {
[15:32:10.972]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.972]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:10.972]                         USE.NAMES = FALSE)
[15:32:10.972]                       do.call(mapply, args = args)
[15:32:10.972]                     }
[15:32:10.972]                   }
[15:32:10.972]                 }, immediateCondition = function(cond) {
[15:32:10.972]                   sendCondition <- ...future.makeSendCondition()
[15:32:10.972]                   sendCondition(cond)
[15:32:10.972]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.972]                   {
[15:32:10.972]                     inherits <- base::inherits
[15:32:10.972]                     invokeRestart <- base::invokeRestart
[15:32:10.972]                     is.null <- base::is.null
[15:32:10.972]                     muffled <- FALSE
[15:32:10.972]                     if (inherits(cond, "message")) {
[15:32:10.972]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:10.972]                       if (muffled) 
[15:32:10.972]                         invokeRestart("muffleMessage")
[15:32:10.972]                     }
[15:32:10.972]                     else if (inherits(cond, "warning")) {
[15:32:10.972]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:10.972]                       if (muffled) 
[15:32:10.972]                         invokeRestart("muffleWarning")
[15:32:10.972]                     }
[15:32:10.972]                     else if (inherits(cond, "condition")) {
[15:32:10.972]                       if (!is.null(pattern)) {
[15:32:10.972]                         computeRestarts <- base::computeRestarts
[15:32:10.972]                         grepl <- base::grepl
[15:32:10.972]                         restarts <- computeRestarts(cond)
[15:32:10.972]                         for (restart in restarts) {
[15:32:10.972]                           name <- restart$name
[15:32:10.972]                           if (is.null(name)) 
[15:32:10.972]                             next
[15:32:10.972]                           if (!grepl(pattern, name)) 
[15:32:10.972]                             next
[15:32:10.972]                           invokeRestart(restart)
[15:32:10.972]                           muffled <- TRUE
[15:32:10.972]                           break
[15:32:10.972]                         }
[15:32:10.972]                       }
[15:32:10.972]                     }
[15:32:10.972]                     invisible(muffled)
[15:32:10.972]                   }
[15:32:10.972]                   muffleCondition(cond)
[15:32:10.972]                 })
[15:32:10.972]             }))
[15:32:10.972]             future::FutureResult(value = ...future.value$value, 
[15:32:10.972]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.972]                   ...future.rng), globalenv = if (FALSE) 
[15:32:10.972]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:10.972]                     ...future.globalenv.names))
[15:32:10.972]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:10.972]         }, condition = base::local({
[15:32:10.972]             c <- base::c
[15:32:10.972]             inherits <- base::inherits
[15:32:10.972]             invokeRestart <- base::invokeRestart
[15:32:10.972]             length <- base::length
[15:32:10.972]             list <- base::list
[15:32:10.972]             seq.int <- base::seq.int
[15:32:10.972]             signalCondition <- base::signalCondition
[15:32:10.972]             sys.calls <- base::sys.calls
[15:32:10.972]             `[[` <- base::`[[`
[15:32:10.972]             `+` <- base::`+`
[15:32:10.972]             `<<-` <- base::`<<-`
[15:32:10.972]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:10.972]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:10.972]                   3L)]
[15:32:10.972]             }
[15:32:10.972]             function(cond) {
[15:32:10.972]                 is_error <- inherits(cond, "error")
[15:32:10.972]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:10.972]                   NULL)
[15:32:10.972]                 if (is_error) {
[15:32:10.972]                   sessionInformation <- function() {
[15:32:10.972]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:10.972]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:10.972]                       search = base::search(), system = base::Sys.info())
[15:32:10.972]                   }
[15:32:10.972]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.972]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:10.972]                     cond$call), session = sessionInformation(), 
[15:32:10.972]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:10.972]                   signalCondition(cond)
[15:32:10.972]                 }
[15:32:10.972]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:10.972]                 "immediateCondition"))) {
[15:32:10.972]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:10.972]                   ...future.conditions[[length(...future.conditions) + 
[15:32:10.972]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:10.972]                   if (TRUE && !signal) {
[15:32:10.972]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.972]                     {
[15:32:10.972]                       inherits <- base::inherits
[15:32:10.972]                       invokeRestart <- base::invokeRestart
[15:32:10.972]                       is.null <- base::is.null
[15:32:10.972]                       muffled <- FALSE
[15:32:10.972]                       if (inherits(cond, "message")) {
[15:32:10.972]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.972]                         if (muffled) 
[15:32:10.972]                           invokeRestart("muffleMessage")
[15:32:10.972]                       }
[15:32:10.972]                       else if (inherits(cond, "warning")) {
[15:32:10.972]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.972]                         if (muffled) 
[15:32:10.972]                           invokeRestart("muffleWarning")
[15:32:10.972]                       }
[15:32:10.972]                       else if (inherits(cond, "condition")) {
[15:32:10.972]                         if (!is.null(pattern)) {
[15:32:10.972]                           computeRestarts <- base::computeRestarts
[15:32:10.972]                           grepl <- base::grepl
[15:32:10.972]                           restarts <- computeRestarts(cond)
[15:32:10.972]                           for (restart in restarts) {
[15:32:10.972]                             name <- restart$name
[15:32:10.972]                             if (is.null(name)) 
[15:32:10.972]                               next
[15:32:10.972]                             if (!grepl(pattern, name)) 
[15:32:10.972]                               next
[15:32:10.972]                             invokeRestart(restart)
[15:32:10.972]                             muffled <- TRUE
[15:32:10.972]                             break
[15:32:10.972]                           }
[15:32:10.972]                         }
[15:32:10.972]                       }
[15:32:10.972]                       invisible(muffled)
[15:32:10.972]                     }
[15:32:10.972]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.972]                   }
[15:32:10.972]                 }
[15:32:10.972]                 else {
[15:32:10.972]                   if (TRUE) {
[15:32:10.972]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:10.972]                     {
[15:32:10.972]                       inherits <- base::inherits
[15:32:10.972]                       invokeRestart <- base::invokeRestart
[15:32:10.972]                       is.null <- base::is.null
[15:32:10.972]                       muffled <- FALSE
[15:32:10.972]                       if (inherits(cond, "message")) {
[15:32:10.972]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:10.972]                         if (muffled) 
[15:32:10.972]                           invokeRestart("muffleMessage")
[15:32:10.972]                       }
[15:32:10.972]                       else if (inherits(cond, "warning")) {
[15:32:10.972]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:10.972]                         if (muffled) 
[15:32:10.972]                           invokeRestart("muffleWarning")
[15:32:10.972]                       }
[15:32:10.972]                       else if (inherits(cond, "condition")) {
[15:32:10.972]                         if (!is.null(pattern)) {
[15:32:10.972]                           computeRestarts <- base::computeRestarts
[15:32:10.972]                           grepl <- base::grepl
[15:32:10.972]                           restarts <- computeRestarts(cond)
[15:32:10.972]                           for (restart in restarts) {
[15:32:10.972]                             name <- restart$name
[15:32:10.972]                             if (is.null(name)) 
[15:32:10.972]                               next
[15:32:10.972]                             if (!grepl(pattern, name)) 
[15:32:10.972]                               next
[15:32:10.972]                             invokeRestart(restart)
[15:32:10.972]                             muffled <- TRUE
[15:32:10.972]                             break
[15:32:10.972]                           }
[15:32:10.972]                         }
[15:32:10.972]                       }
[15:32:10.972]                       invisible(muffled)
[15:32:10.972]                     }
[15:32:10.972]                     muffleCondition(cond, pattern = "^muffle")
[15:32:10.972]                   }
[15:32:10.972]                 }
[15:32:10.972]             }
[15:32:10.972]         }))
[15:32:10.972]     }, error = function(ex) {
[15:32:10.972]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:10.972]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:10.972]                 ...future.rng), started = ...future.startTime, 
[15:32:10.972]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:10.972]             version = "1.8"), class = "FutureResult")
[15:32:10.972]     }, finally = {
[15:32:10.972]         if (!identical(...future.workdir, getwd())) 
[15:32:10.972]             setwd(...future.workdir)
[15:32:10.972]         {
[15:32:10.972]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:10.972]                 ...future.oldOptions$nwarnings <- NULL
[15:32:10.972]             }
[15:32:10.972]             base::options(...future.oldOptions)
[15:32:10.972]             if (.Platform$OS.type == "windows") {
[15:32:10.972]                 old_names <- names(...future.oldEnvVars)
[15:32:10.972]                 envs <- base::Sys.getenv()
[15:32:10.972]                 names <- names(envs)
[15:32:10.972]                 common <- intersect(names, old_names)
[15:32:10.972]                 added <- setdiff(names, old_names)
[15:32:10.972]                 removed <- setdiff(old_names, names)
[15:32:10.972]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:10.972]                   envs[common]]
[15:32:10.972]                 NAMES <- toupper(changed)
[15:32:10.972]                 args <- list()
[15:32:10.972]                 for (kk in seq_along(NAMES)) {
[15:32:10.972]                   name <- changed[[kk]]
[15:32:10.972]                   NAME <- NAMES[[kk]]
[15:32:10.972]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.972]                     next
[15:32:10.972]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.972]                 }
[15:32:10.972]                 NAMES <- toupper(added)
[15:32:10.972]                 for (kk in seq_along(NAMES)) {
[15:32:10.972]                   name <- added[[kk]]
[15:32:10.972]                   NAME <- NAMES[[kk]]
[15:32:10.972]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.972]                     next
[15:32:10.972]                   args[[name]] <- ""
[15:32:10.972]                 }
[15:32:10.972]                 NAMES <- toupper(removed)
[15:32:10.972]                 for (kk in seq_along(NAMES)) {
[15:32:10.972]                   name <- removed[[kk]]
[15:32:10.972]                   NAME <- NAMES[[kk]]
[15:32:10.972]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:10.972]                     next
[15:32:10.972]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:10.972]                 }
[15:32:10.972]                 if (length(args) > 0) 
[15:32:10.972]                   base::do.call(base::Sys.setenv, args = args)
[15:32:10.972]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:10.972]             }
[15:32:10.972]             else {
[15:32:10.972]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:10.972]             }
[15:32:10.972]             {
[15:32:10.972]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:10.972]                   0L) {
[15:32:10.972]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:10.972]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:10.972]                   base::options(opts)
[15:32:10.972]                 }
[15:32:10.972]                 {
[15:32:10.972]                   {
[15:32:10.972]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:10.972]                     NULL
[15:32:10.972]                   }
[15:32:10.972]                   options(future.plan = NULL)
[15:32:10.972]                   if (is.na(NA_character_)) 
[15:32:10.972]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:10.972]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:10.972]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:10.972]                     .init = FALSE)
[15:32:10.972]                 }
[15:32:10.972]             }
[15:32:10.972]         }
[15:32:10.972]     })
[15:32:10.972]     if (TRUE) {
[15:32:10.972]         base::sink(type = "output", split = FALSE)
[15:32:10.972]         if (TRUE) {
[15:32:10.972]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:10.972]         }
[15:32:10.972]         else {
[15:32:10.972]             ...future.result["stdout"] <- base::list(NULL)
[15:32:10.972]         }
[15:32:10.972]         base::close(...future.stdout)
[15:32:10.972]         ...future.stdout <- NULL
[15:32:10.972]     }
[15:32:10.972]     ...future.result$conditions <- ...future.conditions
[15:32:10.972]     ...future.result$finished <- base::Sys.time()
[15:32:10.972]     ...future.result
[15:32:10.972] }
[15:32:10.982] Exporting 5 global objects (2.15 KiB) to cluster node #1 ...
[15:32:10.982] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ...
[15:32:10.983] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ... DONE
[15:32:10.984] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:10.984] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:10.985] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:10.985] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:10.986] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:10.986] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:10.986] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:10.987] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:10.987] Exporting 5 global objects (2.15 KiB) to cluster node #1 ... DONE
[15:32:10.988] MultisessionFuture started
[15:32:10.989] - Launch lazy future ... done
[15:32:10.989] run() for 'MultisessionFuture' ... done
[15:32:10.989] Created future:
[15:32:11.010] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.011] - Validating connection of MultisessionFuture
[15:32:11.011] - received message: FutureResult
[15:32:11.012] - Received FutureResult
[15:32:11.012] - Erased future from FutureRegistry
[15:32:11.012] result() for ClusterFuture ...
[15:32:11.012] - result already collected: FutureResult
[15:32:11.013] result() for ClusterFuture ... done
[15:32:11.013] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:10.990] MultisessionFuture:
[15:32:10.990] Label: 'future_mapply-2'
[15:32:10.990] Expression:
[15:32:10.990] {
[15:32:10.990]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:10.990]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:10.990]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:10.990]         on.exit(options(oopts), add = TRUE)
[15:32:10.990]     }
[15:32:10.990]     {
[15:32:10.990]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:10.990]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:10.990]         do.call(mapply, args = args)
[15:32:10.990]     }
[15:32:10.990] }
[15:32:10.990] Lazy evaluation: FALSE
[15:32:10.990] Asynchronous evaluation: TRUE
[15:32:10.990] Local evaluation: TRUE
[15:32:10.990] Environment: R_GlobalEnv
[15:32:10.990] Capture standard output: TRUE
[15:32:10.990] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:10.990] Globals: 5 objects totaling 2.15 KiB (function '...future.FUN' of 1.93 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:10.990] Packages: <none>
[15:32:10.990] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:10.990] Resolved: TRUE
[15:32:10.990] Value: <not collected>
[15:32:10.990] Conditions captured: <none>
[15:32:10.990] Early signaling: FALSE
[15:32:10.990] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:10.990] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.014] Chunk #2 of 2 ... DONE
[15:32:11.014] Launching 2 futures (chunks) ... DONE
[15:32:11.015] Resolving 2 futures (chunks) ...
[15:32:11.015] resolve() on list ...
[15:32:11.015]  recursive: 0
[15:32:11.016]  length: 2
[15:32:11.016] 
[15:32:11.016] Future #1
[15:32:11.016] result() for ClusterFuture ...
[15:32:11.017] - result already collected: FutureResult
[15:32:11.017] result() for ClusterFuture ... done
[15:32:11.017] result() for ClusterFuture ...
[15:32:11.018] - result already collected: FutureResult
[15:32:11.018] result() for ClusterFuture ... done
[15:32:11.018] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:11.018] - nx: 2
[15:32:11.019] - relay: TRUE
[15:32:11.019] - stdout: TRUE
[15:32:11.019] - signal: TRUE
[15:32:11.020] - resignal: FALSE
[15:32:11.020] - force: TRUE
[15:32:11.020] - relayed: [n=2] FALSE, FALSE
[15:32:11.020] - queued futures: [n=2] FALSE, FALSE
[15:32:11.021]  - until=1
[15:32:11.021]  - relaying element #1
[15:32:11.021] result() for ClusterFuture ...
[15:32:11.022] - result already collected: FutureResult
[15:32:11.022] result() for ClusterFuture ... done
[15:32:11.022] result() for ClusterFuture ...
[15:32:11.022] - result already collected: FutureResult
[15:32:11.023] result() for ClusterFuture ... done
[15:32:11.023] result() for ClusterFuture ...
[15:32:11.023] - result already collected: FutureResult
[15:32:11.024] result() for ClusterFuture ... done
[15:32:11.024] result() for ClusterFuture ...
[15:32:11.024] - result already collected: FutureResult
[15:32:11.024] result() for ClusterFuture ... done
[15:32:11.025] - relayed: [n=2] TRUE, FALSE
[15:32:11.025] - queued futures: [n=2] TRUE, FALSE
[15:32:11.025] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:11.026]  length: 1 (resolved future 1)
[15:32:11.026] Future #2
[15:32:11.026] result() for ClusterFuture ...
[15:32:11.026] - result already collected: FutureResult
[15:32:11.027] result() for ClusterFuture ... done
[15:32:11.027] result() for ClusterFuture ...
[15:32:11.027] - result already collected: FutureResult
[15:32:11.028] result() for ClusterFuture ... done
[15:32:11.028] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:11.028] - nx: 2
[15:32:11.028] - relay: TRUE
[15:32:11.029] - stdout: TRUE
[15:32:11.029] - signal: TRUE
[15:32:11.029] - resignal: FALSE
[15:32:11.030] - force: TRUE
[15:32:11.030] - relayed: [n=2] TRUE, FALSE
[15:32:11.030] - queued futures: [n=2] TRUE, FALSE
[15:32:11.030]  - until=2
[15:32:11.031]  - relaying element #2
[15:32:11.031] result() for ClusterFuture ...
[15:32:11.031] - result already collected: FutureResult
[15:32:11.031] result() for ClusterFuture ... done
[15:32:11.032] result() for ClusterFuture ...
[15:32:11.032] - result already collected: FutureResult
[15:32:11.032] result() for ClusterFuture ... done
[15:32:11.033] result() for ClusterFuture ...
[15:32:11.033] - result already collected: FutureResult
[15:32:11.033] result() for ClusterFuture ... done
[15:32:11.033] result() for ClusterFuture ...
[15:32:11.034] - result already collected: FutureResult
[15:32:11.034] result() for ClusterFuture ... done
[15:32:11.034] - relayed: [n=2] TRUE, TRUE
[15:32:11.035] - queued futures: [n=2] TRUE, TRUE
[15:32:11.035] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:11.035]  length: 0 (resolved future 2)
[15:32:11.035] Relaying remaining futures
[15:32:11.036] signalConditionsASAP(NULL, pos=0) ...
[15:32:11.036] - nx: 2
[15:32:11.036] - relay: TRUE
[15:32:11.037] - stdout: TRUE
[15:32:11.037] - signal: TRUE
[15:32:11.037] - resignal: FALSE
[15:32:11.037] - force: TRUE
[15:32:11.038] - relayed: [n=2] TRUE, TRUE
[15:32:11.038] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:11.038] - relayed: [n=2] TRUE, TRUE
[15:32:11.039] - queued futures: [n=2] TRUE, TRUE
[15:32:11.039] signalConditionsASAP(NULL, pos=0) ... done
[15:32:11.039] resolve() on list ... DONE
[15:32:11.040] result() for ClusterFuture ...
[15:32:11.040] - result already collected: FutureResult
[15:32:11.040] result() for ClusterFuture ... done
[15:32:11.040] result() for ClusterFuture ...
[15:32:11.041] - result already collected: FutureResult
[15:32:11.041] result() for ClusterFuture ... done
[15:32:11.041] result() for ClusterFuture ...
[15:32:11.041] - result already collected: FutureResult
[15:32:11.042] result() for ClusterFuture ... done
[15:32:11.042] result() for ClusterFuture ...
[15:32:11.042] - result already collected: FutureResult
[15:32:11.043] result() for ClusterFuture ... done
[15:32:11.043]  - Number of value chunks collected: 2
[15:32:11.043] Resolving 2 futures (chunks) ... DONE
[15:32:11.043] Reducing values from 2 chunks ...
[15:32:11.044]  - Number of values collected after concatenation: 3
[15:32:11.044]  - Number of values expected: 3
[15:32:11.044] Reducing values from 2 chunks ... DONE
[15:32:11.044] future_mapply() ... DONE
- future_.mapply()
[15:32:11.045] future_mapply() ...
[15:32:11.049] Number of chunks: 2
[15:32:11.050] getGlobalsAndPackagesXApply() ...
[15:32:11.050]  - future.globals: TRUE
[15:32:11.050] getGlobalsAndPackages() ...
[15:32:11.051] Searching for globals...
[15:32:11.054] - globals found: [3] 'FUN', '+', 'seq_len'
[15:32:11.054] Searching for globals ... DONE
[15:32:11.054] Resolving globals: FALSE
[15:32:11.055] The total size of the 1 globals is 1.93 KiB (1976 bytes)
[15:32:11.056] The total size of the 1 globals exported for future expression ('FUN()') is 1.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.93 KiB of class 'function')
[15:32:11.056] - globals: [1] 'FUN'
[15:32:11.056] 
[15:32:11.057] getGlobalsAndPackages() ... DONE
[15:32:11.057]  - globals found/used: [n=1] 'FUN'
[15:32:11.057]  - needed namespaces: [n=0] 
[15:32:11.057] Finding globals ... DONE
[15:32:11.058] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:11.058] List of 2
[15:32:11.058]  $ ...future.FUN:function (x, y)  
[15:32:11.058]  $ MoreArgs     : list()
[15:32:11.058]  - attr(*, "where")=List of 2
[15:32:11.058]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:11.058]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:11.058]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:11.058]  - attr(*, "resolved")= logi FALSE
[15:32:11.058]  - attr(*, "total_size")= num NA
[15:32:11.064] Packages to be attached in all futures: [n=0] 
[15:32:11.064] getGlobalsAndPackagesXApply() ... DONE
[15:32:11.065] Number of futures (= number of chunks): 2
[15:32:11.065] Launching 2 futures (chunks) ...
[15:32:11.065] Chunk #1 of 2 ...
[15:32:11.065]  - Finding globals in '...' for chunk #1 ...
[15:32:11.066] getGlobalsAndPackages() ...
[15:32:11.066] Searching for globals...
[15:32:11.067] 
[15:32:11.067] Searching for globals ... DONE
[15:32:11.067] - globals: [0] <none>
[15:32:11.067] getGlobalsAndPackages() ... DONE
[15:32:11.068]    + additional globals found: [n=0] 
[15:32:11.068]    + additional namespaces needed: [n=0] 
[15:32:11.068]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:11.068]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:11.069]  - seeds: <none>
[15:32:11.069]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.069] getGlobalsAndPackages() ...
[15:32:11.070] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.070] Resolving globals: FALSE
[15:32:11.071] The total size of the 5 globals is 2.04 KiB (2088 bytes)
[15:32:11.072] 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 2.04 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.93 KiB of class 'function'), '...future.elements_ii' (112 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:11.072] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.073] 
[15:32:11.073] getGlobalsAndPackages() ... DONE
[15:32:11.074] run() for 'Future' ...
[15:32:11.074] - state: 'created'
[15:32:11.074] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.093] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.094] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.094]   - Field: 'node'
[15:32:11.094]   - Field: 'label'
[15:32:11.095]   - Field: 'local'
[15:32:11.095]   - Field: 'owner'
[15:32:11.095]   - Field: 'envir'
[15:32:11.096]   - Field: 'workers'
[15:32:11.096]   - Field: 'packages'
[15:32:11.096]   - Field: 'gc'
[15:32:11.097]   - Field: 'conditions'
[15:32:11.097]   - Field: 'persistent'
[15:32:11.097]   - Field: 'expr'
[15:32:11.097]   - Field: 'uuid'
[15:32:11.098]   - Field: 'seed'
[15:32:11.098]   - Field: 'version'
[15:32:11.098]   - Field: 'result'
[15:32:11.099]   - Field: 'asynchronous'
[15:32:11.099]   - Field: 'calls'
[15:32:11.099]   - Field: 'globals'
[15:32:11.100]   - Field: 'stdout'
[15:32:11.100]   - Field: 'earlySignal'
[15:32:11.100]   - Field: 'lazy'
[15:32:11.101]   - Field: 'state'
[15:32:11.101] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.101] - Launch lazy future ...
[15:32:11.102] Packages needed by the future expression (n = 0): <none>
[15:32:11.102] Packages needed by future strategies (n = 0): <none>
[15:32:11.103] {
[15:32:11.103]     {
[15:32:11.103]         {
[15:32:11.103]             ...future.startTime <- base::Sys.time()
[15:32:11.103]             {
[15:32:11.103]                 {
[15:32:11.103]                   {
[15:32:11.103]                     {
[15:32:11.103]                       base::local({
[15:32:11.103]                         has_future <- base::requireNamespace("future", 
[15:32:11.103]                           quietly = TRUE)
[15:32:11.103]                         if (has_future) {
[15:32:11.103]                           ns <- base::getNamespace("future")
[15:32:11.103]                           version <- ns[[".package"]][["version"]]
[15:32:11.103]                           if (is.null(version)) 
[15:32:11.103]                             version <- utils::packageVersion("future")
[15:32:11.103]                         }
[15:32:11.103]                         else {
[15:32:11.103]                           version <- NULL
[15:32:11.103]                         }
[15:32:11.103]                         if (!has_future || version < "1.8.0") {
[15:32:11.103]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.103]                             "", base::R.version$version.string), 
[15:32:11.103]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.103]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.103]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.103]                               "release", "version")], collapse = " "), 
[15:32:11.103]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.103]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.103]                             info)
[15:32:11.103]                           info <- base::paste(info, collapse = "; ")
[15:32:11.103]                           if (!has_future) {
[15:32:11.103]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.103]                               info)
[15:32:11.103]                           }
[15:32:11.103]                           else {
[15:32:11.103]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.103]                               info, version)
[15:32:11.103]                           }
[15:32:11.103]                           base::stop(msg)
[15:32:11.103]                         }
[15:32:11.103]                       })
[15:32:11.103]                     }
[15:32:11.103]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.103]                     base::options(mc.cores = 1L)
[15:32:11.103]                   }
[15:32:11.103]                   ...future.strategy.old <- future::plan("list")
[15:32:11.103]                   options(future.plan = NULL)
[15:32:11.103]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.103]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.103]                 }
[15:32:11.103]                 ...future.workdir <- getwd()
[15:32:11.103]             }
[15:32:11.103]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.103]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.103]         }
[15:32:11.103]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.103]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:11.103]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.103]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.103]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.103]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.103]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.103]             base::names(...future.oldOptions))
[15:32:11.103]     }
[15:32:11.103]     if (FALSE) {
[15:32:11.103]     }
[15:32:11.103]     else {
[15:32:11.103]         if (TRUE) {
[15:32:11.103]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.103]                 open = "w")
[15:32:11.103]         }
[15:32:11.103]         else {
[15:32:11.103]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.103]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.103]         }
[15:32:11.103]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.103]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.103]             base::sink(type = "output", split = FALSE)
[15:32:11.103]             base::close(...future.stdout)
[15:32:11.103]         }, add = TRUE)
[15:32:11.103]     }
[15:32:11.103]     ...future.frame <- base::sys.nframe()
[15:32:11.103]     ...future.conditions <- base::list()
[15:32:11.103]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.103]     if (FALSE) {
[15:32:11.103]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.103]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.103]     }
[15:32:11.103]     ...future.result <- base::tryCatch({
[15:32:11.103]         base::withCallingHandlers({
[15:32:11.103]             ...future.value <- base::withVisible(base::local({
[15:32:11.103]                 ...future.makeSendCondition <- base::local({
[15:32:11.103]                   sendCondition <- NULL
[15:32:11.103]                   function(frame = 1L) {
[15:32:11.103]                     if (is.function(sendCondition)) 
[15:32:11.103]                       return(sendCondition)
[15:32:11.103]                     ns <- getNamespace("parallel")
[15:32:11.103]                     if (exists("sendData", mode = "function", 
[15:32:11.103]                       envir = ns)) {
[15:32:11.103]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.103]                         envir = ns)
[15:32:11.103]                       envir <- sys.frame(frame)
[15:32:11.103]                       master <- NULL
[15:32:11.103]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.103]                         !identical(envir, emptyenv())) {
[15:32:11.103]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.103]                           inherits = FALSE)) {
[15:32:11.103]                           master <- get("master", mode = "list", 
[15:32:11.103]                             envir = envir, inherits = FALSE)
[15:32:11.103]                           if (inherits(master, c("SOCKnode", 
[15:32:11.103]                             "SOCK0node"))) {
[15:32:11.103]                             sendCondition <<- function(cond) {
[15:32:11.103]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.103]                                 success = TRUE)
[15:32:11.103]                               parallel_sendData(master, data)
[15:32:11.103]                             }
[15:32:11.103]                             return(sendCondition)
[15:32:11.103]                           }
[15:32:11.103]                         }
[15:32:11.103]                         frame <- frame + 1L
[15:32:11.103]                         envir <- sys.frame(frame)
[15:32:11.103]                       }
[15:32:11.103]                     }
[15:32:11.103]                     sendCondition <<- function(cond) NULL
[15:32:11.103]                   }
[15:32:11.103]                 })
[15:32:11.103]                 withCallingHandlers({
[15:32:11.103]                   {
[15:32:11.103]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.103]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.103]                       ...future.globals.maxSize)) {
[15:32:11.103]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.103]                       on.exit(options(oopts), add = TRUE)
[15:32:11.103]                     }
[15:32:11.103]                     {
[15:32:11.103]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.103]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.103]                         USE.NAMES = FALSE)
[15:32:11.103]                       do.call(mapply, args = args)
[15:32:11.103]                     }
[15:32:11.103]                   }
[15:32:11.103]                 }, immediateCondition = function(cond) {
[15:32:11.103]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.103]                   sendCondition(cond)
[15:32:11.103]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.103]                   {
[15:32:11.103]                     inherits <- base::inherits
[15:32:11.103]                     invokeRestart <- base::invokeRestart
[15:32:11.103]                     is.null <- base::is.null
[15:32:11.103]                     muffled <- FALSE
[15:32:11.103]                     if (inherits(cond, "message")) {
[15:32:11.103]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.103]                       if (muffled) 
[15:32:11.103]                         invokeRestart("muffleMessage")
[15:32:11.103]                     }
[15:32:11.103]                     else if (inherits(cond, "warning")) {
[15:32:11.103]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.103]                       if (muffled) 
[15:32:11.103]                         invokeRestart("muffleWarning")
[15:32:11.103]                     }
[15:32:11.103]                     else if (inherits(cond, "condition")) {
[15:32:11.103]                       if (!is.null(pattern)) {
[15:32:11.103]                         computeRestarts <- base::computeRestarts
[15:32:11.103]                         grepl <- base::grepl
[15:32:11.103]                         restarts <- computeRestarts(cond)
[15:32:11.103]                         for (restart in restarts) {
[15:32:11.103]                           name <- restart$name
[15:32:11.103]                           if (is.null(name)) 
[15:32:11.103]                             next
[15:32:11.103]                           if (!grepl(pattern, name)) 
[15:32:11.103]                             next
[15:32:11.103]                           invokeRestart(restart)
[15:32:11.103]                           muffled <- TRUE
[15:32:11.103]                           break
[15:32:11.103]                         }
[15:32:11.103]                       }
[15:32:11.103]                     }
[15:32:11.103]                     invisible(muffled)
[15:32:11.103]                   }
[15:32:11.103]                   muffleCondition(cond)
[15:32:11.103]                 })
[15:32:11.103]             }))
[15:32:11.103]             future::FutureResult(value = ...future.value$value, 
[15:32:11.103]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.103]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.103]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.103]                     ...future.globalenv.names))
[15:32:11.103]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.103]         }, condition = base::local({
[15:32:11.103]             c <- base::c
[15:32:11.103]             inherits <- base::inherits
[15:32:11.103]             invokeRestart <- base::invokeRestart
[15:32:11.103]             length <- base::length
[15:32:11.103]             list <- base::list
[15:32:11.103]             seq.int <- base::seq.int
[15:32:11.103]             signalCondition <- base::signalCondition
[15:32:11.103]             sys.calls <- base::sys.calls
[15:32:11.103]             `[[` <- base::`[[`
[15:32:11.103]             `+` <- base::`+`
[15:32:11.103]             `<<-` <- base::`<<-`
[15:32:11.103]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.103]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.103]                   3L)]
[15:32:11.103]             }
[15:32:11.103]             function(cond) {
[15:32:11.103]                 is_error <- inherits(cond, "error")
[15:32:11.103]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.103]                   NULL)
[15:32:11.103]                 if (is_error) {
[15:32:11.103]                   sessionInformation <- function() {
[15:32:11.103]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.103]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.103]                       search = base::search(), system = base::Sys.info())
[15:32:11.103]                   }
[15:32:11.103]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.103]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.103]                     cond$call), session = sessionInformation(), 
[15:32:11.103]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.103]                   signalCondition(cond)
[15:32:11.103]                 }
[15:32:11.103]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.103]                 "immediateCondition"))) {
[15:32:11.103]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.103]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.103]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.103]                   if (TRUE && !signal) {
[15:32:11.103]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.103]                     {
[15:32:11.103]                       inherits <- base::inherits
[15:32:11.103]                       invokeRestart <- base::invokeRestart
[15:32:11.103]                       is.null <- base::is.null
[15:32:11.103]                       muffled <- FALSE
[15:32:11.103]                       if (inherits(cond, "message")) {
[15:32:11.103]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.103]                         if (muffled) 
[15:32:11.103]                           invokeRestart("muffleMessage")
[15:32:11.103]                       }
[15:32:11.103]                       else if (inherits(cond, "warning")) {
[15:32:11.103]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.103]                         if (muffled) 
[15:32:11.103]                           invokeRestart("muffleWarning")
[15:32:11.103]                       }
[15:32:11.103]                       else if (inherits(cond, "condition")) {
[15:32:11.103]                         if (!is.null(pattern)) {
[15:32:11.103]                           computeRestarts <- base::computeRestarts
[15:32:11.103]                           grepl <- base::grepl
[15:32:11.103]                           restarts <- computeRestarts(cond)
[15:32:11.103]                           for (restart in restarts) {
[15:32:11.103]                             name <- restart$name
[15:32:11.103]                             if (is.null(name)) 
[15:32:11.103]                               next
[15:32:11.103]                             if (!grepl(pattern, name)) 
[15:32:11.103]                               next
[15:32:11.103]                             invokeRestart(restart)
[15:32:11.103]                             muffled <- TRUE
[15:32:11.103]                             break
[15:32:11.103]                           }
[15:32:11.103]                         }
[15:32:11.103]                       }
[15:32:11.103]                       invisible(muffled)
[15:32:11.103]                     }
[15:32:11.103]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.103]                   }
[15:32:11.103]                 }
[15:32:11.103]                 else {
[15:32:11.103]                   if (TRUE) {
[15:32:11.103]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.103]                     {
[15:32:11.103]                       inherits <- base::inherits
[15:32:11.103]                       invokeRestart <- base::invokeRestart
[15:32:11.103]                       is.null <- base::is.null
[15:32:11.103]                       muffled <- FALSE
[15:32:11.103]                       if (inherits(cond, "message")) {
[15:32:11.103]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.103]                         if (muffled) 
[15:32:11.103]                           invokeRestart("muffleMessage")
[15:32:11.103]                       }
[15:32:11.103]                       else if (inherits(cond, "warning")) {
[15:32:11.103]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.103]                         if (muffled) 
[15:32:11.103]                           invokeRestart("muffleWarning")
[15:32:11.103]                       }
[15:32:11.103]                       else if (inherits(cond, "condition")) {
[15:32:11.103]                         if (!is.null(pattern)) {
[15:32:11.103]                           computeRestarts <- base::computeRestarts
[15:32:11.103]                           grepl <- base::grepl
[15:32:11.103]                           restarts <- computeRestarts(cond)
[15:32:11.103]                           for (restart in restarts) {
[15:32:11.103]                             name <- restart$name
[15:32:11.103]                             if (is.null(name)) 
[15:32:11.103]                               next
[15:32:11.103]                             if (!grepl(pattern, name)) 
[15:32:11.103]                               next
[15:32:11.103]                             invokeRestart(restart)
[15:32:11.103]                             muffled <- TRUE
[15:32:11.103]                             break
[15:32:11.103]                           }
[15:32:11.103]                         }
[15:32:11.103]                       }
[15:32:11.103]                       invisible(muffled)
[15:32:11.103]                     }
[15:32:11.103]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.103]                   }
[15:32:11.103]                 }
[15:32:11.103]             }
[15:32:11.103]         }))
[15:32:11.103]     }, error = function(ex) {
[15:32:11.103]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.103]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.103]                 ...future.rng), started = ...future.startTime, 
[15:32:11.103]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.103]             version = "1.8"), class = "FutureResult")
[15:32:11.103]     }, finally = {
[15:32:11.103]         if (!identical(...future.workdir, getwd())) 
[15:32:11.103]             setwd(...future.workdir)
[15:32:11.103]         {
[15:32:11.103]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.103]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.103]             }
[15:32:11.103]             base::options(...future.oldOptions)
[15:32:11.103]             if (.Platform$OS.type == "windows") {
[15:32:11.103]                 old_names <- names(...future.oldEnvVars)
[15:32:11.103]                 envs <- base::Sys.getenv()
[15:32:11.103]                 names <- names(envs)
[15:32:11.103]                 common <- intersect(names, old_names)
[15:32:11.103]                 added <- setdiff(names, old_names)
[15:32:11.103]                 removed <- setdiff(old_names, names)
[15:32:11.103]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.103]                   envs[common]]
[15:32:11.103]                 NAMES <- toupper(changed)
[15:32:11.103]                 args <- list()
[15:32:11.103]                 for (kk in seq_along(NAMES)) {
[15:32:11.103]                   name <- changed[[kk]]
[15:32:11.103]                   NAME <- NAMES[[kk]]
[15:32:11.103]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.103]                     next
[15:32:11.103]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.103]                 }
[15:32:11.103]                 NAMES <- toupper(added)
[15:32:11.103]                 for (kk in seq_along(NAMES)) {
[15:32:11.103]                   name <- added[[kk]]
[15:32:11.103]                   NAME <- NAMES[[kk]]
[15:32:11.103]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.103]                     next
[15:32:11.103]                   args[[name]] <- ""
[15:32:11.103]                 }
[15:32:11.103]                 NAMES <- toupper(removed)
[15:32:11.103]                 for (kk in seq_along(NAMES)) {
[15:32:11.103]                   name <- removed[[kk]]
[15:32:11.103]                   NAME <- NAMES[[kk]]
[15:32:11.103]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.103]                     next
[15:32:11.103]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.103]                 }
[15:32:11.103]                 if (length(args) > 0) 
[15:32:11.103]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.103]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.103]             }
[15:32:11.103]             else {
[15:32:11.103]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.103]             }
[15:32:11.103]             {
[15:32:11.103]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.103]                   0L) {
[15:32:11.103]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.103]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.103]                   base::options(opts)
[15:32:11.103]                 }
[15:32:11.103]                 {
[15:32:11.103]                   {
[15:32:11.103]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.103]                     NULL
[15:32:11.103]                   }
[15:32:11.103]                   options(future.plan = NULL)
[15:32:11.103]                   if (is.na(NA_character_)) 
[15:32:11.103]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.103]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.103]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.103]                     .init = FALSE)
[15:32:11.103]                 }
[15:32:11.103]             }
[15:32:11.103]         }
[15:32:11.103]     })
[15:32:11.103]     if (TRUE) {
[15:32:11.103]         base::sink(type = "output", split = FALSE)
[15:32:11.103]         if (TRUE) {
[15:32:11.103]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.103]         }
[15:32:11.103]         else {
[15:32:11.103]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.103]         }
[15:32:11.103]         base::close(...future.stdout)
[15:32:11.103]         ...future.stdout <- NULL
[15:32:11.103]     }
[15:32:11.103]     ...future.result$conditions <- ...future.conditions
[15:32:11.103]     ...future.result$finished <- base::Sys.time()
[15:32:11.103]     ...future.result
[15:32:11.103] }
[15:32:11.113] Exporting 5 global objects (2.04 KiB) to cluster node #1 ...
[15:32:11.113] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ...
[15:32:11.114] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ... DONE
[15:32:11.115] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.115] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.116] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:11.116] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:11.117] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.117] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.118] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.118] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.119] Exporting 5 global objects (2.04 KiB) to cluster node #1 ... DONE
[15:32:11.120] MultisessionFuture started
[15:32:11.120] - Launch lazy future ... done
[15:32:11.120] run() for 'MultisessionFuture' ... done
[15:32:11.121] Created future:
[15:32:11.147] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.148] - Validating connection of MultisessionFuture
[15:32:11.148] - received message: FutureResult
[15:32:11.149] - Received FutureResult
[15:32:11.149] - Erased future from FutureRegistry
[15:32:11.150] result() for ClusterFuture ...
[15:32:11.150] - result already collected: FutureResult
[15:32:11.150] result() for ClusterFuture ... done
[15:32:11.151] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.121] MultisessionFuture:
[15:32:11.121] Label: 'future_.mapply-1'
[15:32:11.121] Expression:
[15:32:11.121] {
[15:32:11.121]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.121]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.121]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.121]         on.exit(options(oopts), add = TRUE)
[15:32:11.121]     }
[15:32:11.121]     {
[15:32:11.121]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.121]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.121]         do.call(mapply, args = args)
[15:32:11.121]     }
[15:32:11.121] }
[15:32:11.121] Lazy evaluation: FALSE
[15:32:11.121] Asynchronous evaluation: TRUE
[15:32:11.121] Local evaluation: TRUE
[15:32:11.121] Environment: R_GlobalEnv
[15:32:11.121] Capture standard output: TRUE
[15:32:11.121] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.121] Globals: 5 objects totaling 2.04 KiB (function '...future.FUN' of 1.93 KiB, list '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:32:11.121] Packages: <none>
[15:32:11.121] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.121] Resolved: TRUE
[15:32:11.121] Value: <not collected>
[15:32:11.121] Conditions captured: <none>
[15:32:11.121] Early signaling: FALSE
[15:32:11.121] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.121] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.152] Chunk #1 of 2 ... DONE
[15:32:11.152] Chunk #2 of 2 ...
[15:32:11.152]  - Finding globals in '...' for chunk #2 ...
[15:32:11.153] getGlobalsAndPackages() ...
[15:32:11.153] Searching for globals...
[15:32:11.154] 
[15:32:11.154] Searching for globals ... DONE
[15:32:11.154] - globals: [0] <none>
[15:32:11.155] getGlobalsAndPackages() ... DONE
[15:32:11.155]    + additional globals found: [n=0] 
[15:32:11.156]    + additional namespaces needed: [n=0] 
[15:32:11.156]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:11.156]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:11.157]  - seeds: <none>
[15:32:11.157]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.157] getGlobalsAndPackages() ...
[15:32:11.157] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.158] Resolving globals: FALSE
[15:32:11.159] The total size of the 5 globals is 2.15 KiB (2200 bytes)
[15:32:11.160] 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 2.15 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.93 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:11.161] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.161] 
[15:32:11.161] getGlobalsAndPackages() ... DONE
[15:32:11.162] run() for 'Future' ...
[15:32:11.162] - state: 'created'
[15:32:11.163] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.183] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.183] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.184]   - Field: 'node'
[15:32:11.184]   - Field: 'label'
[15:32:11.184]   - Field: 'local'
[15:32:11.185]   - Field: 'owner'
[15:32:11.185]   - Field: 'envir'
[15:32:11.185]   - Field: 'workers'
[15:32:11.186]   - Field: 'packages'
[15:32:11.186]   - Field: 'gc'
[15:32:11.186]   - Field: 'conditions'
[15:32:11.187]   - Field: 'persistent'
[15:32:11.187]   - Field: 'expr'
[15:32:11.187]   - Field: 'uuid'
[15:32:11.187]   - Field: 'seed'
[15:32:11.188]   - Field: 'version'
[15:32:11.188]   - Field: 'result'
[15:32:11.188]   - Field: 'asynchronous'
[15:32:11.189]   - Field: 'calls'
[15:32:11.189]   - Field: 'globals'
[15:32:11.189]   - Field: 'stdout'
[15:32:11.190]   - Field: 'earlySignal'
[15:32:11.190]   - Field: 'lazy'
[15:32:11.190]   - Field: 'state'
[15:32:11.191] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.191] - Launch lazy future ...
[15:32:11.192] Packages needed by the future expression (n = 0): <none>
[15:32:11.192] Packages needed by future strategies (n = 0): <none>
[15:32:11.193] {
[15:32:11.193]     {
[15:32:11.193]         {
[15:32:11.193]             ...future.startTime <- base::Sys.time()
[15:32:11.193]             {
[15:32:11.193]                 {
[15:32:11.193]                   {
[15:32:11.193]                     {
[15:32:11.193]                       base::local({
[15:32:11.193]                         has_future <- base::requireNamespace("future", 
[15:32:11.193]                           quietly = TRUE)
[15:32:11.193]                         if (has_future) {
[15:32:11.193]                           ns <- base::getNamespace("future")
[15:32:11.193]                           version <- ns[[".package"]][["version"]]
[15:32:11.193]                           if (is.null(version)) 
[15:32:11.193]                             version <- utils::packageVersion("future")
[15:32:11.193]                         }
[15:32:11.193]                         else {
[15:32:11.193]                           version <- NULL
[15:32:11.193]                         }
[15:32:11.193]                         if (!has_future || version < "1.8.0") {
[15:32:11.193]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.193]                             "", base::R.version$version.string), 
[15:32:11.193]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.193]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.193]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.193]                               "release", "version")], collapse = " "), 
[15:32:11.193]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.193]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.193]                             info)
[15:32:11.193]                           info <- base::paste(info, collapse = "; ")
[15:32:11.193]                           if (!has_future) {
[15:32:11.193]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.193]                               info)
[15:32:11.193]                           }
[15:32:11.193]                           else {
[15:32:11.193]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.193]                               info, version)
[15:32:11.193]                           }
[15:32:11.193]                           base::stop(msg)
[15:32:11.193]                         }
[15:32:11.193]                       })
[15:32:11.193]                     }
[15:32:11.193]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.193]                     base::options(mc.cores = 1L)
[15:32:11.193]                   }
[15:32:11.193]                   ...future.strategy.old <- future::plan("list")
[15:32:11.193]                   options(future.plan = NULL)
[15:32:11.193]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.193]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.193]                 }
[15:32:11.193]                 ...future.workdir <- getwd()
[15:32:11.193]             }
[15:32:11.193]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.193]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.193]         }
[15:32:11.193]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.193]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:11.193]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.193]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.193]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.193]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.193]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.193]             base::names(...future.oldOptions))
[15:32:11.193]     }
[15:32:11.193]     if (FALSE) {
[15:32:11.193]     }
[15:32:11.193]     else {
[15:32:11.193]         if (TRUE) {
[15:32:11.193]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.193]                 open = "w")
[15:32:11.193]         }
[15:32:11.193]         else {
[15:32:11.193]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.193]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.193]         }
[15:32:11.193]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.193]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.193]             base::sink(type = "output", split = FALSE)
[15:32:11.193]             base::close(...future.stdout)
[15:32:11.193]         }, add = TRUE)
[15:32:11.193]     }
[15:32:11.193]     ...future.frame <- base::sys.nframe()
[15:32:11.193]     ...future.conditions <- base::list()
[15:32:11.193]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.193]     if (FALSE) {
[15:32:11.193]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.193]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.193]     }
[15:32:11.193]     ...future.result <- base::tryCatch({
[15:32:11.193]         base::withCallingHandlers({
[15:32:11.193]             ...future.value <- base::withVisible(base::local({
[15:32:11.193]                 ...future.makeSendCondition <- base::local({
[15:32:11.193]                   sendCondition <- NULL
[15:32:11.193]                   function(frame = 1L) {
[15:32:11.193]                     if (is.function(sendCondition)) 
[15:32:11.193]                       return(sendCondition)
[15:32:11.193]                     ns <- getNamespace("parallel")
[15:32:11.193]                     if (exists("sendData", mode = "function", 
[15:32:11.193]                       envir = ns)) {
[15:32:11.193]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.193]                         envir = ns)
[15:32:11.193]                       envir <- sys.frame(frame)
[15:32:11.193]                       master <- NULL
[15:32:11.193]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.193]                         !identical(envir, emptyenv())) {
[15:32:11.193]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.193]                           inherits = FALSE)) {
[15:32:11.193]                           master <- get("master", mode = "list", 
[15:32:11.193]                             envir = envir, inherits = FALSE)
[15:32:11.193]                           if (inherits(master, c("SOCKnode", 
[15:32:11.193]                             "SOCK0node"))) {
[15:32:11.193]                             sendCondition <<- function(cond) {
[15:32:11.193]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.193]                                 success = TRUE)
[15:32:11.193]                               parallel_sendData(master, data)
[15:32:11.193]                             }
[15:32:11.193]                             return(sendCondition)
[15:32:11.193]                           }
[15:32:11.193]                         }
[15:32:11.193]                         frame <- frame + 1L
[15:32:11.193]                         envir <- sys.frame(frame)
[15:32:11.193]                       }
[15:32:11.193]                     }
[15:32:11.193]                     sendCondition <<- function(cond) NULL
[15:32:11.193]                   }
[15:32:11.193]                 })
[15:32:11.193]                 withCallingHandlers({
[15:32:11.193]                   {
[15:32:11.193]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.193]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.193]                       ...future.globals.maxSize)) {
[15:32:11.193]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.193]                       on.exit(options(oopts), add = TRUE)
[15:32:11.193]                     }
[15:32:11.193]                     {
[15:32:11.193]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.193]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.193]                         USE.NAMES = FALSE)
[15:32:11.193]                       do.call(mapply, args = args)
[15:32:11.193]                     }
[15:32:11.193]                   }
[15:32:11.193]                 }, immediateCondition = function(cond) {
[15:32:11.193]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.193]                   sendCondition(cond)
[15:32:11.193]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.193]                   {
[15:32:11.193]                     inherits <- base::inherits
[15:32:11.193]                     invokeRestart <- base::invokeRestart
[15:32:11.193]                     is.null <- base::is.null
[15:32:11.193]                     muffled <- FALSE
[15:32:11.193]                     if (inherits(cond, "message")) {
[15:32:11.193]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.193]                       if (muffled) 
[15:32:11.193]                         invokeRestart("muffleMessage")
[15:32:11.193]                     }
[15:32:11.193]                     else if (inherits(cond, "warning")) {
[15:32:11.193]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.193]                       if (muffled) 
[15:32:11.193]                         invokeRestart("muffleWarning")
[15:32:11.193]                     }
[15:32:11.193]                     else if (inherits(cond, "condition")) {
[15:32:11.193]                       if (!is.null(pattern)) {
[15:32:11.193]                         computeRestarts <- base::computeRestarts
[15:32:11.193]                         grepl <- base::grepl
[15:32:11.193]                         restarts <- computeRestarts(cond)
[15:32:11.193]                         for (restart in restarts) {
[15:32:11.193]                           name <- restart$name
[15:32:11.193]                           if (is.null(name)) 
[15:32:11.193]                             next
[15:32:11.193]                           if (!grepl(pattern, name)) 
[15:32:11.193]                             next
[15:32:11.193]                           invokeRestart(restart)
[15:32:11.193]                           muffled <- TRUE
[15:32:11.193]                           break
[15:32:11.193]                         }
[15:32:11.193]                       }
[15:32:11.193]                     }
[15:32:11.193]                     invisible(muffled)
[15:32:11.193]                   }
[15:32:11.193]                   muffleCondition(cond)
[15:32:11.193]                 })
[15:32:11.193]             }))
[15:32:11.193]             future::FutureResult(value = ...future.value$value, 
[15:32:11.193]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.193]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.193]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.193]                     ...future.globalenv.names))
[15:32:11.193]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.193]         }, condition = base::local({
[15:32:11.193]             c <- base::c
[15:32:11.193]             inherits <- base::inherits
[15:32:11.193]             invokeRestart <- base::invokeRestart
[15:32:11.193]             length <- base::length
[15:32:11.193]             list <- base::list
[15:32:11.193]             seq.int <- base::seq.int
[15:32:11.193]             signalCondition <- base::signalCondition
[15:32:11.193]             sys.calls <- base::sys.calls
[15:32:11.193]             `[[` <- base::`[[`
[15:32:11.193]             `+` <- base::`+`
[15:32:11.193]             `<<-` <- base::`<<-`
[15:32:11.193]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.193]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.193]                   3L)]
[15:32:11.193]             }
[15:32:11.193]             function(cond) {
[15:32:11.193]                 is_error <- inherits(cond, "error")
[15:32:11.193]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.193]                   NULL)
[15:32:11.193]                 if (is_error) {
[15:32:11.193]                   sessionInformation <- function() {
[15:32:11.193]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.193]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.193]                       search = base::search(), system = base::Sys.info())
[15:32:11.193]                   }
[15:32:11.193]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.193]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.193]                     cond$call), session = sessionInformation(), 
[15:32:11.193]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.193]                   signalCondition(cond)
[15:32:11.193]                 }
[15:32:11.193]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.193]                 "immediateCondition"))) {
[15:32:11.193]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.193]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.193]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.193]                   if (TRUE && !signal) {
[15:32:11.193]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.193]                     {
[15:32:11.193]                       inherits <- base::inherits
[15:32:11.193]                       invokeRestart <- base::invokeRestart
[15:32:11.193]                       is.null <- base::is.null
[15:32:11.193]                       muffled <- FALSE
[15:32:11.193]                       if (inherits(cond, "message")) {
[15:32:11.193]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.193]                         if (muffled) 
[15:32:11.193]                           invokeRestart("muffleMessage")
[15:32:11.193]                       }
[15:32:11.193]                       else if (inherits(cond, "warning")) {
[15:32:11.193]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.193]                         if (muffled) 
[15:32:11.193]                           invokeRestart("muffleWarning")
[15:32:11.193]                       }
[15:32:11.193]                       else if (inherits(cond, "condition")) {
[15:32:11.193]                         if (!is.null(pattern)) {
[15:32:11.193]                           computeRestarts <- base::computeRestarts
[15:32:11.193]                           grepl <- base::grepl
[15:32:11.193]                           restarts <- computeRestarts(cond)
[15:32:11.193]                           for (restart in restarts) {
[15:32:11.193]                             name <- restart$name
[15:32:11.193]                             if (is.null(name)) 
[15:32:11.193]                               next
[15:32:11.193]                             if (!grepl(pattern, name)) 
[15:32:11.193]                               next
[15:32:11.193]                             invokeRestart(restart)
[15:32:11.193]                             muffled <- TRUE
[15:32:11.193]                             break
[15:32:11.193]                           }
[15:32:11.193]                         }
[15:32:11.193]                       }
[15:32:11.193]                       invisible(muffled)
[15:32:11.193]                     }
[15:32:11.193]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.193]                   }
[15:32:11.193]                 }
[15:32:11.193]                 else {
[15:32:11.193]                   if (TRUE) {
[15:32:11.193]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.193]                     {
[15:32:11.193]                       inherits <- base::inherits
[15:32:11.193]                       invokeRestart <- base::invokeRestart
[15:32:11.193]                       is.null <- base::is.null
[15:32:11.193]                       muffled <- FALSE
[15:32:11.193]                       if (inherits(cond, "message")) {
[15:32:11.193]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.193]                         if (muffled) 
[15:32:11.193]                           invokeRestart("muffleMessage")
[15:32:11.193]                       }
[15:32:11.193]                       else if (inherits(cond, "warning")) {
[15:32:11.193]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.193]                         if (muffled) 
[15:32:11.193]                           invokeRestart("muffleWarning")
[15:32:11.193]                       }
[15:32:11.193]                       else if (inherits(cond, "condition")) {
[15:32:11.193]                         if (!is.null(pattern)) {
[15:32:11.193]                           computeRestarts <- base::computeRestarts
[15:32:11.193]                           grepl <- base::grepl
[15:32:11.193]                           restarts <- computeRestarts(cond)
[15:32:11.193]                           for (restart in restarts) {
[15:32:11.193]                             name <- restart$name
[15:32:11.193]                             if (is.null(name)) 
[15:32:11.193]                               next
[15:32:11.193]                             if (!grepl(pattern, name)) 
[15:32:11.193]                               next
[15:32:11.193]                             invokeRestart(restart)
[15:32:11.193]                             muffled <- TRUE
[15:32:11.193]                             break
[15:32:11.193]                           }
[15:32:11.193]                         }
[15:32:11.193]                       }
[15:32:11.193]                       invisible(muffled)
[15:32:11.193]                     }
[15:32:11.193]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.193]                   }
[15:32:11.193]                 }
[15:32:11.193]             }
[15:32:11.193]         }))
[15:32:11.193]     }, error = function(ex) {
[15:32:11.193]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.193]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.193]                 ...future.rng), started = ...future.startTime, 
[15:32:11.193]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.193]             version = "1.8"), class = "FutureResult")
[15:32:11.193]     }, finally = {
[15:32:11.193]         if (!identical(...future.workdir, getwd())) 
[15:32:11.193]             setwd(...future.workdir)
[15:32:11.193]         {
[15:32:11.193]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.193]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.193]             }
[15:32:11.193]             base::options(...future.oldOptions)
[15:32:11.193]             if (.Platform$OS.type == "windows") {
[15:32:11.193]                 old_names <- names(...future.oldEnvVars)
[15:32:11.193]                 envs <- base::Sys.getenv()
[15:32:11.193]                 names <- names(envs)
[15:32:11.193]                 common <- intersect(names, old_names)
[15:32:11.193]                 added <- setdiff(names, old_names)
[15:32:11.193]                 removed <- setdiff(old_names, names)
[15:32:11.193]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.193]                   envs[common]]
[15:32:11.193]                 NAMES <- toupper(changed)
[15:32:11.193]                 args <- list()
[15:32:11.193]                 for (kk in seq_along(NAMES)) {
[15:32:11.193]                   name <- changed[[kk]]
[15:32:11.193]                   NAME <- NAMES[[kk]]
[15:32:11.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.193]                     next
[15:32:11.193]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.193]                 }
[15:32:11.193]                 NAMES <- toupper(added)
[15:32:11.193]                 for (kk in seq_along(NAMES)) {
[15:32:11.193]                   name <- added[[kk]]
[15:32:11.193]                   NAME <- NAMES[[kk]]
[15:32:11.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.193]                     next
[15:32:11.193]                   args[[name]] <- ""
[15:32:11.193]                 }
[15:32:11.193]                 NAMES <- toupper(removed)
[15:32:11.193]                 for (kk in seq_along(NAMES)) {
[15:32:11.193]                   name <- removed[[kk]]
[15:32:11.193]                   NAME <- NAMES[[kk]]
[15:32:11.193]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.193]                     next
[15:32:11.193]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.193]                 }
[15:32:11.193]                 if (length(args) > 0) 
[15:32:11.193]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.193]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.193]             }
[15:32:11.193]             else {
[15:32:11.193]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.193]             }
[15:32:11.193]             {
[15:32:11.193]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.193]                   0L) {
[15:32:11.193]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.193]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.193]                   base::options(opts)
[15:32:11.193]                 }
[15:32:11.193]                 {
[15:32:11.193]                   {
[15:32:11.193]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.193]                     NULL
[15:32:11.193]                   }
[15:32:11.193]                   options(future.plan = NULL)
[15:32:11.193]                   if (is.na(NA_character_)) 
[15:32:11.193]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.193]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.193]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.193]                     .init = FALSE)
[15:32:11.193]                 }
[15:32:11.193]             }
[15:32:11.193]         }
[15:32:11.193]     })
[15:32:11.193]     if (TRUE) {
[15:32:11.193]         base::sink(type = "output", split = FALSE)
[15:32:11.193]         if (TRUE) {
[15:32:11.193]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.193]         }
[15:32:11.193]         else {
[15:32:11.193]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.193]         }
[15:32:11.193]         base::close(...future.stdout)
[15:32:11.193]         ...future.stdout <- NULL
[15:32:11.193]     }
[15:32:11.193]     ...future.result$conditions <- ...future.conditions
[15:32:11.193]     ...future.result$finished <- base::Sys.time()
[15:32:11.193]     ...future.result
[15:32:11.193] }
[15:32:11.202] Exporting 5 global objects (2.15 KiB) to cluster node #1 ...
[15:32:11.203] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ...
[15:32:11.203] Exporting '...future.FUN' (1.93 KiB) to cluster node #1 ... DONE
[15:32:11.204] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.204] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.205] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:11.206] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:11.206] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.207] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.207] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.208] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.208] Exporting 5 global objects (2.15 KiB) to cluster node #1 ... DONE
[15:32:11.213] MultisessionFuture started
[15:32:11.213] - Launch lazy future ... done
[15:32:11.214] run() for 'MultisessionFuture' ... done
[15:32:11.214] Created future:
[15:32:11.243] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.243] - Validating connection of MultisessionFuture
[15:32:11.244] - received message: FutureResult
[15:32:11.244] - Received FutureResult
[15:32:11.245] - Erased future from FutureRegistry
[15:32:11.245] result() for ClusterFuture ...
[15:32:11.245] - result already collected: FutureResult
[15:32:11.246] result() for ClusterFuture ... done
[15:32:11.246] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.215] MultisessionFuture:
[15:32:11.215] Label: 'future_.mapply-2'
[15:32:11.215] Expression:
[15:32:11.215] {
[15:32:11.215]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.215]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.215]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.215]         on.exit(options(oopts), add = TRUE)
[15:32:11.215]     }
[15:32:11.215]     {
[15:32:11.215]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.215]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.215]         do.call(mapply, args = args)
[15:32:11.215]     }
[15:32:11.215] }
[15:32:11.215] Lazy evaluation: FALSE
[15:32:11.215] Asynchronous evaluation: TRUE
[15:32:11.215] Local evaluation: TRUE
[15:32:11.215] Environment: R_GlobalEnv
[15:32:11.215] Capture standard output: TRUE
[15:32:11.215] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.215] Globals: 5 objects totaling 2.15 KiB (function '...future.FUN' of 1.93 KiB, list '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:11.215] Packages: <none>
[15:32:11.215] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.215] Resolved: TRUE
[15:32:11.215] Value: <not collected>
[15:32:11.215] Conditions captured: <none>
[15:32:11.215] Early signaling: FALSE
[15:32:11.215] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.215] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.247] Chunk #2 of 2 ... DONE
[15:32:11.247] Launching 2 futures (chunks) ... DONE
[15:32:11.247] Resolving 2 futures (chunks) ...
[15:32:11.248] resolve() on list ...
[15:32:11.248]  recursive: 0
[15:32:11.248]  length: 2
[15:32:11.248] 
[15:32:11.249] Future #1
[15:32:11.249] result() for ClusterFuture ...
[15:32:11.249] - result already collected: FutureResult
[15:32:11.250] result() for ClusterFuture ... done
[15:32:11.250] result() for ClusterFuture ...
[15:32:11.250] - result already collected: FutureResult
[15:32:11.250] result() for ClusterFuture ... done
[15:32:11.251] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:11.251] - nx: 2
[15:32:11.251] - relay: TRUE
[15:32:11.252] - stdout: TRUE
[15:32:11.252] - signal: TRUE
[15:32:11.252] - resignal: FALSE
[15:32:11.252] - force: TRUE
[15:32:11.253] - relayed: [n=2] FALSE, FALSE
[15:32:11.253] - queued futures: [n=2] FALSE, FALSE
[15:32:11.253]  - until=1
[15:32:11.254]  - relaying element #1
[15:32:11.254] result() for ClusterFuture ...
[15:32:11.254] - result already collected: FutureResult
[15:32:11.254] result() for ClusterFuture ... done
[15:32:11.255] result() for ClusterFuture ...
[15:32:11.255] - result already collected: FutureResult
[15:32:11.255] result() for ClusterFuture ... done
[15:32:11.256] result() for ClusterFuture ...
[15:32:11.256] - result already collected: FutureResult
[15:32:11.256] result() for ClusterFuture ... done
[15:32:11.256] result() for ClusterFuture ...
[15:32:11.257] - result already collected: FutureResult
[15:32:11.257] result() for ClusterFuture ... done
[15:32:11.257] - relayed: [n=2] TRUE, FALSE
[15:32:11.258] - queued futures: [n=2] TRUE, FALSE
[15:32:11.258] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:11.258]  length: 1 (resolved future 1)
[15:32:11.258] Future #2
[15:32:11.259] result() for ClusterFuture ...
[15:32:11.259] - result already collected: FutureResult
[15:32:11.259] result() for ClusterFuture ... done
[15:32:11.260] result() for ClusterFuture ...
[15:32:11.260] - result already collected: FutureResult
[15:32:11.260] result() for ClusterFuture ... done
[15:32:11.260] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:11.261] - nx: 2
[15:32:11.261] - relay: TRUE
[15:32:11.261] - stdout: TRUE
[15:32:11.261] - signal: TRUE
[15:32:11.262] - resignal: FALSE
[15:32:11.262] - force: TRUE
[15:32:11.262] - relayed: [n=2] TRUE, FALSE
[15:32:11.262] - queued futures: [n=2] TRUE, FALSE
[15:32:11.263]  - until=2
[15:32:11.263]  - relaying element #2
[15:32:11.263] result() for ClusterFuture ...
[15:32:11.263] - result already collected: FutureResult
[15:32:11.264] result() for ClusterFuture ... done
[15:32:11.264] result() for ClusterFuture ...
[15:32:11.264] - result already collected: FutureResult
[15:32:11.265] result() for ClusterFuture ... done
[15:32:11.265] result() for ClusterFuture ...
[15:32:11.265] - result already collected: FutureResult
[15:32:11.265] result() for ClusterFuture ... done
[15:32:11.266] result() for ClusterFuture ...
[15:32:11.266] - result already collected: FutureResult
[15:32:11.266] result() for ClusterFuture ... done
[15:32:11.266] - relayed: [n=2] TRUE, TRUE
[15:32:11.267] - queued futures: [n=2] TRUE, TRUE
[15:32:11.267] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:11.267]  length: 0 (resolved future 2)
[15:32:11.268] Relaying remaining futures
[15:32:11.268] signalConditionsASAP(NULL, pos=0) ...
[15:32:11.268] - nx: 2
[15:32:11.268] - relay: TRUE
[15:32:11.269] - stdout: TRUE
[15:32:11.269] - signal: TRUE
[15:32:11.269] - resignal: FALSE
[15:32:11.269] - force: TRUE
[15:32:11.270] - relayed: [n=2] TRUE, TRUE
[15:32:11.270] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:11.270] - relayed: [n=2] TRUE, TRUE
[15:32:11.271] - queued futures: [n=2] TRUE, TRUE
[15:32:11.271] signalConditionsASAP(NULL, pos=0) ... done
[15:32:11.271] resolve() on list ... DONE
[15:32:11.271] result() for ClusterFuture ...
[15:32:11.272] - result already collected: FutureResult
[15:32:11.272] result() for ClusterFuture ... done
[15:32:11.272] result() for ClusterFuture ...
[15:32:11.272] - result already collected: FutureResult
[15:32:11.273] result() for ClusterFuture ... done
[15:32:11.273] result() for ClusterFuture ...
[15:32:11.273] - result already collected: FutureResult
[15:32:11.274] result() for ClusterFuture ... done
[15:32:11.274] result() for ClusterFuture ...
[15:32:11.274] - result already collected: FutureResult
[15:32:11.275] result() for ClusterFuture ... done
[15:32:11.275]  - Number of value chunks collected: 2
[15:32:11.275] Resolving 2 futures (chunks) ... DONE
[15:32:11.275] Reducing values from 2 chunks ...
[15:32:11.276]  - Number of values collected after concatenation: 3
[15:32:11.276]  - Number of values expected: 3
[15:32:11.276] Reducing values from 2 chunks ... DONE
[15:32:11.276] future_mapply() ... DONE
[15:32:11.277] future_mapply() ...
[15:32:11.281] Number of chunks: 5
[15:32:11.281] getGlobalsAndPackagesXApply() ...
[15:32:11.281]  - future.globals: TRUE
[15:32:11.282] getGlobalsAndPackages() ...
[15:32:11.282] Searching for globals...
[15:32:11.283] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:11.284] Searching for globals ... DONE
[15:32:11.284] Resolving globals: FALSE
[15:32:11.284] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:11.285] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:11.285] - globals: [1] 'FUN'
[15:32:11.285] 
[15:32:11.286] getGlobalsAndPackages() ... DONE
[15:32:11.286]  - globals found/used: [n=1] 'FUN'
[15:32:11.286]  - needed namespaces: [n=0] 
[15:32:11.286] Finding globals ... DONE
[15:32:11.286] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:11.287] List of 2
[15:32:11.287]  $ ...future.FUN:function (C, k)  
[15:32:11.287]  $ MoreArgs     : NULL
[15:32:11.287]  - attr(*, "where")=List of 2
[15:32:11.287]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:11.287]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:11.287]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:11.287]  - attr(*, "resolved")= logi FALSE
[15:32:11.287]  - attr(*, "total_size")= num NA
[15:32:11.290] Packages to be attached in all futures: [n=0] 
[15:32:11.290] getGlobalsAndPackagesXApply() ... DONE
[15:32:11.290] Number of futures (= number of chunks): 5
[15:32:11.291] Launching 5 futures (chunks) ...
[15:32:11.291] Chunk #1 of 5 ...
[15:32:11.291]  - Finding globals in '...' for chunk #1 ...
[15:32:11.291] getGlobalsAndPackages() ...
[15:32:11.291] Searching for globals...
[15:32:11.292] 
[15:32:11.292] Searching for globals ... DONE
[15:32:11.292] - globals: [0] <none>
[15:32:11.292] getGlobalsAndPackages() ... DONE
[15:32:11.292]    + additional globals found: [n=0] 
[15:32:11.293]    + additional namespaces needed: [n=0] 
[15:32:11.293]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:11.293]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:11.293]  - seeds: <none>
[15:32:11.293]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.294] getGlobalsAndPackages() ...
[15:32:11.294] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.294] Resolving globals: FALSE
[15:32:11.295] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:11.295] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:11.295] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.296] 
[15:32:11.296] getGlobalsAndPackages() ... DONE
[15:32:11.297] run() for 'Future' ...
[15:32:11.297] - state: 'created'
[15:32:11.297] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.315] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.316] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.316]   - Field: 'node'
[15:32:11.316]   - Field: 'label'
[15:32:11.316]   - Field: 'local'
[15:32:11.317]   - Field: 'owner'
[15:32:11.317]   - Field: 'envir'
[15:32:11.317]   - Field: 'workers'
[15:32:11.317]   - Field: 'packages'
[15:32:11.317]   - Field: 'gc'
[15:32:11.318]   - Field: 'conditions'
[15:32:11.318]   - Field: 'persistent'
[15:32:11.318]   - Field: 'expr'
[15:32:11.318]   - Field: 'uuid'
[15:32:11.318]   - Field: 'seed'
[15:32:11.318]   - Field: 'version'
[15:32:11.319]   - Field: 'result'
[15:32:11.319]   - Field: 'asynchronous'
[15:32:11.319]   - Field: 'calls'
[15:32:11.319]   - Field: 'globals'
[15:32:11.319]   - Field: 'stdout'
[15:32:11.320]   - Field: 'earlySignal'
[15:32:11.320]   - Field: 'lazy'
[15:32:11.320]   - Field: 'state'
[15:32:11.320] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.320] - Launch lazy future ...
[15:32:11.321] Packages needed by the future expression (n = 0): <none>
[15:32:11.321] Packages needed by future strategies (n = 0): <none>
[15:32:11.322] {
[15:32:11.322]     {
[15:32:11.322]         {
[15:32:11.322]             ...future.startTime <- base::Sys.time()
[15:32:11.322]             {
[15:32:11.322]                 {
[15:32:11.322]                   {
[15:32:11.322]                     {
[15:32:11.322]                       base::local({
[15:32:11.322]                         has_future <- base::requireNamespace("future", 
[15:32:11.322]                           quietly = TRUE)
[15:32:11.322]                         if (has_future) {
[15:32:11.322]                           ns <- base::getNamespace("future")
[15:32:11.322]                           version <- ns[[".package"]][["version"]]
[15:32:11.322]                           if (is.null(version)) 
[15:32:11.322]                             version <- utils::packageVersion("future")
[15:32:11.322]                         }
[15:32:11.322]                         else {
[15:32:11.322]                           version <- NULL
[15:32:11.322]                         }
[15:32:11.322]                         if (!has_future || version < "1.8.0") {
[15:32:11.322]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.322]                             "", base::R.version$version.string), 
[15:32:11.322]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.322]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.322]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.322]                               "release", "version")], collapse = " "), 
[15:32:11.322]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.322]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.322]                             info)
[15:32:11.322]                           info <- base::paste(info, collapse = "; ")
[15:32:11.322]                           if (!has_future) {
[15:32:11.322]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.322]                               info)
[15:32:11.322]                           }
[15:32:11.322]                           else {
[15:32:11.322]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.322]                               info, version)
[15:32:11.322]                           }
[15:32:11.322]                           base::stop(msg)
[15:32:11.322]                         }
[15:32:11.322]                       })
[15:32:11.322]                     }
[15:32:11.322]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.322]                     base::options(mc.cores = 1L)
[15:32:11.322]                   }
[15:32:11.322]                   ...future.strategy.old <- future::plan("list")
[15:32:11.322]                   options(future.plan = NULL)
[15:32:11.322]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.322]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.322]                 }
[15:32:11.322]                 ...future.workdir <- getwd()
[15:32:11.322]             }
[15:32:11.322]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.322]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.322]         }
[15:32:11.322]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.322]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:11.322]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.322]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.322]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.322]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.322]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.322]             base::names(...future.oldOptions))
[15:32:11.322]     }
[15:32:11.322]     if (FALSE) {
[15:32:11.322]     }
[15:32:11.322]     else {
[15:32:11.322]         if (TRUE) {
[15:32:11.322]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.322]                 open = "w")
[15:32:11.322]         }
[15:32:11.322]         else {
[15:32:11.322]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.322]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.322]         }
[15:32:11.322]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.322]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.322]             base::sink(type = "output", split = FALSE)
[15:32:11.322]             base::close(...future.stdout)
[15:32:11.322]         }, add = TRUE)
[15:32:11.322]     }
[15:32:11.322]     ...future.frame <- base::sys.nframe()
[15:32:11.322]     ...future.conditions <- base::list()
[15:32:11.322]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.322]     if (FALSE) {
[15:32:11.322]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.322]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.322]     }
[15:32:11.322]     ...future.result <- base::tryCatch({
[15:32:11.322]         base::withCallingHandlers({
[15:32:11.322]             ...future.value <- base::withVisible(base::local({
[15:32:11.322]                 ...future.makeSendCondition <- base::local({
[15:32:11.322]                   sendCondition <- NULL
[15:32:11.322]                   function(frame = 1L) {
[15:32:11.322]                     if (is.function(sendCondition)) 
[15:32:11.322]                       return(sendCondition)
[15:32:11.322]                     ns <- getNamespace("parallel")
[15:32:11.322]                     if (exists("sendData", mode = "function", 
[15:32:11.322]                       envir = ns)) {
[15:32:11.322]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.322]                         envir = ns)
[15:32:11.322]                       envir <- sys.frame(frame)
[15:32:11.322]                       master <- NULL
[15:32:11.322]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.322]                         !identical(envir, emptyenv())) {
[15:32:11.322]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.322]                           inherits = FALSE)) {
[15:32:11.322]                           master <- get("master", mode = "list", 
[15:32:11.322]                             envir = envir, inherits = FALSE)
[15:32:11.322]                           if (inherits(master, c("SOCKnode", 
[15:32:11.322]                             "SOCK0node"))) {
[15:32:11.322]                             sendCondition <<- function(cond) {
[15:32:11.322]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.322]                                 success = TRUE)
[15:32:11.322]                               parallel_sendData(master, data)
[15:32:11.322]                             }
[15:32:11.322]                             return(sendCondition)
[15:32:11.322]                           }
[15:32:11.322]                         }
[15:32:11.322]                         frame <- frame + 1L
[15:32:11.322]                         envir <- sys.frame(frame)
[15:32:11.322]                       }
[15:32:11.322]                     }
[15:32:11.322]                     sendCondition <<- function(cond) NULL
[15:32:11.322]                   }
[15:32:11.322]                 })
[15:32:11.322]                 withCallingHandlers({
[15:32:11.322]                   {
[15:32:11.322]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.322]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.322]                       ...future.globals.maxSize)) {
[15:32:11.322]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.322]                       on.exit(options(oopts), add = TRUE)
[15:32:11.322]                     }
[15:32:11.322]                     {
[15:32:11.322]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.322]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.322]                         USE.NAMES = FALSE)
[15:32:11.322]                       do.call(mapply, args = args)
[15:32:11.322]                     }
[15:32:11.322]                   }
[15:32:11.322]                 }, immediateCondition = function(cond) {
[15:32:11.322]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.322]                   sendCondition(cond)
[15:32:11.322]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.322]                   {
[15:32:11.322]                     inherits <- base::inherits
[15:32:11.322]                     invokeRestart <- base::invokeRestart
[15:32:11.322]                     is.null <- base::is.null
[15:32:11.322]                     muffled <- FALSE
[15:32:11.322]                     if (inherits(cond, "message")) {
[15:32:11.322]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.322]                       if (muffled) 
[15:32:11.322]                         invokeRestart("muffleMessage")
[15:32:11.322]                     }
[15:32:11.322]                     else if (inherits(cond, "warning")) {
[15:32:11.322]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.322]                       if (muffled) 
[15:32:11.322]                         invokeRestart("muffleWarning")
[15:32:11.322]                     }
[15:32:11.322]                     else if (inherits(cond, "condition")) {
[15:32:11.322]                       if (!is.null(pattern)) {
[15:32:11.322]                         computeRestarts <- base::computeRestarts
[15:32:11.322]                         grepl <- base::grepl
[15:32:11.322]                         restarts <- computeRestarts(cond)
[15:32:11.322]                         for (restart in restarts) {
[15:32:11.322]                           name <- restart$name
[15:32:11.322]                           if (is.null(name)) 
[15:32:11.322]                             next
[15:32:11.322]                           if (!grepl(pattern, name)) 
[15:32:11.322]                             next
[15:32:11.322]                           invokeRestart(restart)
[15:32:11.322]                           muffled <- TRUE
[15:32:11.322]                           break
[15:32:11.322]                         }
[15:32:11.322]                       }
[15:32:11.322]                     }
[15:32:11.322]                     invisible(muffled)
[15:32:11.322]                   }
[15:32:11.322]                   muffleCondition(cond)
[15:32:11.322]                 })
[15:32:11.322]             }))
[15:32:11.322]             future::FutureResult(value = ...future.value$value, 
[15:32:11.322]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.322]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.322]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.322]                     ...future.globalenv.names))
[15:32:11.322]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.322]         }, condition = base::local({
[15:32:11.322]             c <- base::c
[15:32:11.322]             inherits <- base::inherits
[15:32:11.322]             invokeRestart <- base::invokeRestart
[15:32:11.322]             length <- base::length
[15:32:11.322]             list <- base::list
[15:32:11.322]             seq.int <- base::seq.int
[15:32:11.322]             signalCondition <- base::signalCondition
[15:32:11.322]             sys.calls <- base::sys.calls
[15:32:11.322]             `[[` <- base::`[[`
[15:32:11.322]             `+` <- base::`+`
[15:32:11.322]             `<<-` <- base::`<<-`
[15:32:11.322]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.322]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.322]                   3L)]
[15:32:11.322]             }
[15:32:11.322]             function(cond) {
[15:32:11.322]                 is_error <- inherits(cond, "error")
[15:32:11.322]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.322]                   NULL)
[15:32:11.322]                 if (is_error) {
[15:32:11.322]                   sessionInformation <- function() {
[15:32:11.322]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.322]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.322]                       search = base::search(), system = base::Sys.info())
[15:32:11.322]                   }
[15:32:11.322]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.322]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.322]                     cond$call), session = sessionInformation(), 
[15:32:11.322]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.322]                   signalCondition(cond)
[15:32:11.322]                 }
[15:32:11.322]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.322]                 "immediateCondition"))) {
[15:32:11.322]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.322]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.322]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.322]                   if (TRUE && !signal) {
[15:32:11.322]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.322]                     {
[15:32:11.322]                       inherits <- base::inherits
[15:32:11.322]                       invokeRestart <- base::invokeRestart
[15:32:11.322]                       is.null <- base::is.null
[15:32:11.322]                       muffled <- FALSE
[15:32:11.322]                       if (inherits(cond, "message")) {
[15:32:11.322]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.322]                         if (muffled) 
[15:32:11.322]                           invokeRestart("muffleMessage")
[15:32:11.322]                       }
[15:32:11.322]                       else if (inherits(cond, "warning")) {
[15:32:11.322]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.322]                         if (muffled) 
[15:32:11.322]                           invokeRestart("muffleWarning")
[15:32:11.322]                       }
[15:32:11.322]                       else if (inherits(cond, "condition")) {
[15:32:11.322]                         if (!is.null(pattern)) {
[15:32:11.322]                           computeRestarts <- base::computeRestarts
[15:32:11.322]                           grepl <- base::grepl
[15:32:11.322]                           restarts <- computeRestarts(cond)
[15:32:11.322]                           for (restart in restarts) {
[15:32:11.322]                             name <- restart$name
[15:32:11.322]                             if (is.null(name)) 
[15:32:11.322]                               next
[15:32:11.322]                             if (!grepl(pattern, name)) 
[15:32:11.322]                               next
[15:32:11.322]                             invokeRestart(restart)
[15:32:11.322]                             muffled <- TRUE
[15:32:11.322]                             break
[15:32:11.322]                           }
[15:32:11.322]                         }
[15:32:11.322]                       }
[15:32:11.322]                       invisible(muffled)
[15:32:11.322]                     }
[15:32:11.322]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.322]                   }
[15:32:11.322]                 }
[15:32:11.322]                 else {
[15:32:11.322]                   if (TRUE) {
[15:32:11.322]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.322]                     {
[15:32:11.322]                       inherits <- base::inherits
[15:32:11.322]                       invokeRestart <- base::invokeRestart
[15:32:11.322]                       is.null <- base::is.null
[15:32:11.322]                       muffled <- FALSE
[15:32:11.322]                       if (inherits(cond, "message")) {
[15:32:11.322]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.322]                         if (muffled) 
[15:32:11.322]                           invokeRestart("muffleMessage")
[15:32:11.322]                       }
[15:32:11.322]                       else if (inherits(cond, "warning")) {
[15:32:11.322]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.322]                         if (muffled) 
[15:32:11.322]                           invokeRestart("muffleWarning")
[15:32:11.322]                       }
[15:32:11.322]                       else if (inherits(cond, "condition")) {
[15:32:11.322]                         if (!is.null(pattern)) {
[15:32:11.322]                           computeRestarts <- base::computeRestarts
[15:32:11.322]                           grepl <- base::grepl
[15:32:11.322]                           restarts <- computeRestarts(cond)
[15:32:11.322]                           for (restart in restarts) {
[15:32:11.322]                             name <- restart$name
[15:32:11.322]                             if (is.null(name)) 
[15:32:11.322]                               next
[15:32:11.322]                             if (!grepl(pattern, name)) 
[15:32:11.322]                               next
[15:32:11.322]                             invokeRestart(restart)
[15:32:11.322]                             muffled <- TRUE
[15:32:11.322]                             break
[15:32:11.322]                           }
[15:32:11.322]                         }
[15:32:11.322]                       }
[15:32:11.322]                       invisible(muffled)
[15:32:11.322]                     }
[15:32:11.322]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.322]                   }
[15:32:11.322]                 }
[15:32:11.322]             }
[15:32:11.322]         }))
[15:32:11.322]     }, error = function(ex) {
[15:32:11.322]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.322]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.322]                 ...future.rng), started = ...future.startTime, 
[15:32:11.322]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.322]             version = "1.8"), class = "FutureResult")
[15:32:11.322]     }, finally = {
[15:32:11.322]         if (!identical(...future.workdir, getwd())) 
[15:32:11.322]             setwd(...future.workdir)
[15:32:11.322]         {
[15:32:11.322]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.322]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.322]             }
[15:32:11.322]             base::options(...future.oldOptions)
[15:32:11.322]             if (.Platform$OS.type == "windows") {
[15:32:11.322]                 old_names <- names(...future.oldEnvVars)
[15:32:11.322]                 envs <- base::Sys.getenv()
[15:32:11.322]                 names <- names(envs)
[15:32:11.322]                 common <- intersect(names, old_names)
[15:32:11.322]                 added <- setdiff(names, old_names)
[15:32:11.322]                 removed <- setdiff(old_names, names)
[15:32:11.322]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.322]                   envs[common]]
[15:32:11.322]                 NAMES <- toupper(changed)
[15:32:11.322]                 args <- list()
[15:32:11.322]                 for (kk in seq_along(NAMES)) {
[15:32:11.322]                   name <- changed[[kk]]
[15:32:11.322]                   NAME <- NAMES[[kk]]
[15:32:11.322]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.322]                     next
[15:32:11.322]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.322]                 }
[15:32:11.322]                 NAMES <- toupper(added)
[15:32:11.322]                 for (kk in seq_along(NAMES)) {
[15:32:11.322]                   name <- added[[kk]]
[15:32:11.322]                   NAME <- NAMES[[kk]]
[15:32:11.322]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.322]                     next
[15:32:11.322]                   args[[name]] <- ""
[15:32:11.322]                 }
[15:32:11.322]                 NAMES <- toupper(removed)
[15:32:11.322]                 for (kk in seq_along(NAMES)) {
[15:32:11.322]                   name <- removed[[kk]]
[15:32:11.322]                   NAME <- NAMES[[kk]]
[15:32:11.322]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.322]                     next
[15:32:11.322]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.322]                 }
[15:32:11.322]                 if (length(args) > 0) 
[15:32:11.322]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.322]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.322]             }
[15:32:11.322]             else {
[15:32:11.322]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.322]             }
[15:32:11.322]             {
[15:32:11.322]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.322]                   0L) {
[15:32:11.322]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.322]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.322]                   base::options(opts)
[15:32:11.322]                 }
[15:32:11.322]                 {
[15:32:11.322]                   {
[15:32:11.322]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.322]                     NULL
[15:32:11.322]                   }
[15:32:11.322]                   options(future.plan = NULL)
[15:32:11.322]                   if (is.na(NA_character_)) 
[15:32:11.322]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.322]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.322]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.322]                     .init = FALSE)
[15:32:11.322]                 }
[15:32:11.322]             }
[15:32:11.322]         }
[15:32:11.322]     })
[15:32:11.322]     if (TRUE) {
[15:32:11.322]         base::sink(type = "output", split = FALSE)
[15:32:11.322]         if (TRUE) {
[15:32:11.322]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.322]         }
[15:32:11.322]         else {
[15:32:11.322]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.322]         }
[15:32:11.322]         base::close(...future.stdout)
[15:32:11.322]         ...future.stdout <- NULL
[15:32:11.322]     }
[15:32:11.322]     ...future.result$conditions <- ...future.conditions
[15:32:11.322]     ...future.result$finished <- base::Sys.time()
[15:32:11.322]     ...future.result
[15:32:11.322] }
[15:32:11.328] Exporting 5 global objects (3.41 KiB) to cluster node #1 ...
[15:32:11.328] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.329] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.329] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.330] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.330] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:11.331] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:11.331] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.332] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.332] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.333] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.333] Exporting 5 global objects (3.41 KiB) to cluster node #1 ... DONE
[15:32:11.334] MultisessionFuture started
[15:32:11.334] - Launch lazy future ... done
[15:32:11.334] run() for 'MultisessionFuture' ... done
[15:32:11.335] Created future:
[15:32:11.360] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.360] - Validating connection of MultisessionFuture
[15:32:11.361] - received message: FutureResult
[15:32:11.361] - Received FutureResult
[15:32:11.361] - Erased future from FutureRegistry
[15:32:11.362] result() for ClusterFuture ...
[15:32:11.362] - result already collected: FutureResult
[15:32:11.362] result() for ClusterFuture ... done
[15:32:11.363] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.335] MultisessionFuture:
[15:32:11.335] Label: 'future_mapply-1'
[15:32:11.335] Expression:
[15:32:11.335] {
[15:32:11.335]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.335]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.335]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.335]         on.exit(options(oopts), add = TRUE)
[15:32:11.335]     }
[15:32:11.335]     {
[15:32:11.335]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.335]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.335]         do.call(mapply, args = args)
[15:32:11.335]     }
[15:32:11.335] }
[15:32:11.335] Lazy evaluation: FALSE
[15:32:11.335] Asynchronous evaluation: TRUE
[15:32:11.335] Local evaluation: TRUE
[15:32:11.335] Environment: R_GlobalEnv
[15:32:11.335] Capture standard output: TRUE
[15:32:11.335] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.335] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.335] Packages: <none>
[15:32:11.335] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.335] Resolved: TRUE
[15:32:11.335] Value: <not collected>
[15:32:11.335] Conditions captured: <none>
[15:32:11.335] Early signaling: FALSE
[15:32:11.335] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.335] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.363] Chunk #1 of 5 ... DONE
[15:32:11.364] Chunk #2 of 5 ...
[15:32:11.364]  - Finding globals in '...' for chunk #2 ...
[15:32:11.365] getGlobalsAndPackages() ...
[15:32:11.365] Searching for globals...
[15:32:11.366] 
[15:32:11.366] Searching for globals ... DONE
[15:32:11.366] - globals: [0] <none>
[15:32:11.367] getGlobalsAndPackages() ... DONE
[15:32:11.367]    + additional globals found: [n=0] 
[15:32:11.367]    + additional namespaces needed: [n=0] 
[15:32:11.368]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:11.368]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:11.368]  - seeds: <none>
[15:32:11.369]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.369] getGlobalsAndPackages() ...
[15:32:11.369] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.370] Resolving globals: FALSE
[15:32:11.371] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:11.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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:11.373] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.373] 
[15:32:11.373] getGlobalsAndPackages() ... DONE
[15:32:11.374] run() for 'Future' ...
[15:32:11.374] - state: 'created'
[15:32:11.375] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.394] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.394] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.395]   - Field: 'node'
[15:32:11.395]   - Field: 'label'
[15:32:11.395]   - Field: 'local'
[15:32:11.395]   - Field: 'owner'
[15:32:11.396]   - Field: 'envir'
[15:32:11.396]   - Field: 'workers'
[15:32:11.396]   - Field: 'packages'
[15:32:11.397]   - Field: 'gc'
[15:32:11.397]   - Field: 'conditions'
[15:32:11.397]   - Field: 'persistent'
[15:32:11.398]   - Field: 'expr'
[15:32:11.398]   - Field: 'uuid'
[15:32:11.399]   - Field: 'seed'
[15:32:11.399]   - Field: 'version'
[15:32:11.399]   - Field: 'result'
[15:32:11.400]   - Field: 'asynchronous'
[15:32:11.400]   - Field: 'calls'
[15:32:11.401]   - Field: 'globals'
[15:32:11.401]   - Field: 'stdout'
[15:32:11.401]   - Field: 'earlySignal'
[15:32:11.402]   - Field: 'lazy'
[15:32:11.402]   - Field: 'state'
[15:32:11.403] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.403] - Launch lazy future ...
[15:32:11.404] Packages needed by the future expression (n = 0): <none>
[15:32:11.404] Packages needed by future strategies (n = 0): <none>
[15:32:11.405] {
[15:32:11.405]     {
[15:32:11.405]         {
[15:32:11.405]             ...future.startTime <- base::Sys.time()
[15:32:11.405]             {
[15:32:11.405]                 {
[15:32:11.405]                   {
[15:32:11.405]                     {
[15:32:11.405]                       base::local({
[15:32:11.405]                         has_future <- base::requireNamespace("future", 
[15:32:11.405]                           quietly = TRUE)
[15:32:11.405]                         if (has_future) {
[15:32:11.405]                           ns <- base::getNamespace("future")
[15:32:11.405]                           version <- ns[[".package"]][["version"]]
[15:32:11.405]                           if (is.null(version)) 
[15:32:11.405]                             version <- utils::packageVersion("future")
[15:32:11.405]                         }
[15:32:11.405]                         else {
[15:32:11.405]                           version <- NULL
[15:32:11.405]                         }
[15:32:11.405]                         if (!has_future || version < "1.8.0") {
[15:32:11.405]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.405]                             "", base::R.version$version.string), 
[15:32:11.405]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.405]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.405]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.405]                               "release", "version")], collapse = " "), 
[15:32:11.405]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.405]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.405]                             info)
[15:32:11.405]                           info <- base::paste(info, collapse = "; ")
[15:32:11.405]                           if (!has_future) {
[15:32:11.405]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.405]                               info)
[15:32:11.405]                           }
[15:32:11.405]                           else {
[15:32:11.405]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.405]                               info, version)
[15:32:11.405]                           }
[15:32:11.405]                           base::stop(msg)
[15:32:11.405]                         }
[15:32:11.405]                       })
[15:32:11.405]                     }
[15:32:11.405]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.405]                     base::options(mc.cores = 1L)
[15:32:11.405]                   }
[15:32:11.405]                   ...future.strategy.old <- future::plan("list")
[15:32:11.405]                   options(future.plan = NULL)
[15:32:11.405]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.405]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.405]                 }
[15:32:11.405]                 ...future.workdir <- getwd()
[15:32:11.405]             }
[15:32:11.405]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.405]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.405]         }
[15:32:11.405]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.405]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:11.405]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.405]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.405]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.405]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.405]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.405]             base::names(...future.oldOptions))
[15:32:11.405]     }
[15:32:11.405]     if (FALSE) {
[15:32:11.405]     }
[15:32:11.405]     else {
[15:32:11.405]         if (TRUE) {
[15:32:11.405]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.405]                 open = "w")
[15:32:11.405]         }
[15:32:11.405]         else {
[15:32:11.405]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.405]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.405]         }
[15:32:11.405]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.405]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.405]             base::sink(type = "output", split = FALSE)
[15:32:11.405]             base::close(...future.stdout)
[15:32:11.405]         }, add = TRUE)
[15:32:11.405]     }
[15:32:11.405]     ...future.frame <- base::sys.nframe()
[15:32:11.405]     ...future.conditions <- base::list()
[15:32:11.405]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.405]     if (FALSE) {
[15:32:11.405]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.405]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.405]     }
[15:32:11.405]     ...future.result <- base::tryCatch({
[15:32:11.405]         base::withCallingHandlers({
[15:32:11.405]             ...future.value <- base::withVisible(base::local({
[15:32:11.405]                 ...future.makeSendCondition <- base::local({
[15:32:11.405]                   sendCondition <- NULL
[15:32:11.405]                   function(frame = 1L) {
[15:32:11.405]                     if (is.function(sendCondition)) 
[15:32:11.405]                       return(sendCondition)
[15:32:11.405]                     ns <- getNamespace("parallel")
[15:32:11.405]                     if (exists("sendData", mode = "function", 
[15:32:11.405]                       envir = ns)) {
[15:32:11.405]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.405]                         envir = ns)
[15:32:11.405]                       envir <- sys.frame(frame)
[15:32:11.405]                       master <- NULL
[15:32:11.405]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.405]                         !identical(envir, emptyenv())) {
[15:32:11.405]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.405]                           inherits = FALSE)) {
[15:32:11.405]                           master <- get("master", mode = "list", 
[15:32:11.405]                             envir = envir, inherits = FALSE)
[15:32:11.405]                           if (inherits(master, c("SOCKnode", 
[15:32:11.405]                             "SOCK0node"))) {
[15:32:11.405]                             sendCondition <<- function(cond) {
[15:32:11.405]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.405]                                 success = TRUE)
[15:32:11.405]                               parallel_sendData(master, data)
[15:32:11.405]                             }
[15:32:11.405]                             return(sendCondition)
[15:32:11.405]                           }
[15:32:11.405]                         }
[15:32:11.405]                         frame <- frame + 1L
[15:32:11.405]                         envir <- sys.frame(frame)
[15:32:11.405]                       }
[15:32:11.405]                     }
[15:32:11.405]                     sendCondition <<- function(cond) NULL
[15:32:11.405]                   }
[15:32:11.405]                 })
[15:32:11.405]                 withCallingHandlers({
[15:32:11.405]                   {
[15:32:11.405]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.405]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.405]                       ...future.globals.maxSize)) {
[15:32:11.405]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.405]                       on.exit(options(oopts), add = TRUE)
[15:32:11.405]                     }
[15:32:11.405]                     {
[15:32:11.405]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.405]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.405]                         USE.NAMES = FALSE)
[15:32:11.405]                       do.call(mapply, args = args)
[15:32:11.405]                     }
[15:32:11.405]                   }
[15:32:11.405]                 }, immediateCondition = function(cond) {
[15:32:11.405]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.405]                   sendCondition(cond)
[15:32:11.405]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.405]                   {
[15:32:11.405]                     inherits <- base::inherits
[15:32:11.405]                     invokeRestart <- base::invokeRestart
[15:32:11.405]                     is.null <- base::is.null
[15:32:11.405]                     muffled <- FALSE
[15:32:11.405]                     if (inherits(cond, "message")) {
[15:32:11.405]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.405]                       if (muffled) 
[15:32:11.405]                         invokeRestart("muffleMessage")
[15:32:11.405]                     }
[15:32:11.405]                     else if (inherits(cond, "warning")) {
[15:32:11.405]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.405]                       if (muffled) 
[15:32:11.405]                         invokeRestart("muffleWarning")
[15:32:11.405]                     }
[15:32:11.405]                     else if (inherits(cond, "condition")) {
[15:32:11.405]                       if (!is.null(pattern)) {
[15:32:11.405]                         computeRestarts <- base::computeRestarts
[15:32:11.405]                         grepl <- base::grepl
[15:32:11.405]                         restarts <- computeRestarts(cond)
[15:32:11.405]                         for (restart in restarts) {
[15:32:11.405]                           name <- restart$name
[15:32:11.405]                           if (is.null(name)) 
[15:32:11.405]                             next
[15:32:11.405]                           if (!grepl(pattern, name)) 
[15:32:11.405]                             next
[15:32:11.405]                           invokeRestart(restart)
[15:32:11.405]                           muffled <- TRUE
[15:32:11.405]                           break
[15:32:11.405]                         }
[15:32:11.405]                       }
[15:32:11.405]                     }
[15:32:11.405]                     invisible(muffled)
[15:32:11.405]                   }
[15:32:11.405]                   muffleCondition(cond)
[15:32:11.405]                 })
[15:32:11.405]             }))
[15:32:11.405]             future::FutureResult(value = ...future.value$value, 
[15:32:11.405]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.405]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.405]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.405]                     ...future.globalenv.names))
[15:32:11.405]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.405]         }, condition = base::local({
[15:32:11.405]             c <- base::c
[15:32:11.405]             inherits <- base::inherits
[15:32:11.405]             invokeRestart <- base::invokeRestart
[15:32:11.405]             length <- base::length
[15:32:11.405]             list <- base::list
[15:32:11.405]             seq.int <- base::seq.int
[15:32:11.405]             signalCondition <- base::signalCondition
[15:32:11.405]             sys.calls <- base::sys.calls
[15:32:11.405]             `[[` <- base::`[[`
[15:32:11.405]             `+` <- base::`+`
[15:32:11.405]             `<<-` <- base::`<<-`
[15:32:11.405]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.405]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.405]                   3L)]
[15:32:11.405]             }
[15:32:11.405]             function(cond) {
[15:32:11.405]                 is_error <- inherits(cond, "error")
[15:32:11.405]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.405]                   NULL)
[15:32:11.405]                 if (is_error) {
[15:32:11.405]                   sessionInformation <- function() {
[15:32:11.405]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.405]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.405]                       search = base::search(), system = base::Sys.info())
[15:32:11.405]                   }
[15:32:11.405]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.405]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.405]                     cond$call), session = sessionInformation(), 
[15:32:11.405]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.405]                   signalCondition(cond)
[15:32:11.405]                 }
[15:32:11.405]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.405]                 "immediateCondition"))) {
[15:32:11.405]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.405]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.405]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.405]                   if (TRUE && !signal) {
[15:32:11.405]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.405]                     {
[15:32:11.405]                       inherits <- base::inherits
[15:32:11.405]                       invokeRestart <- base::invokeRestart
[15:32:11.405]                       is.null <- base::is.null
[15:32:11.405]                       muffled <- FALSE
[15:32:11.405]                       if (inherits(cond, "message")) {
[15:32:11.405]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.405]                         if (muffled) 
[15:32:11.405]                           invokeRestart("muffleMessage")
[15:32:11.405]                       }
[15:32:11.405]                       else if (inherits(cond, "warning")) {
[15:32:11.405]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.405]                         if (muffled) 
[15:32:11.405]                           invokeRestart("muffleWarning")
[15:32:11.405]                       }
[15:32:11.405]                       else if (inherits(cond, "condition")) {
[15:32:11.405]                         if (!is.null(pattern)) {
[15:32:11.405]                           computeRestarts <- base::computeRestarts
[15:32:11.405]                           grepl <- base::grepl
[15:32:11.405]                           restarts <- computeRestarts(cond)
[15:32:11.405]                           for (restart in restarts) {
[15:32:11.405]                             name <- restart$name
[15:32:11.405]                             if (is.null(name)) 
[15:32:11.405]                               next
[15:32:11.405]                             if (!grepl(pattern, name)) 
[15:32:11.405]                               next
[15:32:11.405]                             invokeRestart(restart)
[15:32:11.405]                             muffled <- TRUE
[15:32:11.405]                             break
[15:32:11.405]                           }
[15:32:11.405]                         }
[15:32:11.405]                       }
[15:32:11.405]                       invisible(muffled)
[15:32:11.405]                     }
[15:32:11.405]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.405]                   }
[15:32:11.405]                 }
[15:32:11.405]                 else {
[15:32:11.405]                   if (TRUE) {
[15:32:11.405]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.405]                     {
[15:32:11.405]                       inherits <- base::inherits
[15:32:11.405]                       invokeRestart <- base::invokeRestart
[15:32:11.405]                       is.null <- base::is.null
[15:32:11.405]                       muffled <- FALSE
[15:32:11.405]                       if (inherits(cond, "message")) {
[15:32:11.405]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.405]                         if (muffled) 
[15:32:11.405]                           invokeRestart("muffleMessage")
[15:32:11.405]                       }
[15:32:11.405]                       else if (inherits(cond, "warning")) {
[15:32:11.405]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.405]                         if (muffled) 
[15:32:11.405]                           invokeRestart("muffleWarning")
[15:32:11.405]                       }
[15:32:11.405]                       else if (inherits(cond, "condition")) {
[15:32:11.405]                         if (!is.null(pattern)) {
[15:32:11.405]                           computeRestarts <- base::computeRestarts
[15:32:11.405]                           grepl <- base::grepl
[15:32:11.405]                           restarts <- computeRestarts(cond)
[15:32:11.405]                           for (restart in restarts) {
[15:32:11.405]                             name <- restart$name
[15:32:11.405]                             if (is.null(name)) 
[15:32:11.405]                               next
[15:32:11.405]                             if (!grepl(pattern, name)) 
[15:32:11.405]                               next
[15:32:11.405]                             invokeRestart(restart)
[15:32:11.405]                             muffled <- TRUE
[15:32:11.405]                             break
[15:32:11.405]                           }
[15:32:11.405]                         }
[15:32:11.405]                       }
[15:32:11.405]                       invisible(muffled)
[15:32:11.405]                     }
[15:32:11.405]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.405]                   }
[15:32:11.405]                 }
[15:32:11.405]             }
[15:32:11.405]         }))
[15:32:11.405]     }, error = function(ex) {
[15:32:11.405]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.405]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.405]                 ...future.rng), started = ...future.startTime, 
[15:32:11.405]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.405]             version = "1.8"), class = "FutureResult")
[15:32:11.405]     }, finally = {
[15:32:11.405]         if (!identical(...future.workdir, getwd())) 
[15:32:11.405]             setwd(...future.workdir)
[15:32:11.405]         {
[15:32:11.405]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.405]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.405]             }
[15:32:11.405]             base::options(...future.oldOptions)
[15:32:11.405]             if (.Platform$OS.type == "windows") {
[15:32:11.405]                 old_names <- names(...future.oldEnvVars)
[15:32:11.405]                 envs <- base::Sys.getenv()
[15:32:11.405]                 names <- names(envs)
[15:32:11.405]                 common <- intersect(names, old_names)
[15:32:11.405]                 added <- setdiff(names, old_names)
[15:32:11.405]                 removed <- setdiff(old_names, names)
[15:32:11.405]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.405]                   envs[common]]
[15:32:11.405]                 NAMES <- toupper(changed)
[15:32:11.405]                 args <- list()
[15:32:11.405]                 for (kk in seq_along(NAMES)) {
[15:32:11.405]                   name <- changed[[kk]]
[15:32:11.405]                   NAME <- NAMES[[kk]]
[15:32:11.405]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.405]                     next
[15:32:11.405]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.405]                 }
[15:32:11.405]                 NAMES <- toupper(added)
[15:32:11.405]                 for (kk in seq_along(NAMES)) {
[15:32:11.405]                   name <- added[[kk]]
[15:32:11.405]                   NAME <- NAMES[[kk]]
[15:32:11.405]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.405]                     next
[15:32:11.405]                   args[[name]] <- ""
[15:32:11.405]                 }
[15:32:11.405]                 NAMES <- toupper(removed)
[15:32:11.405]                 for (kk in seq_along(NAMES)) {
[15:32:11.405]                   name <- removed[[kk]]
[15:32:11.405]                   NAME <- NAMES[[kk]]
[15:32:11.405]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.405]                     next
[15:32:11.405]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.405]                 }
[15:32:11.405]                 if (length(args) > 0) 
[15:32:11.405]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.405]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.405]             }
[15:32:11.405]             else {
[15:32:11.405]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.405]             }
[15:32:11.405]             {
[15:32:11.405]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.405]                   0L) {
[15:32:11.405]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.405]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.405]                   base::options(opts)
[15:32:11.405]                 }
[15:32:11.405]                 {
[15:32:11.405]                   {
[15:32:11.405]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.405]                     NULL
[15:32:11.405]                   }
[15:32:11.405]                   options(future.plan = NULL)
[15:32:11.405]                   if (is.na(NA_character_)) 
[15:32:11.405]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.405]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.405]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.405]                     .init = FALSE)
[15:32:11.405]                 }
[15:32:11.405]             }
[15:32:11.405]         }
[15:32:11.405]     })
[15:32:11.405]     if (TRUE) {
[15:32:11.405]         base::sink(type = "output", split = FALSE)
[15:32:11.405]         if (TRUE) {
[15:32:11.405]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.405]         }
[15:32:11.405]         else {
[15:32:11.405]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.405]         }
[15:32:11.405]         base::close(...future.stdout)
[15:32:11.405]         ...future.stdout <- NULL
[15:32:11.405]     }
[15:32:11.405]     ...future.result$conditions <- ...future.conditions
[15:32:11.405]     ...future.result$finished <- base::Sys.time()
[15:32:11.405]     ...future.result
[15:32:11.405] }
[15:32:11.415] Exporting 5 global objects (3.41 KiB) to cluster node #1 ...
[15:32:11.415] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.416] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.417] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.417] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.418] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:11.418] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:11.419] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.419] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.420] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.420] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.421] Exporting 5 global objects (3.41 KiB) to cluster node #1 ... DONE
[15:32:11.422] MultisessionFuture started
[15:32:11.422] - Launch lazy future ... done
[15:32:11.422] run() for 'MultisessionFuture' ... done
[15:32:11.423] Created future:
[15:32:11.450] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.450] - Validating connection of MultisessionFuture
[15:32:11.451] - received message: FutureResult
[15:32:11.451] - Received FutureResult
[15:32:11.451] - Erased future from FutureRegistry
[15:32:11.451] result() for ClusterFuture ...
[15:32:11.451] - result already collected: FutureResult
[15:32:11.452] result() for ClusterFuture ... done
[15:32:11.452] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.423] MultisessionFuture:
[15:32:11.423] Label: 'future_mapply-2'
[15:32:11.423] Expression:
[15:32:11.423] {
[15:32:11.423]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.423]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.423]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.423]         on.exit(options(oopts), add = TRUE)
[15:32:11.423]     }
[15:32:11.423]     {
[15:32:11.423]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.423]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.423]         do.call(mapply, args = args)
[15:32:11.423]     }
[15:32:11.423] }
[15:32:11.423] Lazy evaluation: FALSE
[15:32:11.423] Asynchronous evaluation: TRUE
[15:32:11.423] Local evaluation: TRUE
[15:32:11.423] Environment: R_GlobalEnv
[15:32:11.423] Capture standard output: TRUE
[15:32:11.423] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.423] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.423] Packages: <none>
[15:32:11.423] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.423] Resolved: TRUE
[15:32:11.423] Value: <not collected>
[15:32:11.423] Conditions captured: <none>
[15:32:11.423] Early signaling: FALSE
[15:32:11.423] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.423] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.452] Chunk #2 of 5 ... DONE
[15:32:11.453] Chunk #3 of 5 ...
[15:32:11.453]  - Finding globals in '...' for chunk #3 ...
[15:32:11.453] getGlobalsAndPackages() ...
[15:32:11.454] Searching for globals...
[15:32:11.454] 
[15:32:11.455] Searching for globals ... DONE
[15:32:11.455] - globals: [0] <none>
[15:32:11.455] getGlobalsAndPackages() ... DONE
[15:32:11.455]    + additional globals found: [n=0] 
[15:32:11.456]    + additional namespaces needed: [n=0] 
[15:32:11.456]  - Finding globals in '...' for chunk #3 ... DONE
[15:32:11.456]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:11.456]  - seeds: <none>
[15:32:11.456]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.457] getGlobalsAndPackages() ...
[15:32:11.457] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.457] Resolving globals: FALSE
[15:32:11.458] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:11.459] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:11.459] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.459] 
[15:32:11.460] getGlobalsAndPackages() ... DONE
[15:32:11.460] run() for 'Future' ...
[15:32:11.460] - state: 'created'
[15:32:11.461] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.481] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.481] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.482]   - Field: 'node'
[15:32:11.482]   - Field: 'label'
[15:32:11.483]   - Field: 'local'
[15:32:11.483]   - Field: 'owner'
[15:32:11.483]   - Field: 'envir'
[15:32:11.484]   - Field: 'workers'
[15:32:11.484]   - Field: 'packages'
[15:32:11.484]   - Field: 'gc'
[15:32:11.485]   - Field: 'conditions'
[15:32:11.485]   - Field: 'persistent'
[15:32:11.485]   - Field: 'expr'
[15:32:11.486]   - Field: 'uuid'
[15:32:11.486]   - Field: 'seed'
[15:32:11.486]   - Field: 'version'
[15:32:11.487]   - Field: 'result'
[15:32:11.487]   - Field: 'asynchronous'
[15:32:11.487]   - Field: 'calls'
[15:32:11.488]   - Field: 'globals'
[15:32:11.488]   - Field: 'stdout'
[15:32:11.488]   - Field: 'earlySignal'
[15:32:11.489]   - Field: 'lazy'
[15:32:11.489]   - Field: 'state'
[15:32:11.489] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.489] - Launch lazy future ...
[15:32:11.490] Packages needed by the future expression (n = 0): <none>
[15:32:11.491] Packages needed by future strategies (n = 0): <none>
[15:32:11.492] {
[15:32:11.492]     {
[15:32:11.492]         {
[15:32:11.492]             ...future.startTime <- base::Sys.time()
[15:32:11.492]             {
[15:32:11.492]                 {
[15:32:11.492]                   {
[15:32:11.492]                     {
[15:32:11.492]                       base::local({
[15:32:11.492]                         has_future <- base::requireNamespace("future", 
[15:32:11.492]                           quietly = TRUE)
[15:32:11.492]                         if (has_future) {
[15:32:11.492]                           ns <- base::getNamespace("future")
[15:32:11.492]                           version <- ns[[".package"]][["version"]]
[15:32:11.492]                           if (is.null(version)) 
[15:32:11.492]                             version <- utils::packageVersion("future")
[15:32:11.492]                         }
[15:32:11.492]                         else {
[15:32:11.492]                           version <- NULL
[15:32:11.492]                         }
[15:32:11.492]                         if (!has_future || version < "1.8.0") {
[15:32:11.492]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.492]                             "", base::R.version$version.string), 
[15:32:11.492]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.492]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.492]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.492]                               "release", "version")], collapse = " "), 
[15:32:11.492]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.492]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.492]                             info)
[15:32:11.492]                           info <- base::paste(info, collapse = "; ")
[15:32:11.492]                           if (!has_future) {
[15:32:11.492]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.492]                               info)
[15:32:11.492]                           }
[15:32:11.492]                           else {
[15:32:11.492]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.492]                               info, version)
[15:32:11.492]                           }
[15:32:11.492]                           base::stop(msg)
[15:32:11.492]                         }
[15:32:11.492]                       })
[15:32:11.492]                     }
[15:32:11.492]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.492]                     base::options(mc.cores = 1L)
[15:32:11.492]                   }
[15:32:11.492]                   ...future.strategy.old <- future::plan("list")
[15:32:11.492]                   options(future.plan = NULL)
[15:32:11.492]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.492]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.492]                 }
[15:32:11.492]                 ...future.workdir <- getwd()
[15:32:11.492]             }
[15:32:11.492]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.492]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.492]         }
[15:32:11.492]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.492]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:11.492]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.492]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.492]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.492]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.492]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.492]             base::names(...future.oldOptions))
[15:32:11.492]     }
[15:32:11.492]     if (FALSE) {
[15:32:11.492]     }
[15:32:11.492]     else {
[15:32:11.492]         if (TRUE) {
[15:32:11.492]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.492]                 open = "w")
[15:32:11.492]         }
[15:32:11.492]         else {
[15:32:11.492]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.492]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.492]         }
[15:32:11.492]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.492]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.492]             base::sink(type = "output", split = FALSE)
[15:32:11.492]             base::close(...future.stdout)
[15:32:11.492]         }, add = TRUE)
[15:32:11.492]     }
[15:32:11.492]     ...future.frame <- base::sys.nframe()
[15:32:11.492]     ...future.conditions <- base::list()
[15:32:11.492]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.492]     if (FALSE) {
[15:32:11.492]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.492]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.492]     }
[15:32:11.492]     ...future.result <- base::tryCatch({
[15:32:11.492]         base::withCallingHandlers({
[15:32:11.492]             ...future.value <- base::withVisible(base::local({
[15:32:11.492]                 ...future.makeSendCondition <- base::local({
[15:32:11.492]                   sendCondition <- NULL
[15:32:11.492]                   function(frame = 1L) {
[15:32:11.492]                     if (is.function(sendCondition)) 
[15:32:11.492]                       return(sendCondition)
[15:32:11.492]                     ns <- getNamespace("parallel")
[15:32:11.492]                     if (exists("sendData", mode = "function", 
[15:32:11.492]                       envir = ns)) {
[15:32:11.492]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.492]                         envir = ns)
[15:32:11.492]                       envir <- sys.frame(frame)
[15:32:11.492]                       master <- NULL
[15:32:11.492]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.492]                         !identical(envir, emptyenv())) {
[15:32:11.492]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.492]                           inherits = FALSE)) {
[15:32:11.492]                           master <- get("master", mode = "list", 
[15:32:11.492]                             envir = envir, inherits = FALSE)
[15:32:11.492]                           if (inherits(master, c("SOCKnode", 
[15:32:11.492]                             "SOCK0node"))) {
[15:32:11.492]                             sendCondition <<- function(cond) {
[15:32:11.492]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.492]                                 success = TRUE)
[15:32:11.492]                               parallel_sendData(master, data)
[15:32:11.492]                             }
[15:32:11.492]                             return(sendCondition)
[15:32:11.492]                           }
[15:32:11.492]                         }
[15:32:11.492]                         frame <- frame + 1L
[15:32:11.492]                         envir <- sys.frame(frame)
[15:32:11.492]                       }
[15:32:11.492]                     }
[15:32:11.492]                     sendCondition <<- function(cond) NULL
[15:32:11.492]                   }
[15:32:11.492]                 })
[15:32:11.492]                 withCallingHandlers({
[15:32:11.492]                   {
[15:32:11.492]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.492]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.492]                       ...future.globals.maxSize)) {
[15:32:11.492]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.492]                       on.exit(options(oopts), add = TRUE)
[15:32:11.492]                     }
[15:32:11.492]                     {
[15:32:11.492]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.492]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.492]                         USE.NAMES = FALSE)
[15:32:11.492]                       do.call(mapply, args = args)
[15:32:11.492]                     }
[15:32:11.492]                   }
[15:32:11.492]                 }, immediateCondition = function(cond) {
[15:32:11.492]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.492]                   sendCondition(cond)
[15:32:11.492]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.492]                   {
[15:32:11.492]                     inherits <- base::inherits
[15:32:11.492]                     invokeRestart <- base::invokeRestart
[15:32:11.492]                     is.null <- base::is.null
[15:32:11.492]                     muffled <- FALSE
[15:32:11.492]                     if (inherits(cond, "message")) {
[15:32:11.492]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.492]                       if (muffled) 
[15:32:11.492]                         invokeRestart("muffleMessage")
[15:32:11.492]                     }
[15:32:11.492]                     else if (inherits(cond, "warning")) {
[15:32:11.492]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.492]                       if (muffled) 
[15:32:11.492]                         invokeRestart("muffleWarning")
[15:32:11.492]                     }
[15:32:11.492]                     else if (inherits(cond, "condition")) {
[15:32:11.492]                       if (!is.null(pattern)) {
[15:32:11.492]                         computeRestarts <- base::computeRestarts
[15:32:11.492]                         grepl <- base::grepl
[15:32:11.492]                         restarts <- computeRestarts(cond)
[15:32:11.492]                         for (restart in restarts) {
[15:32:11.492]                           name <- restart$name
[15:32:11.492]                           if (is.null(name)) 
[15:32:11.492]                             next
[15:32:11.492]                           if (!grepl(pattern, name)) 
[15:32:11.492]                             next
[15:32:11.492]                           invokeRestart(restart)
[15:32:11.492]                           muffled <- TRUE
[15:32:11.492]                           break
[15:32:11.492]                         }
[15:32:11.492]                       }
[15:32:11.492]                     }
[15:32:11.492]                     invisible(muffled)
[15:32:11.492]                   }
[15:32:11.492]                   muffleCondition(cond)
[15:32:11.492]                 })
[15:32:11.492]             }))
[15:32:11.492]             future::FutureResult(value = ...future.value$value, 
[15:32:11.492]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.492]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.492]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.492]                     ...future.globalenv.names))
[15:32:11.492]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.492]         }, condition = base::local({
[15:32:11.492]             c <- base::c
[15:32:11.492]             inherits <- base::inherits
[15:32:11.492]             invokeRestart <- base::invokeRestart
[15:32:11.492]             length <- base::length
[15:32:11.492]             list <- base::list
[15:32:11.492]             seq.int <- base::seq.int
[15:32:11.492]             signalCondition <- base::signalCondition
[15:32:11.492]             sys.calls <- base::sys.calls
[15:32:11.492]             `[[` <- base::`[[`
[15:32:11.492]             `+` <- base::`+`
[15:32:11.492]             `<<-` <- base::`<<-`
[15:32:11.492]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.492]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.492]                   3L)]
[15:32:11.492]             }
[15:32:11.492]             function(cond) {
[15:32:11.492]                 is_error <- inherits(cond, "error")
[15:32:11.492]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.492]                   NULL)
[15:32:11.492]                 if (is_error) {
[15:32:11.492]                   sessionInformation <- function() {
[15:32:11.492]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.492]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.492]                       search = base::search(), system = base::Sys.info())
[15:32:11.492]                   }
[15:32:11.492]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.492]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.492]                     cond$call), session = sessionInformation(), 
[15:32:11.492]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.492]                   signalCondition(cond)
[15:32:11.492]                 }
[15:32:11.492]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.492]                 "immediateCondition"))) {
[15:32:11.492]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.492]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.492]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.492]                   if (TRUE && !signal) {
[15:32:11.492]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.492]                     {
[15:32:11.492]                       inherits <- base::inherits
[15:32:11.492]                       invokeRestart <- base::invokeRestart
[15:32:11.492]                       is.null <- base::is.null
[15:32:11.492]                       muffled <- FALSE
[15:32:11.492]                       if (inherits(cond, "message")) {
[15:32:11.492]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.492]                         if (muffled) 
[15:32:11.492]                           invokeRestart("muffleMessage")
[15:32:11.492]                       }
[15:32:11.492]                       else if (inherits(cond, "warning")) {
[15:32:11.492]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.492]                         if (muffled) 
[15:32:11.492]                           invokeRestart("muffleWarning")
[15:32:11.492]                       }
[15:32:11.492]                       else if (inherits(cond, "condition")) {
[15:32:11.492]                         if (!is.null(pattern)) {
[15:32:11.492]                           computeRestarts <- base::computeRestarts
[15:32:11.492]                           grepl <- base::grepl
[15:32:11.492]                           restarts <- computeRestarts(cond)
[15:32:11.492]                           for (restart in restarts) {
[15:32:11.492]                             name <- restart$name
[15:32:11.492]                             if (is.null(name)) 
[15:32:11.492]                               next
[15:32:11.492]                             if (!grepl(pattern, name)) 
[15:32:11.492]                               next
[15:32:11.492]                             invokeRestart(restart)
[15:32:11.492]                             muffled <- TRUE
[15:32:11.492]                             break
[15:32:11.492]                           }
[15:32:11.492]                         }
[15:32:11.492]                       }
[15:32:11.492]                       invisible(muffled)
[15:32:11.492]                     }
[15:32:11.492]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.492]                   }
[15:32:11.492]                 }
[15:32:11.492]                 else {
[15:32:11.492]                   if (TRUE) {
[15:32:11.492]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.492]                     {
[15:32:11.492]                       inherits <- base::inherits
[15:32:11.492]                       invokeRestart <- base::invokeRestart
[15:32:11.492]                       is.null <- base::is.null
[15:32:11.492]                       muffled <- FALSE
[15:32:11.492]                       if (inherits(cond, "message")) {
[15:32:11.492]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.492]                         if (muffled) 
[15:32:11.492]                           invokeRestart("muffleMessage")
[15:32:11.492]                       }
[15:32:11.492]                       else if (inherits(cond, "warning")) {
[15:32:11.492]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.492]                         if (muffled) 
[15:32:11.492]                           invokeRestart("muffleWarning")
[15:32:11.492]                       }
[15:32:11.492]                       else if (inherits(cond, "condition")) {
[15:32:11.492]                         if (!is.null(pattern)) {
[15:32:11.492]                           computeRestarts <- base::computeRestarts
[15:32:11.492]                           grepl <- base::grepl
[15:32:11.492]                           restarts <- computeRestarts(cond)
[15:32:11.492]                           for (restart in restarts) {
[15:32:11.492]                             name <- restart$name
[15:32:11.492]                             if (is.null(name)) 
[15:32:11.492]                               next
[15:32:11.492]                             if (!grepl(pattern, name)) 
[15:32:11.492]                               next
[15:32:11.492]                             invokeRestart(restart)
[15:32:11.492]                             muffled <- TRUE
[15:32:11.492]                             break
[15:32:11.492]                           }
[15:32:11.492]                         }
[15:32:11.492]                       }
[15:32:11.492]                       invisible(muffled)
[15:32:11.492]                     }
[15:32:11.492]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.492]                   }
[15:32:11.492]                 }
[15:32:11.492]             }
[15:32:11.492]         }))
[15:32:11.492]     }, error = function(ex) {
[15:32:11.492]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.492]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.492]                 ...future.rng), started = ...future.startTime, 
[15:32:11.492]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.492]             version = "1.8"), class = "FutureResult")
[15:32:11.492]     }, finally = {
[15:32:11.492]         if (!identical(...future.workdir, getwd())) 
[15:32:11.492]             setwd(...future.workdir)
[15:32:11.492]         {
[15:32:11.492]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.492]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.492]             }
[15:32:11.492]             base::options(...future.oldOptions)
[15:32:11.492]             if (.Platform$OS.type == "windows") {
[15:32:11.492]                 old_names <- names(...future.oldEnvVars)
[15:32:11.492]                 envs <- base::Sys.getenv()
[15:32:11.492]                 names <- names(envs)
[15:32:11.492]                 common <- intersect(names, old_names)
[15:32:11.492]                 added <- setdiff(names, old_names)
[15:32:11.492]                 removed <- setdiff(old_names, names)
[15:32:11.492]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.492]                   envs[common]]
[15:32:11.492]                 NAMES <- toupper(changed)
[15:32:11.492]                 args <- list()
[15:32:11.492]                 for (kk in seq_along(NAMES)) {
[15:32:11.492]                   name <- changed[[kk]]
[15:32:11.492]                   NAME <- NAMES[[kk]]
[15:32:11.492]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.492]                     next
[15:32:11.492]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.492]                 }
[15:32:11.492]                 NAMES <- toupper(added)
[15:32:11.492]                 for (kk in seq_along(NAMES)) {
[15:32:11.492]                   name <- added[[kk]]
[15:32:11.492]                   NAME <- NAMES[[kk]]
[15:32:11.492]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.492]                     next
[15:32:11.492]                   args[[name]] <- ""
[15:32:11.492]                 }
[15:32:11.492]                 NAMES <- toupper(removed)
[15:32:11.492]                 for (kk in seq_along(NAMES)) {
[15:32:11.492]                   name <- removed[[kk]]
[15:32:11.492]                   NAME <- NAMES[[kk]]
[15:32:11.492]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.492]                     next
[15:32:11.492]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.492]                 }
[15:32:11.492]                 if (length(args) > 0) 
[15:32:11.492]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.492]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.492]             }
[15:32:11.492]             else {
[15:32:11.492]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.492]             }
[15:32:11.492]             {
[15:32:11.492]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.492]                   0L) {
[15:32:11.492]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.492]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.492]                   base::options(opts)
[15:32:11.492]                 }
[15:32:11.492]                 {
[15:32:11.492]                   {
[15:32:11.492]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.492]                     NULL
[15:32:11.492]                   }
[15:32:11.492]                   options(future.plan = NULL)
[15:32:11.492]                   if (is.na(NA_character_)) 
[15:32:11.492]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.492]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.492]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.492]                     .init = FALSE)
[15:32:11.492]                 }
[15:32:11.492]             }
[15:32:11.492]         }
[15:32:11.492]     })
[15:32:11.492]     if (TRUE) {
[15:32:11.492]         base::sink(type = "output", split = FALSE)
[15:32:11.492]         if (TRUE) {
[15:32:11.492]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.492]         }
[15:32:11.492]         else {
[15:32:11.492]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.492]         }
[15:32:11.492]         base::close(...future.stdout)
[15:32:11.492]         ...future.stdout <- NULL
[15:32:11.492]     }
[15:32:11.492]     ...future.result$conditions <- ...future.conditions
[15:32:11.492]     ...future.result$finished <- base::Sys.time()
[15:32:11.492]     ...future.result
[15:32:11.492] }
[15:32:11.503] Exporting 5 global objects (3.41 KiB) to cluster node #1 ...
[15:32:11.503] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.504] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.504] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.505] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.505] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:11.505] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:11.506] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.506] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.507] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.507] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.508] Exporting 5 global objects (3.41 KiB) to cluster node #1 ... DONE
[15:32:11.509] MultisessionFuture started
[15:32:11.509] - Launch lazy future ... done
[15:32:11.510] run() for 'MultisessionFuture' ... done
[15:32:11.510] Created future:
[15:32:11.527] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.527] - Validating connection of MultisessionFuture
[15:32:11.528] - received message: FutureResult
[15:32:11.528] - Received FutureResult
[15:32:11.528] - Erased future from FutureRegistry
[15:32:11.528] result() for ClusterFuture ...
[15:32:11.529] - result already collected: FutureResult
[15:32:11.529] result() for ClusterFuture ... done
[15:32:11.529] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.511] MultisessionFuture:
[15:32:11.511] Label: 'future_mapply-3'
[15:32:11.511] Expression:
[15:32:11.511] {
[15:32:11.511]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.511]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.511]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.511]         on.exit(options(oopts), add = TRUE)
[15:32:11.511]     }
[15:32:11.511]     {
[15:32:11.511]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.511]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.511]         do.call(mapply, args = args)
[15:32:11.511]     }
[15:32:11.511] }
[15:32:11.511] Lazy evaluation: FALSE
[15:32:11.511] Asynchronous evaluation: TRUE
[15:32:11.511] Local evaluation: TRUE
[15:32:11.511] Environment: R_GlobalEnv
[15:32:11.511] Capture standard output: TRUE
[15:32:11.511] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.511] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.511] Packages: <none>
[15:32:11.511] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.511] Resolved: TRUE
[15:32:11.511] Value: <not collected>
[15:32:11.511] Conditions captured: <none>
[15:32:11.511] Early signaling: FALSE
[15:32:11.511] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.511] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.529] Chunk #3 of 5 ... DONE
[15:32:11.530] Chunk #4 of 5 ...
[15:32:11.530]  - Finding globals in '...' for chunk #4 ...
[15:32:11.530] getGlobalsAndPackages() ...
[15:32:11.530] Searching for globals...
[15:32:11.531] 
[15:32:11.531] Searching for globals ... DONE
[15:32:11.531] - globals: [0] <none>
[15:32:11.531] getGlobalsAndPackages() ... DONE
[15:32:11.532]    + additional globals found: [n=0] 
[15:32:11.532]    + additional namespaces needed: [n=0] 
[15:32:11.532]  - Finding globals in '...' for chunk #4 ... DONE
[15:32:11.532]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:11.532]  - seeds: <none>
[15:32:11.533]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.533] getGlobalsAndPackages() ...
[15:32:11.533] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.533] Resolving globals: FALSE
[15:32:11.534] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:11.535] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:11.535] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.535] 
[15:32:11.535] getGlobalsAndPackages() ... DONE
[15:32:11.536] run() for 'Future' ...
[15:32:11.536] - state: 'created'
[15:32:11.536] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.550] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.551] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.551]   - Field: 'node'
[15:32:11.551]   - Field: 'label'
[15:32:11.551]   - Field: 'local'
[15:32:11.552]   - Field: 'owner'
[15:32:11.552]   - Field: 'envir'
[15:32:11.552]   - Field: 'workers'
[15:32:11.552]   - Field: 'packages'
[15:32:11.553]   - Field: 'gc'
[15:32:11.553]   - Field: 'conditions'
[15:32:11.553]   - Field: 'persistent'
[15:32:11.553]   - Field: 'expr'
[15:32:11.553]   - Field: 'uuid'
[15:32:11.553]   - Field: 'seed'
[15:32:11.554]   - Field: 'version'
[15:32:11.554]   - Field: 'result'
[15:32:11.554]   - Field: 'asynchronous'
[15:32:11.554]   - Field: 'calls'
[15:32:11.554]   - Field: 'globals'
[15:32:11.554]   - Field: 'stdout'
[15:32:11.555]   - Field: 'earlySignal'
[15:32:11.555]   - Field: 'lazy'
[15:32:11.555]   - Field: 'state'
[15:32:11.555] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.555] - Launch lazy future ...
[15:32:11.556] Packages needed by the future expression (n = 0): <none>
[15:32:11.556] Packages needed by future strategies (n = 0): <none>
[15:32:11.557] {
[15:32:11.557]     {
[15:32:11.557]         {
[15:32:11.557]             ...future.startTime <- base::Sys.time()
[15:32:11.557]             {
[15:32:11.557]                 {
[15:32:11.557]                   {
[15:32:11.557]                     {
[15:32:11.557]                       base::local({
[15:32:11.557]                         has_future <- base::requireNamespace("future", 
[15:32:11.557]                           quietly = TRUE)
[15:32:11.557]                         if (has_future) {
[15:32:11.557]                           ns <- base::getNamespace("future")
[15:32:11.557]                           version <- ns[[".package"]][["version"]]
[15:32:11.557]                           if (is.null(version)) 
[15:32:11.557]                             version <- utils::packageVersion("future")
[15:32:11.557]                         }
[15:32:11.557]                         else {
[15:32:11.557]                           version <- NULL
[15:32:11.557]                         }
[15:32:11.557]                         if (!has_future || version < "1.8.0") {
[15:32:11.557]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.557]                             "", base::R.version$version.string), 
[15:32:11.557]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.557]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.557]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.557]                               "release", "version")], collapse = " "), 
[15:32:11.557]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.557]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.557]                             info)
[15:32:11.557]                           info <- base::paste(info, collapse = "; ")
[15:32:11.557]                           if (!has_future) {
[15:32:11.557]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.557]                               info)
[15:32:11.557]                           }
[15:32:11.557]                           else {
[15:32:11.557]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.557]                               info, version)
[15:32:11.557]                           }
[15:32:11.557]                           base::stop(msg)
[15:32:11.557]                         }
[15:32:11.557]                       })
[15:32:11.557]                     }
[15:32:11.557]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.557]                     base::options(mc.cores = 1L)
[15:32:11.557]                   }
[15:32:11.557]                   ...future.strategy.old <- future::plan("list")
[15:32:11.557]                   options(future.plan = NULL)
[15:32:11.557]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.557]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.557]                 }
[15:32:11.557]                 ...future.workdir <- getwd()
[15:32:11.557]             }
[15:32:11.557]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.557]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.557]         }
[15:32:11.557]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.557]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:11.557]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.557]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.557]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.557]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.557]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.557]             base::names(...future.oldOptions))
[15:32:11.557]     }
[15:32:11.557]     if (FALSE) {
[15:32:11.557]     }
[15:32:11.557]     else {
[15:32:11.557]         if (TRUE) {
[15:32:11.557]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.557]                 open = "w")
[15:32:11.557]         }
[15:32:11.557]         else {
[15:32:11.557]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.557]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.557]         }
[15:32:11.557]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.557]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.557]             base::sink(type = "output", split = FALSE)
[15:32:11.557]             base::close(...future.stdout)
[15:32:11.557]         }, add = TRUE)
[15:32:11.557]     }
[15:32:11.557]     ...future.frame <- base::sys.nframe()
[15:32:11.557]     ...future.conditions <- base::list()
[15:32:11.557]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.557]     if (FALSE) {
[15:32:11.557]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.557]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.557]     }
[15:32:11.557]     ...future.result <- base::tryCatch({
[15:32:11.557]         base::withCallingHandlers({
[15:32:11.557]             ...future.value <- base::withVisible(base::local({
[15:32:11.557]                 ...future.makeSendCondition <- base::local({
[15:32:11.557]                   sendCondition <- NULL
[15:32:11.557]                   function(frame = 1L) {
[15:32:11.557]                     if (is.function(sendCondition)) 
[15:32:11.557]                       return(sendCondition)
[15:32:11.557]                     ns <- getNamespace("parallel")
[15:32:11.557]                     if (exists("sendData", mode = "function", 
[15:32:11.557]                       envir = ns)) {
[15:32:11.557]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.557]                         envir = ns)
[15:32:11.557]                       envir <- sys.frame(frame)
[15:32:11.557]                       master <- NULL
[15:32:11.557]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.557]                         !identical(envir, emptyenv())) {
[15:32:11.557]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.557]                           inherits = FALSE)) {
[15:32:11.557]                           master <- get("master", mode = "list", 
[15:32:11.557]                             envir = envir, inherits = FALSE)
[15:32:11.557]                           if (inherits(master, c("SOCKnode", 
[15:32:11.557]                             "SOCK0node"))) {
[15:32:11.557]                             sendCondition <<- function(cond) {
[15:32:11.557]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.557]                                 success = TRUE)
[15:32:11.557]                               parallel_sendData(master, data)
[15:32:11.557]                             }
[15:32:11.557]                             return(sendCondition)
[15:32:11.557]                           }
[15:32:11.557]                         }
[15:32:11.557]                         frame <- frame + 1L
[15:32:11.557]                         envir <- sys.frame(frame)
[15:32:11.557]                       }
[15:32:11.557]                     }
[15:32:11.557]                     sendCondition <<- function(cond) NULL
[15:32:11.557]                   }
[15:32:11.557]                 })
[15:32:11.557]                 withCallingHandlers({
[15:32:11.557]                   {
[15:32:11.557]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.557]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.557]                       ...future.globals.maxSize)) {
[15:32:11.557]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.557]                       on.exit(options(oopts), add = TRUE)
[15:32:11.557]                     }
[15:32:11.557]                     {
[15:32:11.557]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.557]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.557]                         USE.NAMES = FALSE)
[15:32:11.557]                       do.call(mapply, args = args)
[15:32:11.557]                     }
[15:32:11.557]                   }
[15:32:11.557]                 }, immediateCondition = function(cond) {
[15:32:11.557]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.557]                   sendCondition(cond)
[15:32:11.557]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.557]                   {
[15:32:11.557]                     inherits <- base::inherits
[15:32:11.557]                     invokeRestart <- base::invokeRestart
[15:32:11.557]                     is.null <- base::is.null
[15:32:11.557]                     muffled <- FALSE
[15:32:11.557]                     if (inherits(cond, "message")) {
[15:32:11.557]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.557]                       if (muffled) 
[15:32:11.557]                         invokeRestart("muffleMessage")
[15:32:11.557]                     }
[15:32:11.557]                     else if (inherits(cond, "warning")) {
[15:32:11.557]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.557]                       if (muffled) 
[15:32:11.557]                         invokeRestart("muffleWarning")
[15:32:11.557]                     }
[15:32:11.557]                     else if (inherits(cond, "condition")) {
[15:32:11.557]                       if (!is.null(pattern)) {
[15:32:11.557]                         computeRestarts <- base::computeRestarts
[15:32:11.557]                         grepl <- base::grepl
[15:32:11.557]                         restarts <- computeRestarts(cond)
[15:32:11.557]                         for (restart in restarts) {
[15:32:11.557]                           name <- restart$name
[15:32:11.557]                           if (is.null(name)) 
[15:32:11.557]                             next
[15:32:11.557]                           if (!grepl(pattern, name)) 
[15:32:11.557]                             next
[15:32:11.557]                           invokeRestart(restart)
[15:32:11.557]                           muffled <- TRUE
[15:32:11.557]                           break
[15:32:11.557]                         }
[15:32:11.557]                       }
[15:32:11.557]                     }
[15:32:11.557]                     invisible(muffled)
[15:32:11.557]                   }
[15:32:11.557]                   muffleCondition(cond)
[15:32:11.557]                 })
[15:32:11.557]             }))
[15:32:11.557]             future::FutureResult(value = ...future.value$value, 
[15:32:11.557]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.557]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.557]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.557]                     ...future.globalenv.names))
[15:32:11.557]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.557]         }, condition = base::local({
[15:32:11.557]             c <- base::c
[15:32:11.557]             inherits <- base::inherits
[15:32:11.557]             invokeRestart <- base::invokeRestart
[15:32:11.557]             length <- base::length
[15:32:11.557]             list <- base::list
[15:32:11.557]             seq.int <- base::seq.int
[15:32:11.557]             signalCondition <- base::signalCondition
[15:32:11.557]             sys.calls <- base::sys.calls
[15:32:11.557]             `[[` <- base::`[[`
[15:32:11.557]             `+` <- base::`+`
[15:32:11.557]             `<<-` <- base::`<<-`
[15:32:11.557]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.557]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.557]                   3L)]
[15:32:11.557]             }
[15:32:11.557]             function(cond) {
[15:32:11.557]                 is_error <- inherits(cond, "error")
[15:32:11.557]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.557]                   NULL)
[15:32:11.557]                 if (is_error) {
[15:32:11.557]                   sessionInformation <- function() {
[15:32:11.557]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.557]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.557]                       search = base::search(), system = base::Sys.info())
[15:32:11.557]                   }
[15:32:11.557]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.557]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.557]                     cond$call), session = sessionInformation(), 
[15:32:11.557]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.557]                   signalCondition(cond)
[15:32:11.557]                 }
[15:32:11.557]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.557]                 "immediateCondition"))) {
[15:32:11.557]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.557]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.557]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.557]                   if (TRUE && !signal) {
[15:32:11.557]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.557]                     {
[15:32:11.557]                       inherits <- base::inherits
[15:32:11.557]                       invokeRestart <- base::invokeRestart
[15:32:11.557]                       is.null <- base::is.null
[15:32:11.557]                       muffled <- FALSE
[15:32:11.557]                       if (inherits(cond, "message")) {
[15:32:11.557]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.557]                         if (muffled) 
[15:32:11.557]                           invokeRestart("muffleMessage")
[15:32:11.557]                       }
[15:32:11.557]                       else if (inherits(cond, "warning")) {
[15:32:11.557]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.557]                         if (muffled) 
[15:32:11.557]                           invokeRestart("muffleWarning")
[15:32:11.557]                       }
[15:32:11.557]                       else if (inherits(cond, "condition")) {
[15:32:11.557]                         if (!is.null(pattern)) {
[15:32:11.557]                           computeRestarts <- base::computeRestarts
[15:32:11.557]                           grepl <- base::grepl
[15:32:11.557]                           restarts <- computeRestarts(cond)
[15:32:11.557]                           for (restart in restarts) {
[15:32:11.557]                             name <- restart$name
[15:32:11.557]                             if (is.null(name)) 
[15:32:11.557]                               next
[15:32:11.557]                             if (!grepl(pattern, name)) 
[15:32:11.557]                               next
[15:32:11.557]                             invokeRestart(restart)
[15:32:11.557]                             muffled <- TRUE
[15:32:11.557]                             break
[15:32:11.557]                           }
[15:32:11.557]                         }
[15:32:11.557]                       }
[15:32:11.557]                       invisible(muffled)
[15:32:11.557]                     }
[15:32:11.557]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.557]                   }
[15:32:11.557]                 }
[15:32:11.557]                 else {
[15:32:11.557]                   if (TRUE) {
[15:32:11.557]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.557]                     {
[15:32:11.557]                       inherits <- base::inherits
[15:32:11.557]                       invokeRestart <- base::invokeRestart
[15:32:11.557]                       is.null <- base::is.null
[15:32:11.557]                       muffled <- FALSE
[15:32:11.557]                       if (inherits(cond, "message")) {
[15:32:11.557]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.557]                         if (muffled) 
[15:32:11.557]                           invokeRestart("muffleMessage")
[15:32:11.557]                       }
[15:32:11.557]                       else if (inherits(cond, "warning")) {
[15:32:11.557]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.557]                         if (muffled) 
[15:32:11.557]                           invokeRestart("muffleWarning")
[15:32:11.557]                       }
[15:32:11.557]                       else if (inherits(cond, "condition")) {
[15:32:11.557]                         if (!is.null(pattern)) {
[15:32:11.557]                           computeRestarts <- base::computeRestarts
[15:32:11.557]                           grepl <- base::grepl
[15:32:11.557]                           restarts <- computeRestarts(cond)
[15:32:11.557]                           for (restart in restarts) {
[15:32:11.557]                             name <- restart$name
[15:32:11.557]                             if (is.null(name)) 
[15:32:11.557]                               next
[15:32:11.557]                             if (!grepl(pattern, name)) 
[15:32:11.557]                               next
[15:32:11.557]                             invokeRestart(restart)
[15:32:11.557]                             muffled <- TRUE
[15:32:11.557]                             break
[15:32:11.557]                           }
[15:32:11.557]                         }
[15:32:11.557]                       }
[15:32:11.557]                       invisible(muffled)
[15:32:11.557]                     }
[15:32:11.557]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.557]                   }
[15:32:11.557]                 }
[15:32:11.557]             }
[15:32:11.557]         }))
[15:32:11.557]     }, error = function(ex) {
[15:32:11.557]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.557]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.557]                 ...future.rng), started = ...future.startTime, 
[15:32:11.557]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.557]             version = "1.8"), class = "FutureResult")
[15:32:11.557]     }, finally = {
[15:32:11.557]         if (!identical(...future.workdir, getwd())) 
[15:32:11.557]             setwd(...future.workdir)
[15:32:11.557]         {
[15:32:11.557]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.557]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.557]             }
[15:32:11.557]             base::options(...future.oldOptions)
[15:32:11.557]             if (.Platform$OS.type == "windows") {
[15:32:11.557]                 old_names <- names(...future.oldEnvVars)
[15:32:11.557]                 envs <- base::Sys.getenv()
[15:32:11.557]                 names <- names(envs)
[15:32:11.557]                 common <- intersect(names, old_names)
[15:32:11.557]                 added <- setdiff(names, old_names)
[15:32:11.557]                 removed <- setdiff(old_names, names)
[15:32:11.557]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.557]                   envs[common]]
[15:32:11.557]                 NAMES <- toupper(changed)
[15:32:11.557]                 args <- list()
[15:32:11.557]                 for (kk in seq_along(NAMES)) {
[15:32:11.557]                   name <- changed[[kk]]
[15:32:11.557]                   NAME <- NAMES[[kk]]
[15:32:11.557]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.557]                     next
[15:32:11.557]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.557]                 }
[15:32:11.557]                 NAMES <- toupper(added)
[15:32:11.557]                 for (kk in seq_along(NAMES)) {
[15:32:11.557]                   name <- added[[kk]]
[15:32:11.557]                   NAME <- NAMES[[kk]]
[15:32:11.557]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.557]                     next
[15:32:11.557]                   args[[name]] <- ""
[15:32:11.557]                 }
[15:32:11.557]                 NAMES <- toupper(removed)
[15:32:11.557]                 for (kk in seq_along(NAMES)) {
[15:32:11.557]                   name <- removed[[kk]]
[15:32:11.557]                   NAME <- NAMES[[kk]]
[15:32:11.557]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.557]                     next
[15:32:11.557]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.557]                 }
[15:32:11.557]                 if (length(args) > 0) 
[15:32:11.557]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.557]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.557]             }
[15:32:11.557]             else {
[15:32:11.557]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.557]             }
[15:32:11.557]             {
[15:32:11.557]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.557]                   0L) {
[15:32:11.557]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.557]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.557]                   base::options(opts)
[15:32:11.557]                 }
[15:32:11.557]                 {
[15:32:11.557]                   {
[15:32:11.557]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.557]                     NULL
[15:32:11.557]                   }
[15:32:11.557]                   options(future.plan = NULL)
[15:32:11.557]                   if (is.na(NA_character_)) 
[15:32:11.557]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.557]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.557]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.557]                     .init = FALSE)
[15:32:11.557]                 }
[15:32:11.557]             }
[15:32:11.557]         }
[15:32:11.557]     })
[15:32:11.557]     if (TRUE) {
[15:32:11.557]         base::sink(type = "output", split = FALSE)
[15:32:11.557]         if (TRUE) {
[15:32:11.557]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.557]         }
[15:32:11.557]         else {
[15:32:11.557]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.557]         }
[15:32:11.557]         base::close(...future.stdout)
[15:32:11.557]         ...future.stdout <- NULL
[15:32:11.557]     }
[15:32:11.557]     ...future.result$conditions <- ...future.conditions
[15:32:11.557]     ...future.result$finished <- base::Sys.time()
[15:32:11.557]     ...future.result
[15:32:11.557] }
[15:32:11.562] Exporting 5 global objects (3.41 KiB) to cluster node #1 ...
[15:32:11.563] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.564] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.564] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.565] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.565] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:11.568] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:11.569] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.569] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.570] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.570] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.570] Exporting 5 global objects (3.41 KiB) to cluster node #1 ... DONE
[15:32:11.571] MultisessionFuture started
[15:32:11.571] - Launch lazy future ... done
[15:32:11.571] run() for 'MultisessionFuture' ... done
[15:32:11.572] Created future:
[15:32:11.602] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.603] - Validating connection of MultisessionFuture
[15:32:11.603] - received message: FutureResult
[15:32:11.603] - Received FutureResult
[15:32:11.604] - Erased future from FutureRegistry
[15:32:11.604] result() for ClusterFuture ...
[15:32:11.604] - result already collected: FutureResult
[15:32:11.604] result() for ClusterFuture ... done
[15:32:11.605] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.572] MultisessionFuture:
[15:32:11.572] Label: 'future_mapply-4'
[15:32:11.572] Expression:
[15:32:11.572] {
[15:32:11.572]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.572]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.572]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.572]         on.exit(options(oopts), add = TRUE)
[15:32:11.572]     }
[15:32:11.572]     {
[15:32:11.572]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.572]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.572]         do.call(mapply, args = args)
[15:32:11.572]     }
[15:32:11.572] }
[15:32:11.572] Lazy evaluation: FALSE
[15:32:11.572] Asynchronous evaluation: TRUE
[15:32:11.572] Local evaluation: TRUE
[15:32:11.572] Environment: R_GlobalEnv
[15:32:11.572] Capture standard output: TRUE
[15:32:11.572] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.572] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.572] Packages: <none>
[15:32:11.572] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.572] Resolved: TRUE
[15:32:11.572] Value: <not collected>
[15:32:11.572] Conditions captured: <none>
[15:32:11.572] Early signaling: FALSE
[15:32:11.572] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.572] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.606] Chunk #4 of 5 ... DONE
[15:32:11.606] Chunk #5 of 5 ...
[15:32:11.606]  - Finding globals in '...' for chunk #5 ...
[15:32:11.606] getGlobalsAndPackages() ...
[15:32:11.607] Searching for globals...
[15:32:11.607] 
[15:32:11.608] Searching for globals ... DONE
[15:32:11.608] - globals: [0] <none>
[15:32:11.608] getGlobalsAndPackages() ... DONE
[15:32:11.608]    + additional globals found: [n=0] 
[15:32:11.609]    + additional namespaces needed: [n=0] 
[15:32:11.609]  - Finding globals in '...' for chunk #5 ... DONE
[15:32:11.609]  - Adjusted option 'future.globals.maxSize': 524288000 -> 5 * 524288000 = 2621440000 (bytes)
[15:32:11.609]  - seeds: <none>
[15:32:11.610]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.610] getGlobalsAndPackages() ...
[15:32:11.610] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.610] Resolving globals: FALSE
[15:32:11.611] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:11.613] 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 3.41 KiB.. This exceeds the maximum allowed size of 2.44 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:11.613] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.613] 
[15:32:11.613] getGlobalsAndPackages() ... DONE
[15:32:11.614] run() for 'Future' ...
[15:32:11.614] - state: 'created'
[15:32:11.615] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.635] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.635] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.636]   - Field: 'node'
[15:32:11.636]   - Field: 'label'
[15:32:11.636]   - Field: 'local'
[15:32:11.637]   - Field: 'owner'
[15:32:11.637]   - Field: 'envir'
[15:32:11.637]   - Field: 'workers'
[15:32:11.638]   - Field: 'packages'
[15:32:11.638]   - Field: 'gc'
[15:32:11.638]   - Field: 'conditions'
[15:32:11.639]   - Field: 'persistent'
[15:32:11.639]   - Field: 'expr'
[15:32:11.639]   - Field: 'uuid'
[15:32:11.639]   - Field: 'seed'
[15:32:11.640]   - Field: 'version'
[15:32:11.640]   - Field: 'result'
[15:32:11.641]   - Field: 'asynchronous'
[15:32:11.641]   - Field: 'calls'
[15:32:11.641]   - Field: 'globals'
[15:32:11.642]   - Field: 'stdout'
[15:32:11.642]   - Field: 'earlySignal'
[15:32:11.642]   - Field: 'lazy'
[15:32:11.643]   - Field: 'state'
[15:32:11.643] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.643] - Launch lazy future ...
[15:32:11.644] Packages needed by the future expression (n = 0): <none>
[15:32:11.644] Packages needed by future strategies (n = 0): <none>
[15:32:11.646] {
[15:32:11.646]     {
[15:32:11.646]         {
[15:32:11.646]             ...future.startTime <- base::Sys.time()
[15:32:11.646]             {
[15:32:11.646]                 {
[15:32:11.646]                   {
[15:32:11.646]                     {
[15:32:11.646]                       base::local({
[15:32:11.646]                         has_future <- base::requireNamespace("future", 
[15:32:11.646]                           quietly = TRUE)
[15:32:11.646]                         if (has_future) {
[15:32:11.646]                           ns <- base::getNamespace("future")
[15:32:11.646]                           version <- ns[[".package"]][["version"]]
[15:32:11.646]                           if (is.null(version)) 
[15:32:11.646]                             version <- utils::packageVersion("future")
[15:32:11.646]                         }
[15:32:11.646]                         else {
[15:32:11.646]                           version <- NULL
[15:32:11.646]                         }
[15:32:11.646]                         if (!has_future || version < "1.8.0") {
[15:32:11.646]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.646]                             "", base::R.version$version.string), 
[15:32:11.646]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.646]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.646]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.646]                               "release", "version")], collapse = " "), 
[15:32:11.646]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.646]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.646]                             info)
[15:32:11.646]                           info <- base::paste(info, collapse = "; ")
[15:32:11.646]                           if (!has_future) {
[15:32:11.646]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.646]                               info)
[15:32:11.646]                           }
[15:32:11.646]                           else {
[15:32:11.646]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.646]                               info, version)
[15:32:11.646]                           }
[15:32:11.646]                           base::stop(msg)
[15:32:11.646]                         }
[15:32:11.646]                       })
[15:32:11.646]                     }
[15:32:11.646]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.646]                     base::options(mc.cores = 1L)
[15:32:11.646]                   }
[15:32:11.646]                   ...future.strategy.old <- future::plan("list")
[15:32:11.646]                   options(future.plan = NULL)
[15:32:11.646]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.646]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.646]                 }
[15:32:11.646]                 ...future.workdir <- getwd()
[15:32:11.646]             }
[15:32:11.646]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.646]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.646]         }
[15:32:11.646]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.646]             future.globals.maxSize = 2621440000, future.globals.method = NULL, 
[15:32:11.646]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.646]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.646]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.646]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.646]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.646]             base::names(...future.oldOptions))
[15:32:11.646]     }
[15:32:11.646]     if (FALSE) {
[15:32:11.646]     }
[15:32:11.646]     else {
[15:32:11.646]         if (TRUE) {
[15:32:11.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.646]                 open = "w")
[15:32:11.646]         }
[15:32:11.646]         else {
[15:32:11.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.646]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.646]         }
[15:32:11.646]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.646]             base::sink(type = "output", split = FALSE)
[15:32:11.646]             base::close(...future.stdout)
[15:32:11.646]         }, add = TRUE)
[15:32:11.646]     }
[15:32:11.646]     ...future.frame <- base::sys.nframe()
[15:32:11.646]     ...future.conditions <- base::list()
[15:32:11.646]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.646]     if (FALSE) {
[15:32:11.646]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.646]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.646]     }
[15:32:11.646]     ...future.result <- base::tryCatch({
[15:32:11.646]         base::withCallingHandlers({
[15:32:11.646]             ...future.value <- base::withVisible(base::local({
[15:32:11.646]                 ...future.makeSendCondition <- base::local({
[15:32:11.646]                   sendCondition <- NULL
[15:32:11.646]                   function(frame = 1L) {
[15:32:11.646]                     if (is.function(sendCondition)) 
[15:32:11.646]                       return(sendCondition)
[15:32:11.646]                     ns <- getNamespace("parallel")
[15:32:11.646]                     if (exists("sendData", mode = "function", 
[15:32:11.646]                       envir = ns)) {
[15:32:11.646]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.646]                         envir = ns)
[15:32:11.646]                       envir <- sys.frame(frame)
[15:32:11.646]                       master <- NULL
[15:32:11.646]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.646]                         !identical(envir, emptyenv())) {
[15:32:11.646]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.646]                           inherits = FALSE)) {
[15:32:11.646]                           master <- get("master", mode = "list", 
[15:32:11.646]                             envir = envir, inherits = FALSE)
[15:32:11.646]                           if (inherits(master, c("SOCKnode", 
[15:32:11.646]                             "SOCK0node"))) {
[15:32:11.646]                             sendCondition <<- function(cond) {
[15:32:11.646]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.646]                                 success = TRUE)
[15:32:11.646]                               parallel_sendData(master, data)
[15:32:11.646]                             }
[15:32:11.646]                             return(sendCondition)
[15:32:11.646]                           }
[15:32:11.646]                         }
[15:32:11.646]                         frame <- frame + 1L
[15:32:11.646]                         envir <- sys.frame(frame)
[15:32:11.646]                       }
[15:32:11.646]                     }
[15:32:11.646]                     sendCondition <<- function(cond) NULL
[15:32:11.646]                   }
[15:32:11.646]                 })
[15:32:11.646]                 withCallingHandlers({
[15:32:11.646]                   {
[15:32:11.646]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.646]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.646]                       ...future.globals.maxSize)) {
[15:32:11.646]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.646]                       on.exit(options(oopts), add = TRUE)
[15:32:11.646]                     }
[15:32:11.646]                     {
[15:32:11.646]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.646]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.646]                         USE.NAMES = FALSE)
[15:32:11.646]                       do.call(mapply, args = args)
[15:32:11.646]                     }
[15:32:11.646]                   }
[15:32:11.646]                 }, immediateCondition = function(cond) {
[15:32:11.646]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.646]                   sendCondition(cond)
[15:32:11.646]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.646]                   {
[15:32:11.646]                     inherits <- base::inherits
[15:32:11.646]                     invokeRestart <- base::invokeRestart
[15:32:11.646]                     is.null <- base::is.null
[15:32:11.646]                     muffled <- FALSE
[15:32:11.646]                     if (inherits(cond, "message")) {
[15:32:11.646]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.646]                       if (muffled) 
[15:32:11.646]                         invokeRestart("muffleMessage")
[15:32:11.646]                     }
[15:32:11.646]                     else if (inherits(cond, "warning")) {
[15:32:11.646]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.646]                       if (muffled) 
[15:32:11.646]                         invokeRestart("muffleWarning")
[15:32:11.646]                     }
[15:32:11.646]                     else if (inherits(cond, "condition")) {
[15:32:11.646]                       if (!is.null(pattern)) {
[15:32:11.646]                         computeRestarts <- base::computeRestarts
[15:32:11.646]                         grepl <- base::grepl
[15:32:11.646]                         restarts <- computeRestarts(cond)
[15:32:11.646]                         for (restart in restarts) {
[15:32:11.646]                           name <- restart$name
[15:32:11.646]                           if (is.null(name)) 
[15:32:11.646]                             next
[15:32:11.646]                           if (!grepl(pattern, name)) 
[15:32:11.646]                             next
[15:32:11.646]                           invokeRestart(restart)
[15:32:11.646]                           muffled <- TRUE
[15:32:11.646]                           break
[15:32:11.646]                         }
[15:32:11.646]                       }
[15:32:11.646]                     }
[15:32:11.646]                     invisible(muffled)
[15:32:11.646]                   }
[15:32:11.646]                   muffleCondition(cond)
[15:32:11.646]                 })
[15:32:11.646]             }))
[15:32:11.646]             future::FutureResult(value = ...future.value$value, 
[15:32:11.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.646]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.646]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.646]                     ...future.globalenv.names))
[15:32:11.646]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.646]         }, condition = base::local({
[15:32:11.646]             c <- base::c
[15:32:11.646]             inherits <- base::inherits
[15:32:11.646]             invokeRestart <- base::invokeRestart
[15:32:11.646]             length <- base::length
[15:32:11.646]             list <- base::list
[15:32:11.646]             seq.int <- base::seq.int
[15:32:11.646]             signalCondition <- base::signalCondition
[15:32:11.646]             sys.calls <- base::sys.calls
[15:32:11.646]             `[[` <- base::`[[`
[15:32:11.646]             `+` <- base::`+`
[15:32:11.646]             `<<-` <- base::`<<-`
[15:32:11.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.646]                   3L)]
[15:32:11.646]             }
[15:32:11.646]             function(cond) {
[15:32:11.646]                 is_error <- inherits(cond, "error")
[15:32:11.646]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.646]                   NULL)
[15:32:11.646]                 if (is_error) {
[15:32:11.646]                   sessionInformation <- function() {
[15:32:11.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.646]                       search = base::search(), system = base::Sys.info())
[15:32:11.646]                   }
[15:32:11.646]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.646]                     cond$call), session = sessionInformation(), 
[15:32:11.646]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.646]                   signalCondition(cond)
[15:32:11.646]                 }
[15:32:11.646]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.646]                 "immediateCondition"))) {
[15:32:11.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.646]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.646]                   if (TRUE && !signal) {
[15:32:11.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.646]                     {
[15:32:11.646]                       inherits <- base::inherits
[15:32:11.646]                       invokeRestart <- base::invokeRestart
[15:32:11.646]                       is.null <- base::is.null
[15:32:11.646]                       muffled <- FALSE
[15:32:11.646]                       if (inherits(cond, "message")) {
[15:32:11.646]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.646]                         if (muffled) 
[15:32:11.646]                           invokeRestart("muffleMessage")
[15:32:11.646]                       }
[15:32:11.646]                       else if (inherits(cond, "warning")) {
[15:32:11.646]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.646]                         if (muffled) 
[15:32:11.646]                           invokeRestart("muffleWarning")
[15:32:11.646]                       }
[15:32:11.646]                       else if (inherits(cond, "condition")) {
[15:32:11.646]                         if (!is.null(pattern)) {
[15:32:11.646]                           computeRestarts <- base::computeRestarts
[15:32:11.646]                           grepl <- base::grepl
[15:32:11.646]                           restarts <- computeRestarts(cond)
[15:32:11.646]                           for (restart in restarts) {
[15:32:11.646]                             name <- restart$name
[15:32:11.646]                             if (is.null(name)) 
[15:32:11.646]                               next
[15:32:11.646]                             if (!grepl(pattern, name)) 
[15:32:11.646]                               next
[15:32:11.646]                             invokeRestart(restart)
[15:32:11.646]                             muffled <- TRUE
[15:32:11.646]                             break
[15:32:11.646]                           }
[15:32:11.646]                         }
[15:32:11.646]                       }
[15:32:11.646]                       invisible(muffled)
[15:32:11.646]                     }
[15:32:11.646]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.646]                   }
[15:32:11.646]                 }
[15:32:11.646]                 else {
[15:32:11.646]                   if (TRUE) {
[15:32:11.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.646]                     {
[15:32:11.646]                       inherits <- base::inherits
[15:32:11.646]                       invokeRestart <- base::invokeRestart
[15:32:11.646]                       is.null <- base::is.null
[15:32:11.646]                       muffled <- FALSE
[15:32:11.646]                       if (inherits(cond, "message")) {
[15:32:11.646]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.646]                         if (muffled) 
[15:32:11.646]                           invokeRestart("muffleMessage")
[15:32:11.646]                       }
[15:32:11.646]                       else if (inherits(cond, "warning")) {
[15:32:11.646]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.646]                         if (muffled) 
[15:32:11.646]                           invokeRestart("muffleWarning")
[15:32:11.646]                       }
[15:32:11.646]                       else if (inherits(cond, "condition")) {
[15:32:11.646]                         if (!is.null(pattern)) {
[15:32:11.646]                           computeRestarts <- base::computeRestarts
[15:32:11.646]                           grepl <- base::grepl
[15:32:11.646]                           restarts <- computeRestarts(cond)
[15:32:11.646]                           for (restart in restarts) {
[15:32:11.646]                             name <- restart$name
[15:32:11.646]                             if (is.null(name)) 
[15:32:11.646]                               next
[15:32:11.646]                             if (!grepl(pattern, name)) 
[15:32:11.646]                               next
[15:32:11.646]                             invokeRestart(restart)
[15:32:11.646]                             muffled <- TRUE
[15:32:11.646]                             break
[15:32:11.646]                           }
[15:32:11.646]                         }
[15:32:11.646]                       }
[15:32:11.646]                       invisible(muffled)
[15:32:11.646]                     }
[15:32:11.646]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.646]                   }
[15:32:11.646]                 }
[15:32:11.646]             }
[15:32:11.646]         }))
[15:32:11.646]     }, error = function(ex) {
[15:32:11.646]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.646]                 ...future.rng), started = ...future.startTime, 
[15:32:11.646]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.646]             version = "1.8"), class = "FutureResult")
[15:32:11.646]     }, finally = {
[15:32:11.646]         if (!identical(...future.workdir, getwd())) 
[15:32:11.646]             setwd(...future.workdir)
[15:32:11.646]         {
[15:32:11.646]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.646]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.646]             }
[15:32:11.646]             base::options(...future.oldOptions)
[15:32:11.646]             if (.Platform$OS.type == "windows") {
[15:32:11.646]                 old_names <- names(...future.oldEnvVars)
[15:32:11.646]                 envs <- base::Sys.getenv()
[15:32:11.646]                 names <- names(envs)
[15:32:11.646]                 common <- intersect(names, old_names)
[15:32:11.646]                 added <- setdiff(names, old_names)
[15:32:11.646]                 removed <- setdiff(old_names, names)
[15:32:11.646]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.646]                   envs[common]]
[15:32:11.646]                 NAMES <- toupper(changed)
[15:32:11.646]                 args <- list()
[15:32:11.646]                 for (kk in seq_along(NAMES)) {
[15:32:11.646]                   name <- changed[[kk]]
[15:32:11.646]                   NAME <- NAMES[[kk]]
[15:32:11.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.646]                     next
[15:32:11.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.646]                 }
[15:32:11.646]                 NAMES <- toupper(added)
[15:32:11.646]                 for (kk in seq_along(NAMES)) {
[15:32:11.646]                   name <- added[[kk]]
[15:32:11.646]                   NAME <- NAMES[[kk]]
[15:32:11.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.646]                     next
[15:32:11.646]                   args[[name]] <- ""
[15:32:11.646]                 }
[15:32:11.646]                 NAMES <- toupper(removed)
[15:32:11.646]                 for (kk in seq_along(NAMES)) {
[15:32:11.646]                   name <- removed[[kk]]
[15:32:11.646]                   NAME <- NAMES[[kk]]
[15:32:11.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.646]                     next
[15:32:11.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.646]                 }
[15:32:11.646]                 if (length(args) > 0) 
[15:32:11.646]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.646]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.646]             }
[15:32:11.646]             else {
[15:32:11.646]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.646]             }
[15:32:11.646]             {
[15:32:11.646]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.646]                   0L) {
[15:32:11.646]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.646]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.646]                   base::options(opts)
[15:32:11.646]                 }
[15:32:11.646]                 {
[15:32:11.646]                   {
[15:32:11.646]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.646]                     NULL
[15:32:11.646]                   }
[15:32:11.646]                   options(future.plan = NULL)
[15:32:11.646]                   if (is.na(NA_character_)) 
[15:32:11.646]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.646]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.646]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.646]                     .init = FALSE)
[15:32:11.646]                 }
[15:32:11.646]             }
[15:32:11.646]         }
[15:32:11.646]     })
[15:32:11.646]     if (TRUE) {
[15:32:11.646]         base::sink(type = "output", split = FALSE)
[15:32:11.646]         if (TRUE) {
[15:32:11.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.646]         }
[15:32:11.646]         else {
[15:32:11.646]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.646]         }
[15:32:11.646]         base::close(...future.stdout)
[15:32:11.646]         ...future.stdout <- NULL
[15:32:11.646]     }
[15:32:11.646]     ...future.result$conditions <- ...future.conditions
[15:32:11.646]     ...future.result$finished <- base::Sys.time()
[15:32:11.646]     ...future.result
[15:32:11.646] }
[15:32:11.656] Exporting 5 global objects (3.41 KiB) to cluster node #1 ...
[15:32:11.656] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.657] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.658] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.658] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.659] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:11.660] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:11.660] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.661] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.661] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.662] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.662] Exporting 5 global objects (3.41 KiB) to cluster node #1 ... DONE
[15:32:11.663] MultisessionFuture started
[15:32:11.664] - Launch lazy future ... done
[15:32:11.664] run() for 'MultisessionFuture' ... done
[15:32:11.665] Created future:
[15:32:11.687] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.688] - Validating connection of MultisessionFuture
[15:32:11.688] - received message: FutureResult
[15:32:11.689] - Received FutureResult
[15:32:11.689] - Erased future from FutureRegistry
[15:32:11.690] result() for ClusterFuture ...
[15:32:11.690] - result already collected: FutureResult
[15:32:11.690] result() for ClusterFuture ... done
[15:32:11.691] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.665] MultisessionFuture:
[15:32:11.665] Label: 'future_mapply-5'
[15:32:11.665] Expression:
[15:32:11.665] {
[15:32:11.665]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.665]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.665]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.665]         on.exit(options(oopts), add = TRUE)
[15:32:11.665]     }
[15:32:11.665]     {
[15:32:11.665]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.665]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.665]         do.call(mapply, args = args)
[15:32:11.665]     }
[15:32:11.665] }
[15:32:11.665] Lazy evaluation: FALSE
[15:32:11.665] Asynchronous evaluation: TRUE
[15:32:11.665] Local evaluation: TRUE
[15:32:11.665] Environment: R_GlobalEnv
[15:32:11.665] Capture standard output: TRUE
[15:32:11.665] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.665] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.665] Packages: <none>
[15:32:11.665] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.665] Resolved: TRUE
[15:32:11.665] Value: <not collected>
[15:32:11.665] Conditions captured: <none>
[15:32:11.665] Early signaling: FALSE
[15:32:11.665] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.665] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.692] Chunk #5 of 5 ... DONE
[15:32:11.692] Launching 5 futures (chunks) ... DONE
[15:32:11.692] Resolving 5 futures (chunks) ...
[15:32:11.693] resolve() on list ...
[15:32:11.693]  recursive: 0
[15:32:11.693]  length: 5
[15:32:11.694] 
[15:32:11.694] Future #1
[15:32:11.695] result() for ClusterFuture ...
[15:32:11.695] - result already collected: FutureResult
[15:32:11.695] result() for ClusterFuture ... done
[15:32:11.696] result() for ClusterFuture ...
[15:32:11.696] - result already collected: FutureResult
[15:32:11.696] result() for ClusterFuture ... done
[15:32:11.697] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:11.697] - nx: 5
[15:32:11.697] - relay: TRUE
[15:32:11.698] - stdout: TRUE
[15:32:11.698] - signal: TRUE
[15:32:11.698] - resignal: FALSE
[15:32:11.699] - force: TRUE
[15:32:11.699] - relayed: [n=5] FALSE, FALSE, FALSE, FALSE, FALSE
[15:32:11.699] - queued futures: [n=5] FALSE, FALSE, FALSE, FALSE, FALSE
[15:32:11.700]  - until=1
[15:32:11.700]  - relaying element #1
[15:32:11.700] result() for ClusterFuture ...
[15:32:11.701] - result already collected: FutureResult
[15:32:11.701] result() for ClusterFuture ... done
[15:32:11.701] result() for ClusterFuture ...
[15:32:11.702] - result already collected: FutureResult
[15:32:11.702] result() for ClusterFuture ... done
[15:32:11.703] result() for ClusterFuture ...
[15:32:11.703] - result already collected: FutureResult
[15:32:11.703] result() for ClusterFuture ... done
[15:32:11.704] result() for ClusterFuture ...
[15:32:11.704] - result already collected: FutureResult
[15:32:11.704] result() for ClusterFuture ... done
[15:32:11.705] - relayed: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:11.705] - queued futures: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:11.705] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:11.705]  length: 4 (resolved future 1)
[15:32:11.706] Future #2
[15:32:11.706] result() for ClusterFuture ...
[15:32:11.706] - result already collected: FutureResult
[15:32:11.707] result() for ClusterFuture ... done
[15:32:11.707] result() for ClusterFuture ...
[15:32:11.707] - result already collected: FutureResult
[15:32:11.708] result() for ClusterFuture ... done
[15:32:11.708] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:11.708] - nx: 5
[15:32:11.709] - relay: TRUE
[15:32:11.709] - stdout: TRUE
[15:32:11.709] - signal: TRUE
[15:32:11.709] - resignal: FALSE
[15:32:11.710] - force: TRUE
[15:32:11.710] - relayed: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:11.710] - queued futures: [n=5] TRUE, FALSE, FALSE, FALSE, FALSE
[15:32:11.711]  - until=2
[15:32:11.711]  - relaying element #2
[15:32:11.711] result() for ClusterFuture ...
[15:32:11.711] - result already collected: FutureResult
[15:32:11.712] result() for ClusterFuture ... done
[15:32:11.712] result() for ClusterFuture ...
[15:32:11.712] - result already collected: FutureResult
[15:32:11.712] result() for ClusterFuture ... done
[15:32:11.713] result() for ClusterFuture ...
[15:32:11.713] - result already collected: FutureResult
[15:32:11.713] result() for ClusterFuture ... done
[15:32:11.714] result() for ClusterFuture ...
[15:32:11.714] - result already collected: FutureResult
[15:32:11.714] result() for ClusterFuture ... done
[15:32:11.714] - relayed: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:11.715] - queued futures: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:11.715] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:11.715]  length: 3 (resolved future 2)
[15:32:11.716] Future #3
[15:32:11.716] result() for ClusterFuture ...
[15:32:11.716] - result already collected: FutureResult
[15:32:11.716] result() for ClusterFuture ... done
[15:32:11.717] result() for ClusterFuture ...
[15:32:11.717] - result already collected: FutureResult
[15:32:11.717] result() for ClusterFuture ... done
[15:32:11.718] signalConditionsASAP(MultisessionFuture, pos=3) ...
[15:32:11.718] - nx: 5
[15:32:11.718] - relay: TRUE
[15:32:11.718] - stdout: TRUE
[15:32:11.719] - signal: TRUE
[15:32:11.719] - resignal: FALSE
[15:32:11.719] - force: TRUE
[15:32:11.720] - relayed: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:11.720] - queued futures: [n=5] TRUE, TRUE, FALSE, FALSE, FALSE
[15:32:11.720]  - until=3
[15:32:11.720]  - relaying element #3
[15:32:11.721] result() for ClusterFuture ...
[15:32:11.721] - result already collected: FutureResult
[15:32:11.721] result() for ClusterFuture ... done
[15:32:11.722] result() for ClusterFuture ...
[15:32:11.722] - result already collected: FutureResult
[15:32:11.722] result() for ClusterFuture ... done
[15:32:11.722] result() for ClusterFuture ...
[15:32:11.723] - result already collected: FutureResult
[15:32:11.723] result() for ClusterFuture ... done
[15:32:11.723] result() for ClusterFuture ...
[15:32:11.724] - result already collected: FutureResult
[15:32:11.724] result() for ClusterFuture ... done
[15:32:11.724] - relayed: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:11.724] - queued futures: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:11.725] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[15:32:11.725]  length: 2 (resolved future 3)
[15:32:11.725] Future #4
[15:32:11.726] result() for ClusterFuture ...
[15:32:11.726] - result already collected: FutureResult
[15:32:11.726] result() for ClusterFuture ... done
[15:32:11.726] result() for ClusterFuture ...
[15:32:11.727] - result already collected: FutureResult
[15:32:11.727] result() for ClusterFuture ... done
[15:32:11.727] signalConditionsASAP(MultisessionFuture, pos=4) ...
[15:32:11.727] - nx: 5
[15:32:11.728] - relay: TRUE
[15:32:11.728] - stdout: TRUE
[15:32:11.728] - signal: TRUE
[15:32:11.728] - resignal: FALSE
[15:32:11.729] - force: TRUE
[15:32:11.729] - relayed: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:11.729] - queued futures: [n=5] TRUE, TRUE, TRUE, FALSE, FALSE
[15:32:11.730]  - until=4
[15:32:11.730]  - relaying element #4
[15:32:11.730] result() for ClusterFuture ...
[15:32:11.730] - result already collected: FutureResult
[15:32:11.731] result() for ClusterFuture ... done
[15:32:11.731] result() for ClusterFuture ...
[15:32:11.731] - result already collected: FutureResult
[15:32:11.731] result() for ClusterFuture ... done
[15:32:11.732] result() for ClusterFuture ...
[15:32:11.732] - result already collected: FutureResult
[15:32:11.732] result() for ClusterFuture ... done
[15:32:11.733] result() for ClusterFuture ...
[15:32:11.733] - result already collected: FutureResult
[15:32:11.733] result() for ClusterFuture ... done
[15:32:11.733] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:11.734] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:11.734] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[15:32:11.734]  length: 1 (resolved future 4)
[15:32:11.735] Future #5
[15:32:11.735] result() for ClusterFuture ...
[15:32:11.735] - result already collected: FutureResult
[15:32:11.735] result() for ClusterFuture ... done
[15:32:11.736] result() for ClusterFuture ...
[15:32:11.736] - result already collected: FutureResult
[15:32:11.736] result() for ClusterFuture ... done
[15:32:11.737] signalConditionsASAP(MultisessionFuture, pos=5) ...
[15:32:11.737] - nx: 5
[15:32:11.737] - relay: TRUE
[15:32:11.737] - stdout: TRUE
[15:32:11.738] - signal: TRUE
[15:32:11.738] - resignal: FALSE
[15:32:11.738] - force: TRUE
[15:32:11.738] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:11.739] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, FALSE
[15:32:11.739]  - until=5
[15:32:11.739]  - relaying element #5
[15:32:11.740] result() for ClusterFuture ...
[15:32:11.740] - result already collected: FutureResult
[15:32:11.740] result() for ClusterFuture ... done
[15:32:11.740] result() for ClusterFuture ...
[15:32:11.741] - result already collected: FutureResult
[15:32:11.741] result() for ClusterFuture ... done
[15:32:11.741] result() for ClusterFuture ...
[15:32:11.742] - result already collected: FutureResult
[15:32:11.742] result() for ClusterFuture ... done
[15:32:11.742] result() for ClusterFuture ...
[15:32:11.742] - result already collected: FutureResult
[15:32:11.743] result() for ClusterFuture ... done
[15:32:11.743] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:11.743] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:11.744] signalConditionsASAP(MultisessionFuture, pos=5) ... done
[15:32:11.744]  length: 0 (resolved future 5)
[15:32:11.744] Relaying remaining futures
[15:32:11.744] signalConditionsASAP(NULL, pos=0) ...
[15:32:11.745] - nx: 5
[15:32:11.745] - relay: TRUE
[15:32:11.745] - stdout: TRUE
[15:32:11.745] - signal: TRUE
[15:32:11.746] - resignal: FALSE
[15:32:11.746] - force: TRUE
[15:32:11.746] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:11.746] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
 - flush all
[15:32:11.747] - relayed: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:11.747] - queued futures: [n=5] TRUE, TRUE, TRUE, TRUE, TRUE
[15:32:11.748] signalConditionsASAP(NULL, pos=0) ... done
[15:32:11.748] resolve() on list ... DONE
[15:32:11.748] result() for ClusterFuture ...
[15:32:11.748] - result already collected: FutureResult
[15:32:11.749] result() for ClusterFuture ... done
[15:32:11.749] result() for ClusterFuture ...
[15:32:11.749] - result already collected: FutureResult
[15:32:11.749] result() for ClusterFuture ... done
[15:32:11.750] result() for ClusterFuture ...
[15:32:11.750] - result already collected: FutureResult
[15:32:11.750] result() for ClusterFuture ... done
[15:32:11.751] result() for ClusterFuture ...
[15:32:11.751] - result already collected: FutureResult
[15:32:11.751] result() for ClusterFuture ... done
[15:32:11.751] result() for ClusterFuture ...
[15:32:11.752] - result already collected: FutureResult
[15:32:11.752] result() for ClusterFuture ... done
[15:32:11.752] result() for ClusterFuture ...
[15:32:11.752] - result already collected: FutureResult
[15:32:11.753] result() for ClusterFuture ... done
[15:32:11.753] result() for ClusterFuture ...
[15:32:11.753] - result already collected: FutureResult
[15:32:11.754] result() for ClusterFuture ... done
[15:32:11.754] result() for ClusterFuture ...
[15:32:11.754] - result already collected: FutureResult
[15:32:11.754] result() for ClusterFuture ... done
[15:32:11.755] result() for ClusterFuture ...
[15:32:11.755] - result already collected: FutureResult
[15:32:11.755] result() for ClusterFuture ... done
[15:32:11.756] result() for ClusterFuture ...
[15:32:11.756] - result already collected: FutureResult
[15:32:11.756] result() for ClusterFuture ... done
[15:32:11.756]  - Number of value chunks collected: 5
[15:32:11.757] Resolving 5 futures (chunks) ... DONE
[15:32:11.757] Reducing values from 5 chunks ...
[15:32:11.757]  - Number of values collected after concatenation: 5
[15:32:11.758]  - Number of values expected: 5
[15:32:11.758] Reducing values from 5 chunks ... DONE
[15:32:11.758] future_mapply() ... DONE
[15:32:11.759] future_mapply() ...
[15:32:11.763] Number of chunks: 2
[15:32:11.763] getGlobalsAndPackagesXApply() ...
[15:32:11.764]  - future.globals: TRUE
[15:32:11.764] getGlobalsAndPackages() ...
[15:32:11.764] Searching for globals...
[15:32:11.767] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:11.767] Searching for globals ... DONE
[15:32:11.767] Resolving globals: FALSE
[15:32:11.768] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:11.769] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:11.769] - globals: [1] 'FUN'
[15:32:11.769] 
[15:32:11.770] getGlobalsAndPackages() ... DONE
[15:32:11.770]  - globals found/used: [n=1] 'FUN'
[15:32:11.770]  - needed namespaces: [n=0] 
[15:32:11.770] Finding globals ... DONE
[15:32:11.771] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:11.771] List of 2
[15:32:11.771]  $ ...future.FUN:function (C, k)  
[15:32:11.771]  $ MoreArgs     : list()
[15:32:11.771]  - attr(*, "where")=List of 2
[15:32:11.771]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:11.771]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:11.771]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:11.771]  - attr(*, "resolved")= logi FALSE
[15:32:11.771]  - attr(*, "total_size")= num NA
[15:32:11.776] Packages to be attached in all futures: [n=0] 
[15:32:11.776] getGlobalsAndPackagesXApply() ... DONE
[15:32:11.777] Number of futures (= number of chunks): 2
[15:32:11.777] Launching 2 futures (chunks) ...
[15:32:11.778] Chunk #1 of 2 ...
[15:32:11.778]  - Finding globals in '...' for chunk #1 ...
[15:32:11.778] getGlobalsAndPackages() ...
[15:32:11.778] Searching for globals...
[15:32:11.779] 
[15:32:11.779] Searching for globals ... DONE
[15:32:11.780] - globals: [0] <none>
[15:32:11.780] getGlobalsAndPackages() ... DONE
[15:32:11.780]    + additional globals found: [n=0] 
[15:32:11.781]    + additional namespaces needed: [n=0] 
[15:32:11.781]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:11.781]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:11.781]  - seeds: <none>
[15:32:11.782]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.782] getGlobalsAndPackages() ...
[15:32:11.782] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.783] Resolving globals: FALSE
[15:32:11.784] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:11.785] 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 3.57 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:11.785] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.785] 
[15:32:11.786] getGlobalsAndPackages() ... DONE
[15:32:11.786] run() for 'Future' ...
[15:32:11.787] - state: 'created'
[15:32:11.787] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.805] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.806] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.806]   - Field: 'node'
[15:32:11.806]   - Field: 'label'
[15:32:11.806]   - Field: 'local'
[15:32:11.806]   - Field: 'owner'
[15:32:11.807]   - Field: 'envir'
[15:32:11.807]   - Field: 'workers'
[15:32:11.807]   - Field: 'packages'
[15:32:11.807]   - Field: 'gc'
[15:32:11.807]   - Field: 'conditions'
[15:32:11.808]   - Field: 'persistent'
[15:32:11.808]   - Field: 'expr'
[15:32:11.808]   - Field: 'uuid'
[15:32:11.808]   - Field: 'seed'
[15:32:11.808]   - Field: 'version'
[15:32:11.809]   - Field: 'result'
[15:32:11.809]   - Field: 'asynchronous'
[15:32:11.809]   - Field: 'calls'
[15:32:11.809]   - Field: 'globals'
[15:32:11.809]   - Field: 'stdout'
[15:32:11.810]   - Field: 'earlySignal'
[15:32:11.810]   - Field: 'lazy'
[15:32:11.810]   - Field: 'state'
[15:32:11.810] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.810] - Launch lazy future ...
[15:32:11.811] Packages needed by the future expression (n = 0): <none>
[15:32:11.811] Packages needed by future strategies (n = 0): <none>
[15:32:11.812] {
[15:32:11.812]     {
[15:32:11.812]         {
[15:32:11.812]             ...future.startTime <- base::Sys.time()
[15:32:11.812]             {
[15:32:11.812]                 {
[15:32:11.812]                   {
[15:32:11.812]                     {
[15:32:11.812]                       base::local({
[15:32:11.812]                         has_future <- base::requireNamespace("future", 
[15:32:11.812]                           quietly = TRUE)
[15:32:11.812]                         if (has_future) {
[15:32:11.812]                           ns <- base::getNamespace("future")
[15:32:11.812]                           version <- ns[[".package"]][["version"]]
[15:32:11.812]                           if (is.null(version)) 
[15:32:11.812]                             version <- utils::packageVersion("future")
[15:32:11.812]                         }
[15:32:11.812]                         else {
[15:32:11.812]                           version <- NULL
[15:32:11.812]                         }
[15:32:11.812]                         if (!has_future || version < "1.8.0") {
[15:32:11.812]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.812]                             "", base::R.version$version.string), 
[15:32:11.812]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.812]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.812]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.812]                               "release", "version")], collapse = " "), 
[15:32:11.812]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.812]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.812]                             info)
[15:32:11.812]                           info <- base::paste(info, collapse = "; ")
[15:32:11.812]                           if (!has_future) {
[15:32:11.812]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.812]                               info)
[15:32:11.812]                           }
[15:32:11.812]                           else {
[15:32:11.812]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.812]                               info, version)
[15:32:11.812]                           }
[15:32:11.812]                           base::stop(msg)
[15:32:11.812]                         }
[15:32:11.812]                       })
[15:32:11.812]                     }
[15:32:11.812]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.812]                     base::options(mc.cores = 1L)
[15:32:11.812]                   }
[15:32:11.812]                   ...future.strategy.old <- future::plan("list")
[15:32:11.812]                   options(future.plan = NULL)
[15:32:11.812]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.812]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.812]                 }
[15:32:11.812]                 ...future.workdir <- getwd()
[15:32:11.812]             }
[15:32:11.812]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.812]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.812]         }
[15:32:11.812]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.812]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:11.812]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.812]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.812]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.812]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.812]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.812]             base::names(...future.oldOptions))
[15:32:11.812]     }
[15:32:11.812]     if (FALSE) {
[15:32:11.812]     }
[15:32:11.812]     else {
[15:32:11.812]         if (TRUE) {
[15:32:11.812]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.812]                 open = "w")
[15:32:11.812]         }
[15:32:11.812]         else {
[15:32:11.812]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.812]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.812]         }
[15:32:11.812]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.812]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.812]             base::sink(type = "output", split = FALSE)
[15:32:11.812]             base::close(...future.stdout)
[15:32:11.812]         }, add = TRUE)
[15:32:11.812]     }
[15:32:11.812]     ...future.frame <- base::sys.nframe()
[15:32:11.812]     ...future.conditions <- base::list()
[15:32:11.812]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.812]     if (FALSE) {
[15:32:11.812]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.812]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.812]     }
[15:32:11.812]     ...future.result <- base::tryCatch({
[15:32:11.812]         base::withCallingHandlers({
[15:32:11.812]             ...future.value <- base::withVisible(base::local({
[15:32:11.812]                 ...future.makeSendCondition <- base::local({
[15:32:11.812]                   sendCondition <- NULL
[15:32:11.812]                   function(frame = 1L) {
[15:32:11.812]                     if (is.function(sendCondition)) 
[15:32:11.812]                       return(sendCondition)
[15:32:11.812]                     ns <- getNamespace("parallel")
[15:32:11.812]                     if (exists("sendData", mode = "function", 
[15:32:11.812]                       envir = ns)) {
[15:32:11.812]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.812]                         envir = ns)
[15:32:11.812]                       envir <- sys.frame(frame)
[15:32:11.812]                       master <- NULL
[15:32:11.812]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.812]                         !identical(envir, emptyenv())) {
[15:32:11.812]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.812]                           inherits = FALSE)) {
[15:32:11.812]                           master <- get("master", mode = "list", 
[15:32:11.812]                             envir = envir, inherits = FALSE)
[15:32:11.812]                           if (inherits(master, c("SOCKnode", 
[15:32:11.812]                             "SOCK0node"))) {
[15:32:11.812]                             sendCondition <<- function(cond) {
[15:32:11.812]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.812]                                 success = TRUE)
[15:32:11.812]                               parallel_sendData(master, data)
[15:32:11.812]                             }
[15:32:11.812]                             return(sendCondition)
[15:32:11.812]                           }
[15:32:11.812]                         }
[15:32:11.812]                         frame <- frame + 1L
[15:32:11.812]                         envir <- sys.frame(frame)
[15:32:11.812]                       }
[15:32:11.812]                     }
[15:32:11.812]                     sendCondition <<- function(cond) NULL
[15:32:11.812]                   }
[15:32:11.812]                 })
[15:32:11.812]                 withCallingHandlers({
[15:32:11.812]                   {
[15:32:11.812]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.812]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.812]                       ...future.globals.maxSize)) {
[15:32:11.812]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.812]                       on.exit(options(oopts), add = TRUE)
[15:32:11.812]                     }
[15:32:11.812]                     {
[15:32:11.812]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.812]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.812]                         USE.NAMES = FALSE)
[15:32:11.812]                       do.call(mapply, args = args)
[15:32:11.812]                     }
[15:32:11.812]                   }
[15:32:11.812]                 }, immediateCondition = function(cond) {
[15:32:11.812]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.812]                   sendCondition(cond)
[15:32:11.812]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.812]                   {
[15:32:11.812]                     inherits <- base::inherits
[15:32:11.812]                     invokeRestart <- base::invokeRestart
[15:32:11.812]                     is.null <- base::is.null
[15:32:11.812]                     muffled <- FALSE
[15:32:11.812]                     if (inherits(cond, "message")) {
[15:32:11.812]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.812]                       if (muffled) 
[15:32:11.812]                         invokeRestart("muffleMessage")
[15:32:11.812]                     }
[15:32:11.812]                     else if (inherits(cond, "warning")) {
[15:32:11.812]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.812]                       if (muffled) 
[15:32:11.812]                         invokeRestart("muffleWarning")
[15:32:11.812]                     }
[15:32:11.812]                     else if (inherits(cond, "condition")) {
[15:32:11.812]                       if (!is.null(pattern)) {
[15:32:11.812]                         computeRestarts <- base::computeRestarts
[15:32:11.812]                         grepl <- base::grepl
[15:32:11.812]                         restarts <- computeRestarts(cond)
[15:32:11.812]                         for (restart in restarts) {
[15:32:11.812]                           name <- restart$name
[15:32:11.812]                           if (is.null(name)) 
[15:32:11.812]                             next
[15:32:11.812]                           if (!grepl(pattern, name)) 
[15:32:11.812]                             next
[15:32:11.812]                           invokeRestart(restart)
[15:32:11.812]                           muffled <- TRUE
[15:32:11.812]                           break
[15:32:11.812]                         }
[15:32:11.812]                       }
[15:32:11.812]                     }
[15:32:11.812]                     invisible(muffled)
[15:32:11.812]                   }
[15:32:11.812]                   muffleCondition(cond)
[15:32:11.812]                 })
[15:32:11.812]             }))
[15:32:11.812]             future::FutureResult(value = ...future.value$value, 
[15:32:11.812]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.812]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.812]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.812]                     ...future.globalenv.names))
[15:32:11.812]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.812]         }, condition = base::local({
[15:32:11.812]             c <- base::c
[15:32:11.812]             inherits <- base::inherits
[15:32:11.812]             invokeRestart <- base::invokeRestart
[15:32:11.812]             length <- base::length
[15:32:11.812]             list <- base::list
[15:32:11.812]             seq.int <- base::seq.int
[15:32:11.812]             signalCondition <- base::signalCondition
[15:32:11.812]             sys.calls <- base::sys.calls
[15:32:11.812]             `[[` <- base::`[[`
[15:32:11.812]             `+` <- base::`+`
[15:32:11.812]             `<<-` <- base::`<<-`
[15:32:11.812]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.812]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.812]                   3L)]
[15:32:11.812]             }
[15:32:11.812]             function(cond) {
[15:32:11.812]                 is_error <- inherits(cond, "error")
[15:32:11.812]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.812]                   NULL)
[15:32:11.812]                 if (is_error) {
[15:32:11.812]                   sessionInformation <- function() {
[15:32:11.812]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.812]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.812]                       search = base::search(), system = base::Sys.info())
[15:32:11.812]                   }
[15:32:11.812]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.812]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.812]                     cond$call), session = sessionInformation(), 
[15:32:11.812]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.812]                   signalCondition(cond)
[15:32:11.812]                 }
[15:32:11.812]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.812]                 "immediateCondition"))) {
[15:32:11.812]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.812]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.812]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.812]                   if (TRUE && !signal) {
[15:32:11.812]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.812]                     {
[15:32:11.812]                       inherits <- base::inherits
[15:32:11.812]                       invokeRestart <- base::invokeRestart
[15:32:11.812]                       is.null <- base::is.null
[15:32:11.812]                       muffled <- FALSE
[15:32:11.812]                       if (inherits(cond, "message")) {
[15:32:11.812]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.812]                         if (muffled) 
[15:32:11.812]                           invokeRestart("muffleMessage")
[15:32:11.812]                       }
[15:32:11.812]                       else if (inherits(cond, "warning")) {
[15:32:11.812]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.812]                         if (muffled) 
[15:32:11.812]                           invokeRestart("muffleWarning")
[15:32:11.812]                       }
[15:32:11.812]                       else if (inherits(cond, "condition")) {
[15:32:11.812]                         if (!is.null(pattern)) {
[15:32:11.812]                           computeRestarts <- base::computeRestarts
[15:32:11.812]                           grepl <- base::grepl
[15:32:11.812]                           restarts <- computeRestarts(cond)
[15:32:11.812]                           for (restart in restarts) {
[15:32:11.812]                             name <- restart$name
[15:32:11.812]                             if (is.null(name)) 
[15:32:11.812]                               next
[15:32:11.812]                             if (!grepl(pattern, name)) 
[15:32:11.812]                               next
[15:32:11.812]                             invokeRestart(restart)
[15:32:11.812]                             muffled <- TRUE
[15:32:11.812]                             break
[15:32:11.812]                           }
[15:32:11.812]                         }
[15:32:11.812]                       }
[15:32:11.812]                       invisible(muffled)
[15:32:11.812]                     }
[15:32:11.812]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.812]                   }
[15:32:11.812]                 }
[15:32:11.812]                 else {
[15:32:11.812]                   if (TRUE) {
[15:32:11.812]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.812]                     {
[15:32:11.812]                       inherits <- base::inherits
[15:32:11.812]                       invokeRestart <- base::invokeRestart
[15:32:11.812]                       is.null <- base::is.null
[15:32:11.812]                       muffled <- FALSE
[15:32:11.812]                       if (inherits(cond, "message")) {
[15:32:11.812]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.812]                         if (muffled) 
[15:32:11.812]                           invokeRestart("muffleMessage")
[15:32:11.812]                       }
[15:32:11.812]                       else if (inherits(cond, "warning")) {
[15:32:11.812]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.812]                         if (muffled) 
[15:32:11.812]                           invokeRestart("muffleWarning")
[15:32:11.812]                       }
[15:32:11.812]                       else if (inherits(cond, "condition")) {
[15:32:11.812]                         if (!is.null(pattern)) {
[15:32:11.812]                           computeRestarts <- base::computeRestarts
[15:32:11.812]                           grepl <- base::grepl
[15:32:11.812]                           restarts <- computeRestarts(cond)
[15:32:11.812]                           for (restart in restarts) {
[15:32:11.812]                             name <- restart$name
[15:32:11.812]                             if (is.null(name)) 
[15:32:11.812]                               next
[15:32:11.812]                             if (!grepl(pattern, name)) 
[15:32:11.812]                               next
[15:32:11.812]                             invokeRestart(restart)
[15:32:11.812]                             muffled <- TRUE
[15:32:11.812]                             break
[15:32:11.812]                           }
[15:32:11.812]                         }
[15:32:11.812]                       }
[15:32:11.812]                       invisible(muffled)
[15:32:11.812]                     }
[15:32:11.812]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.812]                   }
[15:32:11.812]                 }
[15:32:11.812]             }
[15:32:11.812]         }))
[15:32:11.812]     }, error = function(ex) {
[15:32:11.812]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.812]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.812]                 ...future.rng), started = ...future.startTime, 
[15:32:11.812]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.812]             version = "1.8"), class = "FutureResult")
[15:32:11.812]     }, finally = {
[15:32:11.812]         if (!identical(...future.workdir, getwd())) 
[15:32:11.812]             setwd(...future.workdir)
[15:32:11.812]         {
[15:32:11.812]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.812]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.812]             }
[15:32:11.812]             base::options(...future.oldOptions)
[15:32:11.812]             if (.Platform$OS.type == "windows") {
[15:32:11.812]                 old_names <- names(...future.oldEnvVars)
[15:32:11.812]                 envs <- base::Sys.getenv()
[15:32:11.812]                 names <- names(envs)
[15:32:11.812]                 common <- intersect(names, old_names)
[15:32:11.812]                 added <- setdiff(names, old_names)
[15:32:11.812]                 removed <- setdiff(old_names, names)
[15:32:11.812]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.812]                   envs[common]]
[15:32:11.812]                 NAMES <- toupper(changed)
[15:32:11.812]                 args <- list()
[15:32:11.812]                 for (kk in seq_along(NAMES)) {
[15:32:11.812]                   name <- changed[[kk]]
[15:32:11.812]                   NAME <- NAMES[[kk]]
[15:32:11.812]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.812]                     next
[15:32:11.812]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.812]                 }
[15:32:11.812]                 NAMES <- toupper(added)
[15:32:11.812]                 for (kk in seq_along(NAMES)) {
[15:32:11.812]                   name <- added[[kk]]
[15:32:11.812]                   NAME <- NAMES[[kk]]
[15:32:11.812]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.812]                     next
[15:32:11.812]                   args[[name]] <- ""
[15:32:11.812]                 }
[15:32:11.812]                 NAMES <- toupper(removed)
[15:32:11.812]                 for (kk in seq_along(NAMES)) {
[15:32:11.812]                   name <- removed[[kk]]
[15:32:11.812]                   NAME <- NAMES[[kk]]
[15:32:11.812]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.812]                     next
[15:32:11.812]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.812]                 }
[15:32:11.812]                 if (length(args) > 0) 
[15:32:11.812]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.812]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.812]             }
[15:32:11.812]             else {
[15:32:11.812]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.812]             }
[15:32:11.812]             {
[15:32:11.812]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.812]                   0L) {
[15:32:11.812]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.812]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.812]                   base::options(opts)
[15:32:11.812]                 }
[15:32:11.812]                 {
[15:32:11.812]                   {
[15:32:11.812]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.812]                     NULL
[15:32:11.812]                   }
[15:32:11.812]                   options(future.plan = NULL)
[15:32:11.812]                   if (is.na(NA_character_)) 
[15:32:11.812]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.812]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.812]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.812]                     .init = FALSE)
[15:32:11.812]                 }
[15:32:11.812]             }
[15:32:11.812]         }
[15:32:11.812]     })
[15:32:11.812]     if (TRUE) {
[15:32:11.812]         base::sink(type = "output", split = FALSE)
[15:32:11.812]         if (TRUE) {
[15:32:11.812]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.812]         }
[15:32:11.812]         else {
[15:32:11.812]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.812]         }
[15:32:11.812]         base::close(...future.stdout)
[15:32:11.812]         ...future.stdout <- NULL
[15:32:11.812]     }
[15:32:11.812]     ...future.result$conditions <- ...future.conditions
[15:32:11.812]     ...future.result$finished <- base::Sys.time()
[15:32:11.812]     ...future.result
[15:32:11.812] }
[15:32:11.818] Exporting 5 global objects (3.57 KiB) to cluster node #1 ...
[15:32:11.818] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.818] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.819] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.819] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.819] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:32:11.820] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:32:11.820] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.820] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.821] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.821] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.821] Exporting 5 global objects (3.57 KiB) to cluster node #1 ... DONE
[15:32:11.822] MultisessionFuture started
[15:32:11.822] - Launch lazy future ... done
[15:32:11.822] run() for 'MultisessionFuture' ... done
[15:32:11.822] Created future:
[15:32:11.840] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.840] - Validating connection of MultisessionFuture
[15:32:11.840] - received message: FutureResult
[15:32:11.841] - Received FutureResult
[15:32:11.841] - Erased future from FutureRegistry
[15:32:11.841] result() for ClusterFuture ...
[15:32:11.841] - result already collected: FutureResult
[15:32:11.841] result() for ClusterFuture ... done
[15:32:11.842] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.823] MultisessionFuture:
[15:32:11.823] Label: 'future_.mapply-1'
[15:32:11.823] Expression:
[15:32:11.823] {
[15:32:11.823]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.823]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.823]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.823]         on.exit(options(oopts), add = TRUE)
[15:32:11.823]     }
[15:32:11.823]     {
[15:32:11.823]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.823]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.823]         do.call(mapply, args = args)
[15:32:11.823]     }
[15:32:11.823] }
[15:32:11.823] Lazy evaluation: FALSE
[15:32:11.823] Asynchronous evaluation: TRUE
[15:32:11.823] Local evaluation: TRUE
[15:32:11.823] Environment: R_GlobalEnv
[15:32:11.823] Capture standard output: TRUE
[15:32:11.823] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.823] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.823] Packages: <none>
[15:32:11.823] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.823] Resolved: TRUE
[15:32:11.823] Value: <not collected>
[15:32:11.823] Conditions captured: <none>
[15:32:11.823] Early signaling: FALSE
[15:32:11.823] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.823] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.842] Chunk #1 of 2 ... DONE
[15:32:11.842] Chunk #2 of 2 ...
[15:32:11.843]  - Finding globals in '...' for chunk #2 ...
[15:32:11.843] getGlobalsAndPackages() ...
[15:32:11.843] Searching for globals...
[15:32:11.844] 
[15:32:11.844] Searching for globals ... DONE
[15:32:11.844] - globals: [0] <none>
[15:32:11.844] getGlobalsAndPackages() ... DONE
[15:32:11.844]    + additional globals found: [n=0] 
[15:32:11.844]    + additional namespaces needed: [n=0] 
[15:32:11.845]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:11.845]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:11.845]  - seeds: <none>
[15:32:11.845]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.845] getGlobalsAndPackages() ...
[15:32:11.846] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.846] Resolving globals: FALSE
[15:32:11.847] The total size of the 5 globals is 3.73 KiB (3824 bytes)
[15:32:11.847] 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 3.73 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (504 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:11.848] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:11.848] 
[15:32:11.848] getGlobalsAndPackages() ... DONE
[15:32:11.848] run() for 'Future' ...
[15:32:11.849] - state: 'created'
[15:32:11.849] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:11.864] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.865] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:11.865]   - Field: 'node'
[15:32:11.865]   - Field: 'label'
[15:32:11.866]   - Field: 'local'
[15:32:11.866]   - Field: 'owner'
[15:32:11.866]   - Field: 'envir'
[15:32:11.867]   - Field: 'workers'
[15:32:11.867]   - Field: 'packages'
[15:32:11.867]   - Field: 'gc'
[15:32:11.867]   - Field: 'conditions'
[15:32:11.868]   - Field: 'persistent'
[15:32:11.868]   - Field: 'expr'
[15:32:11.868]   - Field: 'uuid'
[15:32:11.869]   - Field: 'seed'
[15:32:11.869]   - Field: 'version'
[15:32:11.869]   - Field: 'result'
[15:32:11.870]   - Field: 'asynchronous'
[15:32:11.870]   - Field: 'calls'
[15:32:11.870]   - Field: 'globals'
[15:32:11.870]   - Field: 'stdout'
[15:32:11.871]   - Field: 'earlySignal'
[15:32:11.871]   - Field: 'lazy'
[15:32:11.871]   - Field: 'state'
[15:32:11.871] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:11.872] - Launch lazy future ...
[15:32:11.872] Packages needed by the future expression (n = 0): <none>
[15:32:11.873] Packages needed by future strategies (n = 0): <none>
[15:32:11.873] {
[15:32:11.873]     {
[15:32:11.873]         {
[15:32:11.873]             ...future.startTime <- base::Sys.time()
[15:32:11.873]             {
[15:32:11.873]                 {
[15:32:11.873]                   {
[15:32:11.873]                     {
[15:32:11.873]                       base::local({
[15:32:11.873]                         has_future <- base::requireNamespace("future", 
[15:32:11.873]                           quietly = TRUE)
[15:32:11.873]                         if (has_future) {
[15:32:11.873]                           ns <- base::getNamespace("future")
[15:32:11.873]                           version <- ns[[".package"]][["version"]]
[15:32:11.873]                           if (is.null(version)) 
[15:32:11.873]                             version <- utils::packageVersion("future")
[15:32:11.873]                         }
[15:32:11.873]                         else {
[15:32:11.873]                           version <- NULL
[15:32:11.873]                         }
[15:32:11.873]                         if (!has_future || version < "1.8.0") {
[15:32:11.873]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:11.873]                             "", base::R.version$version.string), 
[15:32:11.873]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:11.873]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:11.873]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:11.873]                               "release", "version")], collapse = " "), 
[15:32:11.873]                             hostname = base::Sys.info()[["nodename"]])
[15:32:11.873]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:11.873]                             info)
[15:32:11.873]                           info <- base::paste(info, collapse = "; ")
[15:32:11.873]                           if (!has_future) {
[15:32:11.873]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:11.873]                               info)
[15:32:11.873]                           }
[15:32:11.873]                           else {
[15:32:11.873]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:11.873]                               info, version)
[15:32:11.873]                           }
[15:32:11.873]                           base::stop(msg)
[15:32:11.873]                         }
[15:32:11.873]                       })
[15:32:11.873]                     }
[15:32:11.873]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:11.873]                     base::options(mc.cores = 1L)
[15:32:11.873]                   }
[15:32:11.873]                   ...future.strategy.old <- future::plan("list")
[15:32:11.873]                   options(future.plan = NULL)
[15:32:11.873]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.873]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:11.873]                 }
[15:32:11.873]                 ...future.workdir <- getwd()
[15:32:11.873]             }
[15:32:11.873]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:11.873]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:11.873]         }
[15:32:11.873]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:11.873]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:11.873]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:11.873]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:11.873]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:11.873]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:11.873]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:11.873]             base::names(...future.oldOptions))
[15:32:11.873]     }
[15:32:11.873]     if (FALSE) {
[15:32:11.873]     }
[15:32:11.873]     else {
[15:32:11.873]         if (TRUE) {
[15:32:11.873]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:11.873]                 open = "w")
[15:32:11.873]         }
[15:32:11.873]         else {
[15:32:11.873]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:11.873]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:11.873]         }
[15:32:11.873]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:11.873]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:11.873]             base::sink(type = "output", split = FALSE)
[15:32:11.873]             base::close(...future.stdout)
[15:32:11.873]         }, add = TRUE)
[15:32:11.873]     }
[15:32:11.873]     ...future.frame <- base::sys.nframe()
[15:32:11.873]     ...future.conditions <- base::list()
[15:32:11.873]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:11.873]     if (FALSE) {
[15:32:11.873]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:11.873]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:11.873]     }
[15:32:11.873]     ...future.result <- base::tryCatch({
[15:32:11.873]         base::withCallingHandlers({
[15:32:11.873]             ...future.value <- base::withVisible(base::local({
[15:32:11.873]                 ...future.makeSendCondition <- base::local({
[15:32:11.873]                   sendCondition <- NULL
[15:32:11.873]                   function(frame = 1L) {
[15:32:11.873]                     if (is.function(sendCondition)) 
[15:32:11.873]                       return(sendCondition)
[15:32:11.873]                     ns <- getNamespace("parallel")
[15:32:11.873]                     if (exists("sendData", mode = "function", 
[15:32:11.873]                       envir = ns)) {
[15:32:11.873]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:11.873]                         envir = ns)
[15:32:11.873]                       envir <- sys.frame(frame)
[15:32:11.873]                       master <- NULL
[15:32:11.873]                       while (!identical(envir, .GlobalEnv) && 
[15:32:11.873]                         !identical(envir, emptyenv())) {
[15:32:11.873]                         if (exists("master", mode = "list", envir = envir, 
[15:32:11.873]                           inherits = FALSE)) {
[15:32:11.873]                           master <- get("master", mode = "list", 
[15:32:11.873]                             envir = envir, inherits = FALSE)
[15:32:11.873]                           if (inherits(master, c("SOCKnode", 
[15:32:11.873]                             "SOCK0node"))) {
[15:32:11.873]                             sendCondition <<- function(cond) {
[15:32:11.873]                               data <- list(type = "VALUE", value = cond, 
[15:32:11.873]                                 success = TRUE)
[15:32:11.873]                               parallel_sendData(master, data)
[15:32:11.873]                             }
[15:32:11.873]                             return(sendCondition)
[15:32:11.873]                           }
[15:32:11.873]                         }
[15:32:11.873]                         frame <- frame + 1L
[15:32:11.873]                         envir <- sys.frame(frame)
[15:32:11.873]                       }
[15:32:11.873]                     }
[15:32:11.873]                     sendCondition <<- function(cond) NULL
[15:32:11.873]                   }
[15:32:11.873]                 })
[15:32:11.873]                 withCallingHandlers({
[15:32:11.873]                   {
[15:32:11.873]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.873]                     if (!identical(...future.globals.maxSize.org, 
[15:32:11.873]                       ...future.globals.maxSize)) {
[15:32:11.873]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.873]                       on.exit(options(oopts), add = TRUE)
[15:32:11.873]                     }
[15:32:11.873]                     {
[15:32:11.873]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.873]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:11.873]                         USE.NAMES = FALSE)
[15:32:11.873]                       do.call(mapply, args = args)
[15:32:11.873]                     }
[15:32:11.873]                   }
[15:32:11.873]                 }, immediateCondition = function(cond) {
[15:32:11.873]                   sendCondition <- ...future.makeSendCondition()
[15:32:11.873]                   sendCondition(cond)
[15:32:11.873]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.873]                   {
[15:32:11.873]                     inherits <- base::inherits
[15:32:11.873]                     invokeRestart <- base::invokeRestart
[15:32:11.873]                     is.null <- base::is.null
[15:32:11.873]                     muffled <- FALSE
[15:32:11.873]                     if (inherits(cond, "message")) {
[15:32:11.873]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:11.873]                       if (muffled) 
[15:32:11.873]                         invokeRestart("muffleMessage")
[15:32:11.873]                     }
[15:32:11.873]                     else if (inherits(cond, "warning")) {
[15:32:11.873]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:11.873]                       if (muffled) 
[15:32:11.873]                         invokeRestart("muffleWarning")
[15:32:11.873]                     }
[15:32:11.873]                     else if (inherits(cond, "condition")) {
[15:32:11.873]                       if (!is.null(pattern)) {
[15:32:11.873]                         computeRestarts <- base::computeRestarts
[15:32:11.873]                         grepl <- base::grepl
[15:32:11.873]                         restarts <- computeRestarts(cond)
[15:32:11.873]                         for (restart in restarts) {
[15:32:11.873]                           name <- restart$name
[15:32:11.873]                           if (is.null(name)) 
[15:32:11.873]                             next
[15:32:11.873]                           if (!grepl(pattern, name)) 
[15:32:11.873]                             next
[15:32:11.873]                           invokeRestart(restart)
[15:32:11.873]                           muffled <- TRUE
[15:32:11.873]                           break
[15:32:11.873]                         }
[15:32:11.873]                       }
[15:32:11.873]                     }
[15:32:11.873]                     invisible(muffled)
[15:32:11.873]                   }
[15:32:11.873]                   muffleCondition(cond)
[15:32:11.873]                 })
[15:32:11.873]             }))
[15:32:11.873]             future::FutureResult(value = ...future.value$value, 
[15:32:11.873]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.873]                   ...future.rng), globalenv = if (FALSE) 
[15:32:11.873]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:11.873]                     ...future.globalenv.names))
[15:32:11.873]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:11.873]         }, condition = base::local({
[15:32:11.873]             c <- base::c
[15:32:11.873]             inherits <- base::inherits
[15:32:11.873]             invokeRestart <- base::invokeRestart
[15:32:11.873]             length <- base::length
[15:32:11.873]             list <- base::list
[15:32:11.873]             seq.int <- base::seq.int
[15:32:11.873]             signalCondition <- base::signalCondition
[15:32:11.873]             sys.calls <- base::sys.calls
[15:32:11.873]             `[[` <- base::`[[`
[15:32:11.873]             `+` <- base::`+`
[15:32:11.873]             `<<-` <- base::`<<-`
[15:32:11.873]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:11.873]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:11.873]                   3L)]
[15:32:11.873]             }
[15:32:11.873]             function(cond) {
[15:32:11.873]                 is_error <- inherits(cond, "error")
[15:32:11.873]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:11.873]                   NULL)
[15:32:11.873]                 if (is_error) {
[15:32:11.873]                   sessionInformation <- function() {
[15:32:11.873]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:11.873]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:11.873]                       search = base::search(), system = base::Sys.info())
[15:32:11.873]                   }
[15:32:11.873]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.873]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:11.873]                     cond$call), session = sessionInformation(), 
[15:32:11.873]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:11.873]                   signalCondition(cond)
[15:32:11.873]                 }
[15:32:11.873]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:11.873]                 "immediateCondition"))) {
[15:32:11.873]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:11.873]                   ...future.conditions[[length(...future.conditions) + 
[15:32:11.873]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:11.873]                   if (TRUE && !signal) {
[15:32:11.873]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.873]                     {
[15:32:11.873]                       inherits <- base::inherits
[15:32:11.873]                       invokeRestart <- base::invokeRestart
[15:32:11.873]                       is.null <- base::is.null
[15:32:11.873]                       muffled <- FALSE
[15:32:11.873]                       if (inherits(cond, "message")) {
[15:32:11.873]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.873]                         if (muffled) 
[15:32:11.873]                           invokeRestart("muffleMessage")
[15:32:11.873]                       }
[15:32:11.873]                       else if (inherits(cond, "warning")) {
[15:32:11.873]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.873]                         if (muffled) 
[15:32:11.873]                           invokeRestart("muffleWarning")
[15:32:11.873]                       }
[15:32:11.873]                       else if (inherits(cond, "condition")) {
[15:32:11.873]                         if (!is.null(pattern)) {
[15:32:11.873]                           computeRestarts <- base::computeRestarts
[15:32:11.873]                           grepl <- base::grepl
[15:32:11.873]                           restarts <- computeRestarts(cond)
[15:32:11.873]                           for (restart in restarts) {
[15:32:11.873]                             name <- restart$name
[15:32:11.873]                             if (is.null(name)) 
[15:32:11.873]                               next
[15:32:11.873]                             if (!grepl(pattern, name)) 
[15:32:11.873]                               next
[15:32:11.873]                             invokeRestart(restart)
[15:32:11.873]                             muffled <- TRUE
[15:32:11.873]                             break
[15:32:11.873]                           }
[15:32:11.873]                         }
[15:32:11.873]                       }
[15:32:11.873]                       invisible(muffled)
[15:32:11.873]                     }
[15:32:11.873]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.873]                   }
[15:32:11.873]                 }
[15:32:11.873]                 else {
[15:32:11.873]                   if (TRUE) {
[15:32:11.873]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:11.873]                     {
[15:32:11.873]                       inherits <- base::inherits
[15:32:11.873]                       invokeRestart <- base::invokeRestart
[15:32:11.873]                       is.null <- base::is.null
[15:32:11.873]                       muffled <- FALSE
[15:32:11.873]                       if (inherits(cond, "message")) {
[15:32:11.873]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:11.873]                         if (muffled) 
[15:32:11.873]                           invokeRestart("muffleMessage")
[15:32:11.873]                       }
[15:32:11.873]                       else if (inherits(cond, "warning")) {
[15:32:11.873]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:11.873]                         if (muffled) 
[15:32:11.873]                           invokeRestart("muffleWarning")
[15:32:11.873]                       }
[15:32:11.873]                       else if (inherits(cond, "condition")) {
[15:32:11.873]                         if (!is.null(pattern)) {
[15:32:11.873]                           computeRestarts <- base::computeRestarts
[15:32:11.873]                           grepl <- base::grepl
[15:32:11.873]                           restarts <- computeRestarts(cond)
[15:32:11.873]                           for (restart in restarts) {
[15:32:11.873]                             name <- restart$name
[15:32:11.873]                             if (is.null(name)) 
[15:32:11.873]                               next
[15:32:11.873]                             if (!grepl(pattern, name)) 
[15:32:11.873]                               next
[15:32:11.873]                             invokeRestart(restart)
[15:32:11.873]                             muffled <- TRUE
[15:32:11.873]                             break
[15:32:11.873]                           }
[15:32:11.873]                         }
[15:32:11.873]                       }
[15:32:11.873]                       invisible(muffled)
[15:32:11.873]                     }
[15:32:11.873]                     muffleCondition(cond, pattern = "^muffle")
[15:32:11.873]                   }
[15:32:11.873]                 }
[15:32:11.873]             }
[15:32:11.873]         }))
[15:32:11.873]     }, error = function(ex) {
[15:32:11.873]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:11.873]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:11.873]                 ...future.rng), started = ...future.startTime, 
[15:32:11.873]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:11.873]             version = "1.8"), class = "FutureResult")
[15:32:11.873]     }, finally = {
[15:32:11.873]         if (!identical(...future.workdir, getwd())) 
[15:32:11.873]             setwd(...future.workdir)
[15:32:11.873]         {
[15:32:11.873]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:11.873]                 ...future.oldOptions$nwarnings <- NULL
[15:32:11.873]             }
[15:32:11.873]             base::options(...future.oldOptions)
[15:32:11.873]             if (.Platform$OS.type == "windows") {
[15:32:11.873]                 old_names <- names(...future.oldEnvVars)
[15:32:11.873]                 envs <- base::Sys.getenv()
[15:32:11.873]                 names <- names(envs)
[15:32:11.873]                 common <- intersect(names, old_names)
[15:32:11.873]                 added <- setdiff(names, old_names)
[15:32:11.873]                 removed <- setdiff(old_names, names)
[15:32:11.873]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:11.873]                   envs[common]]
[15:32:11.873]                 NAMES <- toupper(changed)
[15:32:11.873]                 args <- list()
[15:32:11.873]                 for (kk in seq_along(NAMES)) {
[15:32:11.873]                   name <- changed[[kk]]
[15:32:11.873]                   NAME <- NAMES[[kk]]
[15:32:11.873]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.873]                     next
[15:32:11.873]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.873]                 }
[15:32:11.873]                 NAMES <- toupper(added)
[15:32:11.873]                 for (kk in seq_along(NAMES)) {
[15:32:11.873]                   name <- added[[kk]]
[15:32:11.873]                   NAME <- NAMES[[kk]]
[15:32:11.873]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.873]                     next
[15:32:11.873]                   args[[name]] <- ""
[15:32:11.873]                 }
[15:32:11.873]                 NAMES <- toupper(removed)
[15:32:11.873]                 for (kk in seq_along(NAMES)) {
[15:32:11.873]                   name <- removed[[kk]]
[15:32:11.873]                   NAME <- NAMES[[kk]]
[15:32:11.873]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:11.873]                     next
[15:32:11.873]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:11.873]                 }
[15:32:11.873]                 if (length(args) > 0) 
[15:32:11.873]                   base::do.call(base::Sys.setenv, args = args)
[15:32:11.873]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:11.873]             }
[15:32:11.873]             else {
[15:32:11.873]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:11.873]             }
[15:32:11.873]             {
[15:32:11.873]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:11.873]                   0L) {
[15:32:11.873]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:11.873]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:11.873]                   base::options(opts)
[15:32:11.873]                 }
[15:32:11.873]                 {
[15:32:11.873]                   {
[15:32:11.873]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:11.873]                     NULL
[15:32:11.873]                   }
[15:32:11.873]                   options(future.plan = NULL)
[15:32:11.873]                   if (is.na(NA_character_)) 
[15:32:11.873]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:11.873]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:11.873]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:11.873]                     .init = FALSE)
[15:32:11.873]                 }
[15:32:11.873]             }
[15:32:11.873]         }
[15:32:11.873]     })
[15:32:11.873]     if (TRUE) {
[15:32:11.873]         base::sink(type = "output", split = FALSE)
[15:32:11.873]         if (TRUE) {
[15:32:11.873]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:11.873]         }
[15:32:11.873]         else {
[15:32:11.873]             ...future.result["stdout"] <- base::list(NULL)
[15:32:11.873]         }
[15:32:11.873]         base::close(...future.stdout)
[15:32:11.873]         ...future.stdout <- NULL
[15:32:11.873]     }
[15:32:11.873]     ...future.result$conditions <- ...future.conditions
[15:32:11.873]     ...future.result$finished <- base::Sys.time()
[15:32:11.873]     ...future.result
[15:32:11.873] }
[15:32:11.882] Exporting 5 global objects (3.73 KiB) to cluster node #1 ...
[15:32:11.882] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:11.883] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:11.884] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:11.885] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:11.885] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ...
[15:32:11.886] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ... DONE
[15:32:11.886] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:11.887] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:11.951] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:11.952] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:11.953] Exporting 5 global objects (3.73 KiB) to cluster node #1 ... DONE
[15:32:11.954] MultisessionFuture started
[15:32:11.955] - Launch lazy future ... done
[15:32:11.955] run() for 'MultisessionFuture' ... done
[15:32:11.955] Created future:
[15:32:11.977] receiveMessageFromWorker() for ClusterFuture ...
[15:32:11.978] - Validating connection of MultisessionFuture
[15:32:11.978] - received message: FutureResult
[15:32:11.979] - Received FutureResult
[15:32:11.979] - Erased future from FutureRegistry
[15:32:11.979] result() for ClusterFuture ...
[15:32:11.979] - result already collected: FutureResult
[15:32:11.980] result() for ClusterFuture ... done
[15:32:11.980] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:11.956] MultisessionFuture:
[15:32:11.956] Label: 'future_.mapply-2'
[15:32:11.956] Expression:
[15:32:11.956] {
[15:32:11.956]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:11.956]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:11.956]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:11.956]         on.exit(options(oopts), add = TRUE)
[15:32:11.956]     }
[15:32:11.956]     {
[15:32:11.956]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:11.956]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:11.956]         do.call(mapply, args = args)
[15:32:11.956]     }
[15:32:11.956] }
[15:32:11.956] Lazy evaluation: FALSE
[15:32:11.956] Asynchronous evaluation: TRUE
[15:32:11.956] Local evaluation: TRUE
[15:32:11.956] Environment: R_GlobalEnv
[15:32:11.956] Capture standard output: TRUE
[15:32:11.956] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:11.956] Globals: 5 objects totaling 3.73 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 504 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:11.956] Packages: <none>
[15:32:11.956] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:11.956] Resolved: TRUE
[15:32:11.956] Value: <not collected>
[15:32:11.956] Conditions captured: <none>
[15:32:11.956] Early signaling: FALSE
[15:32:11.956] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:11.956] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:11.981] Chunk #2 of 2 ... DONE
[15:32:11.981] Launching 2 futures (chunks) ... DONE
[15:32:11.981] Resolving 2 futures (chunks) ...
[15:32:11.981] resolve() on list ...
[15:32:11.982]  recursive: 0
[15:32:11.982]  length: 2
[15:32:11.982] 
[15:32:11.982] Future #1
[15:32:11.982] result() for ClusterFuture ...
[15:32:11.982] - result already collected: FutureResult
[15:32:11.983] result() for ClusterFuture ... done
[15:32:11.983] result() for ClusterFuture ...
[15:32:11.983] - result already collected: FutureResult
[15:32:11.983] result() for ClusterFuture ... done
[15:32:11.984] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:11.984] - nx: 2
[15:32:11.984] - relay: TRUE
[15:32:11.985] - stdout: TRUE
[15:32:11.985] - signal: TRUE
[15:32:11.985] - resignal: FALSE
[15:32:11.985] - force: TRUE
[15:32:11.986] - relayed: [n=2] FALSE, FALSE
[15:32:11.986] - queued futures: [n=2] FALSE, FALSE
[15:32:11.986]  - until=1
[15:32:11.986]  - relaying element #1
[15:32:11.987] result() for ClusterFuture ...
[15:32:11.987] - result already collected: FutureResult
[15:32:11.987] result() for ClusterFuture ... done
[15:32:11.988] result() for ClusterFuture ...
[15:32:11.988] - result already collected: FutureResult
[15:32:11.988] result() for ClusterFuture ... done
[15:32:11.989] result() for ClusterFuture ...
[15:32:11.989] - result already collected: FutureResult
[15:32:11.989] result() for ClusterFuture ... done
[15:32:11.989] result() for ClusterFuture ...
[15:32:11.990] - result already collected: FutureResult
[15:32:11.990] result() for ClusterFuture ... done
[15:32:11.990] - relayed: [n=2] TRUE, FALSE
[15:32:11.990] - queued futures: [n=2] TRUE, FALSE
[15:32:11.991] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:11.991]  length: 1 (resolved future 1)
[15:32:11.991] Future #2
[15:32:11.992] result() for ClusterFuture ...
[15:32:11.992] - result already collected: FutureResult
[15:32:11.992] result() for ClusterFuture ... done
[15:32:11.992] result() for ClusterFuture ...
[15:32:11.993] - result already collected: FutureResult
[15:32:11.993] result() for ClusterFuture ... done
[15:32:11.993] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:11.994] - nx: 2
[15:32:11.994] - relay: TRUE
[15:32:11.994] - stdout: TRUE
[15:32:11.994] - signal: TRUE
[15:32:11.995] - resignal: FALSE
[15:32:11.995] - force: TRUE
[15:32:11.995] - relayed: [n=2] TRUE, FALSE
[15:32:11.995] - queued futures: [n=2] TRUE, FALSE
[15:32:11.996]  - until=2
[15:32:11.996]  - relaying element #2
[15:32:11.996] result() for ClusterFuture ...
[15:32:11.997] - result already collected: FutureResult
[15:32:11.997] result() for ClusterFuture ... done
[15:32:11.997] result() for ClusterFuture ...
[15:32:11.997] - result already collected: FutureResult
[15:32:11.998] result() for ClusterFuture ... done
[15:32:11.998] result() for ClusterFuture ...
[15:32:11.998] - result already collected: FutureResult
[15:32:11.999] result() for ClusterFuture ... done
[15:32:11.999] result() for ClusterFuture ...
[15:32:11.999] - result already collected: FutureResult
[15:32:11.999] result() for ClusterFuture ... done
[15:32:12.000] - relayed: [n=2] TRUE, TRUE
[15:32:12.000] - queued futures: [n=2] TRUE, TRUE
[15:32:12.000] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:12.001]  length: 0 (resolved future 2)
[15:32:12.001] Relaying remaining futures
[15:32:12.001] signalConditionsASAP(NULL, pos=0) ...
[15:32:12.001] - nx: 2
[15:32:12.002] - relay: TRUE
[15:32:12.002] - stdout: TRUE
[15:32:12.002] - signal: TRUE
[15:32:12.002] - resignal: FALSE
[15:32:12.003] - force: TRUE
[15:32:12.003] - relayed: [n=2] TRUE, TRUE
[15:32:12.003] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:12.004] - relayed: [n=2] TRUE, TRUE
[15:32:12.004] - queued futures: [n=2] TRUE, TRUE
[15:32:12.004] signalConditionsASAP(NULL, pos=0) ... done
[15:32:12.004] resolve() on list ... DONE
[15:32:12.004] result() for ClusterFuture ...
[15:32:12.005] - result already collected: FutureResult
[15:32:12.005] result() for ClusterFuture ... done
[15:32:12.005] result() for ClusterFuture ...
[15:32:12.005] - result already collected: FutureResult
[15:32:12.005] result() for ClusterFuture ... done
[15:32:12.005] result() for ClusterFuture ...
[15:32:12.006] - result already collected: FutureResult
[15:32:12.006] result() for ClusterFuture ... done
[15:32:12.006] result() for ClusterFuture ...
[15:32:12.006] - result already collected: FutureResult
[15:32:12.006] result() for ClusterFuture ... done
[15:32:12.006]  - Number of value chunks collected: 2
[15:32:12.007] Resolving 2 futures (chunks) ... DONE
[15:32:12.007] Reducing values from 2 chunks ...
[15:32:12.007]  - Number of values collected after concatenation: 5
[15:32:12.007]  - Number of values expected: 5
[15:32:12.007] Reducing values from 2 chunks ... DONE
[15:32:12.007] future_mapply() ... DONE
[15:32:12.008] future_mapply() ...
[15:32:12.011] Number of chunks: 3
[15:32:12.011] Index remapping (attribute 'ordering'): [n = 5] 2, 5, 1, 3, 4
[15:32:12.011] getGlobalsAndPackagesXApply() ...
[15:32:12.011]  - future.globals: TRUE
[15:32:12.011] getGlobalsAndPackages() ...
[15:32:12.012] Searching for globals...
[15:32:12.013] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:12.014] Searching for globals ... DONE
[15:32:12.014] Resolving globals: FALSE
[15:32:12.015] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:12.015] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:12.015] - globals: [1] 'FUN'
[15:32:12.016] 
[15:32:12.016] getGlobalsAndPackages() ... DONE
[15:32:12.016]  - globals found/used: [n=1] 'FUN'
[15:32:12.016]  - needed namespaces: [n=0] 
[15:32:12.016] Finding globals ... DONE
[15:32:12.017] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:12.017] List of 2
[15:32:12.017]  $ ...future.FUN:function (C, k)  
[15:32:12.017]  $ MoreArgs     : NULL
[15:32:12.017]  - attr(*, "where")=List of 2
[15:32:12.017]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:12.017]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:12.017]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:12.017]  - attr(*, "resolved")= logi FALSE
[15:32:12.017]  - attr(*, "total_size")= num NA
[15:32:12.020] Packages to be attached in all futures: [n=0] 
[15:32:12.020] getGlobalsAndPackagesXApply() ... DONE
[15:32:12.020] Number of futures (= number of chunks): 3
[15:32:12.021] Launching 3 futures (chunks) ...
[15:32:12.021] Chunk #1 of 3 ...
[15:32:12.021]  - Finding globals in '...' for chunk #1 ...
[15:32:12.021] getGlobalsAndPackages() ...
[15:32:12.021] Searching for globals...
[15:32:12.022] 
[15:32:12.022] Searching for globals ... DONE
[15:32:12.022] - globals: [0] <none>
[15:32:12.022] getGlobalsAndPackages() ... DONE
[15:32:12.022]    + additional globals found: [n=0] 
[15:32:12.022]    + additional namespaces needed: [n=0] 
[15:32:12.023]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:12.023]  - Adjusted option 'future.globals.maxSize': 524288000 -> 3 * 524288000 = 1572864000 (bytes)
[15:32:12.023]  - seeds: <none>
[15:32:12.023]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.023] getGlobalsAndPackages() ...
[15:32:12.024] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.024] Resolving globals: FALSE
[15:32:12.024] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:12.025] 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 3.57 KiB.. This exceeds the maximum allowed size of 1.46 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:12.025] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.025] 
[15:32:12.026] getGlobalsAndPackages() ... DONE
[15:32:12.026] run() for 'Future' ...
[15:32:12.027] - state: 'created'
[15:32:12.027] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.042] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.043] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.043]   - Field: 'node'
[15:32:12.043]   - Field: 'label'
[15:32:12.044]   - Field: 'local'
[15:32:12.044]   - Field: 'owner'
[15:32:12.044]   - Field: 'envir'
[15:32:12.044]   - Field: 'workers'
[15:32:12.044]   - Field: 'packages'
[15:32:12.045]   - Field: 'gc'
[15:32:12.045]   - Field: 'conditions'
[15:32:12.045]   - Field: 'persistent'
[15:32:12.045]   - Field: 'expr'
[15:32:12.045]   - Field: 'uuid'
[15:32:12.046]   - Field: 'seed'
[15:32:12.046]   - Field: 'version'
[15:32:12.046]   - Field: 'result'
[15:32:12.046]   - Field: 'asynchronous'
[15:32:12.047]   - Field: 'calls'
[15:32:12.047]   - Field: 'globals'
[15:32:12.047]   - Field: 'stdout'
[15:32:12.048]   - Field: 'earlySignal'
[15:32:12.048]   - Field: 'lazy'
[15:32:12.048]   - Field: 'state'
[15:32:12.049] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.049] - Launch lazy future ...
[15:32:12.049] Packages needed by the future expression (n = 0): <none>
[15:32:12.050] Packages needed by future strategies (n = 0): <none>
[15:32:12.051] {
[15:32:12.051]     {
[15:32:12.051]         {
[15:32:12.051]             ...future.startTime <- base::Sys.time()
[15:32:12.051]             {
[15:32:12.051]                 {
[15:32:12.051]                   {
[15:32:12.051]                     {
[15:32:12.051]                       base::local({
[15:32:12.051]                         has_future <- base::requireNamespace("future", 
[15:32:12.051]                           quietly = TRUE)
[15:32:12.051]                         if (has_future) {
[15:32:12.051]                           ns <- base::getNamespace("future")
[15:32:12.051]                           version <- ns[[".package"]][["version"]]
[15:32:12.051]                           if (is.null(version)) 
[15:32:12.051]                             version <- utils::packageVersion("future")
[15:32:12.051]                         }
[15:32:12.051]                         else {
[15:32:12.051]                           version <- NULL
[15:32:12.051]                         }
[15:32:12.051]                         if (!has_future || version < "1.8.0") {
[15:32:12.051]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.051]                             "", base::R.version$version.string), 
[15:32:12.051]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.051]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.051]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.051]                               "release", "version")], collapse = " "), 
[15:32:12.051]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.051]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.051]                             info)
[15:32:12.051]                           info <- base::paste(info, collapse = "; ")
[15:32:12.051]                           if (!has_future) {
[15:32:12.051]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.051]                               info)
[15:32:12.051]                           }
[15:32:12.051]                           else {
[15:32:12.051]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.051]                               info, version)
[15:32:12.051]                           }
[15:32:12.051]                           base::stop(msg)
[15:32:12.051]                         }
[15:32:12.051]                       })
[15:32:12.051]                     }
[15:32:12.051]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.051]                     base::options(mc.cores = 1L)
[15:32:12.051]                   }
[15:32:12.051]                   ...future.strategy.old <- future::plan("list")
[15:32:12.051]                   options(future.plan = NULL)
[15:32:12.051]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.051]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.051]                 }
[15:32:12.051]                 ...future.workdir <- getwd()
[15:32:12.051]             }
[15:32:12.051]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.051]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.051]         }
[15:32:12.051]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.051]             future.globals.maxSize = 1572864000, future.globals.method = NULL, 
[15:32:12.051]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.051]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.051]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.051]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.051]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.051]             base::names(...future.oldOptions))
[15:32:12.051]     }
[15:32:12.051]     if (FALSE) {
[15:32:12.051]     }
[15:32:12.051]     else {
[15:32:12.051]         if (TRUE) {
[15:32:12.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.051]                 open = "w")
[15:32:12.051]         }
[15:32:12.051]         else {
[15:32:12.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.051]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.051]         }
[15:32:12.051]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.051]             base::sink(type = "output", split = FALSE)
[15:32:12.051]             base::close(...future.stdout)
[15:32:12.051]         }, add = TRUE)
[15:32:12.051]     }
[15:32:12.051]     ...future.frame <- base::sys.nframe()
[15:32:12.051]     ...future.conditions <- base::list()
[15:32:12.051]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.051]     if (FALSE) {
[15:32:12.051]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.051]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.051]     }
[15:32:12.051]     ...future.result <- base::tryCatch({
[15:32:12.051]         base::withCallingHandlers({
[15:32:12.051]             ...future.value <- base::withVisible(base::local({
[15:32:12.051]                 ...future.makeSendCondition <- base::local({
[15:32:12.051]                   sendCondition <- NULL
[15:32:12.051]                   function(frame = 1L) {
[15:32:12.051]                     if (is.function(sendCondition)) 
[15:32:12.051]                       return(sendCondition)
[15:32:12.051]                     ns <- getNamespace("parallel")
[15:32:12.051]                     if (exists("sendData", mode = "function", 
[15:32:12.051]                       envir = ns)) {
[15:32:12.051]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.051]                         envir = ns)
[15:32:12.051]                       envir <- sys.frame(frame)
[15:32:12.051]                       master <- NULL
[15:32:12.051]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.051]                         !identical(envir, emptyenv())) {
[15:32:12.051]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.051]                           inherits = FALSE)) {
[15:32:12.051]                           master <- get("master", mode = "list", 
[15:32:12.051]                             envir = envir, inherits = FALSE)
[15:32:12.051]                           if (inherits(master, c("SOCKnode", 
[15:32:12.051]                             "SOCK0node"))) {
[15:32:12.051]                             sendCondition <<- function(cond) {
[15:32:12.051]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.051]                                 success = TRUE)
[15:32:12.051]                               parallel_sendData(master, data)
[15:32:12.051]                             }
[15:32:12.051]                             return(sendCondition)
[15:32:12.051]                           }
[15:32:12.051]                         }
[15:32:12.051]                         frame <- frame + 1L
[15:32:12.051]                         envir <- sys.frame(frame)
[15:32:12.051]                       }
[15:32:12.051]                     }
[15:32:12.051]                     sendCondition <<- function(cond) NULL
[15:32:12.051]                   }
[15:32:12.051]                 })
[15:32:12.051]                 withCallingHandlers({
[15:32:12.051]                   {
[15:32:12.051]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.051]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.051]                       ...future.globals.maxSize)) {
[15:32:12.051]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.051]                       on.exit(options(oopts), add = TRUE)
[15:32:12.051]                     }
[15:32:12.051]                     {
[15:32:12.051]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.051]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.051]                         USE.NAMES = FALSE)
[15:32:12.051]                       do.call(mapply, args = args)
[15:32:12.051]                     }
[15:32:12.051]                   }
[15:32:12.051]                 }, immediateCondition = function(cond) {
[15:32:12.051]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.051]                   sendCondition(cond)
[15:32:12.051]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.051]                   {
[15:32:12.051]                     inherits <- base::inherits
[15:32:12.051]                     invokeRestart <- base::invokeRestart
[15:32:12.051]                     is.null <- base::is.null
[15:32:12.051]                     muffled <- FALSE
[15:32:12.051]                     if (inherits(cond, "message")) {
[15:32:12.051]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.051]                       if (muffled) 
[15:32:12.051]                         invokeRestart("muffleMessage")
[15:32:12.051]                     }
[15:32:12.051]                     else if (inherits(cond, "warning")) {
[15:32:12.051]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.051]                       if (muffled) 
[15:32:12.051]                         invokeRestart("muffleWarning")
[15:32:12.051]                     }
[15:32:12.051]                     else if (inherits(cond, "condition")) {
[15:32:12.051]                       if (!is.null(pattern)) {
[15:32:12.051]                         computeRestarts <- base::computeRestarts
[15:32:12.051]                         grepl <- base::grepl
[15:32:12.051]                         restarts <- computeRestarts(cond)
[15:32:12.051]                         for (restart in restarts) {
[15:32:12.051]                           name <- restart$name
[15:32:12.051]                           if (is.null(name)) 
[15:32:12.051]                             next
[15:32:12.051]                           if (!grepl(pattern, name)) 
[15:32:12.051]                             next
[15:32:12.051]                           invokeRestart(restart)
[15:32:12.051]                           muffled <- TRUE
[15:32:12.051]                           break
[15:32:12.051]                         }
[15:32:12.051]                       }
[15:32:12.051]                     }
[15:32:12.051]                     invisible(muffled)
[15:32:12.051]                   }
[15:32:12.051]                   muffleCondition(cond)
[15:32:12.051]                 })
[15:32:12.051]             }))
[15:32:12.051]             future::FutureResult(value = ...future.value$value, 
[15:32:12.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.051]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.051]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.051]                     ...future.globalenv.names))
[15:32:12.051]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.051]         }, condition = base::local({
[15:32:12.051]             c <- base::c
[15:32:12.051]             inherits <- base::inherits
[15:32:12.051]             invokeRestart <- base::invokeRestart
[15:32:12.051]             length <- base::length
[15:32:12.051]             list <- base::list
[15:32:12.051]             seq.int <- base::seq.int
[15:32:12.051]             signalCondition <- base::signalCondition
[15:32:12.051]             sys.calls <- base::sys.calls
[15:32:12.051]             `[[` <- base::`[[`
[15:32:12.051]             `+` <- base::`+`
[15:32:12.051]             `<<-` <- base::`<<-`
[15:32:12.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.051]                   3L)]
[15:32:12.051]             }
[15:32:12.051]             function(cond) {
[15:32:12.051]                 is_error <- inherits(cond, "error")
[15:32:12.051]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.051]                   NULL)
[15:32:12.051]                 if (is_error) {
[15:32:12.051]                   sessionInformation <- function() {
[15:32:12.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.051]                       search = base::search(), system = base::Sys.info())
[15:32:12.051]                   }
[15:32:12.051]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.051]                     cond$call), session = sessionInformation(), 
[15:32:12.051]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.051]                   signalCondition(cond)
[15:32:12.051]                 }
[15:32:12.051]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.051]                 "immediateCondition"))) {
[15:32:12.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.051]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.051]                   if (TRUE && !signal) {
[15:32:12.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.051]                     {
[15:32:12.051]                       inherits <- base::inherits
[15:32:12.051]                       invokeRestart <- base::invokeRestart
[15:32:12.051]                       is.null <- base::is.null
[15:32:12.051]                       muffled <- FALSE
[15:32:12.051]                       if (inherits(cond, "message")) {
[15:32:12.051]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.051]                         if (muffled) 
[15:32:12.051]                           invokeRestart("muffleMessage")
[15:32:12.051]                       }
[15:32:12.051]                       else if (inherits(cond, "warning")) {
[15:32:12.051]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.051]                         if (muffled) 
[15:32:12.051]                           invokeRestart("muffleWarning")
[15:32:12.051]                       }
[15:32:12.051]                       else if (inherits(cond, "condition")) {
[15:32:12.051]                         if (!is.null(pattern)) {
[15:32:12.051]                           computeRestarts <- base::computeRestarts
[15:32:12.051]                           grepl <- base::grepl
[15:32:12.051]                           restarts <- computeRestarts(cond)
[15:32:12.051]                           for (restart in restarts) {
[15:32:12.051]                             name <- restart$name
[15:32:12.051]                             if (is.null(name)) 
[15:32:12.051]                               next
[15:32:12.051]                             if (!grepl(pattern, name)) 
[15:32:12.051]                               next
[15:32:12.051]                             invokeRestart(restart)
[15:32:12.051]                             muffled <- TRUE
[15:32:12.051]                             break
[15:32:12.051]                           }
[15:32:12.051]                         }
[15:32:12.051]                       }
[15:32:12.051]                       invisible(muffled)
[15:32:12.051]                     }
[15:32:12.051]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.051]                   }
[15:32:12.051]                 }
[15:32:12.051]                 else {
[15:32:12.051]                   if (TRUE) {
[15:32:12.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.051]                     {
[15:32:12.051]                       inherits <- base::inherits
[15:32:12.051]                       invokeRestart <- base::invokeRestart
[15:32:12.051]                       is.null <- base::is.null
[15:32:12.051]                       muffled <- FALSE
[15:32:12.051]                       if (inherits(cond, "message")) {
[15:32:12.051]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.051]                         if (muffled) 
[15:32:12.051]                           invokeRestart("muffleMessage")
[15:32:12.051]                       }
[15:32:12.051]                       else if (inherits(cond, "warning")) {
[15:32:12.051]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.051]                         if (muffled) 
[15:32:12.051]                           invokeRestart("muffleWarning")
[15:32:12.051]                       }
[15:32:12.051]                       else if (inherits(cond, "condition")) {
[15:32:12.051]                         if (!is.null(pattern)) {
[15:32:12.051]                           computeRestarts <- base::computeRestarts
[15:32:12.051]                           grepl <- base::grepl
[15:32:12.051]                           restarts <- computeRestarts(cond)
[15:32:12.051]                           for (restart in restarts) {
[15:32:12.051]                             name <- restart$name
[15:32:12.051]                             if (is.null(name)) 
[15:32:12.051]                               next
[15:32:12.051]                             if (!grepl(pattern, name)) 
[15:32:12.051]                               next
[15:32:12.051]                             invokeRestart(restart)
[15:32:12.051]                             muffled <- TRUE
[15:32:12.051]                             break
[15:32:12.051]                           }
[15:32:12.051]                         }
[15:32:12.051]                       }
[15:32:12.051]                       invisible(muffled)
[15:32:12.051]                     }
[15:32:12.051]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.051]                   }
[15:32:12.051]                 }
[15:32:12.051]             }
[15:32:12.051]         }))
[15:32:12.051]     }, error = function(ex) {
[15:32:12.051]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.051]                 ...future.rng), started = ...future.startTime, 
[15:32:12.051]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.051]             version = "1.8"), class = "FutureResult")
[15:32:12.051]     }, finally = {
[15:32:12.051]         if (!identical(...future.workdir, getwd())) 
[15:32:12.051]             setwd(...future.workdir)
[15:32:12.051]         {
[15:32:12.051]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.051]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.051]             }
[15:32:12.051]             base::options(...future.oldOptions)
[15:32:12.051]             if (.Platform$OS.type == "windows") {
[15:32:12.051]                 old_names <- names(...future.oldEnvVars)
[15:32:12.051]                 envs <- base::Sys.getenv()
[15:32:12.051]                 names <- names(envs)
[15:32:12.051]                 common <- intersect(names, old_names)
[15:32:12.051]                 added <- setdiff(names, old_names)
[15:32:12.051]                 removed <- setdiff(old_names, names)
[15:32:12.051]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.051]                   envs[common]]
[15:32:12.051]                 NAMES <- toupper(changed)
[15:32:12.051]                 args <- list()
[15:32:12.051]                 for (kk in seq_along(NAMES)) {
[15:32:12.051]                   name <- changed[[kk]]
[15:32:12.051]                   NAME <- NAMES[[kk]]
[15:32:12.051]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.051]                     next
[15:32:12.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.051]                 }
[15:32:12.051]                 NAMES <- toupper(added)
[15:32:12.051]                 for (kk in seq_along(NAMES)) {
[15:32:12.051]                   name <- added[[kk]]
[15:32:12.051]                   NAME <- NAMES[[kk]]
[15:32:12.051]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.051]                     next
[15:32:12.051]                   args[[name]] <- ""
[15:32:12.051]                 }
[15:32:12.051]                 NAMES <- toupper(removed)
[15:32:12.051]                 for (kk in seq_along(NAMES)) {
[15:32:12.051]                   name <- removed[[kk]]
[15:32:12.051]                   NAME <- NAMES[[kk]]
[15:32:12.051]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.051]                     next
[15:32:12.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.051]                 }
[15:32:12.051]                 if (length(args) > 0) 
[15:32:12.051]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.051]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.051]             }
[15:32:12.051]             else {
[15:32:12.051]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.051]             }
[15:32:12.051]             {
[15:32:12.051]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.051]                   0L) {
[15:32:12.051]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.051]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.051]                   base::options(opts)
[15:32:12.051]                 }
[15:32:12.051]                 {
[15:32:12.051]                   {
[15:32:12.051]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.051]                     NULL
[15:32:12.051]                   }
[15:32:12.051]                   options(future.plan = NULL)
[15:32:12.051]                   if (is.na(NA_character_)) 
[15:32:12.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.051]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.051]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.051]                     .init = FALSE)
[15:32:12.051]                 }
[15:32:12.051]             }
[15:32:12.051]         }
[15:32:12.051]     })
[15:32:12.051]     if (TRUE) {
[15:32:12.051]         base::sink(type = "output", split = FALSE)
[15:32:12.051]         if (TRUE) {
[15:32:12.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.051]         }
[15:32:12.051]         else {
[15:32:12.051]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.051]         }
[15:32:12.051]         base::close(...future.stdout)
[15:32:12.051]         ...future.stdout <- NULL
[15:32:12.051]     }
[15:32:12.051]     ...future.result$conditions <- ...future.conditions
[15:32:12.051]     ...future.result$finished <- base::Sys.time()
[15:32:12.051]     ...future.result
[15:32:12.051] }
[15:32:12.060] Exporting 5 global objects (3.57 KiB) to cluster node #1 ...
[15:32:12.061] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.061] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.062] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.063] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.064] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:32:12.066] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:32:12.067] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.068] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.068] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.068] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.069] Exporting 5 global objects (3.57 KiB) to cluster node #1 ... DONE
[15:32:12.069] MultisessionFuture started
[15:32:12.070] - Launch lazy future ... done
[15:32:12.070] run() for 'MultisessionFuture' ... done
[15:32:12.070] Created future:
[15:32:12.096] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.096] - Validating connection of MultisessionFuture
[15:32:12.097] - received message: FutureResult
[15:32:12.097] - Received FutureResult
[15:32:12.097] - Erased future from FutureRegistry
[15:32:12.097] result() for ClusterFuture ...
[15:32:12.097] - result already collected: FutureResult
[15:32:12.098] result() for ClusterFuture ... done
[15:32:12.098] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.070] MultisessionFuture:
[15:32:12.070] Label: 'future_mapply-1'
[15:32:12.070] Expression:
[15:32:12.070] {
[15:32:12.070]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.070]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.070]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.070]         on.exit(options(oopts), add = TRUE)
[15:32:12.070]     }
[15:32:12.070]     {
[15:32:12.070]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.070]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.070]         do.call(mapply, args = args)
[15:32:12.070]     }
[15:32:12.070] }
[15:32:12.070] Lazy evaluation: FALSE
[15:32:12.070] Asynchronous evaluation: TRUE
[15:32:12.070] Local evaluation: TRUE
[15:32:12.070] Environment: R_GlobalEnv
[15:32:12.070] Capture standard output: TRUE
[15:32:12.070] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.070] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.070] Packages: <none>
[15:32:12.070] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.070] Resolved: TRUE
[15:32:12.070] Value: <not collected>
[15:32:12.070] Conditions captured: <none>
[15:32:12.070] Early signaling: FALSE
[15:32:12.070] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.070] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.099] Chunk #1 of 3 ... DONE
[15:32:12.099] Chunk #2 of 3 ...
[15:32:12.099]  - Finding globals in '...' for chunk #2 ...
[15:32:12.099] getGlobalsAndPackages() ...
[15:32:12.100] Searching for globals...
[15:32:12.100] 
[15:32:12.100] Searching for globals ... DONE
[15:32:12.101] - globals: [0] <none>
[15:32:12.101] getGlobalsAndPackages() ... DONE
[15:32:12.101]    + additional globals found: [n=0] 
[15:32:12.101]    + additional namespaces needed: [n=0] 
[15:32:12.101]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:12.102]  - Adjusted option 'future.globals.maxSize': 524288000 -> 3 * 524288000 = 1572864000 (bytes)
[15:32:12.102]  - seeds: <none>
[15:32:12.102]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.102] getGlobalsAndPackages() ...
[15:32:12.102] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.103] Resolving globals: FALSE
[15:32:12.103] The total size of the 5 globals is 3.41 KiB (3488 bytes)
[15:32:12.104] 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 3.41 KiB.. This exceeds the maximum allowed size of 1.46 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (168 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:12.105] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.105] 
[15:32:12.105] getGlobalsAndPackages() ... DONE
[15:32:12.105] run() for 'Future' ...
[15:32:12.106] - state: 'created'
[15:32:12.106] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.121] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.121] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.122]   - Field: 'node'
[15:32:12.122]   - Field: 'label'
[15:32:12.122]   - Field: 'local'
[15:32:12.122]   - Field: 'owner'
[15:32:12.122]   - Field: 'envir'
[15:32:12.123]   - Field: 'workers'
[15:32:12.123]   - Field: 'packages'
[15:32:12.123]   - Field: 'gc'
[15:32:12.123]   - Field: 'conditions'
[15:32:12.124]   - Field: 'persistent'
[15:32:12.124]   - Field: 'expr'
[15:32:12.124]   - Field: 'uuid'
[15:32:12.125]   - Field: 'seed'
[15:32:12.125]   - Field: 'version'
[15:32:12.125]   - Field: 'result'
[15:32:12.125]   - Field: 'asynchronous'
[15:32:12.126]   - Field: 'calls'
[15:32:12.126]   - Field: 'globals'
[15:32:12.126]   - Field: 'stdout'
[15:32:12.127]   - Field: 'earlySignal'
[15:32:12.127]   - Field: 'lazy'
[15:32:12.127]   - Field: 'state'
[15:32:12.128] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.128] - Launch lazy future ...
[15:32:12.129] Packages needed by the future expression (n = 0): <none>
[15:32:12.129] Packages needed by future strategies (n = 0): <none>
[15:32:12.130] {
[15:32:12.130]     {
[15:32:12.130]         {
[15:32:12.130]             ...future.startTime <- base::Sys.time()
[15:32:12.130]             {
[15:32:12.130]                 {
[15:32:12.130]                   {
[15:32:12.130]                     {
[15:32:12.130]                       base::local({
[15:32:12.130]                         has_future <- base::requireNamespace("future", 
[15:32:12.130]                           quietly = TRUE)
[15:32:12.130]                         if (has_future) {
[15:32:12.130]                           ns <- base::getNamespace("future")
[15:32:12.130]                           version <- ns[[".package"]][["version"]]
[15:32:12.130]                           if (is.null(version)) 
[15:32:12.130]                             version <- utils::packageVersion("future")
[15:32:12.130]                         }
[15:32:12.130]                         else {
[15:32:12.130]                           version <- NULL
[15:32:12.130]                         }
[15:32:12.130]                         if (!has_future || version < "1.8.0") {
[15:32:12.130]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.130]                             "", base::R.version$version.string), 
[15:32:12.130]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.130]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.130]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.130]                               "release", "version")], collapse = " "), 
[15:32:12.130]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.130]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.130]                             info)
[15:32:12.130]                           info <- base::paste(info, collapse = "; ")
[15:32:12.130]                           if (!has_future) {
[15:32:12.130]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.130]                               info)
[15:32:12.130]                           }
[15:32:12.130]                           else {
[15:32:12.130]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.130]                               info, version)
[15:32:12.130]                           }
[15:32:12.130]                           base::stop(msg)
[15:32:12.130]                         }
[15:32:12.130]                       })
[15:32:12.130]                     }
[15:32:12.130]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.130]                     base::options(mc.cores = 1L)
[15:32:12.130]                   }
[15:32:12.130]                   ...future.strategy.old <- future::plan("list")
[15:32:12.130]                   options(future.plan = NULL)
[15:32:12.130]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.130]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.130]                 }
[15:32:12.130]                 ...future.workdir <- getwd()
[15:32:12.130]             }
[15:32:12.130]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.130]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.130]         }
[15:32:12.130]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.130]             future.globals.maxSize = 1572864000, future.globals.method = NULL, 
[15:32:12.130]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.130]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.130]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.130]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.130]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.130]             base::names(...future.oldOptions))
[15:32:12.130]     }
[15:32:12.130]     if (FALSE) {
[15:32:12.130]     }
[15:32:12.130]     else {
[15:32:12.130]         if (TRUE) {
[15:32:12.130]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.130]                 open = "w")
[15:32:12.130]         }
[15:32:12.130]         else {
[15:32:12.130]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.130]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.130]         }
[15:32:12.130]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.130]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.130]             base::sink(type = "output", split = FALSE)
[15:32:12.130]             base::close(...future.stdout)
[15:32:12.130]         }, add = TRUE)
[15:32:12.130]     }
[15:32:12.130]     ...future.frame <- base::sys.nframe()
[15:32:12.130]     ...future.conditions <- base::list()
[15:32:12.130]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.130]     if (FALSE) {
[15:32:12.130]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.130]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.130]     }
[15:32:12.130]     ...future.result <- base::tryCatch({
[15:32:12.130]         base::withCallingHandlers({
[15:32:12.130]             ...future.value <- base::withVisible(base::local({
[15:32:12.130]                 ...future.makeSendCondition <- base::local({
[15:32:12.130]                   sendCondition <- NULL
[15:32:12.130]                   function(frame = 1L) {
[15:32:12.130]                     if (is.function(sendCondition)) 
[15:32:12.130]                       return(sendCondition)
[15:32:12.130]                     ns <- getNamespace("parallel")
[15:32:12.130]                     if (exists("sendData", mode = "function", 
[15:32:12.130]                       envir = ns)) {
[15:32:12.130]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.130]                         envir = ns)
[15:32:12.130]                       envir <- sys.frame(frame)
[15:32:12.130]                       master <- NULL
[15:32:12.130]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.130]                         !identical(envir, emptyenv())) {
[15:32:12.130]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.130]                           inherits = FALSE)) {
[15:32:12.130]                           master <- get("master", mode = "list", 
[15:32:12.130]                             envir = envir, inherits = FALSE)
[15:32:12.130]                           if (inherits(master, c("SOCKnode", 
[15:32:12.130]                             "SOCK0node"))) {
[15:32:12.130]                             sendCondition <<- function(cond) {
[15:32:12.130]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.130]                                 success = TRUE)
[15:32:12.130]                               parallel_sendData(master, data)
[15:32:12.130]                             }
[15:32:12.130]                             return(sendCondition)
[15:32:12.130]                           }
[15:32:12.130]                         }
[15:32:12.130]                         frame <- frame + 1L
[15:32:12.130]                         envir <- sys.frame(frame)
[15:32:12.130]                       }
[15:32:12.130]                     }
[15:32:12.130]                     sendCondition <<- function(cond) NULL
[15:32:12.130]                   }
[15:32:12.130]                 })
[15:32:12.130]                 withCallingHandlers({
[15:32:12.130]                   {
[15:32:12.130]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.130]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.130]                       ...future.globals.maxSize)) {
[15:32:12.130]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.130]                       on.exit(options(oopts), add = TRUE)
[15:32:12.130]                     }
[15:32:12.130]                     {
[15:32:12.130]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.130]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.130]                         USE.NAMES = FALSE)
[15:32:12.130]                       do.call(mapply, args = args)
[15:32:12.130]                     }
[15:32:12.130]                   }
[15:32:12.130]                 }, immediateCondition = function(cond) {
[15:32:12.130]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.130]                   sendCondition(cond)
[15:32:12.130]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.130]                   {
[15:32:12.130]                     inherits <- base::inherits
[15:32:12.130]                     invokeRestart <- base::invokeRestart
[15:32:12.130]                     is.null <- base::is.null
[15:32:12.130]                     muffled <- FALSE
[15:32:12.130]                     if (inherits(cond, "message")) {
[15:32:12.130]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.130]                       if (muffled) 
[15:32:12.130]                         invokeRestart("muffleMessage")
[15:32:12.130]                     }
[15:32:12.130]                     else if (inherits(cond, "warning")) {
[15:32:12.130]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.130]                       if (muffled) 
[15:32:12.130]                         invokeRestart("muffleWarning")
[15:32:12.130]                     }
[15:32:12.130]                     else if (inherits(cond, "condition")) {
[15:32:12.130]                       if (!is.null(pattern)) {
[15:32:12.130]                         computeRestarts <- base::computeRestarts
[15:32:12.130]                         grepl <- base::grepl
[15:32:12.130]                         restarts <- computeRestarts(cond)
[15:32:12.130]                         for (restart in restarts) {
[15:32:12.130]                           name <- restart$name
[15:32:12.130]                           if (is.null(name)) 
[15:32:12.130]                             next
[15:32:12.130]                           if (!grepl(pattern, name)) 
[15:32:12.130]                             next
[15:32:12.130]                           invokeRestart(restart)
[15:32:12.130]                           muffled <- TRUE
[15:32:12.130]                           break
[15:32:12.130]                         }
[15:32:12.130]                       }
[15:32:12.130]                     }
[15:32:12.130]                     invisible(muffled)
[15:32:12.130]                   }
[15:32:12.130]                   muffleCondition(cond)
[15:32:12.130]                 })
[15:32:12.130]             }))
[15:32:12.130]             future::FutureResult(value = ...future.value$value, 
[15:32:12.130]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.130]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.130]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.130]                     ...future.globalenv.names))
[15:32:12.130]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.130]         }, condition = base::local({
[15:32:12.130]             c <- base::c
[15:32:12.130]             inherits <- base::inherits
[15:32:12.130]             invokeRestart <- base::invokeRestart
[15:32:12.130]             length <- base::length
[15:32:12.130]             list <- base::list
[15:32:12.130]             seq.int <- base::seq.int
[15:32:12.130]             signalCondition <- base::signalCondition
[15:32:12.130]             sys.calls <- base::sys.calls
[15:32:12.130]             `[[` <- base::`[[`
[15:32:12.130]             `+` <- base::`+`
[15:32:12.130]             `<<-` <- base::`<<-`
[15:32:12.130]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.130]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.130]                   3L)]
[15:32:12.130]             }
[15:32:12.130]             function(cond) {
[15:32:12.130]                 is_error <- inherits(cond, "error")
[15:32:12.130]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.130]                   NULL)
[15:32:12.130]                 if (is_error) {
[15:32:12.130]                   sessionInformation <- function() {
[15:32:12.130]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.130]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.130]                       search = base::search(), system = base::Sys.info())
[15:32:12.130]                   }
[15:32:12.130]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.130]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.130]                     cond$call), session = sessionInformation(), 
[15:32:12.130]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.130]                   signalCondition(cond)
[15:32:12.130]                 }
[15:32:12.130]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.130]                 "immediateCondition"))) {
[15:32:12.130]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.130]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.130]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.130]                   if (TRUE && !signal) {
[15:32:12.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.130]                     {
[15:32:12.130]                       inherits <- base::inherits
[15:32:12.130]                       invokeRestart <- base::invokeRestart
[15:32:12.130]                       is.null <- base::is.null
[15:32:12.130]                       muffled <- FALSE
[15:32:12.130]                       if (inherits(cond, "message")) {
[15:32:12.130]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.130]                         if (muffled) 
[15:32:12.130]                           invokeRestart("muffleMessage")
[15:32:12.130]                       }
[15:32:12.130]                       else if (inherits(cond, "warning")) {
[15:32:12.130]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.130]                         if (muffled) 
[15:32:12.130]                           invokeRestart("muffleWarning")
[15:32:12.130]                       }
[15:32:12.130]                       else if (inherits(cond, "condition")) {
[15:32:12.130]                         if (!is.null(pattern)) {
[15:32:12.130]                           computeRestarts <- base::computeRestarts
[15:32:12.130]                           grepl <- base::grepl
[15:32:12.130]                           restarts <- computeRestarts(cond)
[15:32:12.130]                           for (restart in restarts) {
[15:32:12.130]                             name <- restart$name
[15:32:12.130]                             if (is.null(name)) 
[15:32:12.130]                               next
[15:32:12.130]                             if (!grepl(pattern, name)) 
[15:32:12.130]                               next
[15:32:12.130]                             invokeRestart(restart)
[15:32:12.130]                             muffled <- TRUE
[15:32:12.130]                             break
[15:32:12.130]                           }
[15:32:12.130]                         }
[15:32:12.130]                       }
[15:32:12.130]                       invisible(muffled)
[15:32:12.130]                     }
[15:32:12.130]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.130]                   }
[15:32:12.130]                 }
[15:32:12.130]                 else {
[15:32:12.130]                   if (TRUE) {
[15:32:12.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.130]                     {
[15:32:12.130]                       inherits <- base::inherits
[15:32:12.130]                       invokeRestart <- base::invokeRestart
[15:32:12.130]                       is.null <- base::is.null
[15:32:12.130]                       muffled <- FALSE
[15:32:12.130]                       if (inherits(cond, "message")) {
[15:32:12.130]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.130]                         if (muffled) 
[15:32:12.130]                           invokeRestart("muffleMessage")
[15:32:12.130]                       }
[15:32:12.130]                       else if (inherits(cond, "warning")) {
[15:32:12.130]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.130]                         if (muffled) 
[15:32:12.130]                           invokeRestart("muffleWarning")
[15:32:12.130]                       }
[15:32:12.130]                       else if (inherits(cond, "condition")) {
[15:32:12.130]                         if (!is.null(pattern)) {
[15:32:12.130]                           computeRestarts <- base::computeRestarts
[15:32:12.130]                           grepl <- base::grepl
[15:32:12.130]                           restarts <- computeRestarts(cond)
[15:32:12.130]                           for (restart in restarts) {
[15:32:12.130]                             name <- restart$name
[15:32:12.130]                             if (is.null(name)) 
[15:32:12.130]                               next
[15:32:12.130]                             if (!grepl(pattern, name)) 
[15:32:12.130]                               next
[15:32:12.130]                             invokeRestart(restart)
[15:32:12.130]                             muffled <- TRUE
[15:32:12.130]                             break
[15:32:12.130]                           }
[15:32:12.130]                         }
[15:32:12.130]                       }
[15:32:12.130]                       invisible(muffled)
[15:32:12.130]                     }
[15:32:12.130]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.130]                   }
[15:32:12.130]                 }
[15:32:12.130]             }
[15:32:12.130]         }))
[15:32:12.130]     }, error = function(ex) {
[15:32:12.130]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.130]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.130]                 ...future.rng), started = ...future.startTime, 
[15:32:12.130]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.130]             version = "1.8"), class = "FutureResult")
[15:32:12.130]     }, finally = {
[15:32:12.130]         if (!identical(...future.workdir, getwd())) 
[15:32:12.130]             setwd(...future.workdir)
[15:32:12.130]         {
[15:32:12.130]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.130]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.130]             }
[15:32:12.130]             base::options(...future.oldOptions)
[15:32:12.130]             if (.Platform$OS.type == "windows") {
[15:32:12.130]                 old_names <- names(...future.oldEnvVars)
[15:32:12.130]                 envs <- base::Sys.getenv()
[15:32:12.130]                 names <- names(envs)
[15:32:12.130]                 common <- intersect(names, old_names)
[15:32:12.130]                 added <- setdiff(names, old_names)
[15:32:12.130]                 removed <- setdiff(old_names, names)
[15:32:12.130]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.130]                   envs[common]]
[15:32:12.130]                 NAMES <- toupper(changed)
[15:32:12.130]                 args <- list()
[15:32:12.130]                 for (kk in seq_along(NAMES)) {
[15:32:12.130]                   name <- changed[[kk]]
[15:32:12.130]                   NAME <- NAMES[[kk]]
[15:32:12.130]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.130]                     next
[15:32:12.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.130]                 }
[15:32:12.130]                 NAMES <- toupper(added)
[15:32:12.130]                 for (kk in seq_along(NAMES)) {
[15:32:12.130]                   name <- added[[kk]]
[15:32:12.130]                   NAME <- NAMES[[kk]]
[15:32:12.130]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.130]                     next
[15:32:12.130]                   args[[name]] <- ""
[15:32:12.130]                 }
[15:32:12.130]                 NAMES <- toupper(removed)
[15:32:12.130]                 for (kk in seq_along(NAMES)) {
[15:32:12.130]                   name <- removed[[kk]]
[15:32:12.130]                   NAME <- NAMES[[kk]]
[15:32:12.130]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.130]                     next
[15:32:12.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.130]                 }
[15:32:12.130]                 if (length(args) > 0) 
[15:32:12.130]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.130]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.130]             }
[15:32:12.130]             else {
[15:32:12.130]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.130]             }
[15:32:12.130]             {
[15:32:12.130]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.130]                   0L) {
[15:32:12.130]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.130]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.130]                   base::options(opts)
[15:32:12.130]                 }
[15:32:12.130]                 {
[15:32:12.130]                   {
[15:32:12.130]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.130]                     NULL
[15:32:12.130]                   }
[15:32:12.130]                   options(future.plan = NULL)
[15:32:12.130]                   if (is.na(NA_character_)) 
[15:32:12.130]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.130]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.130]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.130]                     .init = FALSE)
[15:32:12.130]                 }
[15:32:12.130]             }
[15:32:12.130]         }
[15:32:12.130]     })
[15:32:12.130]     if (TRUE) {
[15:32:12.130]         base::sink(type = "output", split = FALSE)
[15:32:12.130]         if (TRUE) {
[15:32:12.130]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.130]         }
[15:32:12.130]         else {
[15:32:12.130]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.130]         }
[15:32:12.130]         base::close(...future.stdout)
[15:32:12.130]         ...future.stdout <- NULL
[15:32:12.130]     }
[15:32:12.130]     ...future.result$conditions <- ...future.conditions
[15:32:12.130]     ...future.result$finished <- base::Sys.time()
[15:32:12.130]     ...future.result
[15:32:12.130] }
[15:32:12.139] Exporting 5 global objects (3.41 KiB) to cluster node #1 ...
[15:32:12.139] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.140] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.141] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.141] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.142] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ...
[15:32:12.143] Exporting '...future.elements_ii' (168 bytes) to cluster node #1 ... DONE
[15:32:12.143] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.144] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.144] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.145] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.145] Exporting 5 global objects (3.41 KiB) to cluster node #1 ... DONE
[15:32:12.146] MultisessionFuture started
[15:32:12.146] - Launch lazy future ... done
[15:32:12.146] run() for 'MultisessionFuture' ... done
[15:32:12.147] Created future:
[15:32:12.175] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.175] - Validating connection of MultisessionFuture
[15:32:12.176] - received message: FutureResult
[15:32:12.176] - Received FutureResult
[15:32:12.176] - Erased future from FutureRegistry
[15:32:12.176] result() for ClusterFuture ...
[15:32:12.176] - result already collected: FutureResult
[15:32:12.177] result() for ClusterFuture ... done
[15:32:12.177] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.147] MultisessionFuture:
[15:32:12.147] Label: 'future_mapply-2'
[15:32:12.147] Expression:
[15:32:12.147] {
[15:32:12.147]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.147]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.147]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.147]         on.exit(options(oopts), add = TRUE)
[15:32:12.147]     }
[15:32:12.147]     {
[15:32:12.147]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.147]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.147]         do.call(mapply, args = args)
[15:32:12.147]     }
[15:32:12.147] }
[15:32:12.147] Lazy evaluation: FALSE
[15:32:12.147] Asynchronous evaluation: TRUE
[15:32:12.147] Local evaluation: TRUE
[15:32:12.147] Environment: R_GlobalEnv
[15:32:12.147] Capture standard output: TRUE
[15:32:12.147] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.147] Globals: 5 objects totaling 3.41 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 168 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.147] Packages: <none>
[15:32:12.147] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.147] Resolved: TRUE
[15:32:12.147] Value: <not collected>
[15:32:12.147] Conditions captured: <none>
[15:32:12.147] Early signaling: FALSE
[15:32:12.147] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.147] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.177] Chunk #2 of 3 ... DONE
[15:32:12.177] Chunk #3 of 3 ...
[15:32:12.178]  - Finding globals in '...' for chunk #3 ...
[15:32:12.178] getGlobalsAndPackages() ...
[15:32:12.178] Searching for globals...
[15:32:12.179] 
[15:32:12.179] Searching for globals ... DONE
[15:32:12.179] - globals: [0] <none>
[15:32:12.179] getGlobalsAndPackages() ... DONE
[15:32:12.179]    + additional globals found: [n=0] 
[15:32:12.179]    + additional namespaces needed: [n=0] 
[15:32:12.180]  - Finding globals in '...' for chunk #3 ... DONE
[15:32:12.180]  - Adjusted option 'future.globals.maxSize': 524288000 -> 3 * 524288000 = 1572864000 (bytes)
[15:32:12.180]  - seeds: <none>
[15:32:12.180]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.180] getGlobalsAndPackages() ...
[15:32:12.180] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.181] Resolving globals: FALSE
[15:32:12.181] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:12.182] 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 3.57 KiB.. This exceeds the maximum allowed size of 1.46 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:12.182] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.182] 
[15:32:12.183] getGlobalsAndPackages() ... DONE
[15:32:12.183] run() for 'Future' ...
[15:32:12.183] - state: 'created'
[15:32:12.183] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.198] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.198] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.198]   - Field: 'node'
[15:32:12.199]   - Field: 'label'
[15:32:12.199]   - Field: 'local'
[15:32:12.199]   - Field: 'owner'
[15:32:12.199]   - Field: 'envir'
[15:32:12.199]   - Field: 'workers'
[15:32:12.199]   - Field: 'packages'
[15:32:12.200]   - Field: 'gc'
[15:32:12.200]   - Field: 'conditions'
[15:32:12.200]   - Field: 'persistent'
[15:32:12.200]   - Field: 'expr'
[15:32:12.200]   - Field: 'uuid'
[15:32:12.201]   - Field: 'seed'
[15:32:12.201]   - Field: 'version'
[15:32:12.201]   - Field: 'result'
[15:32:12.201]   - Field: 'asynchronous'
[15:32:12.201]   - Field: 'calls'
[15:32:12.201]   - Field: 'globals'
[15:32:12.202]   - Field: 'stdout'
[15:32:12.202]   - Field: 'earlySignal'
[15:32:12.202]   - Field: 'lazy'
[15:32:12.202]   - Field: 'state'
[15:32:12.203] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.203] - Launch lazy future ...
[15:32:12.204] Packages needed by the future expression (n = 0): <none>
[15:32:12.204] Packages needed by future strategies (n = 0): <none>
[15:32:12.205] {
[15:32:12.205]     {
[15:32:12.205]         {
[15:32:12.205]             ...future.startTime <- base::Sys.time()
[15:32:12.205]             {
[15:32:12.205]                 {
[15:32:12.205]                   {
[15:32:12.205]                     {
[15:32:12.205]                       base::local({
[15:32:12.205]                         has_future <- base::requireNamespace("future", 
[15:32:12.205]                           quietly = TRUE)
[15:32:12.205]                         if (has_future) {
[15:32:12.205]                           ns <- base::getNamespace("future")
[15:32:12.205]                           version <- ns[[".package"]][["version"]]
[15:32:12.205]                           if (is.null(version)) 
[15:32:12.205]                             version <- utils::packageVersion("future")
[15:32:12.205]                         }
[15:32:12.205]                         else {
[15:32:12.205]                           version <- NULL
[15:32:12.205]                         }
[15:32:12.205]                         if (!has_future || version < "1.8.0") {
[15:32:12.205]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.205]                             "", base::R.version$version.string), 
[15:32:12.205]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.205]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.205]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.205]                               "release", "version")], collapse = " "), 
[15:32:12.205]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.205]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.205]                             info)
[15:32:12.205]                           info <- base::paste(info, collapse = "; ")
[15:32:12.205]                           if (!has_future) {
[15:32:12.205]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.205]                               info)
[15:32:12.205]                           }
[15:32:12.205]                           else {
[15:32:12.205]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.205]                               info, version)
[15:32:12.205]                           }
[15:32:12.205]                           base::stop(msg)
[15:32:12.205]                         }
[15:32:12.205]                       })
[15:32:12.205]                     }
[15:32:12.205]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.205]                     base::options(mc.cores = 1L)
[15:32:12.205]                   }
[15:32:12.205]                   ...future.strategy.old <- future::plan("list")
[15:32:12.205]                   options(future.plan = NULL)
[15:32:12.205]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.205]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.205]                 }
[15:32:12.205]                 ...future.workdir <- getwd()
[15:32:12.205]             }
[15:32:12.205]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.205]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.205]         }
[15:32:12.205]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.205]             future.globals.maxSize = 1572864000, future.globals.method = NULL, 
[15:32:12.205]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.205]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.205]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.205]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.205]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.205]             base::names(...future.oldOptions))
[15:32:12.205]     }
[15:32:12.205]     if (FALSE) {
[15:32:12.205]     }
[15:32:12.205]     else {
[15:32:12.205]         if (TRUE) {
[15:32:12.205]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.205]                 open = "w")
[15:32:12.205]         }
[15:32:12.205]         else {
[15:32:12.205]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.205]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.205]         }
[15:32:12.205]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.205]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.205]             base::sink(type = "output", split = FALSE)
[15:32:12.205]             base::close(...future.stdout)
[15:32:12.205]         }, add = TRUE)
[15:32:12.205]     }
[15:32:12.205]     ...future.frame <- base::sys.nframe()
[15:32:12.205]     ...future.conditions <- base::list()
[15:32:12.205]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.205]     if (FALSE) {
[15:32:12.205]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.205]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.205]     }
[15:32:12.205]     ...future.result <- base::tryCatch({
[15:32:12.205]         base::withCallingHandlers({
[15:32:12.205]             ...future.value <- base::withVisible(base::local({
[15:32:12.205]                 ...future.makeSendCondition <- base::local({
[15:32:12.205]                   sendCondition <- NULL
[15:32:12.205]                   function(frame = 1L) {
[15:32:12.205]                     if (is.function(sendCondition)) 
[15:32:12.205]                       return(sendCondition)
[15:32:12.205]                     ns <- getNamespace("parallel")
[15:32:12.205]                     if (exists("sendData", mode = "function", 
[15:32:12.205]                       envir = ns)) {
[15:32:12.205]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.205]                         envir = ns)
[15:32:12.205]                       envir <- sys.frame(frame)
[15:32:12.205]                       master <- NULL
[15:32:12.205]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.205]                         !identical(envir, emptyenv())) {
[15:32:12.205]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.205]                           inherits = FALSE)) {
[15:32:12.205]                           master <- get("master", mode = "list", 
[15:32:12.205]                             envir = envir, inherits = FALSE)
[15:32:12.205]                           if (inherits(master, c("SOCKnode", 
[15:32:12.205]                             "SOCK0node"))) {
[15:32:12.205]                             sendCondition <<- function(cond) {
[15:32:12.205]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.205]                                 success = TRUE)
[15:32:12.205]                               parallel_sendData(master, data)
[15:32:12.205]                             }
[15:32:12.205]                             return(sendCondition)
[15:32:12.205]                           }
[15:32:12.205]                         }
[15:32:12.205]                         frame <- frame + 1L
[15:32:12.205]                         envir <- sys.frame(frame)
[15:32:12.205]                       }
[15:32:12.205]                     }
[15:32:12.205]                     sendCondition <<- function(cond) NULL
[15:32:12.205]                   }
[15:32:12.205]                 })
[15:32:12.205]                 withCallingHandlers({
[15:32:12.205]                   {
[15:32:12.205]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.205]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.205]                       ...future.globals.maxSize)) {
[15:32:12.205]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.205]                       on.exit(options(oopts), add = TRUE)
[15:32:12.205]                     }
[15:32:12.205]                     {
[15:32:12.205]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.205]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.205]                         USE.NAMES = FALSE)
[15:32:12.205]                       do.call(mapply, args = args)
[15:32:12.205]                     }
[15:32:12.205]                   }
[15:32:12.205]                 }, immediateCondition = function(cond) {
[15:32:12.205]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.205]                   sendCondition(cond)
[15:32:12.205]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.205]                   {
[15:32:12.205]                     inherits <- base::inherits
[15:32:12.205]                     invokeRestart <- base::invokeRestart
[15:32:12.205]                     is.null <- base::is.null
[15:32:12.205]                     muffled <- FALSE
[15:32:12.205]                     if (inherits(cond, "message")) {
[15:32:12.205]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.205]                       if (muffled) 
[15:32:12.205]                         invokeRestart("muffleMessage")
[15:32:12.205]                     }
[15:32:12.205]                     else if (inherits(cond, "warning")) {
[15:32:12.205]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.205]                       if (muffled) 
[15:32:12.205]                         invokeRestart("muffleWarning")
[15:32:12.205]                     }
[15:32:12.205]                     else if (inherits(cond, "condition")) {
[15:32:12.205]                       if (!is.null(pattern)) {
[15:32:12.205]                         computeRestarts <- base::computeRestarts
[15:32:12.205]                         grepl <- base::grepl
[15:32:12.205]                         restarts <- computeRestarts(cond)
[15:32:12.205]                         for (restart in restarts) {
[15:32:12.205]                           name <- restart$name
[15:32:12.205]                           if (is.null(name)) 
[15:32:12.205]                             next
[15:32:12.205]                           if (!grepl(pattern, name)) 
[15:32:12.205]                             next
[15:32:12.205]                           invokeRestart(restart)
[15:32:12.205]                           muffled <- TRUE
[15:32:12.205]                           break
[15:32:12.205]                         }
[15:32:12.205]                       }
[15:32:12.205]                     }
[15:32:12.205]                     invisible(muffled)
[15:32:12.205]                   }
[15:32:12.205]                   muffleCondition(cond)
[15:32:12.205]                 })
[15:32:12.205]             }))
[15:32:12.205]             future::FutureResult(value = ...future.value$value, 
[15:32:12.205]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.205]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.205]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.205]                     ...future.globalenv.names))
[15:32:12.205]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.205]         }, condition = base::local({
[15:32:12.205]             c <- base::c
[15:32:12.205]             inherits <- base::inherits
[15:32:12.205]             invokeRestart <- base::invokeRestart
[15:32:12.205]             length <- base::length
[15:32:12.205]             list <- base::list
[15:32:12.205]             seq.int <- base::seq.int
[15:32:12.205]             signalCondition <- base::signalCondition
[15:32:12.205]             sys.calls <- base::sys.calls
[15:32:12.205]             `[[` <- base::`[[`
[15:32:12.205]             `+` <- base::`+`
[15:32:12.205]             `<<-` <- base::`<<-`
[15:32:12.205]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.205]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.205]                   3L)]
[15:32:12.205]             }
[15:32:12.205]             function(cond) {
[15:32:12.205]                 is_error <- inherits(cond, "error")
[15:32:12.205]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.205]                   NULL)
[15:32:12.205]                 if (is_error) {
[15:32:12.205]                   sessionInformation <- function() {
[15:32:12.205]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.205]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.205]                       search = base::search(), system = base::Sys.info())
[15:32:12.205]                   }
[15:32:12.205]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.205]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.205]                     cond$call), session = sessionInformation(), 
[15:32:12.205]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.205]                   signalCondition(cond)
[15:32:12.205]                 }
[15:32:12.205]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.205]                 "immediateCondition"))) {
[15:32:12.205]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.205]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.205]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.205]                   if (TRUE && !signal) {
[15:32:12.205]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.205]                     {
[15:32:12.205]                       inherits <- base::inherits
[15:32:12.205]                       invokeRestart <- base::invokeRestart
[15:32:12.205]                       is.null <- base::is.null
[15:32:12.205]                       muffled <- FALSE
[15:32:12.205]                       if (inherits(cond, "message")) {
[15:32:12.205]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.205]                         if (muffled) 
[15:32:12.205]                           invokeRestart("muffleMessage")
[15:32:12.205]                       }
[15:32:12.205]                       else if (inherits(cond, "warning")) {
[15:32:12.205]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.205]                         if (muffled) 
[15:32:12.205]                           invokeRestart("muffleWarning")
[15:32:12.205]                       }
[15:32:12.205]                       else if (inherits(cond, "condition")) {
[15:32:12.205]                         if (!is.null(pattern)) {
[15:32:12.205]                           computeRestarts <- base::computeRestarts
[15:32:12.205]                           grepl <- base::grepl
[15:32:12.205]                           restarts <- computeRestarts(cond)
[15:32:12.205]                           for (restart in restarts) {
[15:32:12.205]                             name <- restart$name
[15:32:12.205]                             if (is.null(name)) 
[15:32:12.205]                               next
[15:32:12.205]                             if (!grepl(pattern, name)) 
[15:32:12.205]                               next
[15:32:12.205]                             invokeRestart(restart)
[15:32:12.205]                             muffled <- TRUE
[15:32:12.205]                             break
[15:32:12.205]                           }
[15:32:12.205]                         }
[15:32:12.205]                       }
[15:32:12.205]                       invisible(muffled)
[15:32:12.205]                     }
[15:32:12.205]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.205]                   }
[15:32:12.205]                 }
[15:32:12.205]                 else {
[15:32:12.205]                   if (TRUE) {
[15:32:12.205]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.205]                     {
[15:32:12.205]                       inherits <- base::inherits
[15:32:12.205]                       invokeRestart <- base::invokeRestart
[15:32:12.205]                       is.null <- base::is.null
[15:32:12.205]                       muffled <- FALSE
[15:32:12.205]                       if (inherits(cond, "message")) {
[15:32:12.205]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.205]                         if (muffled) 
[15:32:12.205]                           invokeRestart("muffleMessage")
[15:32:12.205]                       }
[15:32:12.205]                       else if (inherits(cond, "warning")) {
[15:32:12.205]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.205]                         if (muffled) 
[15:32:12.205]                           invokeRestart("muffleWarning")
[15:32:12.205]                       }
[15:32:12.205]                       else if (inherits(cond, "condition")) {
[15:32:12.205]                         if (!is.null(pattern)) {
[15:32:12.205]                           computeRestarts <- base::computeRestarts
[15:32:12.205]                           grepl <- base::grepl
[15:32:12.205]                           restarts <- computeRestarts(cond)
[15:32:12.205]                           for (restart in restarts) {
[15:32:12.205]                             name <- restart$name
[15:32:12.205]                             if (is.null(name)) 
[15:32:12.205]                               next
[15:32:12.205]                             if (!grepl(pattern, name)) 
[15:32:12.205]                               next
[15:32:12.205]                             invokeRestart(restart)
[15:32:12.205]                             muffled <- TRUE
[15:32:12.205]                             break
[15:32:12.205]                           }
[15:32:12.205]                         }
[15:32:12.205]                       }
[15:32:12.205]                       invisible(muffled)
[15:32:12.205]                     }
[15:32:12.205]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.205]                   }
[15:32:12.205]                 }
[15:32:12.205]             }
[15:32:12.205]         }))
[15:32:12.205]     }, error = function(ex) {
[15:32:12.205]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.205]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.205]                 ...future.rng), started = ...future.startTime, 
[15:32:12.205]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.205]             version = "1.8"), class = "FutureResult")
[15:32:12.205]     }, finally = {
[15:32:12.205]         if (!identical(...future.workdir, getwd())) 
[15:32:12.205]             setwd(...future.workdir)
[15:32:12.205]         {
[15:32:12.205]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.205]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.205]             }
[15:32:12.205]             base::options(...future.oldOptions)
[15:32:12.205]             if (.Platform$OS.type == "windows") {
[15:32:12.205]                 old_names <- names(...future.oldEnvVars)
[15:32:12.205]                 envs <- base::Sys.getenv()
[15:32:12.205]                 names <- names(envs)
[15:32:12.205]                 common <- intersect(names, old_names)
[15:32:12.205]                 added <- setdiff(names, old_names)
[15:32:12.205]                 removed <- setdiff(old_names, names)
[15:32:12.205]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.205]                   envs[common]]
[15:32:12.205]                 NAMES <- toupper(changed)
[15:32:12.205]                 args <- list()
[15:32:12.205]                 for (kk in seq_along(NAMES)) {
[15:32:12.205]                   name <- changed[[kk]]
[15:32:12.205]                   NAME <- NAMES[[kk]]
[15:32:12.205]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.205]                     next
[15:32:12.205]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.205]                 }
[15:32:12.205]                 NAMES <- toupper(added)
[15:32:12.205]                 for (kk in seq_along(NAMES)) {
[15:32:12.205]                   name <- added[[kk]]
[15:32:12.205]                   NAME <- NAMES[[kk]]
[15:32:12.205]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.205]                     next
[15:32:12.205]                   args[[name]] <- ""
[15:32:12.205]                 }
[15:32:12.205]                 NAMES <- toupper(removed)
[15:32:12.205]                 for (kk in seq_along(NAMES)) {
[15:32:12.205]                   name <- removed[[kk]]
[15:32:12.205]                   NAME <- NAMES[[kk]]
[15:32:12.205]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.205]                     next
[15:32:12.205]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.205]                 }
[15:32:12.205]                 if (length(args) > 0) 
[15:32:12.205]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.205]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.205]             }
[15:32:12.205]             else {
[15:32:12.205]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.205]             }
[15:32:12.205]             {
[15:32:12.205]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.205]                   0L) {
[15:32:12.205]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.205]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.205]                   base::options(opts)
[15:32:12.205]                 }
[15:32:12.205]                 {
[15:32:12.205]                   {
[15:32:12.205]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.205]                     NULL
[15:32:12.205]                   }
[15:32:12.205]                   options(future.plan = NULL)
[15:32:12.205]                   if (is.na(NA_character_)) 
[15:32:12.205]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.205]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.205]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.205]                     .init = FALSE)
[15:32:12.205]                 }
[15:32:12.205]             }
[15:32:12.205]         }
[15:32:12.205]     })
[15:32:12.205]     if (TRUE) {
[15:32:12.205]         base::sink(type = "output", split = FALSE)
[15:32:12.205]         if (TRUE) {
[15:32:12.205]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.205]         }
[15:32:12.205]         else {
[15:32:12.205]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.205]         }
[15:32:12.205]         base::close(...future.stdout)
[15:32:12.205]         ...future.stdout <- NULL
[15:32:12.205]     }
[15:32:12.205]     ...future.result$conditions <- ...future.conditions
[15:32:12.205]     ...future.result$finished <- base::Sys.time()
[15:32:12.205]     ...future.result
[15:32:12.205] }
[15:32:12.215] Exporting 5 global objects (3.57 KiB) to cluster node #1 ...
[15:32:12.215] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.216] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.216] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.217] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.217] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:32:12.218] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:32:12.218] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.219] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.219] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.220] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.220] Exporting 5 global objects (3.57 KiB) to cluster node #1 ... DONE
[15:32:12.221] MultisessionFuture started
[15:32:12.221] - Launch lazy future ... done
[15:32:12.222] run() for 'MultisessionFuture' ... done
[15:32:12.222] Created future:
[15:32:12.245] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.245] - Validating connection of MultisessionFuture
[15:32:12.246] - received message: FutureResult
[15:32:12.246] - Received FutureResult
[15:32:12.246] - Erased future from FutureRegistry
[15:32:12.247] result() for ClusterFuture ...
[15:32:12.247] - result already collected: FutureResult
[15:32:12.247] result() for ClusterFuture ... done
[15:32:12.248] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.222] MultisessionFuture:
[15:32:12.222] Label: 'future_mapply-3'
[15:32:12.222] Expression:
[15:32:12.222] {
[15:32:12.222]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.222]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.222]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.222]         on.exit(options(oopts), add = TRUE)
[15:32:12.222]     }
[15:32:12.222]     {
[15:32:12.222]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.222]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.222]         do.call(mapply, args = args)
[15:32:12.222]     }
[15:32:12.222] }
[15:32:12.222] Lazy evaluation: FALSE
[15:32:12.222] Asynchronous evaluation: TRUE
[15:32:12.222] Local evaluation: TRUE
[15:32:12.222] Environment: R_GlobalEnv
[15:32:12.222] Capture standard output: TRUE
[15:32:12.222] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.222] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.222] Packages: <none>
[15:32:12.222] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.222] Resolved: TRUE
[15:32:12.222] Value: <not collected>
[15:32:12.222] Conditions captured: <none>
[15:32:12.222] Early signaling: FALSE
[15:32:12.222] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.222] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.248] Chunk #3 of 3 ... DONE
[15:32:12.249] Launching 3 futures (chunks) ... DONE
[15:32:12.249] Resolving 3 futures (chunks) ...
[15:32:12.249] resolve() on list ...
[15:32:12.249]  recursive: 0
[15:32:12.250]  length: 3
[15:32:12.250] 
[15:32:12.250] Future #1
[15:32:12.251] result() for ClusterFuture ...
[15:32:12.251] - result already collected: FutureResult
[15:32:12.251] result() for ClusterFuture ... done
[15:32:12.251] result() for ClusterFuture ...
[15:32:12.252] - result already collected: FutureResult
[15:32:12.252] result() for ClusterFuture ... done
[15:32:12.252] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:12.253] - nx: 3
[15:32:12.253] - relay: TRUE
[15:32:12.253] - stdout: TRUE
[15:32:12.253] - signal: TRUE
[15:32:12.254] - resignal: FALSE
[15:32:12.254] - force: TRUE
[15:32:12.254] - relayed: [n=3] FALSE, FALSE, FALSE
[15:32:12.254] - queued futures: [n=3] FALSE, FALSE, FALSE
[15:32:12.255]  - until=1
[15:32:12.255]  - relaying element #1
[15:32:12.255] result() for ClusterFuture ...
[15:32:12.256] - result already collected: FutureResult
[15:32:12.256] result() for ClusterFuture ... done
[15:32:12.256] result() for ClusterFuture ...
[15:32:12.256] - result already collected: FutureResult
[15:32:12.257] result() for ClusterFuture ... done
[15:32:12.257] result() for ClusterFuture ...
[15:32:12.257] - result already collected: FutureResult
[15:32:12.258] result() for ClusterFuture ... done
[15:32:12.258] result() for ClusterFuture ...
[15:32:12.258] - result already collected: FutureResult
[15:32:12.258] result() for ClusterFuture ... done
[15:32:12.259] - relayed: [n=3] TRUE, FALSE, FALSE
[15:32:12.259] - queued futures: [n=3] TRUE, FALSE, FALSE
[15:32:12.259] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:12.260]  length: 2 (resolved future 1)
[15:32:12.260] Future #2
[15:32:12.260] result() for ClusterFuture ...
[15:32:12.261] - result already collected: FutureResult
[15:32:12.261] result() for ClusterFuture ... done
[15:32:12.261] result() for ClusterFuture ...
[15:32:12.261] - result already collected: FutureResult
[15:32:12.262] result() for ClusterFuture ... done
[15:32:12.262] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:12.262] - nx: 3
[15:32:12.262] - relay: TRUE
[15:32:12.263] - stdout: TRUE
[15:32:12.263] - signal: TRUE
[15:32:12.263] - resignal: FALSE
[15:32:12.264] - force: TRUE
[15:32:12.264] - relayed: [n=3] TRUE, FALSE, FALSE
[15:32:12.264] - queued futures: [n=3] TRUE, FALSE, FALSE
[15:32:12.264]  - until=2
[15:32:12.265]  - relaying element #2
[15:32:12.265] result() for ClusterFuture ...
[15:32:12.265] - result already collected: FutureResult
[15:32:12.266] result() for ClusterFuture ... done
[15:32:12.266] result() for ClusterFuture ...
[15:32:12.266] - result already collected: FutureResult
[15:32:12.266] result() for ClusterFuture ... done
[15:32:12.267] result() for ClusterFuture ...
[15:32:12.267] - result already collected: FutureResult
[15:32:12.267] result() for ClusterFuture ... done
[15:32:12.268] result() for ClusterFuture ...
[15:32:12.268] - result already collected: FutureResult
[15:32:12.268] result() for ClusterFuture ... done
[15:32:12.268] - relayed: [n=3] TRUE, TRUE, FALSE
[15:32:12.269] - queued futures: [n=3] TRUE, TRUE, FALSE
[15:32:12.269] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:12.269]  length: 1 (resolved future 2)
[15:32:12.270] Future #3
[15:32:12.270] result() for ClusterFuture ...
[15:32:12.270] - result already collected: FutureResult
[15:32:12.270] result() for ClusterFuture ... done
[15:32:12.271] result() for ClusterFuture ...
[15:32:12.271] - result already collected: FutureResult
[15:32:12.271] result() for ClusterFuture ... done
[15:32:12.272] signalConditionsASAP(MultisessionFuture, pos=3) ...
[15:32:12.272] - nx: 3
[15:32:12.272] - relay: TRUE
[15:32:12.272] - stdout: TRUE
[15:32:12.273] - signal: TRUE
[15:32:12.273] - resignal: FALSE
[15:32:12.273] - force: TRUE
[15:32:12.273] - relayed: [n=3] TRUE, TRUE, FALSE
[15:32:12.274] - queued futures: [n=3] TRUE, TRUE, FALSE
[15:32:12.274]  - until=3
[15:32:12.274]  - relaying element #3
[15:32:12.275] result() for ClusterFuture ...
[15:32:12.275] - result already collected: FutureResult
[15:32:12.275] result() for ClusterFuture ... done
[15:32:12.275] result() for ClusterFuture ...
[15:32:12.276] - result already collected: FutureResult
[15:32:12.276] result() for ClusterFuture ... done
[15:32:12.276] result() for ClusterFuture ...
[15:32:12.277] - result already collected: FutureResult
[15:32:12.277] result() for ClusterFuture ... done
[15:32:12.277] result() for ClusterFuture ...
[15:32:12.277] - result already collected: FutureResult
[15:32:12.278] result() for ClusterFuture ... done
[15:32:12.278] - relayed: [n=3] TRUE, TRUE, TRUE
[15:32:12.278] - queued futures: [n=3] TRUE, TRUE, TRUE
[15:32:12.279] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[15:32:12.279]  length: 0 (resolved future 3)
[15:32:12.279] Relaying remaining futures
[15:32:12.279] signalConditionsASAP(NULL, pos=0) ...
[15:32:12.280] - nx: 3
[15:32:12.280] - relay: TRUE
[15:32:12.280] - stdout: TRUE
[15:32:12.281] - signal: TRUE
[15:32:12.281] - resignal: FALSE
[15:32:12.281] - force: TRUE
[15:32:12.281] - relayed: [n=3] TRUE, TRUE, TRUE
[15:32:12.284] - queued futures: [n=3] TRUE, TRUE, TRUE
 - flush all
[15:32:12.285] - relayed: [n=3] TRUE, TRUE, TRUE
[15:32:12.285] - queued futures: [n=3] TRUE, TRUE, TRUE
[15:32:12.285] signalConditionsASAP(NULL, pos=0) ... done
[15:32:12.286] resolve() on list ... DONE
[15:32:12.286] result() for ClusterFuture ...
[15:32:12.286] - result already collected: FutureResult
[15:32:12.286] result() for ClusterFuture ... done
[15:32:12.287] result() for ClusterFuture ...
[15:32:12.287] - result already collected: FutureResult
[15:32:12.287] result() for ClusterFuture ... done
[15:32:12.287] result() for ClusterFuture ...
[15:32:12.288] - result already collected: FutureResult
[15:32:12.288] result() for ClusterFuture ... done
[15:32:12.288] result() for ClusterFuture ...
[15:32:12.288] - result already collected: FutureResult
[15:32:12.289] result() for ClusterFuture ... done
[15:32:12.289] result() for ClusterFuture ...
[15:32:12.289] - result already collected: FutureResult
[15:32:12.289] result() for ClusterFuture ... done
[15:32:12.290] result() for ClusterFuture ...
[15:32:12.290] - result already collected: FutureResult
[15:32:12.290] result() for ClusterFuture ... done
[15:32:12.291]  - Number of value chunks collected: 3
[15:32:12.291] Resolving 3 futures (chunks) ... DONE
[15:32:12.291] Reducing values from 3 chunks ...
[15:32:12.291]  - Number of values collected after concatenation: 5
[15:32:12.292]  - Number of values expected: 5
[15:32:12.292] Reverse index remapping (attribute 'ordering'): [n = 5] 3, 1, 4, 5, 2
[15:32:12.292] Reducing values from 3 chunks ... DONE
[15:32:12.292] future_mapply() ... DONE
[15:32:12.293] future_mapply() ...
[15:32:12.297] Number of chunks: 2
[15:32:12.297] getGlobalsAndPackagesXApply() ...
[15:32:12.298]  - future.globals: TRUE
[15:32:12.298] getGlobalsAndPackages() ...
[15:32:12.298] Searching for globals...
[15:32:12.300] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:12.301] Searching for globals ... DONE
[15:32:12.301] Resolving globals: FALSE
[15:32:12.302] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:12.303] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:12.303] - globals: [1] 'FUN'
[15:32:12.303] 
[15:32:12.303] getGlobalsAndPackages() ... DONE
[15:32:12.304]  - globals found/used: [n=1] 'FUN'
[15:32:12.304]  - needed namespaces: [n=0] 
[15:32:12.304] Finding globals ... DONE
[15:32:12.305] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:12.305] List of 2
[15:32:12.305]  $ ...future.FUN:function (C, k)  
[15:32:12.305]  $ MoreArgs     : list()
[15:32:12.305]  - attr(*, "where")=List of 2
[15:32:12.305]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:12.305]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:12.305]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:12.305]  - attr(*, "resolved")= logi FALSE
[15:32:12.305]  - attr(*, "total_size")= num NA
[15:32:12.309] Packages to be attached in all futures: [n=0] 
[15:32:12.309] getGlobalsAndPackagesXApply() ... DONE
[15:32:12.309] Number of futures (= number of chunks): 2
[15:32:12.310] Launching 2 futures (chunks) ...
[15:32:12.310] Chunk #1 of 2 ...
[15:32:12.310]  - Finding globals in '...' for chunk #1 ...
[15:32:12.310] getGlobalsAndPackages() ...
[15:32:12.311] Searching for globals...
[15:32:12.311] 
[15:32:12.312] Searching for globals ... DONE
[15:32:12.312] - globals: [0] <none>
[15:32:12.312] getGlobalsAndPackages() ... DONE
[15:32:12.312]    + additional globals found: [n=0] 
[15:32:12.313]    + additional namespaces needed: [n=0] 
[15:32:12.313]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:12.313]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:12.313]  - seeds: <none>
[15:32:12.314]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.314] getGlobalsAndPackages() ...
[15:32:12.314] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.315] Resolving globals: FALSE
[15:32:12.316] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:12.317] 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 3.57 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:12.317] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.317] 
[15:32:12.318] getGlobalsAndPackages() ... DONE
[15:32:12.318] run() for 'Future' ...
[15:32:12.318] - state: 'created'
[15:32:12.319] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.337] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.337] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.338]   - Field: 'node'
[15:32:12.338]   - Field: 'label'
[15:32:12.338]   - Field: 'local'
[15:32:12.338]   - Field: 'owner'
[15:32:12.339]   - Field: 'envir'
[15:32:12.339]   - Field: 'workers'
[15:32:12.339]   - Field: 'packages'
[15:32:12.339]   - Field: 'gc'
[15:32:12.340]   - Field: 'conditions'
[15:32:12.340]   - Field: 'persistent'
[15:32:12.340]   - Field: 'expr'
[15:32:12.340]   - Field: 'uuid'
[15:32:12.341]   - Field: 'seed'
[15:32:12.341]   - Field: 'version'
[15:32:12.341]   - Field: 'result'
[15:32:12.341]   - Field: 'asynchronous'
[15:32:12.342]   - Field: 'calls'
[15:32:12.342]   - Field: 'globals'
[15:32:12.342]   - Field: 'stdout'
[15:32:12.343]   - Field: 'earlySignal'
[15:32:12.343]   - Field: 'lazy'
[15:32:12.343]   - Field: 'state'
[15:32:12.343] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.344] - Launch lazy future ...
[15:32:12.344] Packages needed by the future expression (n = 0): <none>
[15:32:12.345] Packages needed by future strategies (n = 0): <none>
[15:32:12.346] {
[15:32:12.346]     {
[15:32:12.346]         {
[15:32:12.346]             ...future.startTime <- base::Sys.time()
[15:32:12.346]             {
[15:32:12.346]                 {
[15:32:12.346]                   {
[15:32:12.346]                     {
[15:32:12.346]                       base::local({
[15:32:12.346]                         has_future <- base::requireNamespace("future", 
[15:32:12.346]                           quietly = TRUE)
[15:32:12.346]                         if (has_future) {
[15:32:12.346]                           ns <- base::getNamespace("future")
[15:32:12.346]                           version <- ns[[".package"]][["version"]]
[15:32:12.346]                           if (is.null(version)) 
[15:32:12.346]                             version <- utils::packageVersion("future")
[15:32:12.346]                         }
[15:32:12.346]                         else {
[15:32:12.346]                           version <- NULL
[15:32:12.346]                         }
[15:32:12.346]                         if (!has_future || version < "1.8.0") {
[15:32:12.346]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.346]                             "", base::R.version$version.string), 
[15:32:12.346]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.346]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.346]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.346]                               "release", "version")], collapse = " "), 
[15:32:12.346]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.346]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.346]                             info)
[15:32:12.346]                           info <- base::paste(info, collapse = "; ")
[15:32:12.346]                           if (!has_future) {
[15:32:12.346]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.346]                               info)
[15:32:12.346]                           }
[15:32:12.346]                           else {
[15:32:12.346]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.346]                               info, version)
[15:32:12.346]                           }
[15:32:12.346]                           base::stop(msg)
[15:32:12.346]                         }
[15:32:12.346]                       })
[15:32:12.346]                     }
[15:32:12.346]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.346]                     base::options(mc.cores = 1L)
[15:32:12.346]                   }
[15:32:12.346]                   ...future.strategy.old <- future::plan("list")
[15:32:12.346]                   options(future.plan = NULL)
[15:32:12.346]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.346]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.346]                 }
[15:32:12.346]                 ...future.workdir <- getwd()
[15:32:12.346]             }
[15:32:12.346]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.346]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.346]         }
[15:32:12.346]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.346]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:12.346]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.346]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.346]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.346]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.346]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.346]             base::names(...future.oldOptions))
[15:32:12.346]     }
[15:32:12.346]     if (FALSE) {
[15:32:12.346]     }
[15:32:12.346]     else {
[15:32:12.346]         if (TRUE) {
[15:32:12.346]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.346]                 open = "w")
[15:32:12.346]         }
[15:32:12.346]         else {
[15:32:12.346]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.346]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.346]         }
[15:32:12.346]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.346]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.346]             base::sink(type = "output", split = FALSE)
[15:32:12.346]             base::close(...future.stdout)
[15:32:12.346]         }, add = TRUE)
[15:32:12.346]     }
[15:32:12.346]     ...future.frame <- base::sys.nframe()
[15:32:12.346]     ...future.conditions <- base::list()
[15:32:12.346]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.346]     if (FALSE) {
[15:32:12.346]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.346]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.346]     }
[15:32:12.346]     ...future.result <- base::tryCatch({
[15:32:12.346]         base::withCallingHandlers({
[15:32:12.346]             ...future.value <- base::withVisible(base::local({
[15:32:12.346]                 ...future.makeSendCondition <- base::local({
[15:32:12.346]                   sendCondition <- NULL
[15:32:12.346]                   function(frame = 1L) {
[15:32:12.346]                     if (is.function(sendCondition)) 
[15:32:12.346]                       return(sendCondition)
[15:32:12.346]                     ns <- getNamespace("parallel")
[15:32:12.346]                     if (exists("sendData", mode = "function", 
[15:32:12.346]                       envir = ns)) {
[15:32:12.346]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.346]                         envir = ns)
[15:32:12.346]                       envir <- sys.frame(frame)
[15:32:12.346]                       master <- NULL
[15:32:12.346]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.346]                         !identical(envir, emptyenv())) {
[15:32:12.346]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.346]                           inherits = FALSE)) {
[15:32:12.346]                           master <- get("master", mode = "list", 
[15:32:12.346]                             envir = envir, inherits = FALSE)
[15:32:12.346]                           if (inherits(master, c("SOCKnode", 
[15:32:12.346]                             "SOCK0node"))) {
[15:32:12.346]                             sendCondition <<- function(cond) {
[15:32:12.346]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.346]                                 success = TRUE)
[15:32:12.346]                               parallel_sendData(master, data)
[15:32:12.346]                             }
[15:32:12.346]                             return(sendCondition)
[15:32:12.346]                           }
[15:32:12.346]                         }
[15:32:12.346]                         frame <- frame + 1L
[15:32:12.346]                         envir <- sys.frame(frame)
[15:32:12.346]                       }
[15:32:12.346]                     }
[15:32:12.346]                     sendCondition <<- function(cond) NULL
[15:32:12.346]                   }
[15:32:12.346]                 })
[15:32:12.346]                 withCallingHandlers({
[15:32:12.346]                   {
[15:32:12.346]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.346]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.346]                       ...future.globals.maxSize)) {
[15:32:12.346]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.346]                       on.exit(options(oopts), add = TRUE)
[15:32:12.346]                     }
[15:32:12.346]                     {
[15:32:12.346]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.346]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.346]                         USE.NAMES = FALSE)
[15:32:12.346]                       do.call(mapply, args = args)
[15:32:12.346]                     }
[15:32:12.346]                   }
[15:32:12.346]                 }, immediateCondition = function(cond) {
[15:32:12.346]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.346]                   sendCondition(cond)
[15:32:12.346]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.346]                   {
[15:32:12.346]                     inherits <- base::inherits
[15:32:12.346]                     invokeRestart <- base::invokeRestart
[15:32:12.346]                     is.null <- base::is.null
[15:32:12.346]                     muffled <- FALSE
[15:32:12.346]                     if (inherits(cond, "message")) {
[15:32:12.346]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.346]                       if (muffled) 
[15:32:12.346]                         invokeRestart("muffleMessage")
[15:32:12.346]                     }
[15:32:12.346]                     else if (inherits(cond, "warning")) {
[15:32:12.346]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.346]                       if (muffled) 
[15:32:12.346]                         invokeRestart("muffleWarning")
[15:32:12.346]                     }
[15:32:12.346]                     else if (inherits(cond, "condition")) {
[15:32:12.346]                       if (!is.null(pattern)) {
[15:32:12.346]                         computeRestarts <- base::computeRestarts
[15:32:12.346]                         grepl <- base::grepl
[15:32:12.346]                         restarts <- computeRestarts(cond)
[15:32:12.346]                         for (restart in restarts) {
[15:32:12.346]                           name <- restart$name
[15:32:12.346]                           if (is.null(name)) 
[15:32:12.346]                             next
[15:32:12.346]                           if (!grepl(pattern, name)) 
[15:32:12.346]                             next
[15:32:12.346]                           invokeRestart(restart)
[15:32:12.346]                           muffled <- TRUE
[15:32:12.346]                           break
[15:32:12.346]                         }
[15:32:12.346]                       }
[15:32:12.346]                     }
[15:32:12.346]                     invisible(muffled)
[15:32:12.346]                   }
[15:32:12.346]                   muffleCondition(cond)
[15:32:12.346]                 })
[15:32:12.346]             }))
[15:32:12.346]             future::FutureResult(value = ...future.value$value, 
[15:32:12.346]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.346]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.346]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.346]                     ...future.globalenv.names))
[15:32:12.346]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.346]         }, condition = base::local({
[15:32:12.346]             c <- base::c
[15:32:12.346]             inherits <- base::inherits
[15:32:12.346]             invokeRestart <- base::invokeRestart
[15:32:12.346]             length <- base::length
[15:32:12.346]             list <- base::list
[15:32:12.346]             seq.int <- base::seq.int
[15:32:12.346]             signalCondition <- base::signalCondition
[15:32:12.346]             sys.calls <- base::sys.calls
[15:32:12.346]             `[[` <- base::`[[`
[15:32:12.346]             `+` <- base::`+`
[15:32:12.346]             `<<-` <- base::`<<-`
[15:32:12.346]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.346]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.346]                   3L)]
[15:32:12.346]             }
[15:32:12.346]             function(cond) {
[15:32:12.346]                 is_error <- inherits(cond, "error")
[15:32:12.346]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.346]                   NULL)
[15:32:12.346]                 if (is_error) {
[15:32:12.346]                   sessionInformation <- function() {
[15:32:12.346]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.346]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.346]                       search = base::search(), system = base::Sys.info())
[15:32:12.346]                   }
[15:32:12.346]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.346]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.346]                     cond$call), session = sessionInformation(), 
[15:32:12.346]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.346]                   signalCondition(cond)
[15:32:12.346]                 }
[15:32:12.346]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.346]                 "immediateCondition"))) {
[15:32:12.346]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.346]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.346]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.346]                   if (TRUE && !signal) {
[15:32:12.346]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.346]                     {
[15:32:12.346]                       inherits <- base::inherits
[15:32:12.346]                       invokeRestart <- base::invokeRestart
[15:32:12.346]                       is.null <- base::is.null
[15:32:12.346]                       muffled <- FALSE
[15:32:12.346]                       if (inherits(cond, "message")) {
[15:32:12.346]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.346]                         if (muffled) 
[15:32:12.346]                           invokeRestart("muffleMessage")
[15:32:12.346]                       }
[15:32:12.346]                       else if (inherits(cond, "warning")) {
[15:32:12.346]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.346]                         if (muffled) 
[15:32:12.346]                           invokeRestart("muffleWarning")
[15:32:12.346]                       }
[15:32:12.346]                       else if (inherits(cond, "condition")) {
[15:32:12.346]                         if (!is.null(pattern)) {
[15:32:12.346]                           computeRestarts <- base::computeRestarts
[15:32:12.346]                           grepl <- base::grepl
[15:32:12.346]                           restarts <- computeRestarts(cond)
[15:32:12.346]                           for (restart in restarts) {
[15:32:12.346]                             name <- restart$name
[15:32:12.346]                             if (is.null(name)) 
[15:32:12.346]                               next
[15:32:12.346]                             if (!grepl(pattern, name)) 
[15:32:12.346]                               next
[15:32:12.346]                             invokeRestart(restart)
[15:32:12.346]                             muffled <- TRUE
[15:32:12.346]                             break
[15:32:12.346]                           }
[15:32:12.346]                         }
[15:32:12.346]                       }
[15:32:12.346]                       invisible(muffled)
[15:32:12.346]                     }
[15:32:12.346]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.346]                   }
[15:32:12.346]                 }
[15:32:12.346]                 else {
[15:32:12.346]                   if (TRUE) {
[15:32:12.346]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.346]                     {
[15:32:12.346]                       inherits <- base::inherits
[15:32:12.346]                       invokeRestart <- base::invokeRestart
[15:32:12.346]                       is.null <- base::is.null
[15:32:12.346]                       muffled <- FALSE
[15:32:12.346]                       if (inherits(cond, "message")) {
[15:32:12.346]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.346]                         if (muffled) 
[15:32:12.346]                           invokeRestart("muffleMessage")
[15:32:12.346]                       }
[15:32:12.346]                       else if (inherits(cond, "warning")) {
[15:32:12.346]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.346]                         if (muffled) 
[15:32:12.346]                           invokeRestart("muffleWarning")
[15:32:12.346]                       }
[15:32:12.346]                       else if (inherits(cond, "condition")) {
[15:32:12.346]                         if (!is.null(pattern)) {
[15:32:12.346]                           computeRestarts <- base::computeRestarts
[15:32:12.346]                           grepl <- base::grepl
[15:32:12.346]                           restarts <- computeRestarts(cond)
[15:32:12.346]                           for (restart in restarts) {
[15:32:12.346]                             name <- restart$name
[15:32:12.346]                             if (is.null(name)) 
[15:32:12.346]                               next
[15:32:12.346]                             if (!grepl(pattern, name)) 
[15:32:12.346]                               next
[15:32:12.346]                             invokeRestart(restart)
[15:32:12.346]                             muffled <- TRUE
[15:32:12.346]                             break
[15:32:12.346]                           }
[15:32:12.346]                         }
[15:32:12.346]                       }
[15:32:12.346]                       invisible(muffled)
[15:32:12.346]                     }
[15:32:12.346]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.346]                   }
[15:32:12.346]                 }
[15:32:12.346]             }
[15:32:12.346]         }))
[15:32:12.346]     }, error = function(ex) {
[15:32:12.346]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.346]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.346]                 ...future.rng), started = ...future.startTime, 
[15:32:12.346]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.346]             version = "1.8"), class = "FutureResult")
[15:32:12.346]     }, finally = {
[15:32:12.346]         if (!identical(...future.workdir, getwd())) 
[15:32:12.346]             setwd(...future.workdir)
[15:32:12.346]         {
[15:32:12.346]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.346]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.346]             }
[15:32:12.346]             base::options(...future.oldOptions)
[15:32:12.346]             if (.Platform$OS.type == "windows") {
[15:32:12.346]                 old_names <- names(...future.oldEnvVars)
[15:32:12.346]                 envs <- base::Sys.getenv()
[15:32:12.346]                 names <- names(envs)
[15:32:12.346]                 common <- intersect(names, old_names)
[15:32:12.346]                 added <- setdiff(names, old_names)
[15:32:12.346]                 removed <- setdiff(old_names, names)
[15:32:12.346]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.346]                   envs[common]]
[15:32:12.346]                 NAMES <- toupper(changed)
[15:32:12.346]                 args <- list()
[15:32:12.346]                 for (kk in seq_along(NAMES)) {
[15:32:12.346]                   name <- changed[[kk]]
[15:32:12.346]                   NAME <- NAMES[[kk]]
[15:32:12.346]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.346]                     next
[15:32:12.346]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.346]                 }
[15:32:12.346]                 NAMES <- toupper(added)
[15:32:12.346]                 for (kk in seq_along(NAMES)) {
[15:32:12.346]                   name <- added[[kk]]
[15:32:12.346]                   NAME <- NAMES[[kk]]
[15:32:12.346]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.346]                     next
[15:32:12.346]                   args[[name]] <- ""
[15:32:12.346]                 }
[15:32:12.346]                 NAMES <- toupper(removed)
[15:32:12.346]                 for (kk in seq_along(NAMES)) {
[15:32:12.346]                   name <- removed[[kk]]
[15:32:12.346]                   NAME <- NAMES[[kk]]
[15:32:12.346]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.346]                     next
[15:32:12.346]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.346]                 }
[15:32:12.346]                 if (length(args) > 0) 
[15:32:12.346]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.346]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.346]             }
[15:32:12.346]             else {
[15:32:12.346]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.346]             }
[15:32:12.346]             {
[15:32:12.346]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.346]                   0L) {
[15:32:12.346]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.346]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.346]                   base::options(opts)
[15:32:12.346]                 }
[15:32:12.346]                 {
[15:32:12.346]                   {
[15:32:12.346]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.346]                     NULL
[15:32:12.346]                   }
[15:32:12.346]                   options(future.plan = NULL)
[15:32:12.346]                   if (is.na(NA_character_)) 
[15:32:12.346]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.346]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.346]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.346]                     .init = FALSE)
[15:32:12.346]                 }
[15:32:12.346]             }
[15:32:12.346]         }
[15:32:12.346]     })
[15:32:12.346]     if (TRUE) {
[15:32:12.346]         base::sink(type = "output", split = FALSE)
[15:32:12.346]         if (TRUE) {
[15:32:12.346]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.346]         }
[15:32:12.346]         else {
[15:32:12.346]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.346]         }
[15:32:12.346]         base::close(...future.stdout)
[15:32:12.346]         ...future.stdout <- NULL
[15:32:12.346]     }
[15:32:12.346]     ...future.result$conditions <- ...future.conditions
[15:32:12.346]     ...future.result$finished <- base::Sys.time()
[15:32:12.346]     ...future.result
[15:32:12.346] }
[15:32:12.355] Exporting 5 global objects (3.57 KiB) to cluster node #1 ...
[15:32:12.355] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.356] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.356] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.357] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.357] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:32:12.358] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:32:12.358] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.359] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.359] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.360] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.360] Exporting 5 global objects (3.57 KiB) to cluster node #1 ... DONE
[15:32:12.361] MultisessionFuture started
[15:32:12.361] - Launch lazy future ... done
[15:32:12.362] run() for 'MultisessionFuture' ... done
[15:32:12.362] Created future:
[15:32:12.382] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.383] - Validating connection of MultisessionFuture
[15:32:12.383] - received message: FutureResult
[15:32:12.384] - Received FutureResult
[15:32:12.384] - Erased future from FutureRegistry
[15:32:12.385] result() for ClusterFuture ...
[15:32:12.385] - result already collected: FutureResult
[15:32:12.385] result() for ClusterFuture ... done
[15:32:12.386] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.362] MultisessionFuture:
[15:32:12.362] Label: 'future_.mapply-1'
[15:32:12.362] Expression:
[15:32:12.362] {
[15:32:12.362]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.362]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.362]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.362]         on.exit(options(oopts), add = TRUE)
[15:32:12.362]     }
[15:32:12.362]     {
[15:32:12.362]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.362]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.362]         do.call(mapply, args = args)
[15:32:12.362]     }
[15:32:12.362] }
[15:32:12.362] Lazy evaluation: FALSE
[15:32:12.362] Asynchronous evaluation: TRUE
[15:32:12.362] Local evaluation: TRUE
[15:32:12.362] Environment: R_GlobalEnv
[15:32:12.362] Capture standard output: TRUE
[15:32:12.362] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.362] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.362] Packages: <none>
[15:32:12.362] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.362] Resolved: TRUE
[15:32:12.362] Value: <not collected>
[15:32:12.362] Conditions captured: <none>
[15:32:12.362] Early signaling: FALSE
[15:32:12.362] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.362] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.387] Chunk #1 of 2 ... DONE
[15:32:12.387] Chunk #2 of 2 ...
[15:32:12.388]  - Finding globals in '...' for chunk #2 ...
[15:32:12.388] getGlobalsAndPackages() ...
[15:32:12.388] Searching for globals...
[15:32:12.389] 
[15:32:12.390] Searching for globals ... DONE
[15:32:12.390] - globals: [0] <none>
[15:32:12.390] getGlobalsAndPackages() ... DONE
[15:32:12.391]    + additional globals found: [n=0] 
[15:32:12.391]    + additional namespaces needed: [n=0] 
[15:32:12.391]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:12.392]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:12.392]  - seeds: <none>
[15:32:12.392]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.393] getGlobalsAndPackages() ...
[15:32:12.393] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.394] Resolving globals: FALSE
[15:32:12.395] The total size of the 5 globals is 3.73 KiB (3824 bytes)
[15:32:12.396] 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 3.73 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (504 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:12.397] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.397] 
[15:32:12.398] getGlobalsAndPackages() ... DONE
[15:32:12.398] run() for 'Future' ...
[15:32:12.399] - state: 'created'
[15:32:12.399] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.420] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.421] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.421]   - Field: 'node'
[15:32:12.421]   - Field: 'label'
[15:32:12.422]   - Field: 'local'
[15:32:12.422]   - Field: 'owner'
[15:32:12.422]   - Field: 'envir'
[15:32:12.423]   - Field: 'workers'
[15:32:12.423]   - Field: 'packages'
[15:32:12.424]   - Field: 'gc'
[15:32:12.424]   - Field: 'conditions'
[15:32:12.424]   - Field: 'persistent'
[15:32:12.425]   - Field: 'expr'
[15:32:12.425]   - Field: 'uuid'
[15:32:12.425]   - Field: 'seed'
[15:32:12.426]   - Field: 'version'
[15:32:12.426]   - Field: 'result'
[15:32:12.426]   - Field: 'asynchronous'
[15:32:12.426]   - Field: 'calls'
[15:32:12.427]   - Field: 'globals'
[15:32:12.427]   - Field: 'stdout'
[15:32:12.427]   - Field: 'earlySignal'
[15:32:12.428]   - Field: 'lazy'
[15:32:12.428]   - Field: 'state'
[15:32:12.428] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.429] - Launch lazy future ...
[15:32:12.429] Packages needed by the future expression (n = 0): <none>
[15:32:12.430] Packages needed by future strategies (n = 0): <none>
[15:32:12.431] {
[15:32:12.431]     {
[15:32:12.431]         {
[15:32:12.431]             ...future.startTime <- base::Sys.time()
[15:32:12.431]             {
[15:32:12.431]                 {
[15:32:12.431]                   {
[15:32:12.431]                     {
[15:32:12.431]                       base::local({
[15:32:12.431]                         has_future <- base::requireNamespace("future", 
[15:32:12.431]                           quietly = TRUE)
[15:32:12.431]                         if (has_future) {
[15:32:12.431]                           ns <- base::getNamespace("future")
[15:32:12.431]                           version <- ns[[".package"]][["version"]]
[15:32:12.431]                           if (is.null(version)) 
[15:32:12.431]                             version <- utils::packageVersion("future")
[15:32:12.431]                         }
[15:32:12.431]                         else {
[15:32:12.431]                           version <- NULL
[15:32:12.431]                         }
[15:32:12.431]                         if (!has_future || version < "1.8.0") {
[15:32:12.431]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.431]                             "", base::R.version$version.string), 
[15:32:12.431]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.431]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.431]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.431]                               "release", "version")], collapse = " "), 
[15:32:12.431]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.431]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.431]                             info)
[15:32:12.431]                           info <- base::paste(info, collapse = "; ")
[15:32:12.431]                           if (!has_future) {
[15:32:12.431]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.431]                               info)
[15:32:12.431]                           }
[15:32:12.431]                           else {
[15:32:12.431]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.431]                               info, version)
[15:32:12.431]                           }
[15:32:12.431]                           base::stop(msg)
[15:32:12.431]                         }
[15:32:12.431]                       })
[15:32:12.431]                     }
[15:32:12.431]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.431]                     base::options(mc.cores = 1L)
[15:32:12.431]                   }
[15:32:12.431]                   ...future.strategy.old <- future::plan("list")
[15:32:12.431]                   options(future.plan = NULL)
[15:32:12.431]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.431]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.431]                 }
[15:32:12.431]                 ...future.workdir <- getwd()
[15:32:12.431]             }
[15:32:12.431]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.431]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.431]         }
[15:32:12.431]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.431]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:12.431]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.431]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.431]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.431]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.431]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.431]             base::names(...future.oldOptions))
[15:32:12.431]     }
[15:32:12.431]     if (FALSE) {
[15:32:12.431]     }
[15:32:12.431]     else {
[15:32:12.431]         if (TRUE) {
[15:32:12.431]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.431]                 open = "w")
[15:32:12.431]         }
[15:32:12.431]         else {
[15:32:12.431]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.431]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.431]         }
[15:32:12.431]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.431]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.431]             base::sink(type = "output", split = FALSE)
[15:32:12.431]             base::close(...future.stdout)
[15:32:12.431]         }, add = TRUE)
[15:32:12.431]     }
[15:32:12.431]     ...future.frame <- base::sys.nframe()
[15:32:12.431]     ...future.conditions <- base::list()
[15:32:12.431]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.431]     if (FALSE) {
[15:32:12.431]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.431]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.431]     }
[15:32:12.431]     ...future.result <- base::tryCatch({
[15:32:12.431]         base::withCallingHandlers({
[15:32:12.431]             ...future.value <- base::withVisible(base::local({
[15:32:12.431]                 ...future.makeSendCondition <- base::local({
[15:32:12.431]                   sendCondition <- NULL
[15:32:12.431]                   function(frame = 1L) {
[15:32:12.431]                     if (is.function(sendCondition)) 
[15:32:12.431]                       return(sendCondition)
[15:32:12.431]                     ns <- getNamespace("parallel")
[15:32:12.431]                     if (exists("sendData", mode = "function", 
[15:32:12.431]                       envir = ns)) {
[15:32:12.431]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.431]                         envir = ns)
[15:32:12.431]                       envir <- sys.frame(frame)
[15:32:12.431]                       master <- NULL
[15:32:12.431]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.431]                         !identical(envir, emptyenv())) {
[15:32:12.431]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.431]                           inherits = FALSE)) {
[15:32:12.431]                           master <- get("master", mode = "list", 
[15:32:12.431]                             envir = envir, inherits = FALSE)
[15:32:12.431]                           if (inherits(master, c("SOCKnode", 
[15:32:12.431]                             "SOCK0node"))) {
[15:32:12.431]                             sendCondition <<- function(cond) {
[15:32:12.431]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.431]                                 success = TRUE)
[15:32:12.431]                               parallel_sendData(master, data)
[15:32:12.431]                             }
[15:32:12.431]                             return(sendCondition)
[15:32:12.431]                           }
[15:32:12.431]                         }
[15:32:12.431]                         frame <- frame + 1L
[15:32:12.431]                         envir <- sys.frame(frame)
[15:32:12.431]                       }
[15:32:12.431]                     }
[15:32:12.431]                     sendCondition <<- function(cond) NULL
[15:32:12.431]                   }
[15:32:12.431]                 })
[15:32:12.431]                 withCallingHandlers({
[15:32:12.431]                   {
[15:32:12.431]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.431]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.431]                       ...future.globals.maxSize)) {
[15:32:12.431]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.431]                       on.exit(options(oopts), add = TRUE)
[15:32:12.431]                     }
[15:32:12.431]                     {
[15:32:12.431]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.431]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.431]                         USE.NAMES = FALSE)
[15:32:12.431]                       do.call(mapply, args = args)
[15:32:12.431]                     }
[15:32:12.431]                   }
[15:32:12.431]                 }, immediateCondition = function(cond) {
[15:32:12.431]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.431]                   sendCondition(cond)
[15:32:12.431]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.431]                   {
[15:32:12.431]                     inherits <- base::inherits
[15:32:12.431]                     invokeRestart <- base::invokeRestart
[15:32:12.431]                     is.null <- base::is.null
[15:32:12.431]                     muffled <- FALSE
[15:32:12.431]                     if (inherits(cond, "message")) {
[15:32:12.431]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.431]                       if (muffled) 
[15:32:12.431]                         invokeRestart("muffleMessage")
[15:32:12.431]                     }
[15:32:12.431]                     else if (inherits(cond, "warning")) {
[15:32:12.431]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.431]                       if (muffled) 
[15:32:12.431]                         invokeRestart("muffleWarning")
[15:32:12.431]                     }
[15:32:12.431]                     else if (inherits(cond, "condition")) {
[15:32:12.431]                       if (!is.null(pattern)) {
[15:32:12.431]                         computeRestarts <- base::computeRestarts
[15:32:12.431]                         grepl <- base::grepl
[15:32:12.431]                         restarts <- computeRestarts(cond)
[15:32:12.431]                         for (restart in restarts) {
[15:32:12.431]                           name <- restart$name
[15:32:12.431]                           if (is.null(name)) 
[15:32:12.431]                             next
[15:32:12.431]                           if (!grepl(pattern, name)) 
[15:32:12.431]                             next
[15:32:12.431]                           invokeRestart(restart)
[15:32:12.431]                           muffled <- TRUE
[15:32:12.431]                           break
[15:32:12.431]                         }
[15:32:12.431]                       }
[15:32:12.431]                     }
[15:32:12.431]                     invisible(muffled)
[15:32:12.431]                   }
[15:32:12.431]                   muffleCondition(cond)
[15:32:12.431]                 })
[15:32:12.431]             }))
[15:32:12.431]             future::FutureResult(value = ...future.value$value, 
[15:32:12.431]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.431]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.431]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.431]                     ...future.globalenv.names))
[15:32:12.431]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.431]         }, condition = base::local({
[15:32:12.431]             c <- base::c
[15:32:12.431]             inherits <- base::inherits
[15:32:12.431]             invokeRestart <- base::invokeRestart
[15:32:12.431]             length <- base::length
[15:32:12.431]             list <- base::list
[15:32:12.431]             seq.int <- base::seq.int
[15:32:12.431]             signalCondition <- base::signalCondition
[15:32:12.431]             sys.calls <- base::sys.calls
[15:32:12.431]             `[[` <- base::`[[`
[15:32:12.431]             `+` <- base::`+`
[15:32:12.431]             `<<-` <- base::`<<-`
[15:32:12.431]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.431]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.431]                   3L)]
[15:32:12.431]             }
[15:32:12.431]             function(cond) {
[15:32:12.431]                 is_error <- inherits(cond, "error")
[15:32:12.431]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.431]                   NULL)
[15:32:12.431]                 if (is_error) {
[15:32:12.431]                   sessionInformation <- function() {
[15:32:12.431]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.431]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.431]                       search = base::search(), system = base::Sys.info())
[15:32:12.431]                   }
[15:32:12.431]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.431]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.431]                     cond$call), session = sessionInformation(), 
[15:32:12.431]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.431]                   signalCondition(cond)
[15:32:12.431]                 }
[15:32:12.431]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.431]                 "immediateCondition"))) {
[15:32:12.431]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.431]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.431]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.431]                   if (TRUE && !signal) {
[15:32:12.431]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.431]                     {
[15:32:12.431]                       inherits <- base::inherits
[15:32:12.431]                       invokeRestart <- base::invokeRestart
[15:32:12.431]                       is.null <- base::is.null
[15:32:12.431]                       muffled <- FALSE
[15:32:12.431]                       if (inherits(cond, "message")) {
[15:32:12.431]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.431]                         if (muffled) 
[15:32:12.431]                           invokeRestart("muffleMessage")
[15:32:12.431]                       }
[15:32:12.431]                       else if (inherits(cond, "warning")) {
[15:32:12.431]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.431]                         if (muffled) 
[15:32:12.431]                           invokeRestart("muffleWarning")
[15:32:12.431]                       }
[15:32:12.431]                       else if (inherits(cond, "condition")) {
[15:32:12.431]                         if (!is.null(pattern)) {
[15:32:12.431]                           computeRestarts <- base::computeRestarts
[15:32:12.431]                           grepl <- base::grepl
[15:32:12.431]                           restarts <- computeRestarts(cond)
[15:32:12.431]                           for (restart in restarts) {
[15:32:12.431]                             name <- restart$name
[15:32:12.431]                             if (is.null(name)) 
[15:32:12.431]                               next
[15:32:12.431]                             if (!grepl(pattern, name)) 
[15:32:12.431]                               next
[15:32:12.431]                             invokeRestart(restart)
[15:32:12.431]                             muffled <- TRUE
[15:32:12.431]                             break
[15:32:12.431]                           }
[15:32:12.431]                         }
[15:32:12.431]                       }
[15:32:12.431]                       invisible(muffled)
[15:32:12.431]                     }
[15:32:12.431]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.431]                   }
[15:32:12.431]                 }
[15:32:12.431]                 else {
[15:32:12.431]                   if (TRUE) {
[15:32:12.431]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.431]                     {
[15:32:12.431]                       inherits <- base::inherits
[15:32:12.431]                       invokeRestart <- base::invokeRestart
[15:32:12.431]                       is.null <- base::is.null
[15:32:12.431]                       muffled <- FALSE
[15:32:12.431]                       if (inherits(cond, "message")) {
[15:32:12.431]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.431]                         if (muffled) 
[15:32:12.431]                           invokeRestart("muffleMessage")
[15:32:12.431]                       }
[15:32:12.431]                       else if (inherits(cond, "warning")) {
[15:32:12.431]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.431]                         if (muffled) 
[15:32:12.431]                           invokeRestart("muffleWarning")
[15:32:12.431]                       }
[15:32:12.431]                       else if (inherits(cond, "condition")) {
[15:32:12.431]                         if (!is.null(pattern)) {
[15:32:12.431]                           computeRestarts <- base::computeRestarts
[15:32:12.431]                           grepl <- base::grepl
[15:32:12.431]                           restarts <- computeRestarts(cond)
[15:32:12.431]                           for (restart in restarts) {
[15:32:12.431]                             name <- restart$name
[15:32:12.431]                             if (is.null(name)) 
[15:32:12.431]                               next
[15:32:12.431]                             if (!grepl(pattern, name)) 
[15:32:12.431]                               next
[15:32:12.431]                             invokeRestart(restart)
[15:32:12.431]                             muffled <- TRUE
[15:32:12.431]                             break
[15:32:12.431]                           }
[15:32:12.431]                         }
[15:32:12.431]                       }
[15:32:12.431]                       invisible(muffled)
[15:32:12.431]                     }
[15:32:12.431]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.431]                   }
[15:32:12.431]                 }
[15:32:12.431]             }
[15:32:12.431]         }))
[15:32:12.431]     }, error = function(ex) {
[15:32:12.431]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.431]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.431]                 ...future.rng), started = ...future.startTime, 
[15:32:12.431]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.431]             version = "1.8"), class = "FutureResult")
[15:32:12.431]     }, finally = {
[15:32:12.431]         if (!identical(...future.workdir, getwd())) 
[15:32:12.431]             setwd(...future.workdir)
[15:32:12.431]         {
[15:32:12.431]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.431]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.431]             }
[15:32:12.431]             base::options(...future.oldOptions)
[15:32:12.431]             if (.Platform$OS.type == "windows") {
[15:32:12.431]                 old_names <- names(...future.oldEnvVars)
[15:32:12.431]                 envs <- base::Sys.getenv()
[15:32:12.431]                 names <- names(envs)
[15:32:12.431]                 common <- intersect(names, old_names)
[15:32:12.431]                 added <- setdiff(names, old_names)
[15:32:12.431]                 removed <- setdiff(old_names, names)
[15:32:12.431]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.431]                   envs[common]]
[15:32:12.431]                 NAMES <- toupper(changed)
[15:32:12.431]                 args <- list()
[15:32:12.431]                 for (kk in seq_along(NAMES)) {
[15:32:12.431]                   name <- changed[[kk]]
[15:32:12.431]                   NAME <- NAMES[[kk]]
[15:32:12.431]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.431]                     next
[15:32:12.431]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.431]                 }
[15:32:12.431]                 NAMES <- toupper(added)
[15:32:12.431]                 for (kk in seq_along(NAMES)) {
[15:32:12.431]                   name <- added[[kk]]
[15:32:12.431]                   NAME <- NAMES[[kk]]
[15:32:12.431]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.431]                     next
[15:32:12.431]                   args[[name]] <- ""
[15:32:12.431]                 }
[15:32:12.431]                 NAMES <- toupper(removed)
[15:32:12.431]                 for (kk in seq_along(NAMES)) {
[15:32:12.431]                   name <- removed[[kk]]
[15:32:12.431]                   NAME <- NAMES[[kk]]
[15:32:12.431]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.431]                     next
[15:32:12.431]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.431]                 }
[15:32:12.431]                 if (length(args) > 0) 
[15:32:12.431]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.431]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.431]             }
[15:32:12.431]             else {
[15:32:12.431]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.431]             }
[15:32:12.431]             {
[15:32:12.431]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.431]                   0L) {
[15:32:12.431]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.431]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.431]                   base::options(opts)
[15:32:12.431]                 }
[15:32:12.431]                 {
[15:32:12.431]                   {
[15:32:12.431]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.431]                     NULL
[15:32:12.431]                   }
[15:32:12.431]                   options(future.plan = NULL)
[15:32:12.431]                   if (is.na(NA_character_)) 
[15:32:12.431]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.431]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.431]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.431]                     .init = FALSE)
[15:32:12.431]                 }
[15:32:12.431]             }
[15:32:12.431]         }
[15:32:12.431]     })
[15:32:12.431]     if (TRUE) {
[15:32:12.431]         base::sink(type = "output", split = FALSE)
[15:32:12.431]         if (TRUE) {
[15:32:12.431]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.431]         }
[15:32:12.431]         else {
[15:32:12.431]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.431]         }
[15:32:12.431]         base::close(...future.stdout)
[15:32:12.431]         ...future.stdout <- NULL
[15:32:12.431]     }
[15:32:12.431]     ...future.result$conditions <- ...future.conditions
[15:32:12.431]     ...future.result$finished <- base::Sys.time()
[15:32:12.431]     ...future.result
[15:32:12.431] }
[15:32:12.440] Exporting 5 global objects (3.73 KiB) to cluster node #1 ...
[15:32:12.441] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.441] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.442] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.443] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.443] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ...
[15:32:12.444] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ... DONE
[15:32:12.444] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.445] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.446] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.447] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.447] Exporting 5 global objects (3.73 KiB) to cluster node #1 ... DONE
[15:32:12.449] MultisessionFuture started
[15:32:12.449] - Launch lazy future ... done
[15:32:12.449] run() for 'MultisessionFuture' ... done
[15:32:12.450] Created future:
[15:32:12.481] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.482] - Validating connection of MultisessionFuture
[15:32:12.482] - received message: FutureResult
[15:32:12.483] - Received FutureResult
[15:32:12.483] - Erased future from FutureRegistry
[15:32:12.483] result() for ClusterFuture ...
[15:32:12.483] - result already collected: FutureResult
[15:32:12.484] result() for ClusterFuture ... done
[15:32:12.484] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.450] MultisessionFuture:
[15:32:12.450] Label: 'future_.mapply-2'
[15:32:12.450] Expression:
[15:32:12.450] {
[15:32:12.450]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.450]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.450]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.450]         on.exit(options(oopts), add = TRUE)
[15:32:12.450]     }
[15:32:12.450]     {
[15:32:12.450]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.450]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.450]         do.call(mapply, args = args)
[15:32:12.450]     }
[15:32:12.450] }
[15:32:12.450] Lazy evaluation: FALSE
[15:32:12.450] Asynchronous evaluation: TRUE
[15:32:12.450] Local evaluation: TRUE
[15:32:12.450] Environment: R_GlobalEnv
[15:32:12.450] Capture standard output: TRUE
[15:32:12.450] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.450] Globals: 5 objects totaling 3.73 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 504 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.450] Packages: <none>
[15:32:12.450] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.450] Resolved: TRUE
[15:32:12.450] Value: <not collected>
[15:32:12.450] Conditions captured: <none>
[15:32:12.450] Early signaling: FALSE
[15:32:12.450] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.450] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.485] Chunk #2 of 2 ... DONE
[15:32:12.485] Launching 2 futures (chunks) ... DONE
[15:32:12.485] Resolving 2 futures (chunks) ...
[15:32:12.485] resolve() on list ...
[15:32:12.485]  recursive: 0
[15:32:12.486]  length: 2
[15:32:12.486] 
[15:32:12.486] Future #1
[15:32:12.486] result() for ClusterFuture ...
[15:32:12.487] - result already collected: FutureResult
[15:32:12.487] result() for ClusterFuture ... done
[15:32:12.487] result() for ClusterFuture ...
[15:32:12.487] - result already collected: FutureResult
[15:32:12.487] result() for ClusterFuture ... done
[15:32:12.488] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:12.488] - nx: 2
[15:32:12.488] - relay: TRUE
[15:32:12.488] - stdout: TRUE
[15:32:12.489] - signal: TRUE
[15:32:12.489] - resignal: FALSE
[15:32:12.489] - force: TRUE
[15:32:12.489] - relayed: [n=2] FALSE, FALSE
[15:32:12.489] - queued futures: [n=2] FALSE, FALSE
[15:32:12.490]  - until=1
[15:32:12.490]  - relaying element #1
[15:32:12.490] result() for ClusterFuture ...
[15:32:12.490] - result already collected: FutureResult
[15:32:12.491] result() for ClusterFuture ... done
[15:32:12.491] result() for ClusterFuture ...
[15:32:12.491] - result already collected: FutureResult
[15:32:12.491] result() for ClusterFuture ... done
[15:32:12.492] result() for ClusterFuture ...
[15:32:12.492] - result already collected: FutureResult
[15:32:12.492] result() for ClusterFuture ... done
[15:32:12.492] result() for ClusterFuture ...
[15:32:12.493] - result already collected: FutureResult
[15:32:12.493] result() for ClusterFuture ... done
[15:32:12.493] - relayed: [n=2] TRUE, FALSE
[15:32:12.493] - queued futures: [n=2] TRUE, FALSE
[15:32:12.493] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:12.494]  length: 1 (resolved future 1)
[15:32:12.494] Future #2
[15:32:12.494] result() for ClusterFuture ...
[15:32:12.495] - result already collected: FutureResult
[15:32:12.495] result() for ClusterFuture ... done
[15:32:12.495] result() for ClusterFuture ...
[15:32:12.495] - result already collected: FutureResult
[15:32:12.495] result() for ClusterFuture ... done
[15:32:12.496] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:12.496] - nx: 2
[15:32:12.496] - relay: TRUE
[15:32:12.496] - stdout: TRUE
[15:32:12.497] - signal: TRUE
[15:32:12.497] - resignal: FALSE
[15:32:12.497] - force: TRUE
[15:32:12.497] - relayed: [n=2] TRUE, FALSE
[15:32:12.497] - queued futures: [n=2] TRUE, FALSE
[15:32:12.498]  - until=2
[15:32:12.498]  - relaying element #2
[15:32:12.498] result() for ClusterFuture ...
[15:32:12.498] - result already collected: FutureResult
[15:32:12.499] result() for ClusterFuture ... done
[15:32:12.499] result() for ClusterFuture ...
[15:32:12.499] - result already collected: FutureResult
[15:32:12.499] result() for ClusterFuture ... done
[15:32:12.500] result() for ClusterFuture ...
[15:32:12.500] - result already collected: FutureResult
[15:32:12.500] result() for ClusterFuture ... done
[15:32:12.500] result() for ClusterFuture ...
[15:32:12.501] - result already collected: FutureResult
[15:32:12.501] result() for ClusterFuture ... done
[15:32:12.501] - relayed: [n=2] TRUE, TRUE
[15:32:12.501] - queued futures: [n=2] TRUE, TRUE
[15:32:12.501] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:12.502]  length: 0 (resolved future 2)
[15:32:12.502] Relaying remaining futures
[15:32:12.502] signalConditionsASAP(NULL, pos=0) ...
[15:32:12.502] - nx: 2
[15:32:12.503] - relay: TRUE
[15:32:12.503] - stdout: TRUE
[15:32:12.503] - signal: TRUE
[15:32:12.503] - resignal: FALSE
[15:32:12.503] - force: TRUE
[15:32:12.504] - relayed: [n=2] TRUE, TRUE
[15:32:12.504] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:12.504] - relayed: [n=2] TRUE, TRUE
[15:32:12.504] - queued futures: [n=2] TRUE, TRUE
[15:32:12.505] signalConditionsASAP(NULL, pos=0) ... done
[15:32:12.505] resolve() on list ... DONE
[15:32:12.505] result() for ClusterFuture ...
[15:32:12.505] - result already collected: FutureResult
[15:32:12.505] result() for ClusterFuture ... done
[15:32:12.506] result() for ClusterFuture ...
[15:32:12.506] - result already collected: FutureResult
[15:32:12.506] result() for ClusterFuture ... done
[15:32:12.506] result() for ClusterFuture ...
[15:32:12.507] - result already collected: FutureResult
[15:32:12.507] result() for ClusterFuture ... done
[15:32:12.507] result() for ClusterFuture ...
[15:32:12.507] - result already collected: FutureResult
[15:32:12.508] result() for ClusterFuture ... done
[15:32:12.508]  - Number of value chunks collected: 2
[15:32:12.508] Resolving 2 futures (chunks) ... DONE
[15:32:12.508] Reducing values from 2 chunks ...
[15:32:12.508]  - Number of values collected after concatenation: 5
[15:32:12.509]  - Number of values expected: 5
[15:32:12.509] Reducing values from 2 chunks ... DONE
[15:32:12.509] future_mapply() ... DONE
[15:32:12.510] future_mapply() ...
[15:32:12.513] Number of chunks: 2
[15:32:12.514] Index remapping (attribute 'ordering'): [n = 5] 5, 4, 3, 2, 1
[15:32:12.514] getGlobalsAndPackagesXApply() ...
[15:32:12.514]  - future.globals: TRUE
[15:32:12.515] getGlobalsAndPackages() ...
[15:32:12.515] Searching for globals...
[15:32:12.517] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:12.517] Searching for globals ... DONE
[15:32:12.518] Resolving globals: FALSE
[15:32:12.518] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:12.519] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:12.519] - globals: [1] 'FUN'
[15:32:12.519] 
[15:32:12.520] getGlobalsAndPackages() ... DONE
[15:32:12.520]  - globals found/used: [n=1] 'FUN'
[15:32:12.520]  - needed namespaces: [n=0] 
[15:32:12.520] Finding globals ... DONE
[15:32:12.521] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:12.521] List of 2
[15:32:12.521]  $ ...future.FUN:function (C, k)  
[15:32:12.521]  $ MoreArgs     : NULL
[15:32:12.521]  - attr(*, "where")=List of 2
[15:32:12.521]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:12.521]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:12.521]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:12.521]  - attr(*, "resolved")= logi FALSE
[15:32:12.521]  - attr(*, "total_size")= num NA
[15:32:12.525] Packages to be attached in all futures: [n=0] 
[15:32:12.525] getGlobalsAndPackagesXApply() ... DONE
[15:32:12.526] Number of futures (= number of chunks): 2
[15:32:12.526] Launching 2 futures (chunks) ...
[15:32:12.526] Chunk #1 of 2 ...
[15:32:12.526]  - Finding globals in '...' for chunk #1 ...
[15:32:12.527] getGlobalsAndPackages() ...
[15:32:12.527] Searching for globals...
[15:32:12.527] 
[15:32:12.528] Searching for globals ... DONE
[15:32:12.528] - globals: [0] <none>
[15:32:12.528] getGlobalsAndPackages() ... DONE
[15:32:12.528]    + additional globals found: [n=0] 
[15:32:12.529]    + additional namespaces needed: [n=0] 
[15:32:12.529]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:12.529]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:12.529]  - seeds: <none>
[15:32:12.529]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.530] getGlobalsAndPackages() ...
[15:32:12.530] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.530] Resolving globals: FALSE
[15:32:12.531] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:12.532] 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 3.57 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:12.532] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.533] 
[15:32:12.533] getGlobalsAndPackages() ... DONE
[15:32:12.533] run() for 'Future' ...
[15:32:12.534] - state: 'created'
[15:32:12.534] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.553] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.553] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.553]   - Field: 'node'
[15:32:12.554]   - Field: 'label'
[15:32:12.554]   - Field: 'local'
[15:32:12.554]   - Field: 'owner'
[15:32:12.554]   - Field: 'envir'
[15:32:12.555]   - Field: 'workers'
[15:32:12.555]   - Field: 'packages'
[15:32:12.555]   - Field: 'gc'
[15:32:12.556]   - Field: 'conditions'
[15:32:12.556]   - Field: 'persistent'
[15:32:12.556]   - Field: 'expr'
[15:32:12.556]   - Field: 'uuid'
[15:32:12.557]   - Field: 'seed'
[15:32:12.557]   - Field: 'version'
[15:32:12.557]   - Field: 'result'
[15:32:12.558]   - Field: 'asynchronous'
[15:32:12.558]   - Field: 'calls'
[15:32:12.558]   - Field: 'globals'
[15:32:12.558]   - Field: 'stdout'
[15:32:12.559]   - Field: 'earlySignal'
[15:32:12.559]   - Field: 'lazy'
[15:32:12.559]   - Field: 'state'
[15:32:12.560] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.560] - Launch lazy future ...
[15:32:12.560] Packages needed by the future expression (n = 0): <none>
[15:32:12.561] Packages needed by future strategies (n = 0): <none>
[15:32:12.562] {
[15:32:12.562]     {
[15:32:12.562]         {
[15:32:12.562]             ...future.startTime <- base::Sys.time()
[15:32:12.562]             {
[15:32:12.562]                 {
[15:32:12.562]                   {
[15:32:12.562]                     {
[15:32:12.562]                       base::local({
[15:32:12.562]                         has_future <- base::requireNamespace("future", 
[15:32:12.562]                           quietly = TRUE)
[15:32:12.562]                         if (has_future) {
[15:32:12.562]                           ns <- base::getNamespace("future")
[15:32:12.562]                           version <- ns[[".package"]][["version"]]
[15:32:12.562]                           if (is.null(version)) 
[15:32:12.562]                             version <- utils::packageVersion("future")
[15:32:12.562]                         }
[15:32:12.562]                         else {
[15:32:12.562]                           version <- NULL
[15:32:12.562]                         }
[15:32:12.562]                         if (!has_future || version < "1.8.0") {
[15:32:12.562]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.562]                             "", base::R.version$version.string), 
[15:32:12.562]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.562]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.562]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.562]                               "release", "version")], collapse = " "), 
[15:32:12.562]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.562]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.562]                             info)
[15:32:12.562]                           info <- base::paste(info, collapse = "; ")
[15:32:12.562]                           if (!has_future) {
[15:32:12.562]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.562]                               info)
[15:32:12.562]                           }
[15:32:12.562]                           else {
[15:32:12.562]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.562]                               info, version)
[15:32:12.562]                           }
[15:32:12.562]                           base::stop(msg)
[15:32:12.562]                         }
[15:32:12.562]                       })
[15:32:12.562]                     }
[15:32:12.562]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.562]                     base::options(mc.cores = 1L)
[15:32:12.562]                   }
[15:32:12.562]                   ...future.strategy.old <- future::plan("list")
[15:32:12.562]                   options(future.plan = NULL)
[15:32:12.562]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.562]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.562]                 }
[15:32:12.562]                 ...future.workdir <- getwd()
[15:32:12.562]             }
[15:32:12.562]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.562]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.562]         }
[15:32:12.562]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.562]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:12.562]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.562]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.562]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.562]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.562]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.562]             base::names(...future.oldOptions))
[15:32:12.562]     }
[15:32:12.562]     if (FALSE) {
[15:32:12.562]     }
[15:32:12.562]     else {
[15:32:12.562]         if (TRUE) {
[15:32:12.562]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.562]                 open = "w")
[15:32:12.562]         }
[15:32:12.562]         else {
[15:32:12.562]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.562]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.562]         }
[15:32:12.562]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.562]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.562]             base::sink(type = "output", split = FALSE)
[15:32:12.562]             base::close(...future.stdout)
[15:32:12.562]         }, add = TRUE)
[15:32:12.562]     }
[15:32:12.562]     ...future.frame <- base::sys.nframe()
[15:32:12.562]     ...future.conditions <- base::list()
[15:32:12.562]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.562]     if (FALSE) {
[15:32:12.562]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.562]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.562]     }
[15:32:12.562]     ...future.result <- base::tryCatch({
[15:32:12.562]         base::withCallingHandlers({
[15:32:12.562]             ...future.value <- base::withVisible(base::local({
[15:32:12.562]                 ...future.makeSendCondition <- base::local({
[15:32:12.562]                   sendCondition <- NULL
[15:32:12.562]                   function(frame = 1L) {
[15:32:12.562]                     if (is.function(sendCondition)) 
[15:32:12.562]                       return(sendCondition)
[15:32:12.562]                     ns <- getNamespace("parallel")
[15:32:12.562]                     if (exists("sendData", mode = "function", 
[15:32:12.562]                       envir = ns)) {
[15:32:12.562]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.562]                         envir = ns)
[15:32:12.562]                       envir <- sys.frame(frame)
[15:32:12.562]                       master <- NULL
[15:32:12.562]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.562]                         !identical(envir, emptyenv())) {
[15:32:12.562]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.562]                           inherits = FALSE)) {
[15:32:12.562]                           master <- get("master", mode = "list", 
[15:32:12.562]                             envir = envir, inherits = FALSE)
[15:32:12.562]                           if (inherits(master, c("SOCKnode", 
[15:32:12.562]                             "SOCK0node"))) {
[15:32:12.562]                             sendCondition <<- function(cond) {
[15:32:12.562]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.562]                                 success = TRUE)
[15:32:12.562]                               parallel_sendData(master, data)
[15:32:12.562]                             }
[15:32:12.562]                             return(sendCondition)
[15:32:12.562]                           }
[15:32:12.562]                         }
[15:32:12.562]                         frame <- frame + 1L
[15:32:12.562]                         envir <- sys.frame(frame)
[15:32:12.562]                       }
[15:32:12.562]                     }
[15:32:12.562]                     sendCondition <<- function(cond) NULL
[15:32:12.562]                   }
[15:32:12.562]                 })
[15:32:12.562]                 withCallingHandlers({
[15:32:12.562]                   {
[15:32:12.562]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.562]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.562]                       ...future.globals.maxSize)) {
[15:32:12.562]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.562]                       on.exit(options(oopts), add = TRUE)
[15:32:12.562]                     }
[15:32:12.562]                     {
[15:32:12.562]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.562]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.562]                         USE.NAMES = FALSE)
[15:32:12.562]                       do.call(mapply, args = args)
[15:32:12.562]                     }
[15:32:12.562]                   }
[15:32:12.562]                 }, immediateCondition = function(cond) {
[15:32:12.562]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.562]                   sendCondition(cond)
[15:32:12.562]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.562]                   {
[15:32:12.562]                     inherits <- base::inherits
[15:32:12.562]                     invokeRestart <- base::invokeRestart
[15:32:12.562]                     is.null <- base::is.null
[15:32:12.562]                     muffled <- FALSE
[15:32:12.562]                     if (inherits(cond, "message")) {
[15:32:12.562]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.562]                       if (muffled) 
[15:32:12.562]                         invokeRestart("muffleMessage")
[15:32:12.562]                     }
[15:32:12.562]                     else if (inherits(cond, "warning")) {
[15:32:12.562]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.562]                       if (muffled) 
[15:32:12.562]                         invokeRestart("muffleWarning")
[15:32:12.562]                     }
[15:32:12.562]                     else if (inherits(cond, "condition")) {
[15:32:12.562]                       if (!is.null(pattern)) {
[15:32:12.562]                         computeRestarts <- base::computeRestarts
[15:32:12.562]                         grepl <- base::grepl
[15:32:12.562]                         restarts <- computeRestarts(cond)
[15:32:12.562]                         for (restart in restarts) {
[15:32:12.562]                           name <- restart$name
[15:32:12.562]                           if (is.null(name)) 
[15:32:12.562]                             next
[15:32:12.562]                           if (!grepl(pattern, name)) 
[15:32:12.562]                             next
[15:32:12.562]                           invokeRestart(restart)
[15:32:12.562]                           muffled <- TRUE
[15:32:12.562]                           break
[15:32:12.562]                         }
[15:32:12.562]                       }
[15:32:12.562]                     }
[15:32:12.562]                     invisible(muffled)
[15:32:12.562]                   }
[15:32:12.562]                   muffleCondition(cond)
[15:32:12.562]                 })
[15:32:12.562]             }))
[15:32:12.562]             future::FutureResult(value = ...future.value$value, 
[15:32:12.562]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.562]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.562]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.562]                     ...future.globalenv.names))
[15:32:12.562]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.562]         }, condition = base::local({
[15:32:12.562]             c <- base::c
[15:32:12.562]             inherits <- base::inherits
[15:32:12.562]             invokeRestart <- base::invokeRestart
[15:32:12.562]             length <- base::length
[15:32:12.562]             list <- base::list
[15:32:12.562]             seq.int <- base::seq.int
[15:32:12.562]             signalCondition <- base::signalCondition
[15:32:12.562]             sys.calls <- base::sys.calls
[15:32:12.562]             `[[` <- base::`[[`
[15:32:12.562]             `+` <- base::`+`
[15:32:12.562]             `<<-` <- base::`<<-`
[15:32:12.562]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.562]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.562]                   3L)]
[15:32:12.562]             }
[15:32:12.562]             function(cond) {
[15:32:12.562]                 is_error <- inherits(cond, "error")
[15:32:12.562]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.562]                   NULL)
[15:32:12.562]                 if (is_error) {
[15:32:12.562]                   sessionInformation <- function() {
[15:32:12.562]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.562]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.562]                       search = base::search(), system = base::Sys.info())
[15:32:12.562]                   }
[15:32:12.562]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.562]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.562]                     cond$call), session = sessionInformation(), 
[15:32:12.562]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.562]                   signalCondition(cond)
[15:32:12.562]                 }
[15:32:12.562]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.562]                 "immediateCondition"))) {
[15:32:12.562]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.562]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.562]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.562]                   if (TRUE && !signal) {
[15:32:12.562]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.562]                     {
[15:32:12.562]                       inherits <- base::inherits
[15:32:12.562]                       invokeRestart <- base::invokeRestart
[15:32:12.562]                       is.null <- base::is.null
[15:32:12.562]                       muffled <- FALSE
[15:32:12.562]                       if (inherits(cond, "message")) {
[15:32:12.562]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.562]                         if (muffled) 
[15:32:12.562]                           invokeRestart("muffleMessage")
[15:32:12.562]                       }
[15:32:12.562]                       else if (inherits(cond, "warning")) {
[15:32:12.562]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.562]                         if (muffled) 
[15:32:12.562]                           invokeRestart("muffleWarning")
[15:32:12.562]                       }
[15:32:12.562]                       else if (inherits(cond, "condition")) {
[15:32:12.562]                         if (!is.null(pattern)) {
[15:32:12.562]                           computeRestarts <- base::computeRestarts
[15:32:12.562]                           grepl <- base::grepl
[15:32:12.562]                           restarts <- computeRestarts(cond)
[15:32:12.562]                           for (restart in restarts) {
[15:32:12.562]                             name <- restart$name
[15:32:12.562]                             if (is.null(name)) 
[15:32:12.562]                               next
[15:32:12.562]                             if (!grepl(pattern, name)) 
[15:32:12.562]                               next
[15:32:12.562]                             invokeRestart(restart)
[15:32:12.562]                             muffled <- TRUE
[15:32:12.562]                             break
[15:32:12.562]                           }
[15:32:12.562]                         }
[15:32:12.562]                       }
[15:32:12.562]                       invisible(muffled)
[15:32:12.562]                     }
[15:32:12.562]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.562]                   }
[15:32:12.562]                 }
[15:32:12.562]                 else {
[15:32:12.562]                   if (TRUE) {
[15:32:12.562]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.562]                     {
[15:32:12.562]                       inherits <- base::inherits
[15:32:12.562]                       invokeRestart <- base::invokeRestart
[15:32:12.562]                       is.null <- base::is.null
[15:32:12.562]                       muffled <- FALSE
[15:32:12.562]                       if (inherits(cond, "message")) {
[15:32:12.562]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.562]                         if (muffled) 
[15:32:12.562]                           invokeRestart("muffleMessage")
[15:32:12.562]                       }
[15:32:12.562]                       else if (inherits(cond, "warning")) {
[15:32:12.562]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.562]                         if (muffled) 
[15:32:12.562]                           invokeRestart("muffleWarning")
[15:32:12.562]                       }
[15:32:12.562]                       else if (inherits(cond, "condition")) {
[15:32:12.562]                         if (!is.null(pattern)) {
[15:32:12.562]                           computeRestarts <- base::computeRestarts
[15:32:12.562]                           grepl <- base::grepl
[15:32:12.562]                           restarts <- computeRestarts(cond)
[15:32:12.562]                           for (restart in restarts) {
[15:32:12.562]                             name <- restart$name
[15:32:12.562]                             if (is.null(name)) 
[15:32:12.562]                               next
[15:32:12.562]                             if (!grepl(pattern, name)) 
[15:32:12.562]                               next
[15:32:12.562]                             invokeRestart(restart)
[15:32:12.562]                             muffled <- TRUE
[15:32:12.562]                             break
[15:32:12.562]                           }
[15:32:12.562]                         }
[15:32:12.562]                       }
[15:32:12.562]                       invisible(muffled)
[15:32:12.562]                     }
[15:32:12.562]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.562]                   }
[15:32:12.562]                 }
[15:32:12.562]             }
[15:32:12.562]         }))
[15:32:12.562]     }, error = function(ex) {
[15:32:12.562]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.562]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.562]                 ...future.rng), started = ...future.startTime, 
[15:32:12.562]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.562]             version = "1.8"), class = "FutureResult")
[15:32:12.562]     }, finally = {
[15:32:12.562]         if (!identical(...future.workdir, getwd())) 
[15:32:12.562]             setwd(...future.workdir)
[15:32:12.562]         {
[15:32:12.562]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.562]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.562]             }
[15:32:12.562]             base::options(...future.oldOptions)
[15:32:12.562]             if (.Platform$OS.type == "windows") {
[15:32:12.562]                 old_names <- names(...future.oldEnvVars)
[15:32:12.562]                 envs <- base::Sys.getenv()
[15:32:12.562]                 names <- names(envs)
[15:32:12.562]                 common <- intersect(names, old_names)
[15:32:12.562]                 added <- setdiff(names, old_names)
[15:32:12.562]                 removed <- setdiff(old_names, names)
[15:32:12.562]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.562]                   envs[common]]
[15:32:12.562]                 NAMES <- toupper(changed)
[15:32:12.562]                 args <- list()
[15:32:12.562]                 for (kk in seq_along(NAMES)) {
[15:32:12.562]                   name <- changed[[kk]]
[15:32:12.562]                   NAME <- NAMES[[kk]]
[15:32:12.562]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.562]                     next
[15:32:12.562]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.562]                 }
[15:32:12.562]                 NAMES <- toupper(added)
[15:32:12.562]                 for (kk in seq_along(NAMES)) {
[15:32:12.562]                   name <- added[[kk]]
[15:32:12.562]                   NAME <- NAMES[[kk]]
[15:32:12.562]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.562]                     next
[15:32:12.562]                   args[[name]] <- ""
[15:32:12.562]                 }
[15:32:12.562]                 NAMES <- toupper(removed)
[15:32:12.562]                 for (kk in seq_along(NAMES)) {
[15:32:12.562]                   name <- removed[[kk]]
[15:32:12.562]                   NAME <- NAMES[[kk]]
[15:32:12.562]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.562]                     next
[15:32:12.562]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.562]                 }
[15:32:12.562]                 if (length(args) > 0) 
[15:32:12.562]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.562]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.562]             }
[15:32:12.562]             else {
[15:32:12.562]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.562]             }
[15:32:12.562]             {
[15:32:12.562]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.562]                   0L) {
[15:32:12.562]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.562]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.562]                   base::options(opts)
[15:32:12.562]                 }
[15:32:12.562]                 {
[15:32:12.562]                   {
[15:32:12.562]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.562]                     NULL
[15:32:12.562]                   }
[15:32:12.562]                   options(future.plan = NULL)
[15:32:12.562]                   if (is.na(NA_character_)) 
[15:32:12.562]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.562]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.562]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.562]                     .init = FALSE)
[15:32:12.562]                 }
[15:32:12.562]             }
[15:32:12.562]         }
[15:32:12.562]     })
[15:32:12.562]     if (TRUE) {
[15:32:12.562]         base::sink(type = "output", split = FALSE)
[15:32:12.562]         if (TRUE) {
[15:32:12.562]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.562]         }
[15:32:12.562]         else {
[15:32:12.562]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.562]         }
[15:32:12.562]         base::close(...future.stdout)
[15:32:12.562]         ...future.stdout <- NULL
[15:32:12.562]     }
[15:32:12.562]     ...future.result$conditions <- ...future.conditions
[15:32:12.562]     ...future.result$finished <- base::Sys.time()
[15:32:12.562]     ...future.result
[15:32:12.562] }
[15:32:12.570] Exporting 5 global objects (3.57 KiB) to cluster node #1 ...
[15:32:12.570] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.571] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.571] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.572] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.572] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:32:12.573] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:32:12.573] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.574] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.574] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.575] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.575] Exporting 5 global objects (3.57 KiB) to cluster node #1 ... DONE
[15:32:12.576] MultisessionFuture started
[15:32:12.576] - Launch lazy future ... done
[15:32:12.576] run() for 'MultisessionFuture' ... done
[15:32:12.577] Created future:
[15:32:12.604] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.605] - Validating connection of MultisessionFuture
[15:32:12.605] - received message: FutureResult
[15:32:12.605] - Received FutureResult
[15:32:12.606] - Erased future from FutureRegistry
[15:32:12.606] result() for ClusterFuture ...
[15:32:12.606] - result already collected: FutureResult
[15:32:12.606] result() for ClusterFuture ... done
[15:32:12.607] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.577] MultisessionFuture:
[15:32:12.577] Label: 'future_mapply-1'
[15:32:12.577] Expression:
[15:32:12.577] {
[15:32:12.577]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.577]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.577]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.577]         on.exit(options(oopts), add = TRUE)
[15:32:12.577]     }
[15:32:12.577]     {
[15:32:12.577]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.577]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.577]         do.call(mapply, args = args)
[15:32:12.577]     }
[15:32:12.577] }
[15:32:12.577] Lazy evaluation: FALSE
[15:32:12.577] Asynchronous evaluation: TRUE
[15:32:12.577] Local evaluation: TRUE
[15:32:12.577] Environment: R_GlobalEnv
[15:32:12.577] Capture standard output: TRUE
[15:32:12.577] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.577] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.577] Packages: <none>
[15:32:12.577] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.577] Resolved: TRUE
[15:32:12.577] Value: <not collected>
[15:32:12.577] Conditions captured: <none>
[15:32:12.577] Early signaling: FALSE
[15:32:12.577] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.577] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.607] Chunk #1 of 2 ... DONE
[15:32:12.608] Chunk #2 of 2 ...
[15:32:12.608]  - Finding globals in '...' for chunk #2 ...
[15:32:12.608] getGlobalsAndPackages() ...
[15:32:12.608] Searching for globals...
[15:32:12.609] 
[15:32:12.609] Searching for globals ... DONE
[15:32:12.610] - globals: [0] <none>
[15:32:12.610] getGlobalsAndPackages() ... DONE
[15:32:12.610]    + additional globals found: [n=0] 
[15:32:12.610]    + additional namespaces needed: [n=0] 
[15:32:12.611]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:12.611]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:12.611]  - seeds: <none>
[15:32:12.611]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.612] getGlobalsAndPackages() ...
[15:32:12.612] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.612] Resolving globals: FALSE
[15:32:12.613] The total size of the 5 globals is 3.73 KiB (3824 bytes)
[15:32:12.613] 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 3.73 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (504 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:12.614] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.615] 
[15:32:12.616] getGlobalsAndPackages() ... DONE
[15:32:12.616] run() for 'Future' ...
[15:32:12.616] - state: 'created'
[15:32:12.617] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.633] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.633] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.634]   - Field: 'node'
[15:32:12.634]   - Field: 'label'
[15:32:12.634]   - Field: 'local'
[15:32:12.635]   - Field: 'owner'
[15:32:12.635]   - Field: 'envir'
[15:32:12.635]   - Field: 'workers'
[15:32:12.636]   - Field: 'packages'
[15:32:12.636]   - Field: 'gc'
[15:32:12.636]   - Field: 'conditions'
[15:32:12.637]   - Field: 'persistent'
[15:32:12.637]   - Field: 'expr'
[15:32:12.637]   - Field: 'uuid'
[15:32:12.638]   - Field: 'seed'
[15:32:12.638]   - Field: 'version'
[15:32:12.638]   - Field: 'result'
[15:32:12.638]   - Field: 'asynchronous'
[15:32:12.639]   - Field: 'calls'
[15:32:12.639]   - Field: 'globals'
[15:32:12.639]   - Field: 'stdout'
[15:32:12.640]   - Field: 'earlySignal'
[15:32:12.640]   - Field: 'lazy'
[15:32:12.640]   - Field: 'state'
[15:32:12.641] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.641] - Launch lazy future ...
[15:32:12.641] Packages needed by the future expression (n = 0): <none>
[15:32:12.642] Packages needed by future strategies (n = 0): <none>
[15:32:12.643] {
[15:32:12.643]     {
[15:32:12.643]         {
[15:32:12.643]             ...future.startTime <- base::Sys.time()
[15:32:12.643]             {
[15:32:12.643]                 {
[15:32:12.643]                   {
[15:32:12.643]                     {
[15:32:12.643]                       base::local({
[15:32:12.643]                         has_future <- base::requireNamespace("future", 
[15:32:12.643]                           quietly = TRUE)
[15:32:12.643]                         if (has_future) {
[15:32:12.643]                           ns <- base::getNamespace("future")
[15:32:12.643]                           version <- ns[[".package"]][["version"]]
[15:32:12.643]                           if (is.null(version)) 
[15:32:12.643]                             version <- utils::packageVersion("future")
[15:32:12.643]                         }
[15:32:12.643]                         else {
[15:32:12.643]                           version <- NULL
[15:32:12.643]                         }
[15:32:12.643]                         if (!has_future || version < "1.8.0") {
[15:32:12.643]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.643]                             "", base::R.version$version.string), 
[15:32:12.643]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.643]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.643]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.643]                               "release", "version")], collapse = " "), 
[15:32:12.643]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.643]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.643]                             info)
[15:32:12.643]                           info <- base::paste(info, collapse = "; ")
[15:32:12.643]                           if (!has_future) {
[15:32:12.643]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.643]                               info)
[15:32:12.643]                           }
[15:32:12.643]                           else {
[15:32:12.643]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.643]                               info, version)
[15:32:12.643]                           }
[15:32:12.643]                           base::stop(msg)
[15:32:12.643]                         }
[15:32:12.643]                       })
[15:32:12.643]                     }
[15:32:12.643]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.643]                     base::options(mc.cores = 1L)
[15:32:12.643]                   }
[15:32:12.643]                   ...future.strategy.old <- future::plan("list")
[15:32:12.643]                   options(future.plan = NULL)
[15:32:12.643]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.643]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.643]                 }
[15:32:12.643]                 ...future.workdir <- getwd()
[15:32:12.643]             }
[15:32:12.643]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.643]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.643]         }
[15:32:12.643]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.643]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:12.643]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.643]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.643]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.643]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.643]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.643]             base::names(...future.oldOptions))
[15:32:12.643]     }
[15:32:12.643]     if (FALSE) {
[15:32:12.643]     }
[15:32:12.643]     else {
[15:32:12.643]         if (TRUE) {
[15:32:12.643]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.643]                 open = "w")
[15:32:12.643]         }
[15:32:12.643]         else {
[15:32:12.643]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.643]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.643]         }
[15:32:12.643]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.643]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.643]             base::sink(type = "output", split = FALSE)
[15:32:12.643]             base::close(...future.stdout)
[15:32:12.643]         }, add = TRUE)
[15:32:12.643]     }
[15:32:12.643]     ...future.frame <- base::sys.nframe()
[15:32:12.643]     ...future.conditions <- base::list()
[15:32:12.643]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.643]     if (FALSE) {
[15:32:12.643]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.643]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.643]     }
[15:32:12.643]     ...future.result <- base::tryCatch({
[15:32:12.643]         base::withCallingHandlers({
[15:32:12.643]             ...future.value <- base::withVisible(base::local({
[15:32:12.643]                 ...future.makeSendCondition <- base::local({
[15:32:12.643]                   sendCondition <- NULL
[15:32:12.643]                   function(frame = 1L) {
[15:32:12.643]                     if (is.function(sendCondition)) 
[15:32:12.643]                       return(sendCondition)
[15:32:12.643]                     ns <- getNamespace("parallel")
[15:32:12.643]                     if (exists("sendData", mode = "function", 
[15:32:12.643]                       envir = ns)) {
[15:32:12.643]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.643]                         envir = ns)
[15:32:12.643]                       envir <- sys.frame(frame)
[15:32:12.643]                       master <- NULL
[15:32:12.643]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.643]                         !identical(envir, emptyenv())) {
[15:32:12.643]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.643]                           inherits = FALSE)) {
[15:32:12.643]                           master <- get("master", mode = "list", 
[15:32:12.643]                             envir = envir, inherits = FALSE)
[15:32:12.643]                           if (inherits(master, c("SOCKnode", 
[15:32:12.643]                             "SOCK0node"))) {
[15:32:12.643]                             sendCondition <<- function(cond) {
[15:32:12.643]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.643]                                 success = TRUE)
[15:32:12.643]                               parallel_sendData(master, data)
[15:32:12.643]                             }
[15:32:12.643]                             return(sendCondition)
[15:32:12.643]                           }
[15:32:12.643]                         }
[15:32:12.643]                         frame <- frame + 1L
[15:32:12.643]                         envir <- sys.frame(frame)
[15:32:12.643]                       }
[15:32:12.643]                     }
[15:32:12.643]                     sendCondition <<- function(cond) NULL
[15:32:12.643]                   }
[15:32:12.643]                 })
[15:32:12.643]                 withCallingHandlers({
[15:32:12.643]                   {
[15:32:12.643]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.643]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.643]                       ...future.globals.maxSize)) {
[15:32:12.643]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.643]                       on.exit(options(oopts), add = TRUE)
[15:32:12.643]                     }
[15:32:12.643]                     {
[15:32:12.643]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.643]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.643]                         USE.NAMES = FALSE)
[15:32:12.643]                       do.call(mapply, args = args)
[15:32:12.643]                     }
[15:32:12.643]                   }
[15:32:12.643]                 }, immediateCondition = function(cond) {
[15:32:12.643]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.643]                   sendCondition(cond)
[15:32:12.643]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.643]                   {
[15:32:12.643]                     inherits <- base::inherits
[15:32:12.643]                     invokeRestart <- base::invokeRestart
[15:32:12.643]                     is.null <- base::is.null
[15:32:12.643]                     muffled <- FALSE
[15:32:12.643]                     if (inherits(cond, "message")) {
[15:32:12.643]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.643]                       if (muffled) 
[15:32:12.643]                         invokeRestart("muffleMessage")
[15:32:12.643]                     }
[15:32:12.643]                     else if (inherits(cond, "warning")) {
[15:32:12.643]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.643]                       if (muffled) 
[15:32:12.643]                         invokeRestart("muffleWarning")
[15:32:12.643]                     }
[15:32:12.643]                     else if (inherits(cond, "condition")) {
[15:32:12.643]                       if (!is.null(pattern)) {
[15:32:12.643]                         computeRestarts <- base::computeRestarts
[15:32:12.643]                         grepl <- base::grepl
[15:32:12.643]                         restarts <- computeRestarts(cond)
[15:32:12.643]                         for (restart in restarts) {
[15:32:12.643]                           name <- restart$name
[15:32:12.643]                           if (is.null(name)) 
[15:32:12.643]                             next
[15:32:12.643]                           if (!grepl(pattern, name)) 
[15:32:12.643]                             next
[15:32:12.643]                           invokeRestart(restart)
[15:32:12.643]                           muffled <- TRUE
[15:32:12.643]                           break
[15:32:12.643]                         }
[15:32:12.643]                       }
[15:32:12.643]                     }
[15:32:12.643]                     invisible(muffled)
[15:32:12.643]                   }
[15:32:12.643]                   muffleCondition(cond)
[15:32:12.643]                 })
[15:32:12.643]             }))
[15:32:12.643]             future::FutureResult(value = ...future.value$value, 
[15:32:12.643]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.643]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.643]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.643]                     ...future.globalenv.names))
[15:32:12.643]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.643]         }, condition = base::local({
[15:32:12.643]             c <- base::c
[15:32:12.643]             inherits <- base::inherits
[15:32:12.643]             invokeRestart <- base::invokeRestart
[15:32:12.643]             length <- base::length
[15:32:12.643]             list <- base::list
[15:32:12.643]             seq.int <- base::seq.int
[15:32:12.643]             signalCondition <- base::signalCondition
[15:32:12.643]             sys.calls <- base::sys.calls
[15:32:12.643]             `[[` <- base::`[[`
[15:32:12.643]             `+` <- base::`+`
[15:32:12.643]             `<<-` <- base::`<<-`
[15:32:12.643]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.643]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.643]                   3L)]
[15:32:12.643]             }
[15:32:12.643]             function(cond) {
[15:32:12.643]                 is_error <- inherits(cond, "error")
[15:32:12.643]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.643]                   NULL)
[15:32:12.643]                 if (is_error) {
[15:32:12.643]                   sessionInformation <- function() {
[15:32:12.643]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.643]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.643]                       search = base::search(), system = base::Sys.info())
[15:32:12.643]                   }
[15:32:12.643]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.643]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.643]                     cond$call), session = sessionInformation(), 
[15:32:12.643]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.643]                   signalCondition(cond)
[15:32:12.643]                 }
[15:32:12.643]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.643]                 "immediateCondition"))) {
[15:32:12.643]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.643]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.643]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.643]                   if (TRUE && !signal) {
[15:32:12.643]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.643]                     {
[15:32:12.643]                       inherits <- base::inherits
[15:32:12.643]                       invokeRestart <- base::invokeRestart
[15:32:12.643]                       is.null <- base::is.null
[15:32:12.643]                       muffled <- FALSE
[15:32:12.643]                       if (inherits(cond, "message")) {
[15:32:12.643]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.643]                         if (muffled) 
[15:32:12.643]                           invokeRestart("muffleMessage")
[15:32:12.643]                       }
[15:32:12.643]                       else if (inherits(cond, "warning")) {
[15:32:12.643]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.643]                         if (muffled) 
[15:32:12.643]                           invokeRestart("muffleWarning")
[15:32:12.643]                       }
[15:32:12.643]                       else if (inherits(cond, "condition")) {
[15:32:12.643]                         if (!is.null(pattern)) {
[15:32:12.643]                           computeRestarts <- base::computeRestarts
[15:32:12.643]                           grepl <- base::grepl
[15:32:12.643]                           restarts <- computeRestarts(cond)
[15:32:12.643]                           for (restart in restarts) {
[15:32:12.643]                             name <- restart$name
[15:32:12.643]                             if (is.null(name)) 
[15:32:12.643]                               next
[15:32:12.643]                             if (!grepl(pattern, name)) 
[15:32:12.643]                               next
[15:32:12.643]                             invokeRestart(restart)
[15:32:12.643]                             muffled <- TRUE
[15:32:12.643]                             break
[15:32:12.643]                           }
[15:32:12.643]                         }
[15:32:12.643]                       }
[15:32:12.643]                       invisible(muffled)
[15:32:12.643]                     }
[15:32:12.643]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.643]                   }
[15:32:12.643]                 }
[15:32:12.643]                 else {
[15:32:12.643]                   if (TRUE) {
[15:32:12.643]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.643]                     {
[15:32:12.643]                       inherits <- base::inherits
[15:32:12.643]                       invokeRestart <- base::invokeRestart
[15:32:12.643]                       is.null <- base::is.null
[15:32:12.643]                       muffled <- FALSE
[15:32:12.643]                       if (inherits(cond, "message")) {
[15:32:12.643]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.643]                         if (muffled) 
[15:32:12.643]                           invokeRestart("muffleMessage")
[15:32:12.643]                       }
[15:32:12.643]                       else if (inherits(cond, "warning")) {
[15:32:12.643]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.643]                         if (muffled) 
[15:32:12.643]                           invokeRestart("muffleWarning")
[15:32:12.643]                       }
[15:32:12.643]                       else if (inherits(cond, "condition")) {
[15:32:12.643]                         if (!is.null(pattern)) {
[15:32:12.643]                           computeRestarts <- base::computeRestarts
[15:32:12.643]                           grepl <- base::grepl
[15:32:12.643]                           restarts <- computeRestarts(cond)
[15:32:12.643]                           for (restart in restarts) {
[15:32:12.643]                             name <- restart$name
[15:32:12.643]                             if (is.null(name)) 
[15:32:12.643]                               next
[15:32:12.643]                             if (!grepl(pattern, name)) 
[15:32:12.643]                               next
[15:32:12.643]                             invokeRestart(restart)
[15:32:12.643]                             muffled <- TRUE
[15:32:12.643]                             break
[15:32:12.643]                           }
[15:32:12.643]                         }
[15:32:12.643]                       }
[15:32:12.643]                       invisible(muffled)
[15:32:12.643]                     }
[15:32:12.643]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.643]                   }
[15:32:12.643]                 }
[15:32:12.643]             }
[15:32:12.643]         }))
[15:32:12.643]     }, error = function(ex) {
[15:32:12.643]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.643]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.643]                 ...future.rng), started = ...future.startTime, 
[15:32:12.643]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.643]             version = "1.8"), class = "FutureResult")
[15:32:12.643]     }, finally = {
[15:32:12.643]         if (!identical(...future.workdir, getwd())) 
[15:32:12.643]             setwd(...future.workdir)
[15:32:12.643]         {
[15:32:12.643]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.643]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.643]             }
[15:32:12.643]             base::options(...future.oldOptions)
[15:32:12.643]             if (.Platform$OS.type == "windows") {
[15:32:12.643]                 old_names <- names(...future.oldEnvVars)
[15:32:12.643]                 envs <- base::Sys.getenv()
[15:32:12.643]                 names <- names(envs)
[15:32:12.643]                 common <- intersect(names, old_names)
[15:32:12.643]                 added <- setdiff(names, old_names)
[15:32:12.643]                 removed <- setdiff(old_names, names)
[15:32:12.643]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.643]                   envs[common]]
[15:32:12.643]                 NAMES <- toupper(changed)
[15:32:12.643]                 args <- list()
[15:32:12.643]                 for (kk in seq_along(NAMES)) {
[15:32:12.643]                   name <- changed[[kk]]
[15:32:12.643]                   NAME <- NAMES[[kk]]
[15:32:12.643]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.643]                     next
[15:32:12.643]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.643]                 }
[15:32:12.643]                 NAMES <- toupper(added)
[15:32:12.643]                 for (kk in seq_along(NAMES)) {
[15:32:12.643]                   name <- added[[kk]]
[15:32:12.643]                   NAME <- NAMES[[kk]]
[15:32:12.643]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.643]                     next
[15:32:12.643]                   args[[name]] <- ""
[15:32:12.643]                 }
[15:32:12.643]                 NAMES <- toupper(removed)
[15:32:12.643]                 for (kk in seq_along(NAMES)) {
[15:32:12.643]                   name <- removed[[kk]]
[15:32:12.643]                   NAME <- NAMES[[kk]]
[15:32:12.643]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.643]                     next
[15:32:12.643]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.643]                 }
[15:32:12.643]                 if (length(args) > 0) 
[15:32:12.643]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.643]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.643]             }
[15:32:12.643]             else {
[15:32:12.643]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.643]             }
[15:32:12.643]             {
[15:32:12.643]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.643]                   0L) {
[15:32:12.643]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.643]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.643]                   base::options(opts)
[15:32:12.643]                 }
[15:32:12.643]                 {
[15:32:12.643]                   {
[15:32:12.643]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.643]                     NULL
[15:32:12.643]                   }
[15:32:12.643]                   options(future.plan = NULL)
[15:32:12.643]                   if (is.na(NA_character_)) 
[15:32:12.643]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.643]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.643]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.643]                     .init = FALSE)
[15:32:12.643]                 }
[15:32:12.643]             }
[15:32:12.643]         }
[15:32:12.643]     })
[15:32:12.643]     if (TRUE) {
[15:32:12.643]         base::sink(type = "output", split = FALSE)
[15:32:12.643]         if (TRUE) {
[15:32:12.643]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.643]         }
[15:32:12.643]         else {
[15:32:12.643]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.643]         }
[15:32:12.643]         base::close(...future.stdout)
[15:32:12.643]         ...future.stdout <- NULL
[15:32:12.643]     }
[15:32:12.643]     ...future.result$conditions <- ...future.conditions
[15:32:12.643]     ...future.result$finished <- base::Sys.time()
[15:32:12.643]     ...future.result
[15:32:12.643] }
[15:32:12.651] Exporting 5 global objects (3.73 KiB) to cluster node #1 ...
[15:32:12.652] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.653] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.653] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.654] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.654] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ...
[15:32:12.655] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ... DONE
[15:32:12.655] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.656] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.656] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.657] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.657] Exporting 5 global objects (3.73 KiB) to cluster node #1 ... DONE
[15:32:12.657] MultisessionFuture started
[15:32:12.658] - Launch lazy future ... done
[15:32:12.658] run() for 'MultisessionFuture' ... done
[15:32:12.658] Created future:
[15:32:12.682] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.683] - Validating connection of MultisessionFuture
[15:32:12.683] - received message: FutureResult
[15:32:12.683] - Received FutureResult
[15:32:12.684] - Erased future from FutureRegistry
[15:32:12.684] result() for ClusterFuture ...
[15:32:12.684] - result already collected: FutureResult
[15:32:12.684] result() for ClusterFuture ... done
[15:32:12.685] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.658] MultisessionFuture:
[15:32:12.658] Label: 'future_mapply-2'
[15:32:12.658] Expression:
[15:32:12.658] {
[15:32:12.658]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.658]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.658]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.658]         on.exit(options(oopts), add = TRUE)
[15:32:12.658]     }
[15:32:12.658]     {
[15:32:12.658]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.658]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.658]         do.call(mapply, args = args)
[15:32:12.658]     }
[15:32:12.658] }
[15:32:12.658] Lazy evaluation: FALSE
[15:32:12.658] Asynchronous evaluation: TRUE
[15:32:12.658] Local evaluation: TRUE
[15:32:12.658] Environment: R_GlobalEnv
[15:32:12.658] Capture standard output: TRUE
[15:32:12.658] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.658] Globals: 5 objects totaling 3.73 KiB (function '...future.FUN' of 3.24 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 504 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.658] Packages: <none>
[15:32:12.658] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.658] Resolved: TRUE
[15:32:12.658] Value: <not collected>
[15:32:12.658] Conditions captured: <none>
[15:32:12.658] Early signaling: FALSE
[15:32:12.658] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.658] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.685] Chunk #2 of 2 ... DONE
[15:32:12.686] Launching 2 futures (chunks) ... DONE
[15:32:12.686] Resolving 2 futures (chunks) ...
[15:32:12.686] resolve() on list ...
[15:32:12.686]  recursive: 0
[15:32:12.687]  length: 2
[15:32:12.687] 
[15:32:12.687] Future #1
[15:32:12.687] result() for ClusterFuture ...
[15:32:12.688] - result already collected: FutureResult
[15:32:12.688] result() for ClusterFuture ... done
[15:32:12.688] result() for ClusterFuture ...
[15:32:12.688] - result already collected: FutureResult
[15:32:12.688] result() for ClusterFuture ... done
[15:32:12.689] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:12.689] - nx: 2
[15:32:12.689] - relay: TRUE
[15:32:12.689] - stdout: TRUE
[15:32:12.690] - signal: TRUE
[15:32:12.690] - resignal: FALSE
[15:32:12.690] - force: TRUE
[15:32:12.690] - relayed: [n=2] FALSE, FALSE
[15:32:12.690] - queued futures: [n=2] FALSE, FALSE
[15:32:12.691]  - until=1
[15:32:12.691]  - relaying element #1
[15:32:12.691] result() for ClusterFuture ...
[15:32:12.691] - result already collected: FutureResult
[15:32:12.692] result() for ClusterFuture ... done
[15:32:12.692] result() for ClusterFuture ...
[15:32:12.692] - result already collected: FutureResult
[15:32:12.692] result() for ClusterFuture ... done
[15:32:12.693] result() for ClusterFuture ...
[15:32:12.693] - result already collected: FutureResult
[15:32:12.693] result() for ClusterFuture ... done
[15:32:12.693] result() for ClusterFuture ...
[15:32:12.694] - result already collected: FutureResult
[15:32:12.694] result() for ClusterFuture ... done
[15:32:12.694] - relayed: [n=2] TRUE, FALSE
[15:32:12.694] - queued futures: [n=2] TRUE, FALSE
[15:32:12.694] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:12.695]  length: 1 (resolved future 1)
[15:32:12.695] Future #2
[15:32:12.695] result() for ClusterFuture ...
[15:32:12.695] - result already collected: FutureResult
[15:32:12.696] result() for ClusterFuture ... done
[15:32:12.696] result() for ClusterFuture ...
[15:32:12.696] - result already collected: FutureResult
[15:32:12.696] result() for ClusterFuture ... done
[15:32:12.697] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:12.697] - nx: 2
[15:32:12.697] - relay: TRUE
[15:32:12.697] - stdout: TRUE
[15:32:12.698] - signal: TRUE
[15:32:12.698] - resignal: FALSE
[15:32:12.698] - force: TRUE
[15:32:12.698] - relayed: [n=2] TRUE, FALSE
[15:32:12.698] - queued futures: [n=2] TRUE, FALSE
[15:32:12.699]  - until=2
[15:32:12.699]  - relaying element #2
[15:32:12.699] result() for ClusterFuture ...
[15:32:12.700] - result already collected: FutureResult
[15:32:12.700] result() for ClusterFuture ... done
[15:32:12.700] result() for ClusterFuture ...
[15:32:12.700] - result already collected: FutureResult
[15:32:12.701] result() for ClusterFuture ... done
[15:32:12.701] result() for ClusterFuture ...
[15:32:12.701] - result already collected: FutureResult
[15:32:12.702] result() for ClusterFuture ... done
[15:32:12.702] result() for ClusterFuture ...
[15:32:12.702] - result already collected: FutureResult
[15:32:12.702] result() for ClusterFuture ... done
[15:32:12.703] - relayed: [n=2] TRUE, TRUE
[15:32:12.703] - queued futures: [n=2] TRUE, TRUE
[15:32:12.703] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:12.703]  length: 0 (resolved future 2)
[15:32:12.704] Relaying remaining futures
[15:32:12.704] signalConditionsASAP(NULL, pos=0) ...
[15:32:12.704] - nx: 2
[15:32:12.704] - relay: TRUE
[15:32:12.705] - stdout: TRUE
[15:32:12.705] - signal: TRUE
[15:32:12.705] - resignal: FALSE
[15:32:12.705] - force: TRUE
[15:32:12.706] - relayed: [n=2] TRUE, TRUE
[15:32:12.706] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:12.706] - relayed: [n=2] TRUE, TRUE
[15:32:12.706] - queued futures: [n=2] TRUE, TRUE
[15:32:12.707] signalConditionsASAP(NULL, pos=0) ... done
[15:32:12.707] resolve() on list ... DONE
[15:32:12.707] result() for ClusterFuture ...
[15:32:12.707] - result already collected: FutureResult
[15:32:12.707] result() for ClusterFuture ... done
[15:32:12.708] result() for ClusterFuture ...
[15:32:12.708] - result already collected: FutureResult
[15:32:12.709] result() for ClusterFuture ... done
[15:32:12.709] result() for ClusterFuture ...
[15:32:12.709] - result already collected: FutureResult
[15:32:12.710] result() for ClusterFuture ... done
[15:32:12.710] result() for ClusterFuture ...
[15:32:12.710] - result already collected: FutureResult
[15:32:12.711] result() for ClusterFuture ... done
[15:32:12.711]  - Number of value chunks collected: 2
[15:32:12.711] Resolving 2 futures (chunks) ... DONE
[15:32:12.712] Reducing values from 2 chunks ...
[15:32:12.712]  - Number of values collected after concatenation: 5
[15:32:12.712]  - Number of values expected: 5
[15:32:12.713] Reverse index remapping (attribute 'ordering'): [n = 5] 5, 4, 3, 2, 1
[15:32:12.713] Reducing values from 2 chunks ... DONE
[15:32:12.713] future_mapply() ... DONE
[15:32:12.714] future_mapply() ...
[15:32:12.718] Number of chunks: 2
[15:32:12.719] getGlobalsAndPackagesXApply() ...
[15:32:12.719]  - future.globals: TRUE
[15:32:12.719] getGlobalsAndPackages() ...
[15:32:12.719] Searching for globals...
[15:32:12.722] - globals found: [3] 'FUN', 'paste', 'rep.int'
[15:32:12.722] Searching for globals ... DONE
[15:32:12.722] Resolving globals: FALSE
[15:32:12.723] The total size of the 1 globals is 3.24 KiB (3320 bytes)
[15:32:12.724] The total size of the 1 globals exported for future expression ('FUN()') is 3.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (3.24 KiB of class 'function')
[15:32:12.724] - globals: [1] 'FUN'
[15:32:12.724] 
[15:32:12.725] getGlobalsAndPackages() ... DONE
[15:32:12.725]  - globals found/used: [n=1] 'FUN'
[15:32:12.725]  - needed namespaces: [n=0] 
[15:32:12.725] Finding globals ... DONE
[15:32:12.726] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:12.726] List of 2
[15:32:12.726]  $ ...future.FUN:function (C, k)  
[15:32:12.726]  $ MoreArgs     : list()
[15:32:12.726]  - attr(*, "where")=List of 2
[15:32:12.726]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:12.726]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:12.726]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:12.726]  - attr(*, "resolved")= logi FALSE
[15:32:12.726]  - attr(*, "total_size")= num NA
[15:32:12.731] Packages to be attached in all futures: [n=0] 
[15:32:12.731] getGlobalsAndPackagesXApply() ... DONE
[15:32:12.732] Number of futures (= number of chunks): 2
[15:32:12.732] Launching 2 futures (chunks) ...
[15:32:12.732] Chunk #1 of 2 ...
[15:32:12.733]  - Finding globals in '...' for chunk #1 ...
[15:32:12.733] getGlobalsAndPackages() ...
[15:32:12.733] Searching for globals...
[15:32:12.734] 
[15:32:12.734] Searching for globals ... DONE
[15:32:12.734] - globals: [0] <none>
[15:32:12.735] getGlobalsAndPackages() ... DONE
[15:32:12.735]    + additional globals found: [n=0] 
[15:32:12.735]    + additional namespaces needed: [n=0] 
[15:32:12.735]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:12.736]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:12.736]  - seeds: <none>
[15:32:12.736]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.737] getGlobalsAndPackages() ...
[15:32:12.737] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.737] Resolving globals: FALSE
[15:32:12.738] The total size of the 5 globals is 3.57 KiB (3656 bytes)
[15:32:12.739] 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 3.57 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (336 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:12.739] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.740] 
[15:32:12.740] getGlobalsAndPackages() ... DONE
[15:32:12.741] run() for 'Future' ...
[15:32:12.741] - state: 'created'
[15:32:12.741] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.758] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.758] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.758]   - Field: 'node'
[15:32:12.758]   - Field: 'label'
[15:32:12.759]   - Field: 'local'
[15:32:12.759]   - Field: 'owner'
[15:32:12.759]   - Field: 'envir'
[15:32:12.759]   - Field: 'workers'
[15:32:12.760]   - Field: 'packages'
[15:32:12.760]   - Field: 'gc'
[15:32:12.760]   - Field: 'conditions'
[15:32:12.760]   - Field: 'persistent'
[15:32:12.761]   - Field: 'expr'
[15:32:12.761]   - Field: 'uuid'
[15:32:12.761]   - Field: 'seed'
[15:32:12.761]   - Field: 'version'
[15:32:12.762]   - Field: 'result'
[15:32:12.762]   - Field: 'asynchronous'
[15:32:12.762]   - Field: 'calls'
[15:32:12.762]   - Field: 'globals'
[15:32:12.763]   - Field: 'stdout'
[15:32:12.763]   - Field: 'earlySignal'
[15:32:12.763]   - Field: 'lazy'
[15:32:12.763]   - Field: 'state'
[15:32:12.764] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.764] - Launch lazy future ...
[15:32:12.764] Packages needed by the future expression (n = 0): <none>
[15:32:12.765] Packages needed by future strategies (n = 0): <none>
[15:32:12.766] {
[15:32:12.766]     {
[15:32:12.766]         {
[15:32:12.766]             ...future.startTime <- base::Sys.time()
[15:32:12.766]             {
[15:32:12.766]                 {
[15:32:12.766]                   {
[15:32:12.766]                     {
[15:32:12.766]                       base::local({
[15:32:12.766]                         has_future <- base::requireNamespace("future", 
[15:32:12.766]                           quietly = TRUE)
[15:32:12.766]                         if (has_future) {
[15:32:12.766]                           ns <- base::getNamespace("future")
[15:32:12.766]                           version <- ns[[".package"]][["version"]]
[15:32:12.766]                           if (is.null(version)) 
[15:32:12.766]                             version <- utils::packageVersion("future")
[15:32:12.766]                         }
[15:32:12.766]                         else {
[15:32:12.766]                           version <- NULL
[15:32:12.766]                         }
[15:32:12.766]                         if (!has_future || version < "1.8.0") {
[15:32:12.766]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.766]                             "", base::R.version$version.string), 
[15:32:12.766]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.766]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.766]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.766]                               "release", "version")], collapse = " "), 
[15:32:12.766]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.766]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.766]                             info)
[15:32:12.766]                           info <- base::paste(info, collapse = "; ")
[15:32:12.766]                           if (!has_future) {
[15:32:12.766]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.766]                               info)
[15:32:12.766]                           }
[15:32:12.766]                           else {
[15:32:12.766]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.766]                               info, version)
[15:32:12.766]                           }
[15:32:12.766]                           base::stop(msg)
[15:32:12.766]                         }
[15:32:12.766]                       })
[15:32:12.766]                     }
[15:32:12.766]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.766]                     base::options(mc.cores = 1L)
[15:32:12.766]                   }
[15:32:12.766]                   ...future.strategy.old <- future::plan("list")
[15:32:12.766]                   options(future.plan = NULL)
[15:32:12.766]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.766]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.766]                 }
[15:32:12.766]                 ...future.workdir <- getwd()
[15:32:12.766]             }
[15:32:12.766]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.766]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.766]         }
[15:32:12.766]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.766]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:12.766]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.766]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.766]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.766]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.766]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.766]             base::names(...future.oldOptions))
[15:32:12.766]     }
[15:32:12.766]     if (FALSE) {
[15:32:12.766]     }
[15:32:12.766]     else {
[15:32:12.766]         if (TRUE) {
[15:32:12.766]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.766]                 open = "w")
[15:32:12.766]         }
[15:32:12.766]         else {
[15:32:12.766]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.766]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.766]         }
[15:32:12.766]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.766]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.766]             base::sink(type = "output", split = FALSE)
[15:32:12.766]             base::close(...future.stdout)
[15:32:12.766]         }, add = TRUE)
[15:32:12.766]     }
[15:32:12.766]     ...future.frame <- base::sys.nframe()
[15:32:12.766]     ...future.conditions <- base::list()
[15:32:12.766]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.766]     if (FALSE) {
[15:32:12.766]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.766]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.766]     }
[15:32:12.766]     ...future.result <- base::tryCatch({
[15:32:12.766]         base::withCallingHandlers({
[15:32:12.766]             ...future.value <- base::withVisible(base::local({
[15:32:12.766]                 ...future.makeSendCondition <- base::local({
[15:32:12.766]                   sendCondition <- NULL
[15:32:12.766]                   function(frame = 1L) {
[15:32:12.766]                     if (is.function(sendCondition)) 
[15:32:12.766]                       return(sendCondition)
[15:32:12.766]                     ns <- getNamespace("parallel")
[15:32:12.766]                     if (exists("sendData", mode = "function", 
[15:32:12.766]                       envir = ns)) {
[15:32:12.766]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.766]                         envir = ns)
[15:32:12.766]                       envir <- sys.frame(frame)
[15:32:12.766]                       master <- NULL
[15:32:12.766]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.766]                         !identical(envir, emptyenv())) {
[15:32:12.766]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.766]                           inherits = FALSE)) {
[15:32:12.766]                           master <- get("master", mode = "list", 
[15:32:12.766]                             envir = envir, inherits = FALSE)
[15:32:12.766]                           if (inherits(master, c("SOCKnode", 
[15:32:12.766]                             "SOCK0node"))) {
[15:32:12.766]                             sendCondition <<- function(cond) {
[15:32:12.766]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.766]                                 success = TRUE)
[15:32:12.766]                               parallel_sendData(master, data)
[15:32:12.766]                             }
[15:32:12.766]                             return(sendCondition)
[15:32:12.766]                           }
[15:32:12.766]                         }
[15:32:12.766]                         frame <- frame + 1L
[15:32:12.766]                         envir <- sys.frame(frame)
[15:32:12.766]                       }
[15:32:12.766]                     }
[15:32:12.766]                     sendCondition <<- function(cond) NULL
[15:32:12.766]                   }
[15:32:12.766]                 })
[15:32:12.766]                 withCallingHandlers({
[15:32:12.766]                   {
[15:32:12.766]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.766]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.766]                       ...future.globals.maxSize)) {
[15:32:12.766]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.766]                       on.exit(options(oopts), add = TRUE)
[15:32:12.766]                     }
[15:32:12.766]                     {
[15:32:12.766]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.766]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.766]                         USE.NAMES = FALSE)
[15:32:12.766]                       do.call(mapply, args = args)
[15:32:12.766]                     }
[15:32:12.766]                   }
[15:32:12.766]                 }, immediateCondition = function(cond) {
[15:32:12.766]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.766]                   sendCondition(cond)
[15:32:12.766]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.766]                   {
[15:32:12.766]                     inherits <- base::inherits
[15:32:12.766]                     invokeRestart <- base::invokeRestart
[15:32:12.766]                     is.null <- base::is.null
[15:32:12.766]                     muffled <- FALSE
[15:32:12.766]                     if (inherits(cond, "message")) {
[15:32:12.766]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.766]                       if (muffled) 
[15:32:12.766]                         invokeRestart("muffleMessage")
[15:32:12.766]                     }
[15:32:12.766]                     else if (inherits(cond, "warning")) {
[15:32:12.766]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.766]                       if (muffled) 
[15:32:12.766]                         invokeRestart("muffleWarning")
[15:32:12.766]                     }
[15:32:12.766]                     else if (inherits(cond, "condition")) {
[15:32:12.766]                       if (!is.null(pattern)) {
[15:32:12.766]                         computeRestarts <- base::computeRestarts
[15:32:12.766]                         grepl <- base::grepl
[15:32:12.766]                         restarts <- computeRestarts(cond)
[15:32:12.766]                         for (restart in restarts) {
[15:32:12.766]                           name <- restart$name
[15:32:12.766]                           if (is.null(name)) 
[15:32:12.766]                             next
[15:32:12.766]                           if (!grepl(pattern, name)) 
[15:32:12.766]                             next
[15:32:12.766]                           invokeRestart(restart)
[15:32:12.766]                           muffled <- TRUE
[15:32:12.766]                           break
[15:32:12.766]                         }
[15:32:12.766]                       }
[15:32:12.766]                     }
[15:32:12.766]                     invisible(muffled)
[15:32:12.766]                   }
[15:32:12.766]                   muffleCondition(cond)
[15:32:12.766]                 })
[15:32:12.766]             }))
[15:32:12.766]             future::FutureResult(value = ...future.value$value, 
[15:32:12.766]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.766]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.766]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.766]                     ...future.globalenv.names))
[15:32:12.766]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.766]         }, condition = base::local({
[15:32:12.766]             c <- base::c
[15:32:12.766]             inherits <- base::inherits
[15:32:12.766]             invokeRestart <- base::invokeRestart
[15:32:12.766]             length <- base::length
[15:32:12.766]             list <- base::list
[15:32:12.766]             seq.int <- base::seq.int
[15:32:12.766]             signalCondition <- base::signalCondition
[15:32:12.766]             sys.calls <- base::sys.calls
[15:32:12.766]             `[[` <- base::`[[`
[15:32:12.766]             `+` <- base::`+`
[15:32:12.766]             `<<-` <- base::`<<-`
[15:32:12.766]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.766]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.766]                   3L)]
[15:32:12.766]             }
[15:32:12.766]             function(cond) {
[15:32:12.766]                 is_error <- inherits(cond, "error")
[15:32:12.766]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.766]                   NULL)
[15:32:12.766]                 if (is_error) {
[15:32:12.766]                   sessionInformation <- function() {
[15:32:12.766]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.766]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.766]                       search = base::search(), system = base::Sys.info())
[15:32:12.766]                   }
[15:32:12.766]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.766]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.766]                     cond$call), session = sessionInformation(), 
[15:32:12.766]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.766]                   signalCondition(cond)
[15:32:12.766]                 }
[15:32:12.766]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.766]                 "immediateCondition"))) {
[15:32:12.766]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.766]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.766]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.766]                   if (TRUE && !signal) {
[15:32:12.766]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.766]                     {
[15:32:12.766]                       inherits <- base::inherits
[15:32:12.766]                       invokeRestart <- base::invokeRestart
[15:32:12.766]                       is.null <- base::is.null
[15:32:12.766]                       muffled <- FALSE
[15:32:12.766]                       if (inherits(cond, "message")) {
[15:32:12.766]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.766]                         if (muffled) 
[15:32:12.766]                           invokeRestart("muffleMessage")
[15:32:12.766]                       }
[15:32:12.766]                       else if (inherits(cond, "warning")) {
[15:32:12.766]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.766]                         if (muffled) 
[15:32:12.766]                           invokeRestart("muffleWarning")
[15:32:12.766]                       }
[15:32:12.766]                       else if (inherits(cond, "condition")) {
[15:32:12.766]                         if (!is.null(pattern)) {
[15:32:12.766]                           computeRestarts <- base::computeRestarts
[15:32:12.766]                           grepl <- base::grepl
[15:32:12.766]                           restarts <- computeRestarts(cond)
[15:32:12.766]                           for (restart in restarts) {
[15:32:12.766]                             name <- restart$name
[15:32:12.766]                             if (is.null(name)) 
[15:32:12.766]                               next
[15:32:12.766]                             if (!grepl(pattern, name)) 
[15:32:12.766]                               next
[15:32:12.766]                             invokeRestart(restart)
[15:32:12.766]                             muffled <- TRUE
[15:32:12.766]                             break
[15:32:12.766]                           }
[15:32:12.766]                         }
[15:32:12.766]                       }
[15:32:12.766]                       invisible(muffled)
[15:32:12.766]                     }
[15:32:12.766]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.766]                   }
[15:32:12.766]                 }
[15:32:12.766]                 else {
[15:32:12.766]                   if (TRUE) {
[15:32:12.766]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.766]                     {
[15:32:12.766]                       inherits <- base::inherits
[15:32:12.766]                       invokeRestart <- base::invokeRestart
[15:32:12.766]                       is.null <- base::is.null
[15:32:12.766]                       muffled <- FALSE
[15:32:12.766]                       if (inherits(cond, "message")) {
[15:32:12.766]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.766]                         if (muffled) 
[15:32:12.766]                           invokeRestart("muffleMessage")
[15:32:12.766]                       }
[15:32:12.766]                       else if (inherits(cond, "warning")) {
[15:32:12.766]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.766]                         if (muffled) 
[15:32:12.766]                           invokeRestart("muffleWarning")
[15:32:12.766]                       }
[15:32:12.766]                       else if (inherits(cond, "condition")) {
[15:32:12.766]                         if (!is.null(pattern)) {
[15:32:12.766]                           computeRestarts <- base::computeRestarts
[15:32:12.766]                           grepl <- base::grepl
[15:32:12.766]                           restarts <- computeRestarts(cond)
[15:32:12.766]                           for (restart in restarts) {
[15:32:12.766]                             name <- restart$name
[15:32:12.766]                             if (is.null(name)) 
[15:32:12.766]                               next
[15:32:12.766]                             if (!grepl(pattern, name)) 
[15:32:12.766]                               next
[15:32:12.766]                             invokeRestart(restart)
[15:32:12.766]                             muffled <- TRUE
[15:32:12.766]                             break
[15:32:12.766]                           }
[15:32:12.766]                         }
[15:32:12.766]                       }
[15:32:12.766]                       invisible(muffled)
[15:32:12.766]                     }
[15:32:12.766]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.766]                   }
[15:32:12.766]                 }
[15:32:12.766]             }
[15:32:12.766]         }))
[15:32:12.766]     }, error = function(ex) {
[15:32:12.766]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.766]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.766]                 ...future.rng), started = ...future.startTime, 
[15:32:12.766]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.766]             version = "1.8"), class = "FutureResult")
[15:32:12.766]     }, finally = {
[15:32:12.766]         if (!identical(...future.workdir, getwd())) 
[15:32:12.766]             setwd(...future.workdir)
[15:32:12.766]         {
[15:32:12.766]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.766]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.766]             }
[15:32:12.766]             base::options(...future.oldOptions)
[15:32:12.766]             if (.Platform$OS.type == "windows") {
[15:32:12.766]                 old_names <- names(...future.oldEnvVars)
[15:32:12.766]                 envs <- base::Sys.getenv()
[15:32:12.766]                 names <- names(envs)
[15:32:12.766]                 common <- intersect(names, old_names)
[15:32:12.766]                 added <- setdiff(names, old_names)
[15:32:12.766]                 removed <- setdiff(old_names, names)
[15:32:12.766]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.766]                   envs[common]]
[15:32:12.766]                 NAMES <- toupper(changed)
[15:32:12.766]                 args <- list()
[15:32:12.766]                 for (kk in seq_along(NAMES)) {
[15:32:12.766]                   name <- changed[[kk]]
[15:32:12.766]                   NAME <- NAMES[[kk]]
[15:32:12.766]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.766]                     next
[15:32:12.766]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.766]                 }
[15:32:12.766]                 NAMES <- toupper(added)
[15:32:12.766]                 for (kk in seq_along(NAMES)) {
[15:32:12.766]                   name <- added[[kk]]
[15:32:12.766]                   NAME <- NAMES[[kk]]
[15:32:12.766]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.766]                     next
[15:32:12.766]                   args[[name]] <- ""
[15:32:12.766]                 }
[15:32:12.766]                 NAMES <- toupper(removed)
[15:32:12.766]                 for (kk in seq_along(NAMES)) {
[15:32:12.766]                   name <- removed[[kk]]
[15:32:12.766]                   NAME <- NAMES[[kk]]
[15:32:12.766]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.766]                     next
[15:32:12.766]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.766]                 }
[15:32:12.766]                 if (length(args) > 0) 
[15:32:12.766]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.766]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.766]             }
[15:32:12.766]             else {
[15:32:12.766]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.766]             }
[15:32:12.766]             {
[15:32:12.766]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.766]                   0L) {
[15:32:12.766]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.766]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.766]                   base::options(opts)
[15:32:12.766]                 }
[15:32:12.766]                 {
[15:32:12.766]                   {
[15:32:12.766]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.766]                     NULL
[15:32:12.766]                   }
[15:32:12.766]                   options(future.plan = NULL)
[15:32:12.766]                   if (is.na(NA_character_)) 
[15:32:12.766]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.766]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.766]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.766]                     .init = FALSE)
[15:32:12.766]                 }
[15:32:12.766]             }
[15:32:12.766]         }
[15:32:12.766]     })
[15:32:12.766]     if (TRUE) {
[15:32:12.766]         base::sink(type = "output", split = FALSE)
[15:32:12.766]         if (TRUE) {
[15:32:12.766]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.766]         }
[15:32:12.766]         else {
[15:32:12.766]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.766]         }
[15:32:12.766]         base::close(...future.stdout)
[15:32:12.766]         ...future.stdout <- NULL
[15:32:12.766]     }
[15:32:12.766]     ...future.result$conditions <- ...future.conditions
[15:32:12.766]     ...future.result$finished <- base::Sys.time()
[15:32:12.766]     ...future.result
[15:32:12.766] }
[15:32:12.773] Exporting 5 global objects (3.57 KiB) to cluster node #1 ...
[15:32:12.773] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.774] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.774] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.775] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.775] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:32:12.776] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:32:12.776] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.777] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.777] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.778] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.778] Exporting 5 global objects (3.57 KiB) to cluster node #1 ... DONE
[15:32:12.778] MultisessionFuture started
[15:32:12.779] - Launch lazy future ... done
[15:32:12.779] run() for 'MultisessionFuture' ... done
[15:32:12.779] Created future:
[15:32:12.806] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.807] - Validating connection of MultisessionFuture
[15:32:12.807] - received message: FutureResult
[15:32:12.807] - Received FutureResult
[15:32:12.808] - Erased future from FutureRegistry
[15:32:12.808] result() for ClusterFuture ...
[15:32:12.808] - result already collected: FutureResult
[15:32:12.808] result() for ClusterFuture ... done
[15:32:12.808] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.779] MultisessionFuture:
[15:32:12.779] Label: 'future_.mapply-1'
[15:32:12.779] Expression:
[15:32:12.779] {
[15:32:12.779]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.779]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.779]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.779]         on.exit(options(oopts), add = TRUE)
[15:32:12.779]     }
[15:32:12.779]     {
[15:32:12.779]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.779]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.779]         do.call(mapply, args = args)
[15:32:12.779]     }
[15:32:12.779] }
[15:32:12.779] Lazy evaluation: FALSE
[15:32:12.779] Asynchronous evaluation: TRUE
[15:32:12.779] Local evaluation: TRUE
[15:32:12.779] Environment: R_GlobalEnv
[15:32:12.779] Capture standard output: TRUE
[15:32:12.779] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.779] Globals: 5 objects totaling 3.57 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.779] Packages: <none>
[15:32:12.779] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.779] Resolved: TRUE
[15:32:12.779] Value: <not collected>
[15:32:12.779] Conditions captured: <none>
[15:32:12.779] Early signaling: FALSE
[15:32:12.779] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.779] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.809] Chunk #1 of 2 ... DONE
[15:32:12.809] Chunk #2 of 2 ...
[15:32:12.809]  - Finding globals in '...' for chunk #2 ...
[15:32:12.809] getGlobalsAndPackages() ...
[15:32:12.810] Searching for globals...
[15:32:12.810] 
[15:32:12.810] Searching for globals ... DONE
[15:32:12.810] - globals: [0] <none>
[15:32:12.811] getGlobalsAndPackages() ... DONE
[15:32:12.811]    + additional globals found: [n=0] 
[15:32:12.811]    + additional namespaces needed: [n=0] 
[15:32:12.811]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:12.811]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:12.811]  - seeds: <none>
[15:32:12.812]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.812] getGlobalsAndPackages() ...
[15:32:12.812] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.812] Resolving globals: FALSE
[15:32:12.813] The total size of the 5 globals is 3.73 KiB (3824 bytes)
[15:32:12.814] 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 3.73 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (3.24 KiB of class 'function'), '...future.elements_ii' (504 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:12.814] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.814] 
[15:32:12.814] getGlobalsAndPackages() ... DONE
[15:32:12.815] run() for 'Future' ...
[15:32:12.815] - state: 'created'
[15:32:12.815] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.830] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.830] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.830]   - Field: 'node'
[15:32:12.830]   - Field: 'label'
[15:32:12.830]   - Field: 'local'
[15:32:12.831]   - Field: 'owner'
[15:32:12.831]   - Field: 'envir'
[15:32:12.831]   - Field: 'workers'
[15:32:12.831]   - Field: 'packages'
[15:32:12.831]   - Field: 'gc'
[15:32:12.832]   - Field: 'conditions'
[15:32:12.832]   - Field: 'persistent'
[15:32:12.832]   - Field: 'expr'
[15:32:12.832]   - Field: 'uuid'
[15:32:12.832]   - Field: 'seed'
[15:32:12.832]   - Field: 'version'
[15:32:12.833]   - Field: 'result'
[15:32:12.833]   - Field: 'asynchronous'
[15:32:12.833]   - Field: 'calls'
[15:32:12.833]   - Field: 'globals'
[15:32:12.833]   - Field: 'stdout'
[15:32:12.833]   - Field: 'earlySignal'
[15:32:12.834]   - Field: 'lazy'
[15:32:12.834]   - Field: 'state'
[15:32:12.834] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.834] - Launch lazy future ...
[15:32:12.835] Packages needed by the future expression (n = 0): <none>
[15:32:12.835] Packages needed by future strategies (n = 0): <none>
[15:32:12.835] {
[15:32:12.835]     {
[15:32:12.835]         {
[15:32:12.835]             ...future.startTime <- base::Sys.time()
[15:32:12.835]             {
[15:32:12.835]                 {
[15:32:12.835]                   {
[15:32:12.835]                     {
[15:32:12.835]                       base::local({
[15:32:12.835]                         has_future <- base::requireNamespace("future", 
[15:32:12.835]                           quietly = TRUE)
[15:32:12.835]                         if (has_future) {
[15:32:12.835]                           ns <- base::getNamespace("future")
[15:32:12.835]                           version <- ns[[".package"]][["version"]]
[15:32:12.835]                           if (is.null(version)) 
[15:32:12.835]                             version <- utils::packageVersion("future")
[15:32:12.835]                         }
[15:32:12.835]                         else {
[15:32:12.835]                           version <- NULL
[15:32:12.835]                         }
[15:32:12.835]                         if (!has_future || version < "1.8.0") {
[15:32:12.835]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.835]                             "", base::R.version$version.string), 
[15:32:12.835]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.835]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.835]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.835]                               "release", "version")], collapse = " "), 
[15:32:12.835]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.835]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.835]                             info)
[15:32:12.835]                           info <- base::paste(info, collapse = "; ")
[15:32:12.835]                           if (!has_future) {
[15:32:12.835]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.835]                               info)
[15:32:12.835]                           }
[15:32:12.835]                           else {
[15:32:12.835]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.835]                               info, version)
[15:32:12.835]                           }
[15:32:12.835]                           base::stop(msg)
[15:32:12.835]                         }
[15:32:12.835]                       })
[15:32:12.835]                     }
[15:32:12.835]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.835]                     base::options(mc.cores = 1L)
[15:32:12.835]                   }
[15:32:12.835]                   ...future.strategy.old <- future::plan("list")
[15:32:12.835]                   options(future.plan = NULL)
[15:32:12.835]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.835]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.835]                 }
[15:32:12.835]                 ...future.workdir <- getwd()
[15:32:12.835]             }
[15:32:12.835]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.835]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.835]         }
[15:32:12.835]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.835]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:12.835]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.835]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.835]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.835]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.835]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.835]             base::names(...future.oldOptions))
[15:32:12.835]     }
[15:32:12.835]     if (FALSE) {
[15:32:12.835]     }
[15:32:12.835]     else {
[15:32:12.835]         if (TRUE) {
[15:32:12.835]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.835]                 open = "w")
[15:32:12.835]         }
[15:32:12.835]         else {
[15:32:12.835]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.835]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.835]         }
[15:32:12.835]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.835]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.835]             base::sink(type = "output", split = FALSE)
[15:32:12.835]             base::close(...future.stdout)
[15:32:12.835]         }, add = TRUE)
[15:32:12.835]     }
[15:32:12.835]     ...future.frame <- base::sys.nframe()
[15:32:12.835]     ...future.conditions <- base::list()
[15:32:12.835]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.835]     if (FALSE) {
[15:32:12.835]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.835]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.835]     }
[15:32:12.835]     ...future.result <- base::tryCatch({
[15:32:12.835]         base::withCallingHandlers({
[15:32:12.835]             ...future.value <- base::withVisible(base::local({
[15:32:12.835]                 ...future.makeSendCondition <- base::local({
[15:32:12.835]                   sendCondition <- NULL
[15:32:12.835]                   function(frame = 1L) {
[15:32:12.835]                     if (is.function(sendCondition)) 
[15:32:12.835]                       return(sendCondition)
[15:32:12.835]                     ns <- getNamespace("parallel")
[15:32:12.835]                     if (exists("sendData", mode = "function", 
[15:32:12.835]                       envir = ns)) {
[15:32:12.835]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.835]                         envir = ns)
[15:32:12.835]                       envir <- sys.frame(frame)
[15:32:12.835]                       master <- NULL
[15:32:12.835]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.835]                         !identical(envir, emptyenv())) {
[15:32:12.835]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.835]                           inherits = FALSE)) {
[15:32:12.835]                           master <- get("master", mode = "list", 
[15:32:12.835]                             envir = envir, inherits = FALSE)
[15:32:12.835]                           if (inherits(master, c("SOCKnode", 
[15:32:12.835]                             "SOCK0node"))) {
[15:32:12.835]                             sendCondition <<- function(cond) {
[15:32:12.835]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.835]                                 success = TRUE)
[15:32:12.835]                               parallel_sendData(master, data)
[15:32:12.835]                             }
[15:32:12.835]                             return(sendCondition)
[15:32:12.835]                           }
[15:32:12.835]                         }
[15:32:12.835]                         frame <- frame + 1L
[15:32:12.835]                         envir <- sys.frame(frame)
[15:32:12.835]                       }
[15:32:12.835]                     }
[15:32:12.835]                     sendCondition <<- function(cond) NULL
[15:32:12.835]                   }
[15:32:12.835]                 })
[15:32:12.835]                 withCallingHandlers({
[15:32:12.835]                   {
[15:32:12.835]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.835]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.835]                       ...future.globals.maxSize)) {
[15:32:12.835]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.835]                       on.exit(options(oopts), add = TRUE)
[15:32:12.835]                     }
[15:32:12.835]                     {
[15:32:12.835]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.835]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.835]                         USE.NAMES = FALSE)
[15:32:12.835]                       do.call(mapply, args = args)
[15:32:12.835]                     }
[15:32:12.835]                   }
[15:32:12.835]                 }, immediateCondition = function(cond) {
[15:32:12.835]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.835]                   sendCondition(cond)
[15:32:12.835]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.835]                   {
[15:32:12.835]                     inherits <- base::inherits
[15:32:12.835]                     invokeRestart <- base::invokeRestart
[15:32:12.835]                     is.null <- base::is.null
[15:32:12.835]                     muffled <- FALSE
[15:32:12.835]                     if (inherits(cond, "message")) {
[15:32:12.835]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.835]                       if (muffled) 
[15:32:12.835]                         invokeRestart("muffleMessage")
[15:32:12.835]                     }
[15:32:12.835]                     else if (inherits(cond, "warning")) {
[15:32:12.835]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.835]                       if (muffled) 
[15:32:12.835]                         invokeRestart("muffleWarning")
[15:32:12.835]                     }
[15:32:12.835]                     else if (inherits(cond, "condition")) {
[15:32:12.835]                       if (!is.null(pattern)) {
[15:32:12.835]                         computeRestarts <- base::computeRestarts
[15:32:12.835]                         grepl <- base::grepl
[15:32:12.835]                         restarts <- computeRestarts(cond)
[15:32:12.835]                         for (restart in restarts) {
[15:32:12.835]                           name <- restart$name
[15:32:12.835]                           if (is.null(name)) 
[15:32:12.835]                             next
[15:32:12.835]                           if (!grepl(pattern, name)) 
[15:32:12.835]                             next
[15:32:12.835]                           invokeRestart(restart)
[15:32:12.835]                           muffled <- TRUE
[15:32:12.835]                           break
[15:32:12.835]                         }
[15:32:12.835]                       }
[15:32:12.835]                     }
[15:32:12.835]                     invisible(muffled)
[15:32:12.835]                   }
[15:32:12.835]                   muffleCondition(cond)
[15:32:12.835]                 })
[15:32:12.835]             }))
[15:32:12.835]             future::FutureResult(value = ...future.value$value, 
[15:32:12.835]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.835]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.835]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.835]                     ...future.globalenv.names))
[15:32:12.835]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.835]         }, condition = base::local({
[15:32:12.835]             c <- base::c
[15:32:12.835]             inherits <- base::inherits
[15:32:12.835]             invokeRestart <- base::invokeRestart
[15:32:12.835]             length <- base::length
[15:32:12.835]             list <- base::list
[15:32:12.835]             seq.int <- base::seq.int
[15:32:12.835]             signalCondition <- base::signalCondition
[15:32:12.835]             sys.calls <- base::sys.calls
[15:32:12.835]             `[[` <- base::`[[`
[15:32:12.835]             `+` <- base::`+`
[15:32:12.835]             `<<-` <- base::`<<-`
[15:32:12.835]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.835]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.835]                   3L)]
[15:32:12.835]             }
[15:32:12.835]             function(cond) {
[15:32:12.835]                 is_error <- inherits(cond, "error")
[15:32:12.835]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.835]                   NULL)
[15:32:12.835]                 if (is_error) {
[15:32:12.835]                   sessionInformation <- function() {
[15:32:12.835]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.835]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.835]                       search = base::search(), system = base::Sys.info())
[15:32:12.835]                   }
[15:32:12.835]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.835]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.835]                     cond$call), session = sessionInformation(), 
[15:32:12.835]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.835]                   signalCondition(cond)
[15:32:12.835]                 }
[15:32:12.835]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.835]                 "immediateCondition"))) {
[15:32:12.835]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.835]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.835]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.835]                   if (TRUE && !signal) {
[15:32:12.835]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.835]                     {
[15:32:12.835]                       inherits <- base::inherits
[15:32:12.835]                       invokeRestart <- base::invokeRestart
[15:32:12.835]                       is.null <- base::is.null
[15:32:12.835]                       muffled <- FALSE
[15:32:12.835]                       if (inherits(cond, "message")) {
[15:32:12.835]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.835]                         if (muffled) 
[15:32:12.835]                           invokeRestart("muffleMessage")
[15:32:12.835]                       }
[15:32:12.835]                       else if (inherits(cond, "warning")) {
[15:32:12.835]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.835]                         if (muffled) 
[15:32:12.835]                           invokeRestart("muffleWarning")
[15:32:12.835]                       }
[15:32:12.835]                       else if (inherits(cond, "condition")) {
[15:32:12.835]                         if (!is.null(pattern)) {
[15:32:12.835]                           computeRestarts <- base::computeRestarts
[15:32:12.835]                           grepl <- base::grepl
[15:32:12.835]                           restarts <- computeRestarts(cond)
[15:32:12.835]                           for (restart in restarts) {
[15:32:12.835]                             name <- restart$name
[15:32:12.835]                             if (is.null(name)) 
[15:32:12.835]                               next
[15:32:12.835]                             if (!grepl(pattern, name)) 
[15:32:12.835]                               next
[15:32:12.835]                             invokeRestart(restart)
[15:32:12.835]                             muffled <- TRUE
[15:32:12.835]                             break
[15:32:12.835]                           }
[15:32:12.835]                         }
[15:32:12.835]                       }
[15:32:12.835]                       invisible(muffled)
[15:32:12.835]                     }
[15:32:12.835]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.835]                   }
[15:32:12.835]                 }
[15:32:12.835]                 else {
[15:32:12.835]                   if (TRUE) {
[15:32:12.835]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.835]                     {
[15:32:12.835]                       inherits <- base::inherits
[15:32:12.835]                       invokeRestart <- base::invokeRestart
[15:32:12.835]                       is.null <- base::is.null
[15:32:12.835]                       muffled <- FALSE
[15:32:12.835]                       if (inherits(cond, "message")) {
[15:32:12.835]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.835]                         if (muffled) 
[15:32:12.835]                           invokeRestart("muffleMessage")
[15:32:12.835]                       }
[15:32:12.835]                       else if (inherits(cond, "warning")) {
[15:32:12.835]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.835]                         if (muffled) 
[15:32:12.835]                           invokeRestart("muffleWarning")
[15:32:12.835]                       }
[15:32:12.835]                       else if (inherits(cond, "condition")) {
[15:32:12.835]                         if (!is.null(pattern)) {
[15:32:12.835]                           computeRestarts <- base::computeRestarts
[15:32:12.835]                           grepl <- base::grepl
[15:32:12.835]                           restarts <- computeRestarts(cond)
[15:32:12.835]                           for (restart in restarts) {
[15:32:12.835]                             name <- restart$name
[15:32:12.835]                             if (is.null(name)) 
[15:32:12.835]                               next
[15:32:12.835]                             if (!grepl(pattern, name)) 
[15:32:12.835]                               next
[15:32:12.835]                             invokeRestart(restart)
[15:32:12.835]                             muffled <- TRUE
[15:32:12.835]                             break
[15:32:12.835]                           }
[15:32:12.835]                         }
[15:32:12.835]                       }
[15:32:12.835]                       invisible(muffled)
[15:32:12.835]                     }
[15:32:12.835]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.835]                   }
[15:32:12.835]                 }
[15:32:12.835]             }
[15:32:12.835]         }))
[15:32:12.835]     }, error = function(ex) {
[15:32:12.835]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.835]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.835]                 ...future.rng), started = ...future.startTime, 
[15:32:12.835]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.835]             version = "1.8"), class = "FutureResult")
[15:32:12.835]     }, finally = {
[15:32:12.835]         if (!identical(...future.workdir, getwd())) 
[15:32:12.835]             setwd(...future.workdir)
[15:32:12.835]         {
[15:32:12.835]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.835]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.835]             }
[15:32:12.835]             base::options(...future.oldOptions)
[15:32:12.835]             if (.Platform$OS.type == "windows") {
[15:32:12.835]                 old_names <- names(...future.oldEnvVars)
[15:32:12.835]                 envs <- base::Sys.getenv()
[15:32:12.835]                 names <- names(envs)
[15:32:12.835]                 common <- intersect(names, old_names)
[15:32:12.835]                 added <- setdiff(names, old_names)
[15:32:12.835]                 removed <- setdiff(old_names, names)
[15:32:12.835]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.835]                   envs[common]]
[15:32:12.835]                 NAMES <- toupper(changed)
[15:32:12.835]                 args <- list()
[15:32:12.835]                 for (kk in seq_along(NAMES)) {
[15:32:12.835]                   name <- changed[[kk]]
[15:32:12.835]                   NAME <- NAMES[[kk]]
[15:32:12.835]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.835]                     next
[15:32:12.835]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.835]                 }
[15:32:12.835]                 NAMES <- toupper(added)
[15:32:12.835]                 for (kk in seq_along(NAMES)) {
[15:32:12.835]                   name <- added[[kk]]
[15:32:12.835]                   NAME <- NAMES[[kk]]
[15:32:12.835]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.835]                     next
[15:32:12.835]                   args[[name]] <- ""
[15:32:12.835]                 }
[15:32:12.835]                 NAMES <- toupper(removed)
[15:32:12.835]                 for (kk in seq_along(NAMES)) {
[15:32:12.835]                   name <- removed[[kk]]
[15:32:12.835]                   NAME <- NAMES[[kk]]
[15:32:12.835]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.835]                     next
[15:32:12.835]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.835]                 }
[15:32:12.835]                 if (length(args) > 0) 
[15:32:12.835]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.835]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.835]             }
[15:32:12.835]             else {
[15:32:12.835]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.835]             }
[15:32:12.835]             {
[15:32:12.835]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.835]                   0L) {
[15:32:12.835]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.835]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.835]                   base::options(opts)
[15:32:12.835]                 }
[15:32:12.835]                 {
[15:32:12.835]                   {
[15:32:12.835]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.835]                     NULL
[15:32:12.835]                   }
[15:32:12.835]                   options(future.plan = NULL)
[15:32:12.835]                   if (is.na(NA_character_)) 
[15:32:12.835]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.835]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.835]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.835]                     .init = FALSE)
[15:32:12.835]                 }
[15:32:12.835]             }
[15:32:12.835]         }
[15:32:12.835]     })
[15:32:12.835]     if (TRUE) {
[15:32:12.835]         base::sink(type = "output", split = FALSE)
[15:32:12.835]         if (TRUE) {
[15:32:12.835]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.835]         }
[15:32:12.835]         else {
[15:32:12.835]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.835]         }
[15:32:12.835]         base::close(...future.stdout)
[15:32:12.835]         ...future.stdout <- NULL
[15:32:12.835]     }
[15:32:12.835]     ...future.result$conditions <- ...future.conditions
[15:32:12.835]     ...future.result$finished <- base::Sys.time()
[15:32:12.835]     ...future.result
[15:32:12.835] }
[15:32:12.841] Exporting 5 global objects (3.73 KiB) to cluster node #1 ...
[15:32:12.841] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ...
[15:32:12.842] Exporting '...future.FUN' (3.24 KiB) to cluster node #1 ... DONE
[15:32:12.842] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:12.843] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:12.843] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ...
[15:32:12.844] Exporting '...future.elements_ii' (504 bytes) to cluster node #1 ... DONE
[15:32:12.844] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:12.844] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:12.844] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:12.845] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:12.845] Exporting 5 global objects (3.73 KiB) to cluster node #1 ... DONE
[15:32:12.846] MultisessionFuture started
[15:32:12.846] - Launch lazy future ... done
[15:32:12.846] run() for 'MultisessionFuture' ... done
[15:32:12.846] Created future:
[15:32:12.903] receiveMessageFromWorker() for ClusterFuture ...
[15:32:12.903] - Validating connection of MultisessionFuture
[15:32:12.904] - received message: FutureResult
[15:32:12.904] - Received FutureResult
[15:32:12.904] - Erased future from FutureRegistry
[15:32:12.905] result() for ClusterFuture ...
[15:32:12.905] - result already collected: FutureResult
[15:32:12.905] result() for ClusterFuture ... done
[15:32:12.905] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:12.846] MultisessionFuture:
[15:32:12.846] Label: 'future_.mapply-2'
[15:32:12.846] Expression:
[15:32:12.846] {
[15:32:12.846]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.846]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:12.846]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.846]         on.exit(options(oopts), add = TRUE)
[15:32:12.846]     }
[15:32:12.846]     {
[15:32:12.846]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.846]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:12.846]         do.call(mapply, args = args)
[15:32:12.846]     }
[15:32:12.846] }
[15:32:12.846] Lazy evaluation: FALSE
[15:32:12.846] Asynchronous evaluation: TRUE
[15:32:12.846] Local evaluation: TRUE
[15:32:12.846] Environment: R_GlobalEnv
[15:32:12.846] Capture standard output: TRUE
[15:32:12.846] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:12.846] Globals: 5 objects totaling 3.73 KiB (function '...future.FUN' of 3.24 KiB, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 504 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:12.846] Packages: <none>
[15:32:12.846] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:12.846] Resolved: TRUE
[15:32:12.846] Value: <not collected>
[15:32:12.846] Conditions captured: <none>
[15:32:12.846] Early signaling: FALSE
[15:32:12.846] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:12.846] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.906] Chunk #2 of 2 ... DONE
[15:32:12.907] Launching 2 futures (chunks) ... DONE
[15:32:12.907] Resolving 2 futures (chunks) ...
[15:32:12.907] resolve() on list ...
[15:32:12.907]  recursive: 0
[15:32:12.908]  length: 2
[15:32:12.908] 
[15:32:12.908] Future #1
[15:32:12.909] result() for ClusterFuture ...
[15:32:12.909] - result already collected: FutureResult
[15:32:12.909] result() for ClusterFuture ... done
[15:32:12.909] result() for ClusterFuture ...
[15:32:12.910] - result already collected: FutureResult
[15:32:12.910] result() for ClusterFuture ... done
[15:32:12.910] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:12.911] - nx: 2
[15:32:12.911] - relay: TRUE
[15:32:12.911] - stdout: TRUE
[15:32:12.911] - signal: TRUE
[15:32:12.912] - resignal: FALSE
[15:32:12.912] - force: TRUE
[15:32:12.912] - relayed: [n=2] FALSE, FALSE
[15:32:12.912] - queued futures: [n=2] FALSE, FALSE
[15:32:12.913]  - until=1
[15:32:12.913]  - relaying element #1
[15:32:12.913] result() for ClusterFuture ...
[15:32:12.914] - result already collected: FutureResult
[15:32:12.914] result() for ClusterFuture ... done
[15:32:12.914] result() for ClusterFuture ...
[15:32:12.914] - result already collected: FutureResult
[15:32:12.915] result() for ClusterFuture ... done
[15:32:12.915] result() for ClusterFuture ...
[15:32:12.915] - result already collected: FutureResult
[15:32:12.915] result() for ClusterFuture ... done
[15:32:12.916] result() for ClusterFuture ...
[15:32:12.916] - result already collected: FutureResult
[15:32:12.916] result() for ClusterFuture ... done
[15:32:12.917] - relayed: [n=2] TRUE, FALSE
[15:32:12.917] - queued futures: [n=2] TRUE, FALSE
[15:32:12.917] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:12.917]  length: 1 (resolved future 1)
[15:32:12.918] Future #2
[15:32:12.918] result() for ClusterFuture ...
[15:32:12.918] - result already collected: FutureResult
[15:32:12.918] result() for ClusterFuture ... done
[15:32:12.919] result() for ClusterFuture ...
[15:32:12.919] - result already collected: FutureResult
[15:32:12.919] result() for ClusterFuture ... done
[15:32:12.919] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:12.920] - nx: 2
[15:32:12.920] - relay: TRUE
[15:32:12.920] - stdout: TRUE
[15:32:12.920] - signal: TRUE
[15:32:12.921] - resignal: FALSE
[15:32:12.921] - force: TRUE
[15:32:12.921] - relayed: [n=2] TRUE, FALSE
[15:32:12.921] - queued futures: [n=2] TRUE, FALSE
[15:32:12.922]  - until=2
[15:32:12.922]  - relaying element #2
[15:32:12.922] result() for ClusterFuture ...
[15:32:12.922] - result already collected: FutureResult
[15:32:12.923] result() for ClusterFuture ... done
[15:32:12.923] result() for ClusterFuture ...
[15:32:12.923] - result already collected: FutureResult
[15:32:12.923] result() for ClusterFuture ... done
[15:32:12.924] result() for ClusterFuture ...
[15:32:12.924] - result already collected: FutureResult
[15:32:12.924] result() for ClusterFuture ... done
[15:32:12.925] result() for ClusterFuture ...
[15:32:12.925] - result already collected: FutureResult
[15:32:12.925] result() for ClusterFuture ... done
[15:32:12.925] - relayed: [n=2] TRUE, TRUE
[15:32:12.926] - queued futures: [n=2] TRUE, TRUE
[15:32:12.926] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:12.926]  length: 0 (resolved future 2)
[15:32:12.927] Relaying remaining futures
[15:32:12.927] signalConditionsASAP(NULL, pos=0) ...
[15:32:12.927] - nx: 2
[15:32:12.927] - relay: TRUE
[15:32:12.928] - stdout: TRUE
[15:32:12.928] - signal: TRUE
[15:32:12.928] - resignal: FALSE
[15:32:12.928] - force: TRUE
[15:32:12.929] - relayed: [n=2] TRUE, TRUE
[15:32:12.929] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:12.929] - relayed: [n=2] TRUE, TRUE
[15:32:12.930] - queued futures: [n=2] TRUE, TRUE
[15:32:12.930] signalConditionsASAP(NULL, pos=0) ... done
[15:32:12.930] resolve() on list ... DONE
[15:32:12.931] result() for ClusterFuture ...
[15:32:12.931] - result already collected: FutureResult
[15:32:12.931] result() for ClusterFuture ... done
[15:32:12.931] result() for ClusterFuture ...
[15:32:12.932] - result already collected: FutureResult
[15:32:12.932] result() for ClusterFuture ... done
[15:32:12.932] result() for ClusterFuture ...
[15:32:12.932] - result already collected: FutureResult
[15:32:12.933] result() for ClusterFuture ... done
[15:32:12.933] result() for ClusterFuture ...
[15:32:12.933] - result already collected: FutureResult
[15:32:12.934] result() for ClusterFuture ... done
[15:32:12.934]  - Number of value chunks collected: 2
[15:32:12.934] Resolving 2 futures (chunks) ... DONE
[15:32:12.934] Reducing values from 2 chunks ...
[15:32:12.935]  - Number of values collected after concatenation: 5
[15:32:12.935]  - Number of values expected: 5
[15:32:12.935] Reducing values from 2 chunks ... DONE
[15:32:12.936] future_mapply() ... DONE
- Subsetting (Issue #17) ...
[15:32:12.936] future_mapply() ...
[15:32:12.940] Number of chunks: 1
[15:32:12.941] getGlobalsAndPackagesXApply() ...
[15:32:12.941]  - future.globals: TRUE
[15:32:12.941] getGlobalsAndPackages() ...
[15:32:12.942] Searching for globals...
[15:32:12.944] - globals found: [1] 'FUN'
[15:32:12.944] Searching for globals ... DONE
[15:32:12.944] Resolving globals: FALSE
[15:32:12.945] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:12.946] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:12.946] - globals: [1] 'FUN'
[15:32:12.946] 
[15:32:12.946] getGlobalsAndPackages() ... DONE
[15:32:12.947]  - globals found/used: [n=1] 'FUN'
[15:32:12.947]  - needed namespaces: [n=0] 
[15:32:12.947] Finding globals ... DONE
[15:32:12.948] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:12.948] List of 2
[15:32:12.948]  $ ...future.FUN:function (x)  
[15:32:12.948]  $ MoreArgs     : NULL
[15:32:12.948]  - attr(*, "where")=List of 2
[15:32:12.948]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:12.948]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:12.948]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:12.948]  - attr(*, "resolved")= logi FALSE
[15:32:12.948]  - attr(*, "total_size")= num NA
[15:32:12.956] Packages to be attached in all futures: [n=0] 
[15:32:12.956] getGlobalsAndPackagesXApply() ... DONE
[15:32:12.957] Number of futures (= number of chunks): 1
[15:32:12.957] Launching 1 futures (chunks) ...
[15:32:12.957] Chunk #1 of 1 ...
[15:32:12.957]  - Finding globals in '...' for chunk #1 ...
[15:32:12.958] getGlobalsAndPackages() ...
[15:32:12.958] Searching for globals...
[15:32:12.959] 
[15:32:12.959] Searching for globals ... DONE
[15:32:12.959] - globals: [0] <none>
[15:32:12.959] getGlobalsAndPackages() ... DONE
[15:32:12.960]    + additional globals found: [n=0] 
[15:32:12.960]    + additional namespaces needed: [n=0] 
[15:32:12.960]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:12.960]  - seeds: <none>
[15:32:12.961]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.961] getGlobalsAndPackages() ...
[15:32:12.961] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.962] Resolving globals: FALSE
[15:32:12.962] The total size of the 5 globals is 1.10 KiB (1128 bytes)
[15:32:12.963] 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 1.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (280 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:12.964] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:12.964] 
[15:32:12.964] getGlobalsAndPackages() ... DONE
[15:32:12.965] run() for 'Future' ...
[15:32:12.965] - state: 'created'
[15:32:12.966] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:12.984] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:12.985] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:12.985]   - Field: 'node'
[15:32:12.985]   - Field: 'label'
[15:32:12.985]   - Field: 'local'
[15:32:12.986]   - Field: 'owner'
[15:32:12.986]   - Field: 'envir'
[15:32:12.986]   - Field: 'workers'
[15:32:12.987]   - Field: 'packages'
[15:32:12.987]   - Field: 'gc'
[15:32:12.987]   - Field: 'conditions'
[15:32:12.988]   - Field: 'persistent'
[15:32:12.988]   - Field: 'expr'
[15:32:12.988]   - Field: 'uuid'
[15:32:12.989]   - Field: 'seed'
[15:32:12.989]   - Field: 'version'
[15:32:12.989]   - Field: 'result'
[15:32:12.990]   - Field: 'asynchronous'
[15:32:12.990]   - Field: 'calls'
[15:32:12.990]   - Field: 'globals'
[15:32:12.990]   - Field: 'stdout'
[15:32:12.991]   - Field: 'earlySignal'
[15:32:12.991]   - Field: 'lazy'
[15:32:12.991]   - Field: 'state'
[15:32:12.992] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:12.992] - Launch lazy future ...
[15:32:12.993] Packages needed by the future expression (n = 0): <none>
[15:32:12.993] Packages needed by future strategies (n = 0): <none>
[15:32:12.994] {
[15:32:12.994]     {
[15:32:12.994]         {
[15:32:12.994]             ...future.startTime <- base::Sys.time()
[15:32:12.994]             {
[15:32:12.994]                 {
[15:32:12.994]                   {
[15:32:12.994]                     {
[15:32:12.994]                       base::local({
[15:32:12.994]                         has_future <- base::requireNamespace("future", 
[15:32:12.994]                           quietly = TRUE)
[15:32:12.994]                         if (has_future) {
[15:32:12.994]                           ns <- base::getNamespace("future")
[15:32:12.994]                           version <- ns[[".package"]][["version"]]
[15:32:12.994]                           if (is.null(version)) 
[15:32:12.994]                             version <- utils::packageVersion("future")
[15:32:12.994]                         }
[15:32:12.994]                         else {
[15:32:12.994]                           version <- NULL
[15:32:12.994]                         }
[15:32:12.994]                         if (!has_future || version < "1.8.0") {
[15:32:12.994]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:12.994]                             "", base::R.version$version.string), 
[15:32:12.994]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:12.994]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:12.994]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:12.994]                               "release", "version")], collapse = " "), 
[15:32:12.994]                             hostname = base::Sys.info()[["nodename"]])
[15:32:12.994]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:12.994]                             info)
[15:32:12.994]                           info <- base::paste(info, collapse = "; ")
[15:32:12.994]                           if (!has_future) {
[15:32:12.994]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:12.994]                               info)
[15:32:12.994]                           }
[15:32:12.994]                           else {
[15:32:12.994]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:12.994]                               info, version)
[15:32:12.994]                           }
[15:32:12.994]                           base::stop(msg)
[15:32:12.994]                         }
[15:32:12.994]                       })
[15:32:12.994]                     }
[15:32:12.994]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:12.994]                     base::options(mc.cores = 1L)
[15:32:12.994]                   }
[15:32:12.994]                   ...future.strategy.old <- future::plan("list")
[15:32:12.994]                   options(future.plan = NULL)
[15:32:12.994]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.994]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:12.994]                 }
[15:32:12.994]                 ...future.workdir <- getwd()
[15:32:12.994]             }
[15:32:12.994]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:12.994]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:12.994]         }
[15:32:12.994]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:12.994]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:12.994]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:12.994]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:12.994]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:12.994]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:12.994]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:12.994]             base::names(...future.oldOptions))
[15:32:12.994]     }
[15:32:12.994]     if (FALSE) {
[15:32:12.994]     }
[15:32:12.994]     else {
[15:32:12.994]         if (TRUE) {
[15:32:12.994]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:12.994]                 open = "w")
[15:32:12.994]         }
[15:32:12.994]         else {
[15:32:12.994]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:12.994]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:12.994]         }
[15:32:12.994]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:12.994]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:12.994]             base::sink(type = "output", split = FALSE)
[15:32:12.994]             base::close(...future.stdout)
[15:32:12.994]         }, add = TRUE)
[15:32:12.994]     }
[15:32:12.994]     ...future.frame <- base::sys.nframe()
[15:32:12.994]     ...future.conditions <- base::list()
[15:32:12.994]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:12.994]     if (FALSE) {
[15:32:12.994]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:12.994]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:12.994]     }
[15:32:12.994]     ...future.result <- base::tryCatch({
[15:32:12.994]         base::withCallingHandlers({
[15:32:12.994]             ...future.value <- base::withVisible(base::local({
[15:32:12.994]                 ...future.makeSendCondition <- base::local({
[15:32:12.994]                   sendCondition <- NULL
[15:32:12.994]                   function(frame = 1L) {
[15:32:12.994]                     if (is.function(sendCondition)) 
[15:32:12.994]                       return(sendCondition)
[15:32:12.994]                     ns <- getNamespace("parallel")
[15:32:12.994]                     if (exists("sendData", mode = "function", 
[15:32:12.994]                       envir = ns)) {
[15:32:12.994]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:12.994]                         envir = ns)
[15:32:12.994]                       envir <- sys.frame(frame)
[15:32:12.994]                       master <- NULL
[15:32:12.994]                       while (!identical(envir, .GlobalEnv) && 
[15:32:12.994]                         !identical(envir, emptyenv())) {
[15:32:12.994]                         if (exists("master", mode = "list", envir = envir, 
[15:32:12.994]                           inherits = FALSE)) {
[15:32:12.994]                           master <- get("master", mode = "list", 
[15:32:12.994]                             envir = envir, inherits = FALSE)
[15:32:12.994]                           if (inherits(master, c("SOCKnode", 
[15:32:12.994]                             "SOCK0node"))) {
[15:32:12.994]                             sendCondition <<- function(cond) {
[15:32:12.994]                               data <- list(type = "VALUE", value = cond, 
[15:32:12.994]                                 success = TRUE)
[15:32:12.994]                               parallel_sendData(master, data)
[15:32:12.994]                             }
[15:32:12.994]                             return(sendCondition)
[15:32:12.994]                           }
[15:32:12.994]                         }
[15:32:12.994]                         frame <- frame + 1L
[15:32:12.994]                         envir <- sys.frame(frame)
[15:32:12.994]                       }
[15:32:12.994]                     }
[15:32:12.994]                     sendCondition <<- function(cond) NULL
[15:32:12.994]                   }
[15:32:12.994]                 })
[15:32:12.994]                 withCallingHandlers({
[15:32:12.994]                   {
[15:32:12.994]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:12.994]                     if (!identical(...future.globals.maxSize.org, 
[15:32:12.994]                       ...future.globals.maxSize)) {
[15:32:12.994]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:12.994]                       on.exit(options(oopts), add = TRUE)
[15:32:12.994]                     }
[15:32:12.994]                     {
[15:32:12.994]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:12.994]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:12.994]                         USE.NAMES = FALSE)
[15:32:12.994]                       do.call(mapply, args = args)
[15:32:12.994]                     }
[15:32:12.994]                   }
[15:32:12.994]                 }, immediateCondition = function(cond) {
[15:32:12.994]                   sendCondition <- ...future.makeSendCondition()
[15:32:12.994]                   sendCondition(cond)
[15:32:12.994]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.994]                   {
[15:32:12.994]                     inherits <- base::inherits
[15:32:12.994]                     invokeRestart <- base::invokeRestart
[15:32:12.994]                     is.null <- base::is.null
[15:32:12.994]                     muffled <- FALSE
[15:32:12.994]                     if (inherits(cond, "message")) {
[15:32:12.994]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:12.994]                       if (muffled) 
[15:32:12.994]                         invokeRestart("muffleMessage")
[15:32:12.994]                     }
[15:32:12.994]                     else if (inherits(cond, "warning")) {
[15:32:12.994]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:12.994]                       if (muffled) 
[15:32:12.994]                         invokeRestart("muffleWarning")
[15:32:12.994]                     }
[15:32:12.994]                     else if (inherits(cond, "condition")) {
[15:32:12.994]                       if (!is.null(pattern)) {
[15:32:12.994]                         computeRestarts <- base::computeRestarts
[15:32:12.994]                         grepl <- base::grepl
[15:32:12.994]                         restarts <- computeRestarts(cond)
[15:32:12.994]                         for (restart in restarts) {
[15:32:12.994]                           name <- restart$name
[15:32:12.994]                           if (is.null(name)) 
[15:32:12.994]                             next
[15:32:12.994]                           if (!grepl(pattern, name)) 
[15:32:12.994]                             next
[15:32:12.994]                           invokeRestart(restart)
[15:32:12.994]                           muffled <- TRUE
[15:32:12.994]                           break
[15:32:12.994]                         }
[15:32:12.994]                       }
[15:32:12.994]                     }
[15:32:12.994]                     invisible(muffled)
[15:32:12.994]                   }
[15:32:12.994]                   muffleCondition(cond)
[15:32:12.994]                 })
[15:32:12.994]             }))
[15:32:12.994]             future::FutureResult(value = ...future.value$value, 
[15:32:12.994]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.994]                   ...future.rng), globalenv = if (FALSE) 
[15:32:12.994]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:12.994]                     ...future.globalenv.names))
[15:32:12.994]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:12.994]         }, condition = base::local({
[15:32:12.994]             c <- base::c
[15:32:12.994]             inherits <- base::inherits
[15:32:12.994]             invokeRestart <- base::invokeRestart
[15:32:12.994]             length <- base::length
[15:32:12.994]             list <- base::list
[15:32:12.994]             seq.int <- base::seq.int
[15:32:12.994]             signalCondition <- base::signalCondition
[15:32:12.994]             sys.calls <- base::sys.calls
[15:32:12.994]             `[[` <- base::`[[`
[15:32:12.994]             `+` <- base::`+`
[15:32:12.994]             `<<-` <- base::`<<-`
[15:32:12.994]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:12.994]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:12.994]                   3L)]
[15:32:12.994]             }
[15:32:12.994]             function(cond) {
[15:32:12.994]                 is_error <- inherits(cond, "error")
[15:32:12.994]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:12.994]                   NULL)
[15:32:12.994]                 if (is_error) {
[15:32:12.994]                   sessionInformation <- function() {
[15:32:12.994]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:12.994]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:12.994]                       search = base::search(), system = base::Sys.info())
[15:32:12.994]                   }
[15:32:12.994]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.994]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:12.994]                     cond$call), session = sessionInformation(), 
[15:32:12.994]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:12.994]                   signalCondition(cond)
[15:32:12.994]                 }
[15:32:12.994]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:12.994]                 "immediateCondition"))) {
[15:32:12.994]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:12.994]                   ...future.conditions[[length(...future.conditions) + 
[15:32:12.994]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:12.994]                   if (TRUE && !signal) {
[15:32:12.994]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.994]                     {
[15:32:12.994]                       inherits <- base::inherits
[15:32:12.994]                       invokeRestart <- base::invokeRestart
[15:32:12.994]                       is.null <- base::is.null
[15:32:12.994]                       muffled <- FALSE
[15:32:12.994]                       if (inherits(cond, "message")) {
[15:32:12.994]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.994]                         if (muffled) 
[15:32:12.994]                           invokeRestart("muffleMessage")
[15:32:12.994]                       }
[15:32:12.994]                       else if (inherits(cond, "warning")) {
[15:32:12.994]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.994]                         if (muffled) 
[15:32:12.994]                           invokeRestart("muffleWarning")
[15:32:12.994]                       }
[15:32:12.994]                       else if (inherits(cond, "condition")) {
[15:32:12.994]                         if (!is.null(pattern)) {
[15:32:12.994]                           computeRestarts <- base::computeRestarts
[15:32:12.994]                           grepl <- base::grepl
[15:32:12.994]                           restarts <- computeRestarts(cond)
[15:32:12.994]                           for (restart in restarts) {
[15:32:12.994]                             name <- restart$name
[15:32:12.994]                             if (is.null(name)) 
[15:32:12.994]                               next
[15:32:12.994]                             if (!grepl(pattern, name)) 
[15:32:12.994]                               next
[15:32:12.994]                             invokeRestart(restart)
[15:32:12.994]                             muffled <- TRUE
[15:32:12.994]                             break
[15:32:12.994]                           }
[15:32:12.994]                         }
[15:32:12.994]                       }
[15:32:12.994]                       invisible(muffled)
[15:32:12.994]                     }
[15:32:12.994]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.994]                   }
[15:32:12.994]                 }
[15:32:12.994]                 else {
[15:32:12.994]                   if (TRUE) {
[15:32:12.994]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:12.994]                     {
[15:32:12.994]                       inherits <- base::inherits
[15:32:12.994]                       invokeRestart <- base::invokeRestart
[15:32:12.994]                       is.null <- base::is.null
[15:32:12.994]                       muffled <- FALSE
[15:32:12.994]                       if (inherits(cond, "message")) {
[15:32:12.994]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:12.994]                         if (muffled) 
[15:32:12.994]                           invokeRestart("muffleMessage")
[15:32:12.994]                       }
[15:32:12.994]                       else if (inherits(cond, "warning")) {
[15:32:12.994]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:12.994]                         if (muffled) 
[15:32:12.994]                           invokeRestart("muffleWarning")
[15:32:12.994]                       }
[15:32:12.994]                       else if (inherits(cond, "condition")) {
[15:32:12.994]                         if (!is.null(pattern)) {
[15:32:12.994]                           computeRestarts <- base::computeRestarts
[15:32:12.994]                           grepl <- base::grepl
[15:32:12.994]                           restarts <- computeRestarts(cond)
[15:32:12.994]                           for (restart in restarts) {
[15:32:12.994]                             name <- restart$name
[15:32:12.994]                             if (is.null(name)) 
[15:32:12.994]                               next
[15:32:12.994]                             if (!grepl(pattern, name)) 
[15:32:12.994]                               next
[15:32:12.994]                             invokeRestart(restart)
[15:32:12.994]                             muffled <- TRUE
[15:32:12.994]                             break
[15:32:12.994]                           }
[15:32:12.994]                         }
[15:32:12.994]                       }
[15:32:12.994]                       invisible(muffled)
[15:32:12.994]                     }
[15:32:12.994]                     muffleCondition(cond, pattern = "^muffle")
[15:32:12.994]                   }
[15:32:12.994]                 }
[15:32:12.994]             }
[15:32:12.994]         }))
[15:32:12.994]     }, error = function(ex) {
[15:32:12.994]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:12.994]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:12.994]                 ...future.rng), started = ...future.startTime, 
[15:32:12.994]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:12.994]             version = "1.8"), class = "FutureResult")
[15:32:12.994]     }, finally = {
[15:32:12.994]         if (!identical(...future.workdir, getwd())) 
[15:32:12.994]             setwd(...future.workdir)
[15:32:12.994]         {
[15:32:12.994]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:12.994]                 ...future.oldOptions$nwarnings <- NULL
[15:32:12.994]             }
[15:32:12.994]             base::options(...future.oldOptions)
[15:32:12.994]             if (.Platform$OS.type == "windows") {
[15:32:12.994]                 old_names <- names(...future.oldEnvVars)
[15:32:12.994]                 envs <- base::Sys.getenv()
[15:32:12.994]                 names <- names(envs)
[15:32:12.994]                 common <- intersect(names, old_names)
[15:32:12.994]                 added <- setdiff(names, old_names)
[15:32:12.994]                 removed <- setdiff(old_names, names)
[15:32:12.994]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:12.994]                   envs[common]]
[15:32:12.994]                 NAMES <- toupper(changed)
[15:32:12.994]                 args <- list()
[15:32:12.994]                 for (kk in seq_along(NAMES)) {
[15:32:12.994]                   name <- changed[[kk]]
[15:32:12.994]                   NAME <- NAMES[[kk]]
[15:32:12.994]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.994]                     next
[15:32:12.994]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.994]                 }
[15:32:12.994]                 NAMES <- toupper(added)
[15:32:12.994]                 for (kk in seq_along(NAMES)) {
[15:32:12.994]                   name <- added[[kk]]
[15:32:12.994]                   NAME <- NAMES[[kk]]
[15:32:12.994]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.994]                     next
[15:32:12.994]                   args[[name]] <- ""
[15:32:12.994]                 }
[15:32:12.994]                 NAMES <- toupper(removed)
[15:32:12.994]                 for (kk in seq_along(NAMES)) {
[15:32:12.994]                   name <- removed[[kk]]
[15:32:12.994]                   NAME <- NAMES[[kk]]
[15:32:12.994]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:12.994]                     next
[15:32:12.994]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:12.994]                 }
[15:32:12.994]                 if (length(args) > 0) 
[15:32:12.994]                   base::do.call(base::Sys.setenv, args = args)
[15:32:12.994]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:12.994]             }
[15:32:12.994]             else {
[15:32:12.994]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:12.994]             }
[15:32:12.994]             {
[15:32:12.994]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:12.994]                   0L) {
[15:32:12.994]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:12.994]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:12.994]                   base::options(opts)
[15:32:12.994]                 }
[15:32:12.994]                 {
[15:32:12.994]                   {
[15:32:12.994]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:12.994]                     NULL
[15:32:12.994]                   }
[15:32:12.994]                   options(future.plan = NULL)
[15:32:12.994]                   if (is.na(NA_character_)) 
[15:32:12.994]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:12.994]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:12.994]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:12.994]                     .init = FALSE)
[15:32:12.994]                 }
[15:32:12.994]             }
[15:32:12.994]         }
[15:32:12.994]     })
[15:32:12.994]     if (TRUE) {
[15:32:12.994]         base::sink(type = "output", split = FALSE)
[15:32:12.994]         if (TRUE) {
[15:32:12.994]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:12.994]         }
[15:32:12.994]         else {
[15:32:12.994]             ...future.result["stdout"] <- base::list(NULL)
[15:32:12.994]         }
[15:32:12.994]         base::close(...future.stdout)
[15:32:12.994]         ...future.stdout <- NULL
[15:32:12.994]     }
[15:32:12.994]     ...future.result$conditions <- ...future.conditions
[15:32:12.994]     ...future.result$finished <- base::Sys.time()
[15:32:12.994]     ...future.result
[15:32:12.994] }
[15:32:13.003] Exporting 5 global objects (1.10 KiB) to cluster node #1 ...
[15:32:13.004] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:13.004] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:13.005] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:13.005] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:13.006] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:13.007] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:13.007] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.008] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.008] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.009] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.009] Exporting 5 global objects (1.10 KiB) to cluster node #1 ... DONE
[15:32:13.010] MultisessionFuture started
[15:32:13.010] - Launch lazy future ... done
[15:32:13.011] run() for 'MultisessionFuture' ... done
[15:32:13.011] Created future:
[15:32:13.034] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.035] - Validating connection of MultisessionFuture
[15:32:13.035] - received message: FutureResult
[15:32:13.036] - Received FutureResult
[15:32:13.036] - Erased future from FutureRegistry
[15:32:13.036] result() for ClusterFuture ...
[15:32:13.037] - result already collected: FutureResult
[15:32:13.037] result() for ClusterFuture ... done
[15:32:13.037] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.011] MultisessionFuture:
[15:32:13.011] Label: 'future_mapply-1'
[15:32:13.011] Expression:
[15:32:13.011] {
[15:32:13.011]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.011]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.011]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.011]         on.exit(options(oopts), add = TRUE)
[15:32:13.011]     }
[15:32:13.011]     {
[15:32:13.011]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.011]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.011]         do.call(mapply, args = args)
[15:32:13.011]     }
[15:32:13.011] }
[15:32:13.011] Lazy evaluation: FALSE
[15:32:13.011] Asynchronous evaluation: TRUE
[15:32:13.011] Local evaluation: TRUE
[15:32:13.011] Environment: R_GlobalEnv
[15:32:13.011] Capture standard output: TRUE
[15:32:13.011] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.011] Globals: 5 objects totaling 1.10 KiB (function '...future.FUN' of 848 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 280 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.011] Packages: <none>
[15:32:13.011] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.011] Resolved: TRUE
[15:32:13.011] Value: <not collected>
[15:32:13.011] Conditions captured: <none>
[15:32:13.011] Early signaling: FALSE
[15:32:13.011] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.011] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.038] Chunk #1 of 1 ... DONE
[15:32:13.038] Launching 1 futures (chunks) ... DONE
[15:32:13.039] Resolving 1 futures (chunks) ...
[15:32:13.039] resolve() on list ...
[15:32:13.039]  recursive: 0
[15:32:13.039]  length: 1
[15:32:13.040] 
[15:32:13.040] Future #1
[15:32:13.040] result() for ClusterFuture ...
[15:32:13.041] - result already collected: FutureResult
[15:32:13.041] result() for ClusterFuture ... done
[15:32:13.041] result() for ClusterFuture ...
[15:32:13.042] - result already collected: FutureResult
[15:32:13.042] result() for ClusterFuture ... done
[15:32:13.042] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:13.042] - nx: 1
[15:32:13.043] - relay: TRUE
[15:32:13.043] - stdout: TRUE
[15:32:13.043] - signal: TRUE
[15:32:13.044] - resignal: FALSE
[15:32:13.044] - force: TRUE
[15:32:13.044] - relayed: [n=1] FALSE
[15:32:13.044] - queued futures: [n=1] FALSE
[15:32:13.045]  - until=1
[15:32:13.045]  - relaying element #1
[15:32:13.045] result() for ClusterFuture ...
[15:32:13.046] - result already collected: FutureResult
[15:32:13.046] result() for ClusterFuture ... done
[15:32:13.046] result() for ClusterFuture ...
[15:32:13.047] - result already collected: FutureResult
[15:32:13.047] result() for ClusterFuture ... done
[15:32:13.047] result() for ClusterFuture ...
[15:32:13.048] - result already collected: FutureResult
[15:32:13.048] result() for ClusterFuture ... done
[15:32:13.048] result() for ClusterFuture ...
[15:32:13.048] - result already collected: FutureResult
[15:32:13.049] result() for ClusterFuture ... done
[15:32:13.049] - relayed: [n=1] TRUE
[15:32:13.049] - queued futures: [n=1] TRUE
[15:32:13.049] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:13.050]  length: 0 (resolved future 1)
[15:32:13.050] Relaying remaining futures
[15:32:13.050] signalConditionsASAP(NULL, pos=0) ...
[15:32:13.051] - nx: 1
[15:32:13.051] - relay: TRUE
[15:32:13.051] - stdout: TRUE
[15:32:13.051] - signal: TRUE
[15:32:13.052] - resignal: FALSE
[15:32:13.052] - force: TRUE
[15:32:13.052] - relayed: [n=1] TRUE
[15:32:13.053] - queued futures: [n=1] TRUE
 - flush all
[15:32:13.053] - relayed: [n=1] TRUE
[15:32:13.053] - queued futures: [n=1] TRUE
[15:32:13.054] signalConditionsASAP(NULL, pos=0) ... done
[15:32:13.054] resolve() on list ... DONE
[15:32:13.054] result() for ClusterFuture ...
[15:32:13.054] - result already collected: FutureResult
[15:32:13.055] result() for ClusterFuture ... done
[15:32:13.055] result() for ClusterFuture ...
[15:32:13.055] - result already collected: FutureResult
[15:32:13.056] result() for ClusterFuture ... done
[15:32:13.056]  - Number of value chunks collected: 1
[15:32:13.056] Resolving 1 futures (chunks) ... DONE
[15:32:13.056] Reducing values from 1 chunks ...
[15:32:13.057]  - Number of values collected after concatenation: 1
[15:32:13.057]  - Number of values expected: 1
[15:32:13.057] Reducing values from 1 chunks ... DONE
[15:32:13.057] future_mapply() ... DONE
[15:32:13.058] future_mapply() ...
[15:32:13.061] Number of chunks: 1
[15:32:13.061] getGlobalsAndPackagesXApply() ...
[15:32:13.062]  - future.globals: TRUE
[15:32:13.062] getGlobalsAndPackages() ...
[15:32:13.062] Searching for globals...
[15:32:13.064] - globals found: [1] 'FUN'
[15:32:13.064] Searching for globals ... DONE
[15:32:13.064] Resolving globals: FALSE
[15:32:13.065] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:13.065] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:13.065] - globals: [1] 'FUN'
[15:32:13.066] 
[15:32:13.066] getGlobalsAndPackages() ... DONE
[15:32:13.066]  - globals found/used: [n=1] 'FUN'
[15:32:13.066]  - needed namespaces: [n=0] 
[15:32:13.067] Finding globals ... DONE
[15:32:13.067] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:13.067] List of 2
[15:32:13.067]  $ ...future.FUN:function (x)  
[15:32:13.067]  $ MoreArgs     : list()
[15:32:13.067]  - attr(*, "where")=List of 2
[15:32:13.067]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:13.067]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:13.067]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:13.067]  - attr(*, "resolved")= logi FALSE
[15:32:13.067]  - attr(*, "total_size")= num NA
[15:32:13.072] Packages to be attached in all futures: [n=0] 
[15:32:13.073] getGlobalsAndPackagesXApply() ... DONE
[15:32:13.073] Number of futures (= number of chunks): 1
[15:32:13.073] Launching 1 futures (chunks) ...
[15:32:13.074] Chunk #1 of 1 ...
[15:32:13.074]  - Finding globals in '...' for chunk #1 ...
[15:32:13.074] getGlobalsAndPackages() ...
[15:32:13.074] Searching for globals...
[15:32:13.075] 
[15:32:13.075] Searching for globals ... DONE
[15:32:13.076] - globals: [0] <none>
[15:32:13.076] getGlobalsAndPackages() ... DONE
[15:32:13.076]    + additional globals found: [n=0] 
[15:32:13.076]    + additional namespaces needed: [n=0] 
[15:32:13.077]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:13.077]  - seeds: <none>
[15:32:13.077]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.077] getGlobalsAndPackages() ...
[15:32:13.078] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.078] Resolving globals: FALSE
[15:32:13.079] The total size of the 5 globals is 1.10 KiB (1128 bytes)
[15:32:13.080] 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 1.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (280 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'list')
[15:32:13.080] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.081] 
[15:32:13.081] getGlobalsAndPackages() ... DONE
[15:32:13.082] run() for 'Future' ...
[15:32:13.082] - state: 'created'
[15:32:13.082] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.099] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.100] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.100]   - Field: 'node'
[15:32:13.100]   - Field: 'label'
[15:32:13.100]   - Field: 'local'
[15:32:13.100]   - Field: 'owner'
[15:32:13.101]   - Field: 'envir'
[15:32:13.101]   - Field: 'workers'
[15:32:13.101]   - Field: 'packages'
[15:32:13.101]   - Field: 'gc'
[15:32:13.101]   - Field: 'conditions'
[15:32:13.102]   - Field: 'persistent'
[15:32:13.102]   - Field: 'expr'
[15:32:13.102]   - Field: 'uuid'
[15:32:13.102]   - Field: 'seed'
[15:32:13.102]   - Field: 'version'
[15:32:13.102]   - Field: 'result'
[15:32:13.103]   - Field: 'asynchronous'
[15:32:13.103]   - Field: 'calls'
[15:32:13.103]   - Field: 'globals'
[15:32:13.103]   - Field: 'stdout'
[15:32:13.103]   - Field: 'earlySignal'
[15:32:13.103]   - Field: 'lazy'
[15:32:13.104]   - Field: 'state'
[15:32:13.104] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.104] - Launch lazy future ...
[15:32:13.104] Packages needed by the future expression (n = 0): <none>
[15:32:13.105] Packages needed by future strategies (n = 0): <none>
[15:32:13.105] {
[15:32:13.105]     {
[15:32:13.105]         {
[15:32:13.105]             ...future.startTime <- base::Sys.time()
[15:32:13.105]             {
[15:32:13.105]                 {
[15:32:13.105]                   {
[15:32:13.105]                     {
[15:32:13.105]                       base::local({
[15:32:13.105]                         has_future <- base::requireNamespace("future", 
[15:32:13.105]                           quietly = TRUE)
[15:32:13.105]                         if (has_future) {
[15:32:13.105]                           ns <- base::getNamespace("future")
[15:32:13.105]                           version <- ns[[".package"]][["version"]]
[15:32:13.105]                           if (is.null(version)) 
[15:32:13.105]                             version <- utils::packageVersion("future")
[15:32:13.105]                         }
[15:32:13.105]                         else {
[15:32:13.105]                           version <- NULL
[15:32:13.105]                         }
[15:32:13.105]                         if (!has_future || version < "1.8.0") {
[15:32:13.105]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.105]                             "", base::R.version$version.string), 
[15:32:13.105]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.105]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.105]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.105]                               "release", "version")], collapse = " "), 
[15:32:13.105]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.105]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.105]                             info)
[15:32:13.105]                           info <- base::paste(info, collapse = "; ")
[15:32:13.105]                           if (!has_future) {
[15:32:13.105]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.105]                               info)
[15:32:13.105]                           }
[15:32:13.105]                           else {
[15:32:13.105]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.105]                               info, version)
[15:32:13.105]                           }
[15:32:13.105]                           base::stop(msg)
[15:32:13.105]                         }
[15:32:13.105]                       })
[15:32:13.105]                     }
[15:32:13.105]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.105]                     base::options(mc.cores = 1L)
[15:32:13.105]                   }
[15:32:13.105]                   ...future.strategy.old <- future::plan("list")
[15:32:13.105]                   options(future.plan = NULL)
[15:32:13.105]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.105]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.105]                 }
[15:32:13.105]                 ...future.workdir <- getwd()
[15:32:13.105]             }
[15:32:13.105]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.105]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.105]         }
[15:32:13.105]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.105]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:13.105]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.105]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.105]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.105]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.105]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.105]             base::names(...future.oldOptions))
[15:32:13.105]     }
[15:32:13.105]     if (FALSE) {
[15:32:13.105]     }
[15:32:13.105]     else {
[15:32:13.105]         if (TRUE) {
[15:32:13.105]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.105]                 open = "w")
[15:32:13.105]         }
[15:32:13.105]         else {
[15:32:13.105]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.105]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.105]         }
[15:32:13.105]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.105]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.105]             base::sink(type = "output", split = FALSE)
[15:32:13.105]             base::close(...future.stdout)
[15:32:13.105]         }, add = TRUE)
[15:32:13.105]     }
[15:32:13.105]     ...future.frame <- base::sys.nframe()
[15:32:13.105]     ...future.conditions <- base::list()
[15:32:13.105]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.105]     if (FALSE) {
[15:32:13.105]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.105]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.105]     }
[15:32:13.105]     ...future.result <- base::tryCatch({
[15:32:13.105]         base::withCallingHandlers({
[15:32:13.105]             ...future.value <- base::withVisible(base::local({
[15:32:13.105]                 ...future.makeSendCondition <- base::local({
[15:32:13.105]                   sendCondition <- NULL
[15:32:13.105]                   function(frame = 1L) {
[15:32:13.105]                     if (is.function(sendCondition)) 
[15:32:13.105]                       return(sendCondition)
[15:32:13.105]                     ns <- getNamespace("parallel")
[15:32:13.105]                     if (exists("sendData", mode = "function", 
[15:32:13.105]                       envir = ns)) {
[15:32:13.105]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.105]                         envir = ns)
[15:32:13.105]                       envir <- sys.frame(frame)
[15:32:13.105]                       master <- NULL
[15:32:13.105]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.105]                         !identical(envir, emptyenv())) {
[15:32:13.105]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.105]                           inherits = FALSE)) {
[15:32:13.105]                           master <- get("master", mode = "list", 
[15:32:13.105]                             envir = envir, inherits = FALSE)
[15:32:13.105]                           if (inherits(master, c("SOCKnode", 
[15:32:13.105]                             "SOCK0node"))) {
[15:32:13.105]                             sendCondition <<- function(cond) {
[15:32:13.105]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.105]                                 success = TRUE)
[15:32:13.105]                               parallel_sendData(master, data)
[15:32:13.105]                             }
[15:32:13.105]                             return(sendCondition)
[15:32:13.105]                           }
[15:32:13.105]                         }
[15:32:13.105]                         frame <- frame + 1L
[15:32:13.105]                         envir <- sys.frame(frame)
[15:32:13.105]                       }
[15:32:13.105]                     }
[15:32:13.105]                     sendCondition <<- function(cond) NULL
[15:32:13.105]                   }
[15:32:13.105]                 })
[15:32:13.105]                 withCallingHandlers({
[15:32:13.105]                   {
[15:32:13.105]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.105]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.105]                       ...future.globals.maxSize)) {
[15:32:13.105]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.105]                       on.exit(options(oopts), add = TRUE)
[15:32:13.105]                     }
[15:32:13.105]                     {
[15:32:13.105]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.105]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.105]                         USE.NAMES = FALSE)
[15:32:13.105]                       do.call(mapply, args = args)
[15:32:13.105]                     }
[15:32:13.105]                   }
[15:32:13.105]                 }, immediateCondition = function(cond) {
[15:32:13.105]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.105]                   sendCondition(cond)
[15:32:13.105]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.105]                   {
[15:32:13.105]                     inherits <- base::inherits
[15:32:13.105]                     invokeRestart <- base::invokeRestart
[15:32:13.105]                     is.null <- base::is.null
[15:32:13.105]                     muffled <- FALSE
[15:32:13.105]                     if (inherits(cond, "message")) {
[15:32:13.105]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.105]                       if (muffled) 
[15:32:13.105]                         invokeRestart("muffleMessage")
[15:32:13.105]                     }
[15:32:13.105]                     else if (inherits(cond, "warning")) {
[15:32:13.105]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.105]                       if (muffled) 
[15:32:13.105]                         invokeRestart("muffleWarning")
[15:32:13.105]                     }
[15:32:13.105]                     else if (inherits(cond, "condition")) {
[15:32:13.105]                       if (!is.null(pattern)) {
[15:32:13.105]                         computeRestarts <- base::computeRestarts
[15:32:13.105]                         grepl <- base::grepl
[15:32:13.105]                         restarts <- computeRestarts(cond)
[15:32:13.105]                         for (restart in restarts) {
[15:32:13.105]                           name <- restart$name
[15:32:13.105]                           if (is.null(name)) 
[15:32:13.105]                             next
[15:32:13.105]                           if (!grepl(pattern, name)) 
[15:32:13.105]                             next
[15:32:13.105]                           invokeRestart(restart)
[15:32:13.105]                           muffled <- TRUE
[15:32:13.105]                           break
[15:32:13.105]                         }
[15:32:13.105]                       }
[15:32:13.105]                     }
[15:32:13.105]                     invisible(muffled)
[15:32:13.105]                   }
[15:32:13.105]                   muffleCondition(cond)
[15:32:13.105]                 })
[15:32:13.105]             }))
[15:32:13.105]             future::FutureResult(value = ...future.value$value, 
[15:32:13.105]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.105]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.105]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.105]                     ...future.globalenv.names))
[15:32:13.105]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.105]         }, condition = base::local({
[15:32:13.105]             c <- base::c
[15:32:13.105]             inherits <- base::inherits
[15:32:13.105]             invokeRestart <- base::invokeRestart
[15:32:13.105]             length <- base::length
[15:32:13.105]             list <- base::list
[15:32:13.105]             seq.int <- base::seq.int
[15:32:13.105]             signalCondition <- base::signalCondition
[15:32:13.105]             sys.calls <- base::sys.calls
[15:32:13.105]             `[[` <- base::`[[`
[15:32:13.105]             `+` <- base::`+`
[15:32:13.105]             `<<-` <- base::`<<-`
[15:32:13.105]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.105]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.105]                   3L)]
[15:32:13.105]             }
[15:32:13.105]             function(cond) {
[15:32:13.105]                 is_error <- inherits(cond, "error")
[15:32:13.105]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.105]                   NULL)
[15:32:13.105]                 if (is_error) {
[15:32:13.105]                   sessionInformation <- function() {
[15:32:13.105]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.105]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.105]                       search = base::search(), system = base::Sys.info())
[15:32:13.105]                   }
[15:32:13.105]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.105]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.105]                     cond$call), session = sessionInformation(), 
[15:32:13.105]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.105]                   signalCondition(cond)
[15:32:13.105]                 }
[15:32:13.105]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.105]                 "immediateCondition"))) {
[15:32:13.105]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.105]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.105]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.105]                   if (TRUE && !signal) {
[15:32:13.105]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.105]                     {
[15:32:13.105]                       inherits <- base::inherits
[15:32:13.105]                       invokeRestart <- base::invokeRestart
[15:32:13.105]                       is.null <- base::is.null
[15:32:13.105]                       muffled <- FALSE
[15:32:13.105]                       if (inherits(cond, "message")) {
[15:32:13.105]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.105]                         if (muffled) 
[15:32:13.105]                           invokeRestart("muffleMessage")
[15:32:13.105]                       }
[15:32:13.105]                       else if (inherits(cond, "warning")) {
[15:32:13.105]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.105]                         if (muffled) 
[15:32:13.105]                           invokeRestart("muffleWarning")
[15:32:13.105]                       }
[15:32:13.105]                       else if (inherits(cond, "condition")) {
[15:32:13.105]                         if (!is.null(pattern)) {
[15:32:13.105]                           computeRestarts <- base::computeRestarts
[15:32:13.105]                           grepl <- base::grepl
[15:32:13.105]                           restarts <- computeRestarts(cond)
[15:32:13.105]                           for (restart in restarts) {
[15:32:13.105]                             name <- restart$name
[15:32:13.105]                             if (is.null(name)) 
[15:32:13.105]                               next
[15:32:13.105]                             if (!grepl(pattern, name)) 
[15:32:13.105]                               next
[15:32:13.105]                             invokeRestart(restart)
[15:32:13.105]                             muffled <- TRUE
[15:32:13.105]                             break
[15:32:13.105]                           }
[15:32:13.105]                         }
[15:32:13.105]                       }
[15:32:13.105]                       invisible(muffled)
[15:32:13.105]                     }
[15:32:13.105]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.105]                   }
[15:32:13.105]                 }
[15:32:13.105]                 else {
[15:32:13.105]                   if (TRUE) {
[15:32:13.105]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.105]                     {
[15:32:13.105]                       inherits <- base::inherits
[15:32:13.105]                       invokeRestart <- base::invokeRestart
[15:32:13.105]                       is.null <- base::is.null
[15:32:13.105]                       muffled <- FALSE
[15:32:13.105]                       if (inherits(cond, "message")) {
[15:32:13.105]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.105]                         if (muffled) 
[15:32:13.105]                           invokeRestart("muffleMessage")
[15:32:13.105]                       }
[15:32:13.105]                       else if (inherits(cond, "warning")) {
[15:32:13.105]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.105]                         if (muffled) 
[15:32:13.105]                           invokeRestart("muffleWarning")
[15:32:13.105]                       }
[15:32:13.105]                       else if (inherits(cond, "condition")) {
[15:32:13.105]                         if (!is.null(pattern)) {
[15:32:13.105]                           computeRestarts <- base::computeRestarts
[15:32:13.105]                           grepl <- base::grepl
[15:32:13.105]                           restarts <- computeRestarts(cond)
[15:32:13.105]                           for (restart in restarts) {
[15:32:13.105]                             name <- restart$name
[15:32:13.105]                             if (is.null(name)) 
[15:32:13.105]                               next
[15:32:13.105]                             if (!grepl(pattern, name)) 
[15:32:13.105]                               next
[15:32:13.105]                             invokeRestart(restart)
[15:32:13.105]                             muffled <- TRUE
[15:32:13.105]                             break
[15:32:13.105]                           }
[15:32:13.105]                         }
[15:32:13.105]                       }
[15:32:13.105]                       invisible(muffled)
[15:32:13.105]                     }
[15:32:13.105]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.105]                   }
[15:32:13.105]                 }
[15:32:13.105]             }
[15:32:13.105]         }))
[15:32:13.105]     }, error = function(ex) {
[15:32:13.105]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.105]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.105]                 ...future.rng), started = ...future.startTime, 
[15:32:13.105]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.105]             version = "1.8"), class = "FutureResult")
[15:32:13.105]     }, finally = {
[15:32:13.105]         if (!identical(...future.workdir, getwd())) 
[15:32:13.105]             setwd(...future.workdir)
[15:32:13.105]         {
[15:32:13.105]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.105]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.105]             }
[15:32:13.105]             base::options(...future.oldOptions)
[15:32:13.105]             if (.Platform$OS.type == "windows") {
[15:32:13.105]                 old_names <- names(...future.oldEnvVars)
[15:32:13.105]                 envs <- base::Sys.getenv()
[15:32:13.105]                 names <- names(envs)
[15:32:13.105]                 common <- intersect(names, old_names)
[15:32:13.105]                 added <- setdiff(names, old_names)
[15:32:13.105]                 removed <- setdiff(old_names, names)
[15:32:13.105]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.105]                   envs[common]]
[15:32:13.105]                 NAMES <- toupper(changed)
[15:32:13.105]                 args <- list()
[15:32:13.105]                 for (kk in seq_along(NAMES)) {
[15:32:13.105]                   name <- changed[[kk]]
[15:32:13.105]                   NAME <- NAMES[[kk]]
[15:32:13.105]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.105]                     next
[15:32:13.105]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.105]                 }
[15:32:13.105]                 NAMES <- toupper(added)
[15:32:13.105]                 for (kk in seq_along(NAMES)) {
[15:32:13.105]                   name <- added[[kk]]
[15:32:13.105]                   NAME <- NAMES[[kk]]
[15:32:13.105]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.105]                     next
[15:32:13.105]                   args[[name]] <- ""
[15:32:13.105]                 }
[15:32:13.105]                 NAMES <- toupper(removed)
[15:32:13.105]                 for (kk in seq_along(NAMES)) {
[15:32:13.105]                   name <- removed[[kk]]
[15:32:13.105]                   NAME <- NAMES[[kk]]
[15:32:13.105]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.105]                     next
[15:32:13.105]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.105]                 }
[15:32:13.105]                 if (length(args) > 0) 
[15:32:13.105]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.105]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.105]             }
[15:32:13.105]             else {
[15:32:13.105]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.105]             }
[15:32:13.105]             {
[15:32:13.105]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.105]                   0L) {
[15:32:13.105]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.105]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.105]                   base::options(opts)
[15:32:13.105]                 }
[15:32:13.105]                 {
[15:32:13.105]                   {
[15:32:13.105]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.105]                     NULL
[15:32:13.105]                   }
[15:32:13.105]                   options(future.plan = NULL)
[15:32:13.105]                   if (is.na(NA_character_)) 
[15:32:13.105]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.105]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.105]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.105]                     .init = FALSE)
[15:32:13.105]                 }
[15:32:13.105]             }
[15:32:13.105]         }
[15:32:13.105]     })
[15:32:13.105]     if (TRUE) {
[15:32:13.105]         base::sink(type = "output", split = FALSE)
[15:32:13.105]         if (TRUE) {
[15:32:13.105]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.105]         }
[15:32:13.105]         else {
[15:32:13.105]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.105]         }
[15:32:13.105]         base::close(...future.stdout)
[15:32:13.105]         ...future.stdout <- NULL
[15:32:13.105]     }
[15:32:13.105]     ...future.result$conditions <- ...future.conditions
[15:32:13.105]     ...future.result$finished <- base::Sys.time()
[15:32:13.105]     ...future.result
[15:32:13.105] }
[15:32:13.111] Exporting 5 global objects (1.10 KiB) to cluster node #1 ...
[15:32:13.111] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:13.112] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:13.112] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:13.113] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:13.113] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:13.113] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:13.114] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.114] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.115] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.115] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.116] Exporting 5 global objects (1.10 KiB) to cluster node #1 ... DONE
[15:32:13.117] MultisessionFuture started
[15:32:13.117] - Launch lazy future ... done
[15:32:13.117] run() for 'MultisessionFuture' ... done
[15:32:13.118] Created future:
[15:32:13.149] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.150] - Validating connection of MultisessionFuture
[15:32:13.150] - received message: FutureResult
[15:32:13.151] - Received FutureResult
[15:32:13.151] - Erased future from FutureRegistry
[15:32:13.151] result() for ClusterFuture ...
[15:32:13.152] - result already collected: FutureResult
[15:32:13.152] result() for ClusterFuture ... done
[15:32:13.152] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.118] MultisessionFuture:
[15:32:13.118] Label: 'future_.mapply-1'
[15:32:13.118] Expression:
[15:32:13.118] {
[15:32:13.118]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.118]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.118]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.118]         on.exit(options(oopts), add = TRUE)
[15:32:13.118]     }
[15:32:13.118]     {
[15:32:13.118]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.118]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.118]         do.call(mapply, args = args)
[15:32:13.118]     }
[15:32:13.118] }
[15:32:13.118] Lazy evaluation: FALSE
[15:32:13.118] Asynchronous evaluation: TRUE
[15:32:13.118] Local evaluation: TRUE
[15:32:13.118] Environment: R_GlobalEnv
[15:32:13.118] Capture standard output: TRUE
[15:32:13.118] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.118] Globals: 5 objects totaling 1.10 KiB (function '...future.FUN' of 848 bytes, list 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 280 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.118] Packages: <none>
[15:32:13.118] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.118] Resolved: TRUE
[15:32:13.118] Value: <not collected>
[15:32:13.118] Conditions captured: <none>
[15:32:13.118] Early signaling: FALSE
[15:32:13.118] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.118] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.153] Chunk #1 of 1 ... DONE
[15:32:13.153] Launching 1 futures (chunks) ... DONE
[15:32:13.154] Resolving 1 futures (chunks) ...
[15:32:13.154] resolve() on list ...
[15:32:13.154]  recursive: 0
[15:32:13.155]  length: 1
[15:32:13.155] 
[15:32:13.155] Future #1
[15:32:13.155] result() for ClusterFuture ...
[15:32:13.156] - result already collected: FutureResult
[15:32:13.156] result() for ClusterFuture ... done
[15:32:13.156] result() for ClusterFuture ...
[15:32:13.157] - result already collected: FutureResult
[15:32:13.157] result() for ClusterFuture ... done
[15:32:13.157] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:13.158] - nx: 1
[15:32:13.158] - relay: TRUE
[15:32:13.158] - stdout: TRUE
[15:32:13.158] - signal: TRUE
[15:32:13.159] - resignal: FALSE
[15:32:13.159] - force: TRUE
[15:32:13.159] - relayed: [n=1] FALSE
[15:32:13.160] - queued futures: [n=1] FALSE
[15:32:13.160]  - until=1
[15:32:13.160]  - relaying element #1
[15:32:13.160] result() for ClusterFuture ...
[15:32:13.161] - result already collected: FutureResult
[15:32:13.161] result() for ClusterFuture ... done
[15:32:13.161] result() for ClusterFuture ...
[15:32:13.162] - result already collected: FutureResult
[15:32:13.162] result() for ClusterFuture ... done
[15:32:13.162] result() for ClusterFuture ...
[15:32:13.163] - result already collected: FutureResult
[15:32:13.163] result() for ClusterFuture ... done
[15:32:13.163] result() for ClusterFuture ...
[15:32:13.164] - result already collected: FutureResult
[15:32:13.164] result() for ClusterFuture ... done
[15:32:13.164] - relayed: [n=1] TRUE
[15:32:13.164] - queued futures: [n=1] TRUE
[15:32:13.165] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:13.165]  length: 0 (resolved future 1)
[15:32:13.165] Relaying remaining futures
[15:32:13.166] signalConditionsASAP(NULL, pos=0) ...
[15:32:13.166] - nx: 1
[15:32:13.166] - relay: TRUE
[15:32:13.166] - stdout: TRUE
[15:32:13.167] - signal: TRUE
[15:32:13.167] - resignal: FALSE
[15:32:13.167] - force: TRUE
[15:32:13.168] - relayed: [n=1] TRUE
[15:32:13.168] - queued futures: [n=1] TRUE
 - flush all
[15:32:13.168] - relayed: [n=1] TRUE
[15:32:13.169] - queued futures: [n=1] TRUE
[15:32:13.169] signalConditionsASAP(NULL, pos=0) ... done
[15:32:13.169] resolve() on list ... DONE
[15:32:13.169] result() for ClusterFuture ...
[15:32:13.170] - result already collected: FutureResult
[15:32:13.170] result() for ClusterFuture ... done
[15:32:13.170] result() for ClusterFuture ...
[15:32:13.171] - result already collected: FutureResult
[15:32:13.171] result() for ClusterFuture ... done
[15:32:13.171]  - Number of value chunks collected: 1
[15:32:13.172] Resolving 1 futures (chunks) ... DONE
[15:32:13.172] Reducing values from 1 chunks ...
[15:32:13.172]  - Number of values collected after concatenation: 1
[15:32:13.172]  - Number of values expected: 1
[15:32:13.173] Reducing values from 1 chunks ... DONE
[15:32:13.173] future_mapply() ... DONE
- Non-recycling of MoreArgs (Issue #51) ...
[15:32:13.174] future_mapply() ...
[15:32:13.178] Number of chunks: 2
[15:32:13.179] getGlobalsAndPackagesXApply() ...
[15:32:13.179]  - future.globals: TRUE
[15:32:13.179] getGlobalsAndPackages() ...
[15:32:13.180] Searching for globals...
[15:32:13.182] - globals found: [1] 'FUN'
[15:32:13.182] Searching for globals ... DONE
[15:32:13.182] Resolving globals: FALSE
[15:32:13.183] The total size of the 1 globals is 1.66 KiB (1704 bytes)
[15:32:13.184] The total size of the 1 globals exported for future expression ('FUN(y = 3:4)') is 1.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.66 KiB of class 'function')
[15:32:13.184] - globals: [1] 'FUN'
[15:32:13.184] 
[15:32:13.185] getGlobalsAndPackages() ... DONE
[15:32:13.185]  - globals found/used: [n=1] 'FUN'
[15:32:13.185]  - needed namespaces: [n=0] 
[15:32:13.186] Finding globals ... DONE
[15:32:13.186] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:13.186] List of 2
[15:32:13.186]  $ ...future.FUN:function (x, y)  
[15:32:13.186]  $ MoreArgs     :List of 1
[15:32:13.186]   ..$ y: int [1:2] 3 4
[15:32:13.186]  - attr(*, "where")=List of 2
[15:32:13.186]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:13.186]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:13.186]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:13.186]  - attr(*, "resolved")= logi FALSE
[15:32:13.186]  - attr(*, "total_size")= num NA
[15:32:13.192] Packages to be attached in all futures: [n=0] 
[15:32:13.193] getGlobalsAndPackagesXApply() ... DONE
[15:32:13.193] Number of futures (= number of chunks): 2
[15:32:13.194] Launching 2 futures (chunks) ...
[15:32:13.194] Chunk #1 of 2 ...
[15:32:13.194]  - Finding globals in '...' for chunk #1 ...
[15:32:13.195] getGlobalsAndPackages() ...
[15:32:13.195] Searching for globals...
[15:32:13.195] 
[15:32:13.196] Searching for globals ... DONE
[15:32:13.196] - globals: [0] <none>
[15:32:13.196] getGlobalsAndPackages() ... DONE
[15:32:13.197]    + additional globals found: [n=0] 
[15:32:13.197]    + additional namespaces needed: [n=0] 
[15:32:13.197]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:13.198]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.198]  - seeds: <none>
[15:32:13.198]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.198] getGlobalsAndPackages() ...
[15:32:13.199] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.199] Resolving globals: FALSE
[15:32:13.200] The total size of the 5 globals is 1.77 KiB (1816 bytes)
[15:32:13.201] 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 1.77 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), 'MoreArgs' (56 bytes of class 'list') and '...future.elements_ii' (56 bytes of class 'list')
[15:32:13.202] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.202] 
[15:32:13.202] getGlobalsAndPackages() ... DONE
[15:32:13.203] run() for 'Future' ...
[15:32:13.203] - state: 'created'
[15:32:13.204] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.221] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.222] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.222]   - Field: 'node'
[15:32:13.222]   - Field: 'label'
[15:32:13.223]   - Field: 'local'
[15:32:13.223]   - Field: 'owner'
[15:32:13.223]   - Field: 'envir'
[15:32:13.224]   - Field: 'workers'
[15:32:13.224]   - Field: 'packages'
[15:32:13.224]   - Field: 'gc'
[15:32:13.225]   - Field: 'conditions'
[15:32:13.225]   - Field: 'persistent'
[15:32:13.225]   - Field: 'expr'
[15:32:13.226]   - Field: 'uuid'
[15:32:13.226]   - Field: 'seed'
[15:32:13.226]   - Field: 'version'
[15:32:13.227]   - Field: 'result'
[15:32:13.227]   - Field: 'asynchronous'
[15:32:13.227]   - Field: 'calls'
[15:32:13.228]   - Field: 'globals'
[15:32:13.228]   - Field: 'stdout'
[15:32:13.228]   - Field: 'earlySignal'
[15:32:13.229]   - Field: 'lazy'
[15:32:13.229]   - Field: 'state'
[15:32:13.229] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.230] - Launch lazy future ...
[15:32:13.230] Packages needed by the future expression (n = 0): <none>
[15:32:13.231] Packages needed by future strategies (n = 0): <none>
[15:32:13.232] {
[15:32:13.232]     {
[15:32:13.232]         {
[15:32:13.232]             ...future.startTime <- base::Sys.time()
[15:32:13.232]             {
[15:32:13.232]                 {
[15:32:13.232]                   {
[15:32:13.232]                     {
[15:32:13.232]                       base::local({
[15:32:13.232]                         has_future <- base::requireNamespace("future", 
[15:32:13.232]                           quietly = TRUE)
[15:32:13.232]                         if (has_future) {
[15:32:13.232]                           ns <- base::getNamespace("future")
[15:32:13.232]                           version <- ns[[".package"]][["version"]]
[15:32:13.232]                           if (is.null(version)) 
[15:32:13.232]                             version <- utils::packageVersion("future")
[15:32:13.232]                         }
[15:32:13.232]                         else {
[15:32:13.232]                           version <- NULL
[15:32:13.232]                         }
[15:32:13.232]                         if (!has_future || version < "1.8.0") {
[15:32:13.232]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.232]                             "", base::R.version$version.string), 
[15:32:13.232]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.232]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.232]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.232]                               "release", "version")], collapse = " "), 
[15:32:13.232]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.232]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.232]                             info)
[15:32:13.232]                           info <- base::paste(info, collapse = "; ")
[15:32:13.232]                           if (!has_future) {
[15:32:13.232]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.232]                               info)
[15:32:13.232]                           }
[15:32:13.232]                           else {
[15:32:13.232]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.232]                               info, version)
[15:32:13.232]                           }
[15:32:13.232]                           base::stop(msg)
[15:32:13.232]                         }
[15:32:13.232]                       })
[15:32:13.232]                     }
[15:32:13.232]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.232]                     base::options(mc.cores = 1L)
[15:32:13.232]                   }
[15:32:13.232]                   ...future.strategy.old <- future::plan("list")
[15:32:13.232]                   options(future.plan = NULL)
[15:32:13.232]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.232]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.232]                 }
[15:32:13.232]                 ...future.workdir <- getwd()
[15:32:13.232]             }
[15:32:13.232]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.232]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.232]         }
[15:32:13.232]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.232]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.232]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.232]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.232]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.232]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.232]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.232]             base::names(...future.oldOptions))
[15:32:13.232]     }
[15:32:13.232]     if (FALSE) {
[15:32:13.232]     }
[15:32:13.232]     else {
[15:32:13.232]         if (TRUE) {
[15:32:13.232]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.232]                 open = "w")
[15:32:13.232]         }
[15:32:13.232]         else {
[15:32:13.232]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.232]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.232]         }
[15:32:13.232]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.232]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.232]             base::sink(type = "output", split = FALSE)
[15:32:13.232]             base::close(...future.stdout)
[15:32:13.232]         }, add = TRUE)
[15:32:13.232]     }
[15:32:13.232]     ...future.frame <- base::sys.nframe()
[15:32:13.232]     ...future.conditions <- base::list()
[15:32:13.232]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.232]     if (FALSE) {
[15:32:13.232]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.232]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.232]     }
[15:32:13.232]     ...future.result <- base::tryCatch({
[15:32:13.232]         base::withCallingHandlers({
[15:32:13.232]             ...future.value <- base::withVisible(base::local({
[15:32:13.232]                 ...future.makeSendCondition <- base::local({
[15:32:13.232]                   sendCondition <- NULL
[15:32:13.232]                   function(frame = 1L) {
[15:32:13.232]                     if (is.function(sendCondition)) 
[15:32:13.232]                       return(sendCondition)
[15:32:13.232]                     ns <- getNamespace("parallel")
[15:32:13.232]                     if (exists("sendData", mode = "function", 
[15:32:13.232]                       envir = ns)) {
[15:32:13.232]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.232]                         envir = ns)
[15:32:13.232]                       envir <- sys.frame(frame)
[15:32:13.232]                       master <- NULL
[15:32:13.232]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.232]                         !identical(envir, emptyenv())) {
[15:32:13.232]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.232]                           inherits = FALSE)) {
[15:32:13.232]                           master <- get("master", mode = "list", 
[15:32:13.232]                             envir = envir, inherits = FALSE)
[15:32:13.232]                           if (inherits(master, c("SOCKnode", 
[15:32:13.232]                             "SOCK0node"))) {
[15:32:13.232]                             sendCondition <<- function(cond) {
[15:32:13.232]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.232]                                 success = TRUE)
[15:32:13.232]                               parallel_sendData(master, data)
[15:32:13.232]                             }
[15:32:13.232]                             return(sendCondition)
[15:32:13.232]                           }
[15:32:13.232]                         }
[15:32:13.232]                         frame <- frame + 1L
[15:32:13.232]                         envir <- sys.frame(frame)
[15:32:13.232]                       }
[15:32:13.232]                     }
[15:32:13.232]                     sendCondition <<- function(cond) NULL
[15:32:13.232]                   }
[15:32:13.232]                 })
[15:32:13.232]                 withCallingHandlers({
[15:32:13.232]                   {
[15:32:13.232]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.232]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.232]                       ...future.globals.maxSize)) {
[15:32:13.232]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.232]                       on.exit(options(oopts), add = TRUE)
[15:32:13.232]                     }
[15:32:13.232]                     {
[15:32:13.232]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.232]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.232]                         USE.NAMES = FALSE)
[15:32:13.232]                       do.call(mapply, args = args)
[15:32:13.232]                     }
[15:32:13.232]                   }
[15:32:13.232]                 }, immediateCondition = function(cond) {
[15:32:13.232]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.232]                   sendCondition(cond)
[15:32:13.232]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.232]                   {
[15:32:13.232]                     inherits <- base::inherits
[15:32:13.232]                     invokeRestart <- base::invokeRestart
[15:32:13.232]                     is.null <- base::is.null
[15:32:13.232]                     muffled <- FALSE
[15:32:13.232]                     if (inherits(cond, "message")) {
[15:32:13.232]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.232]                       if (muffled) 
[15:32:13.232]                         invokeRestart("muffleMessage")
[15:32:13.232]                     }
[15:32:13.232]                     else if (inherits(cond, "warning")) {
[15:32:13.232]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.232]                       if (muffled) 
[15:32:13.232]                         invokeRestart("muffleWarning")
[15:32:13.232]                     }
[15:32:13.232]                     else if (inherits(cond, "condition")) {
[15:32:13.232]                       if (!is.null(pattern)) {
[15:32:13.232]                         computeRestarts <- base::computeRestarts
[15:32:13.232]                         grepl <- base::grepl
[15:32:13.232]                         restarts <- computeRestarts(cond)
[15:32:13.232]                         for (restart in restarts) {
[15:32:13.232]                           name <- restart$name
[15:32:13.232]                           if (is.null(name)) 
[15:32:13.232]                             next
[15:32:13.232]                           if (!grepl(pattern, name)) 
[15:32:13.232]                             next
[15:32:13.232]                           invokeRestart(restart)
[15:32:13.232]                           muffled <- TRUE
[15:32:13.232]                           break
[15:32:13.232]                         }
[15:32:13.232]                       }
[15:32:13.232]                     }
[15:32:13.232]                     invisible(muffled)
[15:32:13.232]                   }
[15:32:13.232]                   muffleCondition(cond)
[15:32:13.232]                 })
[15:32:13.232]             }))
[15:32:13.232]             future::FutureResult(value = ...future.value$value, 
[15:32:13.232]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.232]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.232]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.232]                     ...future.globalenv.names))
[15:32:13.232]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.232]         }, condition = base::local({
[15:32:13.232]             c <- base::c
[15:32:13.232]             inherits <- base::inherits
[15:32:13.232]             invokeRestart <- base::invokeRestart
[15:32:13.232]             length <- base::length
[15:32:13.232]             list <- base::list
[15:32:13.232]             seq.int <- base::seq.int
[15:32:13.232]             signalCondition <- base::signalCondition
[15:32:13.232]             sys.calls <- base::sys.calls
[15:32:13.232]             `[[` <- base::`[[`
[15:32:13.232]             `+` <- base::`+`
[15:32:13.232]             `<<-` <- base::`<<-`
[15:32:13.232]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.232]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.232]                   3L)]
[15:32:13.232]             }
[15:32:13.232]             function(cond) {
[15:32:13.232]                 is_error <- inherits(cond, "error")
[15:32:13.232]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.232]                   NULL)
[15:32:13.232]                 if (is_error) {
[15:32:13.232]                   sessionInformation <- function() {
[15:32:13.232]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.232]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.232]                       search = base::search(), system = base::Sys.info())
[15:32:13.232]                   }
[15:32:13.232]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.232]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.232]                     cond$call), session = sessionInformation(), 
[15:32:13.232]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.232]                   signalCondition(cond)
[15:32:13.232]                 }
[15:32:13.232]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.232]                 "immediateCondition"))) {
[15:32:13.232]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.232]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.232]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.232]                   if (TRUE && !signal) {
[15:32:13.232]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.232]                     {
[15:32:13.232]                       inherits <- base::inherits
[15:32:13.232]                       invokeRestart <- base::invokeRestart
[15:32:13.232]                       is.null <- base::is.null
[15:32:13.232]                       muffled <- FALSE
[15:32:13.232]                       if (inherits(cond, "message")) {
[15:32:13.232]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.232]                         if (muffled) 
[15:32:13.232]                           invokeRestart("muffleMessage")
[15:32:13.232]                       }
[15:32:13.232]                       else if (inherits(cond, "warning")) {
[15:32:13.232]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.232]                         if (muffled) 
[15:32:13.232]                           invokeRestart("muffleWarning")
[15:32:13.232]                       }
[15:32:13.232]                       else if (inherits(cond, "condition")) {
[15:32:13.232]                         if (!is.null(pattern)) {
[15:32:13.232]                           computeRestarts <- base::computeRestarts
[15:32:13.232]                           grepl <- base::grepl
[15:32:13.232]                           restarts <- computeRestarts(cond)
[15:32:13.232]                           for (restart in restarts) {
[15:32:13.232]                             name <- restart$name
[15:32:13.232]                             if (is.null(name)) 
[15:32:13.232]                               next
[15:32:13.232]                             if (!grepl(pattern, name)) 
[15:32:13.232]                               next
[15:32:13.232]                             invokeRestart(restart)
[15:32:13.232]                             muffled <- TRUE
[15:32:13.232]                             break
[15:32:13.232]                           }
[15:32:13.232]                         }
[15:32:13.232]                       }
[15:32:13.232]                       invisible(muffled)
[15:32:13.232]                     }
[15:32:13.232]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.232]                   }
[15:32:13.232]                 }
[15:32:13.232]                 else {
[15:32:13.232]                   if (TRUE) {
[15:32:13.232]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.232]                     {
[15:32:13.232]                       inherits <- base::inherits
[15:32:13.232]                       invokeRestart <- base::invokeRestart
[15:32:13.232]                       is.null <- base::is.null
[15:32:13.232]                       muffled <- FALSE
[15:32:13.232]                       if (inherits(cond, "message")) {
[15:32:13.232]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.232]                         if (muffled) 
[15:32:13.232]                           invokeRestart("muffleMessage")
[15:32:13.232]                       }
[15:32:13.232]                       else if (inherits(cond, "warning")) {
[15:32:13.232]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.232]                         if (muffled) 
[15:32:13.232]                           invokeRestart("muffleWarning")
[15:32:13.232]                       }
[15:32:13.232]                       else if (inherits(cond, "condition")) {
[15:32:13.232]                         if (!is.null(pattern)) {
[15:32:13.232]                           computeRestarts <- base::computeRestarts
[15:32:13.232]                           grepl <- base::grepl
[15:32:13.232]                           restarts <- computeRestarts(cond)
[15:32:13.232]                           for (restart in restarts) {
[15:32:13.232]                             name <- restart$name
[15:32:13.232]                             if (is.null(name)) 
[15:32:13.232]                               next
[15:32:13.232]                             if (!grepl(pattern, name)) 
[15:32:13.232]                               next
[15:32:13.232]                             invokeRestart(restart)
[15:32:13.232]                             muffled <- TRUE
[15:32:13.232]                             break
[15:32:13.232]                           }
[15:32:13.232]                         }
[15:32:13.232]                       }
[15:32:13.232]                       invisible(muffled)
[15:32:13.232]                     }
[15:32:13.232]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.232]                   }
[15:32:13.232]                 }
[15:32:13.232]             }
[15:32:13.232]         }))
[15:32:13.232]     }, error = function(ex) {
[15:32:13.232]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.232]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.232]                 ...future.rng), started = ...future.startTime, 
[15:32:13.232]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.232]             version = "1.8"), class = "FutureResult")
[15:32:13.232]     }, finally = {
[15:32:13.232]         if (!identical(...future.workdir, getwd())) 
[15:32:13.232]             setwd(...future.workdir)
[15:32:13.232]         {
[15:32:13.232]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.232]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.232]             }
[15:32:13.232]             base::options(...future.oldOptions)
[15:32:13.232]             if (.Platform$OS.type == "windows") {
[15:32:13.232]                 old_names <- names(...future.oldEnvVars)
[15:32:13.232]                 envs <- base::Sys.getenv()
[15:32:13.232]                 names <- names(envs)
[15:32:13.232]                 common <- intersect(names, old_names)
[15:32:13.232]                 added <- setdiff(names, old_names)
[15:32:13.232]                 removed <- setdiff(old_names, names)
[15:32:13.232]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.232]                   envs[common]]
[15:32:13.232]                 NAMES <- toupper(changed)
[15:32:13.232]                 args <- list()
[15:32:13.232]                 for (kk in seq_along(NAMES)) {
[15:32:13.232]                   name <- changed[[kk]]
[15:32:13.232]                   NAME <- NAMES[[kk]]
[15:32:13.232]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.232]                     next
[15:32:13.232]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.232]                 }
[15:32:13.232]                 NAMES <- toupper(added)
[15:32:13.232]                 for (kk in seq_along(NAMES)) {
[15:32:13.232]                   name <- added[[kk]]
[15:32:13.232]                   NAME <- NAMES[[kk]]
[15:32:13.232]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.232]                     next
[15:32:13.232]                   args[[name]] <- ""
[15:32:13.232]                 }
[15:32:13.232]                 NAMES <- toupper(removed)
[15:32:13.232]                 for (kk in seq_along(NAMES)) {
[15:32:13.232]                   name <- removed[[kk]]
[15:32:13.232]                   NAME <- NAMES[[kk]]
[15:32:13.232]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.232]                     next
[15:32:13.232]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.232]                 }
[15:32:13.232]                 if (length(args) > 0) 
[15:32:13.232]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.232]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.232]             }
[15:32:13.232]             else {
[15:32:13.232]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.232]             }
[15:32:13.232]             {
[15:32:13.232]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.232]                   0L) {
[15:32:13.232]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.232]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.232]                   base::options(opts)
[15:32:13.232]                 }
[15:32:13.232]                 {
[15:32:13.232]                   {
[15:32:13.232]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.232]                     NULL
[15:32:13.232]                   }
[15:32:13.232]                   options(future.plan = NULL)
[15:32:13.232]                   if (is.na(NA_character_)) 
[15:32:13.232]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.232]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.232]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.232]                     .init = FALSE)
[15:32:13.232]                 }
[15:32:13.232]             }
[15:32:13.232]         }
[15:32:13.232]     })
[15:32:13.232]     if (TRUE) {
[15:32:13.232]         base::sink(type = "output", split = FALSE)
[15:32:13.232]         if (TRUE) {
[15:32:13.232]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.232]         }
[15:32:13.232]         else {
[15:32:13.232]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.232]         }
[15:32:13.232]         base::close(...future.stdout)
[15:32:13.232]         ...future.stdout <- NULL
[15:32:13.232]     }
[15:32:13.232]     ...future.result$conditions <- ...future.conditions
[15:32:13.232]     ...future.result$finished <- base::Sys.time()
[15:32:13.232]     ...future.result
[15:32:13.232] }
[15:32:13.240] Exporting 5 global objects (1.77 KiB) to cluster node #1 ...
[15:32:13.241] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ...
[15:32:13.241] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ... DONE
[15:32:13.242] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:13.243] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:13.243] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:13.244] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:13.244] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.245] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.245] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.246] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.246] Exporting 5 global objects (1.77 KiB) to cluster node #1 ... DONE
[15:32:13.247] MultisessionFuture started
[15:32:13.247] - Launch lazy future ... done
[15:32:13.248] run() for 'MultisessionFuture' ... done
[15:32:13.248] Created future:
[15:32:13.270] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.270] - Validating connection of MultisessionFuture
[15:32:13.271] - received message: FutureResult
[15:32:13.271] - Received FutureResult
[15:32:13.272] - Erased future from FutureRegistry
[15:32:13.272] result() for ClusterFuture ...
[15:32:13.272] - result already collected: FutureResult
[15:32:13.272] result() for ClusterFuture ... done
[15:32:13.273] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.248] MultisessionFuture:
[15:32:13.248] Label: 'future_mapply-1'
[15:32:13.248] Expression:
[15:32:13.248] {
[15:32:13.248]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.248]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.248]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.248]         on.exit(options(oopts), add = TRUE)
[15:32:13.248]     }
[15:32:13.248]     {
[15:32:13.248]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.248]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.248]         do.call(mapply, args = args)
[15:32:13.248]     }
[15:32:13.248] }
[15:32:13.248] Lazy evaluation: FALSE
[15:32:13.248] Asynchronous evaluation: TRUE
[15:32:13.248] Local evaluation: TRUE
[15:32:13.248] Environment: R_GlobalEnv
[15:32:13.248] Capture standard output: TRUE
[15:32:13.248] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.248] Globals: 5 objects totaling 1.77 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.248] Packages: <none>
[15:32:13.248] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.248] Resolved: TRUE
[15:32:13.248] Value: <not collected>
[15:32:13.248] Conditions captured: <none>
[15:32:13.248] Early signaling: FALSE
[15:32:13.248] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.248] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.274] Chunk #1 of 2 ... DONE
[15:32:13.274] Chunk #2 of 2 ...
[15:32:13.274]  - Finding globals in '...' for chunk #2 ...
[15:32:13.275] getGlobalsAndPackages() ...
[15:32:13.275] Searching for globals...
[15:32:13.276] 
[15:32:13.276] Searching for globals ... DONE
[15:32:13.276] - globals: [0] <none>
[15:32:13.276] getGlobalsAndPackages() ... DONE
[15:32:13.277]    + additional globals found: [n=0] 
[15:32:13.277]    + additional namespaces needed: [n=0] 
[15:32:13.277]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:13.277]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.278]  - seeds: <none>
[15:32:13.278]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.278] getGlobalsAndPackages() ...
[15:32:13.279] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.279] Resolving globals: FALSE
[15:32:13.280] The total size of the 5 globals is 1.77 KiB (1816 bytes)
[15:32:13.284] 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 1.77 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), 'MoreArgs' (56 bytes of class 'list') and '...future.elements_ii' (56 bytes of class 'list')
[15:32:13.284] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.285] 
[15:32:13.285] getGlobalsAndPackages() ... DONE
[15:32:13.285] run() for 'Future' ...
[15:32:13.285] - state: 'created'
[15:32:13.286] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.303] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.303] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.304]   - Field: 'node'
[15:32:13.304]   - Field: 'label'
[15:32:13.304]   - Field: 'local'
[15:32:13.305]   - Field: 'owner'
[15:32:13.305]   - Field: 'envir'
[15:32:13.305]   - Field: 'workers'
[15:32:13.306]   - Field: 'packages'
[15:32:13.306]   - Field: 'gc'
[15:32:13.306]   - Field: 'conditions'
[15:32:13.306]   - Field: 'persistent'
[15:32:13.307]   - Field: 'expr'
[15:32:13.307]   - Field: 'uuid'
[15:32:13.307]   - Field: 'seed'
[15:32:13.308]   - Field: 'version'
[15:32:13.308]   - Field: 'result'
[15:32:13.308]   - Field: 'asynchronous'
[15:32:13.309]   - Field: 'calls'
[15:32:13.309]   - Field: 'globals'
[15:32:13.309]   - Field: 'stdout'
[15:32:13.310]   - Field: 'earlySignal'
[15:32:13.310]   - Field: 'lazy'
[15:32:13.310]   - Field: 'state'
[15:32:13.310] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.311] - Launch lazy future ...
[15:32:13.311] Packages needed by the future expression (n = 0): <none>
[15:32:13.312] Packages needed by future strategies (n = 0): <none>
[15:32:13.313] {
[15:32:13.313]     {
[15:32:13.313]         {
[15:32:13.313]             ...future.startTime <- base::Sys.time()
[15:32:13.313]             {
[15:32:13.313]                 {
[15:32:13.313]                   {
[15:32:13.313]                     {
[15:32:13.313]                       base::local({
[15:32:13.313]                         has_future <- base::requireNamespace("future", 
[15:32:13.313]                           quietly = TRUE)
[15:32:13.313]                         if (has_future) {
[15:32:13.313]                           ns <- base::getNamespace("future")
[15:32:13.313]                           version <- ns[[".package"]][["version"]]
[15:32:13.313]                           if (is.null(version)) 
[15:32:13.313]                             version <- utils::packageVersion("future")
[15:32:13.313]                         }
[15:32:13.313]                         else {
[15:32:13.313]                           version <- NULL
[15:32:13.313]                         }
[15:32:13.313]                         if (!has_future || version < "1.8.0") {
[15:32:13.313]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.313]                             "", base::R.version$version.string), 
[15:32:13.313]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.313]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.313]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.313]                               "release", "version")], collapse = " "), 
[15:32:13.313]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.313]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.313]                             info)
[15:32:13.313]                           info <- base::paste(info, collapse = "; ")
[15:32:13.313]                           if (!has_future) {
[15:32:13.313]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.313]                               info)
[15:32:13.313]                           }
[15:32:13.313]                           else {
[15:32:13.313]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.313]                               info, version)
[15:32:13.313]                           }
[15:32:13.313]                           base::stop(msg)
[15:32:13.313]                         }
[15:32:13.313]                       })
[15:32:13.313]                     }
[15:32:13.313]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.313]                     base::options(mc.cores = 1L)
[15:32:13.313]                   }
[15:32:13.313]                   ...future.strategy.old <- future::plan("list")
[15:32:13.313]                   options(future.plan = NULL)
[15:32:13.313]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.313]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.313]                 }
[15:32:13.313]                 ...future.workdir <- getwd()
[15:32:13.313]             }
[15:32:13.313]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.313]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.313]         }
[15:32:13.313]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.313]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.313]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.313]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.313]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.313]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.313]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.313]             base::names(...future.oldOptions))
[15:32:13.313]     }
[15:32:13.313]     if (FALSE) {
[15:32:13.313]     }
[15:32:13.313]     else {
[15:32:13.313]         if (TRUE) {
[15:32:13.313]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.313]                 open = "w")
[15:32:13.313]         }
[15:32:13.313]         else {
[15:32:13.313]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.313]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.313]         }
[15:32:13.313]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.313]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.313]             base::sink(type = "output", split = FALSE)
[15:32:13.313]             base::close(...future.stdout)
[15:32:13.313]         }, add = TRUE)
[15:32:13.313]     }
[15:32:13.313]     ...future.frame <- base::sys.nframe()
[15:32:13.313]     ...future.conditions <- base::list()
[15:32:13.313]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.313]     if (FALSE) {
[15:32:13.313]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.313]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.313]     }
[15:32:13.313]     ...future.result <- base::tryCatch({
[15:32:13.313]         base::withCallingHandlers({
[15:32:13.313]             ...future.value <- base::withVisible(base::local({
[15:32:13.313]                 ...future.makeSendCondition <- base::local({
[15:32:13.313]                   sendCondition <- NULL
[15:32:13.313]                   function(frame = 1L) {
[15:32:13.313]                     if (is.function(sendCondition)) 
[15:32:13.313]                       return(sendCondition)
[15:32:13.313]                     ns <- getNamespace("parallel")
[15:32:13.313]                     if (exists("sendData", mode = "function", 
[15:32:13.313]                       envir = ns)) {
[15:32:13.313]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.313]                         envir = ns)
[15:32:13.313]                       envir <- sys.frame(frame)
[15:32:13.313]                       master <- NULL
[15:32:13.313]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.313]                         !identical(envir, emptyenv())) {
[15:32:13.313]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.313]                           inherits = FALSE)) {
[15:32:13.313]                           master <- get("master", mode = "list", 
[15:32:13.313]                             envir = envir, inherits = FALSE)
[15:32:13.313]                           if (inherits(master, c("SOCKnode", 
[15:32:13.313]                             "SOCK0node"))) {
[15:32:13.313]                             sendCondition <<- function(cond) {
[15:32:13.313]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.313]                                 success = TRUE)
[15:32:13.313]                               parallel_sendData(master, data)
[15:32:13.313]                             }
[15:32:13.313]                             return(sendCondition)
[15:32:13.313]                           }
[15:32:13.313]                         }
[15:32:13.313]                         frame <- frame + 1L
[15:32:13.313]                         envir <- sys.frame(frame)
[15:32:13.313]                       }
[15:32:13.313]                     }
[15:32:13.313]                     sendCondition <<- function(cond) NULL
[15:32:13.313]                   }
[15:32:13.313]                 })
[15:32:13.313]                 withCallingHandlers({
[15:32:13.313]                   {
[15:32:13.313]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.313]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.313]                       ...future.globals.maxSize)) {
[15:32:13.313]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.313]                       on.exit(options(oopts), add = TRUE)
[15:32:13.313]                     }
[15:32:13.313]                     {
[15:32:13.313]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.313]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.313]                         USE.NAMES = FALSE)
[15:32:13.313]                       do.call(mapply, args = args)
[15:32:13.313]                     }
[15:32:13.313]                   }
[15:32:13.313]                 }, immediateCondition = function(cond) {
[15:32:13.313]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.313]                   sendCondition(cond)
[15:32:13.313]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.313]                   {
[15:32:13.313]                     inherits <- base::inherits
[15:32:13.313]                     invokeRestart <- base::invokeRestart
[15:32:13.313]                     is.null <- base::is.null
[15:32:13.313]                     muffled <- FALSE
[15:32:13.313]                     if (inherits(cond, "message")) {
[15:32:13.313]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.313]                       if (muffled) 
[15:32:13.313]                         invokeRestart("muffleMessage")
[15:32:13.313]                     }
[15:32:13.313]                     else if (inherits(cond, "warning")) {
[15:32:13.313]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.313]                       if (muffled) 
[15:32:13.313]                         invokeRestart("muffleWarning")
[15:32:13.313]                     }
[15:32:13.313]                     else if (inherits(cond, "condition")) {
[15:32:13.313]                       if (!is.null(pattern)) {
[15:32:13.313]                         computeRestarts <- base::computeRestarts
[15:32:13.313]                         grepl <- base::grepl
[15:32:13.313]                         restarts <- computeRestarts(cond)
[15:32:13.313]                         for (restart in restarts) {
[15:32:13.313]                           name <- restart$name
[15:32:13.313]                           if (is.null(name)) 
[15:32:13.313]                             next
[15:32:13.313]                           if (!grepl(pattern, name)) 
[15:32:13.313]                             next
[15:32:13.313]                           invokeRestart(restart)
[15:32:13.313]                           muffled <- TRUE
[15:32:13.313]                           break
[15:32:13.313]                         }
[15:32:13.313]                       }
[15:32:13.313]                     }
[15:32:13.313]                     invisible(muffled)
[15:32:13.313]                   }
[15:32:13.313]                   muffleCondition(cond)
[15:32:13.313]                 })
[15:32:13.313]             }))
[15:32:13.313]             future::FutureResult(value = ...future.value$value, 
[15:32:13.313]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.313]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.313]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.313]                     ...future.globalenv.names))
[15:32:13.313]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.313]         }, condition = base::local({
[15:32:13.313]             c <- base::c
[15:32:13.313]             inherits <- base::inherits
[15:32:13.313]             invokeRestart <- base::invokeRestart
[15:32:13.313]             length <- base::length
[15:32:13.313]             list <- base::list
[15:32:13.313]             seq.int <- base::seq.int
[15:32:13.313]             signalCondition <- base::signalCondition
[15:32:13.313]             sys.calls <- base::sys.calls
[15:32:13.313]             `[[` <- base::`[[`
[15:32:13.313]             `+` <- base::`+`
[15:32:13.313]             `<<-` <- base::`<<-`
[15:32:13.313]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.313]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.313]                   3L)]
[15:32:13.313]             }
[15:32:13.313]             function(cond) {
[15:32:13.313]                 is_error <- inherits(cond, "error")
[15:32:13.313]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.313]                   NULL)
[15:32:13.313]                 if (is_error) {
[15:32:13.313]                   sessionInformation <- function() {
[15:32:13.313]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.313]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.313]                       search = base::search(), system = base::Sys.info())
[15:32:13.313]                   }
[15:32:13.313]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.313]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.313]                     cond$call), session = sessionInformation(), 
[15:32:13.313]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.313]                   signalCondition(cond)
[15:32:13.313]                 }
[15:32:13.313]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.313]                 "immediateCondition"))) {
[15:32:13.313]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.313]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.313]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.313]                   if (TRUE && !signal) {
[15:32:13.313]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.313]                     {
[15:32:13.313]                       inherits <- base::inherits
[15:32:13.313]                       invokeRestart <- base::invokeRestart
[15:32:13.313]                       is.null <- base::is.null
[15:32:13.313]                       muffled <- FALSE
[15:32:13.313]                       if (inherits(cond, "message")) {
[15:32:13.313]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.313]                         if (muffled) 
[15:32:13.313]                           invokeRestart("muffleMessage")
[15:32:13.313]                       }
[15:32:13.313]                       else if (inherits(cond, "warning")) {
[15:32:13.313]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.313]                         if (muffled) 
[15:32:13.313]                           invokeRestart("muffleWarning")
[15:32:13.313]                       }
[15:32:13.313]                       else if (inherits(cond, "condition")) {
[15:32:13.313]                         if (!is.null(pattern)) {
[15:32:13.313]                           computeRestarts <- base::computeRestarts
[15:32:13.313]                           grepl <- base::grepl
[15:32:13.313]                           restarts <- computeRestarts(cond)
[15:32:13.313]                           for (restart in restarts) {
[15:32:13.313]                             name <- restart$name
[15:32:13.313]                             if (is.null(name)) 
[15:32:13.313]                               next
[15:32:13.313]                             if (!grepl(pattern, name)) 
[15:32:13.313]                               next
[15:32:13.313]                             invokeRestart(restart)
[15:32:13.313]                             muffled <- TRUE
[15:32:13.313]                             break
[15:32:13.313]                           }
[15:32:13.313]                         }
[15:32:13.313]                       }
[15:32:13.313]                       invisible(muffled)
[15:32:13.313]                     }
[15:32:13.313]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.313]                   }
[15:32:13.313]                 }
[15:32:13.313]                 else {
[15:32:13.313]                   if (TRUE) {
[15:32:13.313]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.313]                     {
[15:32:13.313]                       inherits <- base::inherits
[15:32:13.313]                       invokeRestart <- base::invokeRestart
[15:32:13.313]                       is.null <- base::is.null
[15:32:13.313]                       muffled <- FALSE
[15:32:13.313]                       if (inherits(cond, "message")) {
[15:32:13.313]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.313]                         if (muffled) 
[15:32:13.313]                           invokeRestart("muffleMessage")
[15:32:13.313]                       }
[15:32:13.313]                       else if (inherits(cond, "warning")) {
[15:32:13.313]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.313]                         if (muffled) 
[15:32:13.313]                           invokeRestart("muffleWarning")
[15:32:13.313]                       }
[15:32:13.313]                       else if (inherits(cond, "condition")) {
[15:32:13.313]                         if (!is.null(pattern)) {
[15:32:13.313]                           computeRestarts <- base::computeRestarts
[15:32:13.313]                           grepl <- base::grepl
[15:32:13.313]                           restarts <- computeRestarts(cond)
[15:32:13.313]                           for (restart in restarts) {
[15:32:13.313]                             name <- restart$name
[15:32:13.313]                             if (is.null(name)) 
[15:32:13.313]                               next
[15:32:13.313]                             if (!grepl(pattern, name)) 
[15:32:13.313]                               next
[15:32:13.313]                             invokeRestart(restart)
[15:32:13.313]                             muffled <- TRUE
[15:32:13.313]                             break
[15:32:13.313]                           }
[15:32:13.313]                         }
[15:32:13.313]                       }
[15:32:13.313]                       invisible(muffled)
[15:32:13.313]                     }
[15:32:13.313]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.313]                   }
[15:32:13.313]                 }
[15:32:13.313]             }
[15:32:13.313]         }))
[15:32:13.313]     }, error = function(ex) {
[15:32:13.313]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.313]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.313]                 ...future.rng), started = ...future.startTime, 
[15:32:13.313]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.313]             version = "1.8"), class = "FutureResult")
[15:32:13.313]     }, finally = {
[15:32:13.313]         if (!identical(...future.workdir, getwd())) 
[15:32:13.313]             setwd(...future.workdir)
[15:32:13.313]         {
[15:32:13.313]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.313]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.313]             }
[15:32:13.313]             base::options(...future.oldOptions)
[15:32:13.313]             if (.Platform$OS.type == "windows") {
[15:32:13.313]                 old_names <- names(...future.oldEnvVars)
[15:32:13.313]                 envs <- base::Sys.getenv()
[15:32:13.313]                 names <- names(envs)
[15:32:13.313]                 common <- intersect(names, old_names)
[15:32:13.313]                 added <- setdiff(names, old_names)
[15:32:13.313]                 removed <- setdiff(old_names, names)
[15:32:13.313]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.313]                   envs[common]]
[15:32:13.313]                 NAMES <- toupper(changed)
[15:32:13.313]                 args <- list()
[15:32:13.313]                 for (kk in seq_along(NAMES)) {
[15:32:13.313]                   name <- changed[[kk]]
[15:32:13.313]                   NAME <- NAMES[[kk]]
[15:32:13.313]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.313]                     next
[15:32:13.313]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.313]                 }
[15:32:13.313]                 NAMES <- toupper(added)
[15:32:13.313]                 for (kk in seq_along(NAMES)) {
[15:32:13.313]                   name <- added[[kk]]
[15:32:13.313]                   NAME <- NAMES[[kk]]
[15:32:13.313]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.313]                     next
[15:32:13.313]                   args[[name]] <- ""
[15:32:13.313]                 }
[15:32:13.313]                 NAMES <- toupper(removed)
[15:32:13.313]                 for (kk in seq_along(NAMES)) {
[15:32:13.313]                   name <- removed[[kk]]
[15:32:13.313]                   NAME <- NAMES[[kk]]
[15:32:13.313]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.313]                     next
[15:32:13.313]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.313]                 }
[15:32:13.313]                 if (length(args) > 0) 
[15:32:13.313]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.313]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.313]             }
[15:32:13.313]             else {
[15:32:13.313]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.313]             }
[15:32:13.313]             {
[15:32:13.313]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.313]                   0L) {
[15:32:13.313]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.313]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.313]                   base::options(opts)
[15:32:13.313]                 }
[15:32:13.313]                 {
[15:32:13.313]                   {
[15:32:13.313]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.313]                     NULL
[15:32:13.313]                   }
[15:32:13.313]                   options(future.plan = NULL)
[15:32:13.313]                   if (is.na(NA_character_)) 
[15:32:13.313]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.313]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.313]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.313]                     .init = FALSE)
[15:32:13.313]                 }
[15:32:13.313]             }
[15:32:13.313]         }
[15:32:13.313]     })
[15:32:13.313]     if (TRUE) {
[15:32:13.313]         base::sink(type = "output", split = FALSE)
[15:32:13.313]         if (TRUE) {
[15:32:13.313]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.313]         }
[15:32:13.313]         else {
[15:32:13.313]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.313]         }
[15:32:13.313]         base::close(...future.stdout)
[15:32:13.313]         ...future.stdout <- NULL
[15:32:13.313]     }
[15:32:13.313]     ...future.result$conditions <- ...future.conditions
[15:32:13.313]     ...future.result$finished <- base::Sys.time()
[15:32:13.313]     ...future.result
[15:32:13.313] }
[15:32:13.322] Exporting 5 global objects (1.77 KiB) to cluster node #1 ...
[15:32:13.323] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ...
[15:32:13.324] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ... DONE
[15:32:13.324] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:13.328] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:13.328] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:13.329] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:13.329] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.330] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.330] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.331] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.331] Exporting 5 global objects (1.77 KiB) to cluster node #1 ... DONE
[15:32:13.332] MultisessionFuture started
[15:32:13.333] - Launch lazy future ... done
[15:32:13.333] run() for 'MultisessionFuture' ... done
[15:32:13.333] Created future:
[15:32:13.356] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.356] - Validating connection of MultisessionFuture
[15:32:13.357] - received message: FutureResult
[15:32:13.357] - Received FutureResult
[15:32:13.357] - Erased future from FutureRegistry
[15:32:13.358] result() for ClusterFuture ...
[15:32:13.358] - result already collected: FutureResult
[15:32:13.358] result() for ClusterFuture ... done
[15:32:13.359] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.334] MultisessionFuture:
[15:32:13.334] Label: 'future_mapply-2'
[15:32:13.334] Expression:
[15:32:13.334] {
[15:32:13.334]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.334]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.334]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.334]         on.exit(options(oopts), add = TRUE)
[15:32:13.334]     }
[15:32:13.334]     {
[15:32:13.334]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.334]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.334]         do.call(mapply, args = args)
[15:32:13.334]     }
[15:32:13.334] }
[15:32:13.334] Lazy evaluation: FALSE
[15:32:13.334] Asynchronous evaluation: TRUE
[15:32:13.334] Local evaluation: TRUE
[15:32:13.334] Environment: R_GlobalEnv
[15:32:13.334] Capture standard output: TRUE
[15:32:13.334] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.334] Globals: 5 objects totaling 1.77 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.334] Packages: <none>
[15:32:13.334] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.334] Resolved: TRUE
[15:32:13.334] Value: <not collected>
[15:32:13.334] Conditions captured: <none>
[15:32:13.334] Early signaling: FALSE
[15:32:13.334] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.334] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.359] Chunk #2 of 2 ... DONE
[15:32:13.360] Launching 2 futures (chunks) ... DONE
[15:32:13.360] Resolving 2 futures (chunks) ...
[15:32:13.360] resolve() on list ...
[15:32:13.361]  recursive: 0
[15:32:13.361]  length: 2
[15:32:13.361] 
[15:32:13.361] Future #1
[15:32:13.362] result() for ClusterFuture ...
[15:32:13.362] - result already collected: FutureResult
[15:32:13.362] result() for ClusterFuture ... done
[15:32:13.363] result() for ClusterFuture ...
[15:32:13.363] - result already collected: FutureResult
[15:32:13.363] result() for ClusterFuture ... done
[15:32:13.363] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:13.364] - nx: 2
[15:32:13.364] - relay: TRUE
[15:32:13.364] - stdout: TRUE
[15:32:13.364] - signal: TRUE
[15:32:13.365] - resignal: FALSE
[15:32:13.365] - force: TRUE
[15:32:13.365] - relayed: [n=2] FALSE, FALSE
[15:32:13.365] - queued futures: [n=2] FALSE, FALSE
[15:32:13.366]  - until=1
[15:32:13.366]  - relaying element #1
[15:32:13.366] result() for ClusterFuture ...
[15:32:13.366] - result already collected: FutureResult
[15:32:13.367] result() for ClusterFuture ... done
[15:32:13.367] result() for ClusterFuture ...
[15:32:13.367] - result already collected: FutureResult
[15:32:13.368] result() for ClusterFuture ... done
[15:32:13.368] result() for ClusterFuture ...
[15:32:13.368] - result already collected: FutureResult
[15:32:13.369] result() for ClusterFuture ... done
[15:32:13.369] result() for ClusterFuture ...
[15:32:13.369] - result already collected: FutureResult
[15:32:13.369] result() for ClusterFuture ... done
[15:32:13.370] - relayed: [n=2] TRUE, FALSE
[15:32:13.370] - queued futures: [n=2] TRUE, FALSE
[15:32:13.370] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:13.371]  length: 1 (resolved future 1)
[15:32:13.371] Future #2
[15:32:13.371] result() for ClusterFuture ...
[15:32:13.371] - result already collected: FutureResult
[15:32:13.372] result() for ClusterFuture ... done
[15:32:13.372] result() for ClusterFuture ...
[15:32:13.372] - result already collected: FutureResult
[15:32:13.372] result() for ClusterFuture ... done
[15:32:13.373] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:13.373] - nx: 2
[15:32:13.373] - relay: TRUE
[15:32:13.374] - stdout: TRUE
[15:32:13.374] - signal: TRUE
[15:32:13.374] - resignal: FALSE
[15:32:13.374] - force: TRUE
[15:32:13.375] - relayed: [n=2] TRUE, FALSE
[15:32:13.375] - queued futures: [n=2] TRUE, FALSE
[15:32:13.375]  - until=2
[15:32:13.375]  - relaying element #2
[15:32:13.376] result() for ClusterFuture ...
[15:32:13.376] - result already collected: FutureResult
[15:32:13.376] result() for ClusterFuture ... done
[15:32:13.376] result() for ClusterFuture ...
[15:32:13.377] - result already collected: FutureResult
[15:32:13.377] result() for ClusterFuture ... done
[15:32:13.378] result() for ClusterFuture ...
[15:32:13.378] - result already collected: FutureResult
[15:32:13.378] result() for ClusterFuture ... done
[15:32:13.379] result() for ClusterFuture ...
[15:32:13.379] - result already collected: FutureResult
[15:32:13.379] result() for ClusterFuture ... done
[15:32:13.379] - relayed: [n=2] TRUE, TRUE
[15:32:13.380] - queued futures: [n=2] TRUE, TRUE
[15:32:13.380] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:13.380]  length: 0 (resolved future 2)
[15:32:13.380] Relaying remaining futures
[15:32:13.381] signalConditionsASAP(NULL, pos=0) ...
[15:32:13.381] - nx: 2
[15:32:13.381] - relay: TRUE
[15:32:13.381] - stdout: TRUE
[15:32:13.382] - signal: TRUE
[15:32:13.382] - resignal: FALSE
[15:32:13.382] - force: TRUE
[15:32:13.382] - relayed: [n=2] TRUE, TRUE
[15:32:13.382] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:13.383] - relayed: [n=2] TRUE, TRUE
[15:32:13.383] - queued futures: [n=2] TRUE, TRUE
[15:32:13.383] signalConditionsASAP(NULL, pos=0) ... done
[15:32:13.384] resolve() on list ... DONE
[15:32:13.384] result() for ClusterFuture ...
[15:32:13.384] - result already collected: FutureResult
[15:32:13.384] result() for ClusterFuture ... done
[15:32:13.385] result() for ClusterFuture ...
[15:32:13.385] - result already collected: FutureResult
[15:32:13.385] result() for ClusterFuture ... done
[15:32:13.386] result() for ClusterFuture ...
[15:32:13.386] - result already collected: FutureResult
[15:32:13.386] result() for ClusterFuture ... done
[15:32:13.386] result() for ClusterFuture ...
[15:32:13.387] - result already collected: FutureResult
[15:32:13.387] result() for ClusterFuture ... done
[15:32:13.387]  - Number of value chunks collected: 2
[15:32:13.387] Resolving 2 futures (chunks) ... DONE
[15:32:13.388] Reducing values from 2 chunks ...
[15:32:13.388]  - Number of values collected after concatenation: 2
[15:32:13.388]  - Number of values expected: 2
[15:32:13.388] Reducing values from 2 chunks ... DONE
[15:32:13.389] future_mapply() ... DONE
[15:32:13.389] future_mapply() ...
[15:32:13.389] Generating random seeds ...
[15:32:13.390] Generating random seed streams for 2 elements ...
[15:32:13.390] Generating random seed streams for 2 elements ... DONE
[15:32:13.390] Generating random seeds ... DONE
[15:32:13.391] Will set RNG state on exit: 10407, -521941550, 1961556877, 1359119798, -1504908237, 1316736112, -1477704665
[15:32:13.395] Number of chunks: 2
[15:32:13.395] getGlobalsAndPackagesXApply() ...
[15:32:13.395]  - future.globals: TRUE
[15:32:13.395] getGlobalsAndPackages() ...
[15:32:13.396] Searching for globals...
[15:32:13.398] - globals found: [1] 'FUN'
[15:32:13.398] Searching for globals ... DONE
[15:32:13.398] Resolving globals: FALSE
[15:32:13.399] The total size of the 1 globals is 1.66 KiB (1704 bytes)
[15:32:13.399] The total size of the 1 globals exported for future expression ('FUN(y = 3:4)') is 1.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.66 KiB of class 'function')
[15:32:13.400] - globals: [1] 'FUN'
[15:32:13.400] 
[15:32:13.400] getGlobalsAndPackages() ... DONE
[15:32:13.401]  - globals found/used: [n=1] 'FUN'
[15:32:13.401]  - needed namespaces: [n=0] 
[15:32:13.401] Finding globals ... DONE
[15:32:13.402] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:13.402] List of 2
[15:32:13.402]  $ ...future.FUN:function (x, y)  
[15:32:13.402]  $ MoreArgs     :List of 1
[15:32:13.402]   ..$ y: int [1:2] 3 4
[15:32:13.402]  - attr(*, "where")=List of 2
[15:32:13.402]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:13.402]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:13.402]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:13.402]  - attr(*, "resolved")= logi FALSE
[15:32:13.402]  - attr(*, "total_size")= num NA
[15:32:13.407] Packages to be attached in all futures: [n=0] 
[15:32:13.407] getGlobalsAndPackagesXApply() ... DONE
[15:32:13.408] Number of futures (= number of chunks): 2
[15:32:13.408] Launching 2 futures (chunks) ...
[15:32:13.408] Chunk #1 of 2 ...
[15:32:13.409]  - Finding globals in '...' for chunk #1 ...
[15:32:13.409] getGlobalsAndPackages() ...
[15:32:13.409] Searching for globals...
[15:32:13.410] 
[15:32:13.410] Searching for globals ... DONE
[15:32:13.410] - globals: [0] <none>
[15:32:13.411] getGlobalsAndPackages() ... DONE
[15:32:13.411]    + additional globals found: [n=0] 
[15:32:13.411]    + additional namespaces needed: [n=0] 
[15:32:13.411]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:13.412]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.412]  - seeds: [1] <seeds>
[15:32:13.412]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.413] getGlobalsAndPackages() ...
[15:32:13.413] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.413] Resolving globals: FALSE
[15:32:13.414] The total size of the 5 globals is 1.85 KiB (1896 bytes)
[15:32:13.415] 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 1.85 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), '...future.seeds_ii' (80 bytes of class 'list') and 'MoreArgs' (56 bytes of class 'list')
[15:32:13.415] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.416] 
[15:32:13.416] getGlobalsAndPackages() ... DONE
[15:32:13.416] run() for 'Future' ...
[15:32:13.417] - state: 'created'
[15:32:13.417] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.435] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.436] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.436]   - Field: 'node'
[15:32:13.437]   - Field: 'label'
[15:32:13.437]   - Field: 'local'
[15:32:13.437]   - Field: 'owner'
[15:32:13.437]   - Field: 'envir'
[15:32:13.438]   - Field: 'workers'
[15:32:13.438]   - Field: 'packages'
[15:32:13.438]   - Field: 'gc'
[15:32:13.438]   - Field: 'conditions'
[15:32:13.439]   - Field: 'persistent'
[15:32:13.439]   - Field: 'expr'
[15:32:13.439]   - Field: 'uuid'
[15:32:13.439]   - Field: 'seed'
[15:32:13.440]   - Field: 'version'
[15:32:13.440]   - Field: 'result'
[15:32:13.440]   - Field: 'asynchronous'
[15:32:13.440]   - Field: 'calls'
[15:32:13.441]   - Field: 'globals'
[15:32:13.441]   - Field: 'stdout'
[15:32:13.441]   - Field: 'earlySignal'
[15:32:13.442]   - Field: 'lazy'
[15:32:13.442]   - Field: 'state'
[15:32:13.442] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.442] - Launch lazy future ...
[15:32:13.443] Packages needed by the future expression (n = 0): <none>
[15:32:13.443] Packages needed by future strategies (n = 0): <none>
[15:32:13.444] {
[15:32:13.444]     {
[15:32:13.444]         {
[15:32:13.444]             ...future.startTime <- base::Sys.time()
[15:32:13.444]             {
[15:32:13.444]                 {
[15:32:13.444]                   {
[15:32:13.444]                     {
[15:32:13.444]                       base::local({
[15:32:13.444]                         has_future <- base::requireNamespace("future", 
[15:32:13.444]                           quietly = TRUE)
[15:32:13.444]                         if (has_future) {
[15:32:13.444]                           ns <- base::getNamespace("future")
[15:32:13.444]                           version <- ns[[".package"]][["version"]]
[15:32:13.444]                           if (is.null(version)) 
[15:32:13.444]                             version <- utils::packageVersion("future")
[15:32:13.444]                         }
[15:32:13.444]                         else {
[15:32:13.444]                           version <- NULL
[15:32:13.444]                         }
[15:32:13.444]                         if (!has_future || version < "1.8.0") {
[15:32:13.444]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.444]                             "", base::R.version$version.string), 
[15:32:13.444]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.444]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.444]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.444]                               "release", "version")], collapse = " "), 
[15:32:13.444]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.444]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.444]                             info)
[15:32:13.444]                           info <- base::paste(info, collapse = "; ")
[15:32:13.444]                           if (!has_future) {
[15:32:13.444]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.444]                               info)
[15:32:13.444]                           }
[15:32:13.444]                           else {
[15:32:13.444]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.444]                               info, version)
[15:32:13.444]                           }
[15:32:13.444]                           base::stop(msg)
[15:32:13.444]                         }
[15:32:13.444]                       })
[15:32:13.444]                     }
[15:32:13.444]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.444]                     base::options(mc.cores = 1L)
[15:32:13.444]                   }
[15:32:13.444]                   ...future.strategy.old <- future::plan("list")
[15:32:13.444]                   options(future.plan = NULL)
[15:32:13.444]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.444]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.444]                 }
[15:32:13.444]                 ...future.workdir <- getwd()
[15:32:13.444]             }
[15:32:13.444]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.444]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.444]         }
[15:32:13.444]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.444]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.444]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.444]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.444]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.444]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.444]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.444]             base::names(...future.oldOptions))
[15:32:13.444]     }
[15:32:13.444]     if (FALSE) {
[15:32:13.444]     }
[15:32:13.444]     else {
[15:32:13.444]         if (TRUE) {
[15:32:13.444]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.444]                 open = "w")
[15:32:13.444]         }
[15:32:13.444]         else {
[15:32:13.444]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.444]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.444]         }
[15:32:13.444]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.444]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.444]             base::sink(type = "output", split = FALSE)
[15:32:13.444]             base::close(...future.stdout)
[15:32:13.444]         }, add = TRUE)
[15:32:13.444]     }
[15:32:13.444]     ...future.frame <- base::sys.nframe()
[15:32:13.444]     ...future.conditions <- base::list()
[15:32:13.444]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.444]     if (FALSE) {
[15:32:13.444]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.444]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.444]     }
[15:32:13.444]     ...future.result <- base::tryCatch({
[15:32:13.444]         base::withCallingHandlers({
[15:32:13.444]             ...future.value <- base::withVisible(base::local({
[15:32:13.444]                 ...future.makeSendCondition <- base::local({
[15:32:13.444]                   sendCondition <- NULL
[15:32:13.444]                   function(frame = 1L) {
[15:32:13.444]                     if (is.function(sendCondition)) 
[15:32:13.444]                       return(sendCondition)
[15:32:13.444]                     ns <- getNamespace("parallel")
[15:32:13.444]                     if (exists("sendData", mode = "function", 
[15:32:13.444]                       envir = ns)) {
[15:32:13.444]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.444]                         envir = ns)
[15:32:13.444]                       envir <- sys.frame(frame)
[15:32:13.444]                       master <- NULL
[15:32:13.444]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.444]                         !identical(envir, emptyenv())) {
[15:32:13.444]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.444]                           inherits = FALSE)) {
[15:32:13.444]                           master <- get("master", mode = "list", 
[15:32:13.444]                             envir = envir, inherits = FALSE)
[15:32:13.444]                           if (inherits(master, c("SOCKnode", 
[15:32:13.444]                             "SOCK0node"))) {
[15:32:13.444]                             sendCondition <<- function(cond) {
[15:32:13.444]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.444]                                 success = TRUE)
[15:32:13.444]                               parallel_sendData(master, data)
[15:32:13.444]                             }
[15:32:13.444]                             return(sendCondition)
[15:32:13.444]                           }
[15:32:13.444]                         }
[15:32:13.444]                         frame <- frame + 1L
[15:32:13.444]                         envir <- sys.frame(frame)
[15:32:13.444]                       }
[15:32:13.444]                     }
[15:32:13.444]                     sendCondition <<- function(cond) NULL
[15:32:13.444]                   }
[15:32:13.444]                 })
[15:32:13.444]                 withCallingHandlers({
[15:32:13.444]                   {
[15:32:13.444]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.444]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.444]                       ...future.globals.maxSize)) {
[15:32:13.444]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.444]                       on.exit(options(oopts), add = TRUE)
[15:32:13.444]                     }
[15:32:13.444]                     {
[15:32:13.444]                       ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:13.444]                         assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:13.444]                           envir = globalenv(), inherits = FALSE)
[15:32:13.444]                         ...future.FUN(...)
[15:32:13.444]                       }
[15:32:13.444]                       args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:13.444]                         list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:13.444]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.444]                         USE.NAMES = FALSE)
[15:32:13.444]                       do.call(mapply, args = args)
[15:32:13.444]                     }
[15:32:13.444]                   }
[15:32:13.444]                 }, immediateCondition = function(cond) {
[15:32:13.444]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.444]                   sendCondition(cond)
[15:32:13.444]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.444]                   {
[15:32:13.444]                     inherits <- base::inherits
[15:32:13.444]                     invokeRestart <- base::invokeRestart
[15:32:13.444]                     is.null <- base::is.null
[15:32:13.444]                     muffled <- FALSE
[15:32:13.444]                     if (inherits(cond, "message")) {
[15:32:13.444]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.444]                       if (muffled) 
[15:32:13.444]                         invokeRestart("muffleMessage")
[15:32:13.444]                     }
[15:32:13.444]                     else if (inherits(cond, "warning")) {
[15:32:13.444]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.444]                       if (muffled) 
[15:32:13.444]                         invokeRestart("muffleWarning")
[15:32:13.444]                     }
[15:32:13.444]                     else if (inherits(cond, "condition")) {
[15:32:13.444]                       if (!is.null(pattern)) {
[15:32:13.444]                         computeRestarts <- base::computeRestarts
[15:32:13.444]                         grepl <- base::grepl
[15:32:13.444]                         restarts <- computeRestarts(cond)
[15:32:13.444]                         for (restart in restarts) {
[15:32:13.444]                           name <- restart$name
[15:32:13.444]                           if (is.null(name)) 
[15:32:13.444]                             next
[15:32:13.444]                           if (!grepl(pattern, name)) 
[15:32:13.444]                             next
[15:32:13.444]                           invokeRestart(restart)
[15:32:13.444]                           muffled <- TRUE
[15:32:13.444]                           break
[15:32:13.444]                         }
[15:32:13.444]                       }
[15:32:13.444]                     }
[15:32:13.444]                     invisible(muffled)
[15:32:13.444]                   }
[15:32:13.444]                   muffleCondition(cond)
[15:32:13.444]                 })
[15:32:13.444]             }))
[15:32:13.444]             future::FutureResult(value = ...future.value$value, 
[15:32:13.444]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.444]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.444]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.444]                     ...future.globalenv.names))
[15:32:13.444]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.444]         }, condition = base::local({
[15:32:13.444]             c <- base::c
[15:32:13.444]             inherits <- base::inherits
[15:32:13.444]             invokeRestart <- base::invokeRestart
[15:32:13.444]             length <- base::length
[15:32:13.444]             list <- base::list
[15:32:13.444]             seq.int <- base::seq.int
[15:32:13.444]             signalCondition <- base::signalCondition
[15:32:13.444]             sys.calls <- base::sys.calls
[15:32:13.444]             `[[` <- base::`[[`
[15:32:13.444]             `+` <- base::`+`
[15:32:13.444]             `<<-` <- base::`<<-`
[15:32:13.444]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.444]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.444]                   3L)]
[15:32:13.444]             }
[15:32:13.444]             function(cond) {
[15:32:13.444]                 is_error <- inherits(cond, "error")
[15:32:13.444]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.444]                   NULL)
[15:32:13.444]                 if (is_error) {
[15:32:13.444]                   sessionInformation <- function() {
[15:32:13.444]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.444]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.444]                       search = base::search(), system = base::Sys.info())
[15:32:13.444]                   }
[15:32:13.444]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.444]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.444]                     cond$call), session = sessionInformation(), 
[15:32:13.444]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.444]                   signalCondition(cond)
[15:32:13.444]                 }
[15:32:13.444]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.444]                 "immediateCondition"))) {
[15:32:13.444]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.444]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.444]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.444]                   if (TRUE && !signal) {
[15:32:13.444]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.444]                     {
[15:32:13.444]                       inherits <- base::inherits
[15:32:13.444]                       invokeRestart <- base::invokeRestart
[15:32:13.444]                       is.null <- base::is.null
[15:32:13.444]                       muffled <- FALSE
[15:32:13.444]                       if (inherits(cond, "message")) {
[15:32:13.444]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.444]                         if (muffled) 
[15:32:13.444]                           invokeRestart("muffleMessage")
[15:32:13.444]                       }
[15:32:13.444]                       else if (inherits(cond, "warning")) {
[15:32:13.444]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.444]                         if (muffled) 
[15:32:13.444]                           invokeRestart("muffleWarning")
[15:32:13.444]                       }
[15:32:13.444]                       else if (inherits(cond, "condition")) {
[15:32:13.444]                         if (!is.null(pattern)) {
[15:32:13.444]                           computeRestarts <- base::computeRestarts
[15:32:13.444]                           grepl <- base::grepl
[15:32:13.444]                           restarts <- computeRestarts(cond)
[15:32:13.444]                           for (restart in restarts) {
[15:32:13.444]                             name <- restart$name
[15:32:13.444]                             if (is.null(name)) 
[15:32:13.444]                               next
[15:32:13.444]                             if (!grepl(pattern, name)) 
[15:32:13.444]                               next
[15:32:13.444]                             invokeRestart(restart)
[15:32:13.444]                             muffled <- TRUE
[15:32:13.444]                             break
[15:32:13.444]                           }
[15:32:13.444]                         }
[15:32:13.444]                       }
[15:32:13.444]                       invisible(muffled)
[15:32:13.444]                     }
[15:32:13.444]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.444]                   }
[15:32:13.444]                 }
[15:32:13.444]                 else {
[15:32:13.444]                   if (TRUE) {
[15:32:13.444]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.444]                     {
[15:32:13.444]                       inherits <- base::inherits
[15:32:13.444]                       invokeRestart <- base::invokeRestart
[15:32:13.444]                       is.null <- base::is.null
[15:32:13.444]                       muffled <- FALSE
[15:32:13.444]                       if (inherits(cond, "message")) {
[15:32:13.444]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.444]                         if (muffled) 
[15:32:13.444]                           invokeRestart("muffleMessage")
[15:32:13.444]                       }
[15:32:13.444]                       else if (inherits(cond, "warning")) {
[15:32:13.444]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.444]                         if (muffled) 
[15:32:13.444]                           invokeRestart("muffleWarning")
[15:32:13.444]                       }
[15:32:13.444]                       else if (inherits(cond, "condition")) {
[15:32:13.444]                         if (!is.null(pattern)) {
[15:32:13.444]                           computeRestarts <- base::computeRestarts
[15:32:13.444]                           grepl <- base::grepl
[15:32:13.444]                           restarts <- computeRestarts(cond)
[15:32:13.444]                           for (restart in restarts) {
[15:32:13.444]                             name <- restart$name
[15:32:13.444]                             if (is.null(name)) 
[15:32:13.444]                               next
[15:32:13.444]                             if (!grepl(pattern, name)) 
[15:32:13.444]                               next
[15:32:13.444]                             invokeRestart(restart)
[15:32:13.444]                             muffled <- TRUE
[15:32:13.444]                             break
[15:32:13.444]                           }
[15:32:13.444]                         }
[15:32:13.444]                       }
[15:32:13.444]                       invisible(muffled)
[15:32:13.444]                     }
[15:32:13.444]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.444]                   }
[15:32:13.444]                 }
[15:32:13.444]             }
[15:32:13.444]         }))
[15:32:13.444]     }, error = function(ex) {
[15:32:13.444]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.444]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.444]                 ...future.rng), started = ...future.startTime, 
[15:32:13.444]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.444]             version = "1.8"), class = "FutureResult")
[15:32:13.444]     }, finally = {
[15:32:13.444]         if (!identical(...future.workdir, getwd())) 
[15:32:13.444]             setwd(...future.workdir)
[15:32:13.444]         {
[15:32:13.444]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.444]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.444]             }
[15:32:13.444]             base::options(...future.oldOptions)
[15:32:13.444]             if (.Platform$OS.type == "windows") {
[15:32:13.444]                 old_names <- names(...future.oldEnvVars)
[15:32:13.444]                 envs <- base::Sys.getenv()
[15:32:13.444]                 names <- names(envs)
[15:32:13.444]                 common <- intersect(names, old_names)
[15:32:13.444]                 added <- setdiff(names, old_names)
[15:32:13.444]                 removed <- setdiff(old_names, names)
[15:32:13.444]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.444]                   envs[common]]
[15:32:13.444]                 NAMES <- toupper(changed)
[15:32:13.444]                 args <- list()
[15:32:13.444]                 for (kk in seq_along(NAMES)) {
[15:32:13.444]                   name <- changed[[kk]]
[15:32:13.444]                   NAME <- NAMES[[kk]]
[15:32:13.444]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.444]                     next
[15:32:13.444]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.444]                 }
[15:32:13.444]                 NAMES <- toupper(added)
[15:32:13.444]                 for (kk in seq_along(NAMES)) {
[15:32:13.444]                   name <- added[[kk]]
[15:32:13.444]                   NAME <- NAMES[[kk]]
[15:32:13.444]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.444]                     next
[15:32:13.444]                   args[[name]] <- ""
[15:32:13.444]                 }
[15:32:13.444]                 NAMES <- toupper(removed)
[15:32:13.444]                 for (kk in seq_along(NAMES)) {
[15:32:13.444]                   name <- removed[[kk]]
[15:32:13.444]                   NAME <- NAMES[[kk]]
[15:32:13.444]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.444]                     next
[15:32:13.444]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.444]                 }
[15:32:13.444]                 if (length(args) > 0) 
[15:32:13.444]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.444]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.444]             }
[15:32:13.444]             else {
[15:32:13.444]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.444]             }
[15:32:13.444]             {
[15:32:13.444]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.444]                   0L) {
[15:32:13.444]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.444]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.444]                   base::options(opts)
[15:32:13.444]                 }
[15:32:13.444]                 {
[15:32:13.444]                   {
[15:32:13.444]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.444]                     NULL
[15:32:13.444]                   }
[15:32:13.444]                   options(future.plan = NULL)
[15:32:13.444]                   if (is.na(NA_character_)) 
[15:32:13.444]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.444]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.444]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.444]                     .init = FALSE)
[15:32:13.444]                 }
[15:32:13.444]             }
[15:32:13.444]         }
[15:32:13.444]     })
[15:32:13.444]     if (TRUE) {
[15:32:13.444]         base::sink(type = "output", split = FALSE)
[15:32:13.444]         if (TRUE) {
[15:32:13.444]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.444]         }
[15:32:13.444]         else {
[15:32:13.444]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.444]         }
[15:32:13.444]         base::close(...future.stdout)
[15:32:13.444]         ...future.stdout <- NULL
[15:32:13.444]     }
[15:32:13.444]     ...future.result$conditions <- ...future.conditions
[15:32:13.444]     ...future.result$finished <- base::Sys.time()
[15:32:13.444]     ...future.result
[15:32:13.444] }
[15:32:13.453] Exporting 5 global objects (1.85 KiB) to cluster node #1 ...
[15:32:13.454] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ...
[15:32:13.455] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ... DONE
[15:32:13.455] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:13.456] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:13.456] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:13.457] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:13.458] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ...
[15:32:13.458] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ... DONE
[15:32:13.459] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.460] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.460] Exporting 5 global objects (1.85 KiB) to cluster node #1 ... DONE
[15:32:13.461] MultisessionFuture started
[15:32:13.462] - Launch lazy future ... done
[15:32:13.462] run() for 'MultisessionFuture' ... done
[15:32:13.462] Created future:
[15:32:13.485] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.485] - Validating connection of MultisessionFuture
[15:32:13.486] - received message: FutureResult
[15:32:13.486] - Received FutureResult
[15:32:13.486] - Erased future from FutureRegistry
[15:32:13.486] result() for ClusterFuture ...
[15:32:13.487] - result already collected: FutureResult
[15:32:13.487] result() for ClusterFuture ... done
[15:32:13.487] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.463] MultisessionFuture:
[15:32:13.463] Label: 'future_mapply-1'
[15:32:13.463] Expression:
[15:32:13.463] {
[15:32:13.463]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.463]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.463]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.463]         on.exit(options(oopts), add = TRUE)
[15:32:13.463]     }
[15:32:13.463]     {
[15:32:13.463]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:13.463]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:13.463]                 inherits = FALSE)
[15:32:13.463]             ...future.FUN(...)
[15:32:13.463]         }
[15:32:13.463]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:13.463]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:13.463]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.463]         do.call(mapply, args = args)
[15:32:13.463]     }
[15:32:13.463] }
[15:32:13.463] Lazy evaluation: FALSE
[15:32:13.463] Asynchronous evaluation: TRUE
[15:32:13.463] Local evaluation: TRUE
[15:32:13.463] Environment: R_GlobalEnv
[15:32:13.463] Capture standard output: TRUE
[15:32:13.463] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.463] Globals: 5 objects totaling 1.85 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 56 bytes, list '...future.seeds_ii' of 80 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.463] Packages: <none>
[15:32:13.463] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:13.463] Resolved: TRUE
[15:32:13.463] Value: <not collected>
[15:32:13.463] Conditions captured: <none>
[15:32:13.463] Early signaling: FALSE
[15:32:13.463] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.463] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.488] Chunk #1 of 2 ... DONE
[15:32:13.488] Chunk #2 of 2 ...
[15:32:13.488]  - Finding globals in '...' for chunk #2 ...
[15:32:13.489] getGlobalsAndPackages() ...
[15:32:13.489] Searching for globals...
[15:32:13.489] 
[15:32:13.489] Searching for globals ... DONE
[15:32:13.490] - globals: [0] <none>
[15:32:13.490] getGlobalsAndPackages() ... DONE
[15:32:13.490]    + additional globals found: [n=0] 
[15:32:13.490]    + additional namespaces needed: [n=0] 
[15:32:13.490]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:13.491]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.491]  - seeds: [1] <seeds>
[15:32:13.491]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.491] getGlobalsAndPackages() ...
[15:32:13.491] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.492] Resolving globals: FALSE
[15:32:13.492] The total size of the 5 globals is 1.85 KiB (1896 bytes)
[15:32:13.493] 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 1.85 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), '...future.seeds_ii' (80 bytes of class 'list') and 'MoreArgs' (56 bytes of class 'list')
[15:32:13.494] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.494] 
[15:32:13.494] getGlobalsAndPackages() ... DONE
[15:32:13.495] run() for 'Future' ...
[15:32:13.495] - state: 'created'
[15:32:13.495] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.511] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.512] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.512]   - Field: 'node'
[15:32:13.513]   - Field: 'label'
[15:32:13.513]   - Field: 'local'
[15:32:13.513]   - Field: 'owner'
[15:32:13.514]   - Field: 'envir'
[15:32:13.514]   - Field: 'workers'
[15:32:13.514]   - Field: 'packages'
[15:32:13.515]   - Field: 'gc'
[15:32:13.515]   - Field: 'conditions'
[15:32:13.515]   - Field: 'persistent'
[15:32:13.516]   - Field: 'expr'
[15:32:13.516]   - Field: 'uuid'
[15:32:13.516]   - Field: 'seed'
[15:32:13.517]   - Field: 'version'
[15:32:13.517]   - Field: 'result'
[15:32:13.517]   - Field: 'asynchronous'
[15:32:13.518]   - Field: 'calls'
[15:32:13.518]   - Field: 'globals'
[15:32:13.518]   - Field: 'stdout'
[15:32:13.518]   - Field: 'earlySignal'
[15:32:13.519]   - Field: 'lazy'
[15:32:13.519]   - Field: 'state'
[15:32:13.519] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.519] - Launch lazy future ...
[15:32:13.520] Packages needed by the future expression (n = 0): <none>
[15:32:13.521] Packages needed by future strategies (n = 0): <none>
[15:32:13.522] {
[15:32:13.522]     {
[15:32:13.522]         {
[15:32:13.522]             ...future.startTime <- base::Sys.time()
[15:32:13.522]             {
[15:32:13.522]                 {
[15:32:13.522]                   {
[15:32:13.522]                     {
[15:32:13.522]                       base::local({
[15:32:13.522]                         has_future <- base::requireNamespace("future", 
[15:32:13.522]                           quietly = TRUE)
[15:32:13.522]                         if (has_future) {
[15:32:13.522]                           ns <- base::getNamespace("future")
[15:32:13.522]                           version <- ns[[".package"]][["version"]]
[15:32:13.522]                           if (is.null(version)) 
[15:32:13.522]                             version <- utils::packageVersion("future")
[15:32:13.522]                         }
[15:32:13.522]                         else {
[15:32:13.522]                           version <- NULL
[15:32:13.522]                         }
[15:32:13.522]                         if (!has_future || version < "1.8.0") {
[15:32:13.522]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.522]                             "", base::R.version$version.string), 
[15:32:13.522]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.522]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.522]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.522]                               "release", "version")], collapse = " "), 
[15:32:13.522]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.522]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.522]                             info)
[15:32:13.522]                           info <- base::paste(info, collapse = "; ")
[15:32:13.522]                           if (!has_future) {
[15:32:13.522]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.522]                               info)
[15:32:13.522]                           }
[15:32:13.522]                           else {
[15:32:13.522]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.522]                               info, version)
[15:32:13.522]                           }
[15:32:13.522]                           base::stop(msg)
[15:32:13.522]                         }
[15:32:13.522]                       })
[15:32:13.522]                     }
[15:32:13.522]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.522]                     base::options(mc.cores = 1L)
[15:32:13.522]                   }
[15:32:13.522]                   ...future.strategy.old <- future::plan("list")
[15:32:13.522]                   options(future.plan = NULL)
[15:32:13.522]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.522]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.522]                 }
[15:32:13.522]                 ...future.workdir <- getwd()
[15:32:13.522]             }
[15:32:13.522]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.522]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.522]         }
[15:32:13.522]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.522]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.522]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.522]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.522]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.522]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.522]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.522]             base::names(...future.oldOptions))
[15:32:13.522]     }
[15:32:13.522]     if (FALSE) {
[15:32:13.522]     }
[15:32:13.522]     else {
[15:32:13.522]         if (TRUE) {
[15:32:13.522]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.522]                 open = "w")
[15:32:13.522]         }
[15:32:13.522]         else {
[15:32:13.522]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.522]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.522]         }
[15:32:13.522]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.522]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.522]             base::sink(type = "output", split = FALSE)
[15:32:13.522]             base::close(...future.stdout)
[15:32:13.522]         }, add = TRUE)
[15:32:13.522]     }
[15:32:13.522]     ...future.frame <- base::sys.nframe()
[15:32:13.522]     ...future.conditions <- base::list()
[15:32:13.522]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.522]     if (FALSE) {
[15:32:13.522]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.522]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.522]     }
[15:32:13.522]     ...future.result <- base::tryCatch({
[15:32:13.522]         base::withCallingHandlers({
[15:32:13.522]             ...future.value <- base::withVisible(base::local({
[15:32:13.522]                 ...future.makeSendCondition <- base::local({
[15:32:13.522]                   sendCondition <- NULL
[15:32:13.522]                   function(frame = 1L) {
[15:32:13.522]                     if (is.function(sendCondition)) 
[15:32:13.522]                       return(sendCondition)
[15:32:13.522]                     ns <- getNamespace("parallel")
[15:32:13.522]                     if (exists("sendData", mode = "function", 
[15:32:13.522]                       envir = ns)) {
[15:32:13.522]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.522]                         envir = ns)
[15:32:13.522]                       envir <- sys.frame(frame)
[15:32:13.522]                       master <- NULL
[15:32:13.522]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.522]                         !identical(envir, emptyenv())) {
[15:32:13.522]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.522]                           inherits = FALSE)) {
[15:32:13.522]                           master <- get("master", mode = "list", 
[15:32:13.522]                             envir = envir, inherits = FALSE)
[15:32:13.522]                           if (inherits(master, c("SOCKnode", 
[15:32:13.522]                             "SOCK0node"))) {
[15:32:13.522]                             sendCondition <<- function(cond) {
[15:32:13.522]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.522]                                 success = TRUE)
[15:32:13.522]                               parallel_sendData(master, data)
[15:32:13.522]                             }
[15:32:13.522]                             return(sendCondition)
[15:32:13.522]                           }
[15:32:13.522]                         }
[15:32:13.522]                         frame <- frame + 1L
[15:32:13.522]                         envir <- sys.frame(frame)
[15:32:13.522]                       }
[15:32:13.522]                     }
[15:32:13.522]                     sendCondition <<- function(cond) NULL
[15:32:13.522]                   }
[15:32:13.522]                 })
[15:32:13.522]                 withCallingHandlers({
[15:32:13.522]                   {
[15:32:13.522]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.522]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.522]                       ...future.globals.maxSize)) {
[15:32:13.522]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.522]                       on.exit(options(oopts), add = TRUE)
[15:32:13.522]                     }
[15:32:13.522]                     {
[15:32:13.522]                       ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:13.522]                         assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:13.522]                           envir = globalenv(), inherits = FALSE)
[15:32:13.522]                         ...future.FUN(...)
[15:32:13.522]                       }
[15:32:13.522]                       args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:13.522]                         list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:13.522]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.522]                         USE.NAMES = FALSE)
[15:32:13.522]                       do.call(mapply, args = args)
[15:32:13.522]                     }
[15:32:13.522]                   }
[15:32:13.522]                 }, immediateCondition = function(cond) {
[15:32:13.522]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.522]                   sendCondition(cond)
[15:32:13.522]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.522]                   {
[15:32:13.522]                     inherits <- base::inherits
[15:32:13.522]                     invokeRestart <- base::invokeRestart
[15:32:13.522]                     is.null <- base::is.null
[15:32:13.522]                     muffled <- FALSE
[15:32:13.522]                     if (inherits(cond, "message")) {
[15:32:13.522]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.522]                       if (muffled) 
[15:32:13.522]                         invokeRestart("muffleMessage")
[15:32:13.522]                     }
[15:32:13.522]                     else if (inherits(cond, "warning")) {
[15:32:13.522]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.522]                       if (muffled) 
[15:32:13.522]                         invokeRestart("muffleWarning")
[15:32:13.522]                     }
[15:32:13.522]                     else if (inherits(cond, "condition")) {
[15:32:13.522]                       if (!is.null(pattern)) {
[15:32:13.522]                         computeRestarts <- base::computeRestarts
[15:32:13.522]                         grepl <- base::grepl
[15:32:13.522]                         restarts <- computeRestarts(cond)
[15:32:13.522]                         for (restart in restarts) {
[15:32:13.522]                           name <- restart$name
[15:32:13.522]                           if (is.null(name)) 
[15:32:13.522]                             next
[15:32:13.522]                           if (!grepl(pattern, name)) 
[15:32:13.522]                             next
[15:32:13.522]                           invokeRestart(restart)
[15:32:13.522]                           muffled <- TRUE
[15:32:13.522]                           break
[15:32:13.522]                         }
[15:32:13.522]                       }
[15:32:13.522]                     }
[15:32:13.522]                     invisible(muffled)
[15:32:13.522]                   }
[15:32:13.522]                   muffleCondition(cond)
[15:32:13.522]                 })
[15:32:13.522]             }))
[15:32:13.522]             future::FutureResult(value = ...future.value$value, 
[15:32:13.522]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.522]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.522]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.522]                     ...future.globalenv.names))
[15:32:13.522]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.522]         }, condition = base::local({
[15:32:13.522]             c <- base::c
[15:32:13.522]             inherits <- base::inherits
[15:32:13.522]             invokeRestart <- base::invokeRestart
[15:32:13.522]             length <- base::length
[15:32:13.522]             list <- base::list
[15:32:13.522]             seq.int <- base::seq.int
[15:32:13.522]             signalCondition <- base::signalCondition
[15:32:13.522]             sys.calls <- base::sys.calls
[15:32:13.522]             `[[` <- base::`[[`
[15:32:13.522]             `+` <- base::`+`
[15:32:13.522]             `<<-` <- base::`<<-`
[15:32:13.522]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.522]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.522]                   3L)]
[15:32:13.522]             }
[15:32:13.522]             function(cond) {
[15:32:13.522]                 is_error <- inherits(cond, "error")
[15:32:13.522]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.522]                   NULL)
[15:32:13.522]                 if (is_error) {
[15:32:13.522]                   sessionInformation <- function() {
[15:32:13.522]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.522]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.522]                       search = base::search(), system = base::Sys.info())
[15:32:13.522]                   }
[15:32:13.522]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.522]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.522]                     cond$call), session = sessionInformation(), 
[15:32:13.522]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.522]                   signalCondition(cond)
[15:32:13.522]                 }
[15:32:13.522]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.522]                 "immediateCondition"))) {
[15:32:13.522]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.522]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.522]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.522]                   if (TRUE && !signal) {
[15:32:13.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.522]                     {
[15:32:13.522]                       inherits <- base::inherits
[15:32:13.522]                       invokeRestart <- base::invokeRestart
[15:32:13.522]                       is.null <- base::is.null
[15:32:13.522]                       muffled <- FALSE
[15:32:13.522]                       if (inherits(cond, "message")) {
[15:32:13.522]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.522]                         if (muffled) 
[15:32:13.522]                           invokeRestart("muffleMessage")
[15:32:13.522]                       }
[15:32:13.522]                       else if (inherits(cond, "warning")) {
[15:32:13.522]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.522]                         if (muffled) 
[15:32:13.522]                           invokeRestart("muffleWarning")
[15:32:13.522]                       }
[15:32:13.522]                       else if (inherits(cond, "condition")) {
[15:32:13.522]                         if (!is.null(pattern)) {
[15:32:13.522]                           computeRestarts <- base::computeRestarts
[15:32:13.522]                           grepl <- base::grepl
[15:32:13.522]                           restarts <- computeRestarts(cond)
[15:32:13.522]                           for (restart in restarts) {
[15:32:13.522]                             name <- restart$name
[15:32:13.522]                             if (is.null(name)) 
[15:32:13.522]                               next
[15:32:13.522]                             if (!grepl(pattern, name)) 
[15:32:13.522]                               next
[15:32:13.522]                             invokeRestart(restart)
[15:32:13.522]                             muffled <- TRUE
[15:32:13.522]                             break
[15:32:13.522]                           }
[15:32:13.522]                         }
[15:32:13.522]                       }
[15:32:13.522]                       invisible(muffled)
[15:32:13.522]                     }
[15:32:13.522]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.522]                   }
[15:32:13.522]                 }
[15:32:13.522]                 else {
[15:32:13.522]                   if (TRUE) {
[15:32:13.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.522]                     {
[15:32:13.522]                       inherits <- base::inherits
[15:32:13.522]                       invokeRestart <- base::invokeRestart
[15:32:13.522]                       is.null <- base::is.null
[15:32:13.522]                       muffled <- FALSE
[15:32:13.522]                       if (inherits(cond, "message")) {
[15:32:13.522]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.522]                         if (muffled) 
[15:32:13.522]                           invokeRestart("muffleMessage")
[15:32:13.522]                       }
[15:32:13.522]                       else if (inherits(cond, "warning")) {
[15:32:13.522]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.522]                         if (muffled) 
[15:32:13.522]                           invokeRestart("muffleWarning")
[15:32:13.522]                       }
[15:32:13.522]                       else if (inherits(cond, "condition")) {
[15:32:13.522]                         if (!is.null(pattern)) {
[15:32:13.522]                           computeRestarts <- base::computeRestarts
[15:32:13.522]                           grepl <- base::grepl
[15:32:13.522]                           restarts <- computeRestarts(cond)
[15:32:13.522]                           for (restart in restarts) {
[15:32:13.522]                             name <- restart$name
[15:32:13.522]                             if (is.null(name)) 
[15:32:13.522]                               next
[15:32:13.522]                             if (!grepl(pattern, name)) 
[15:32:13.522]                               next
[15:32:13.522]                             invokeRestart(restart)
[15:32:13.522]                             muffled <- TRUE
[15:32:13.522]                             break
[15:32:13.522]                           }
[15:32:13.522]                         }
[15:32:13.522]                       }
[15:32:13.522]                       invisible(muffled)
[15:32:13.522]                     }
[15:32:13.522]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.522]                   }
[15:32:13.522]                 }
[15:32:13.522]             }
[15:32:13.522]         }))
[15:32:13.522]     }, error = function(ex) {
[15:32:13.522]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.522]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.522]                 ...future.rng), started = ...future.startTime, 
[15:32:13.522]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.522]             version = "1.8"), class = "FutureResult")
[15:32:13.522]     }, finally = {
[15:32:13.522]         if (!identical(...future.workdir, getwd())) 
[15:32:13.522]             setwd(...future.workdir)
[15:32:13.522]         {
[15:32:13.522]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.522]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.522]             }
[15:32:13.522]             base::options(...future.oldOptions)
[15:32:13.522]             if (.Platform$OS.type == "windows") {
[15:32:13.522]                 old_names <- names(...future.oldEnvVars)
[15:32:13.522]                 envs <- base::Sys.getenv()
[15:32:13.522]                 names <- names(envs)
[15:32:13.522]                 common <- intersect(names, old_names)
[15:32:13.522]                 added <- setdiff(names, old_names)
[15:32:13.522]                 removed <- setdiff(old_names, names)
[15:32:13.522]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.522]                   envs[common]]
[15:32:13.522]                 NAMES <- toupper(changed)
[15:32:13.522]                 args <- list()
[15:32:13.522]                 for (kk in seq_along(NAMES)) {
[15:32:13.522]                   name <- changed[[kk]]
[15:32:13.522]                   NAME <- NAMES[[kk]]
[15:32:13.522]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.522]                     next
[15:32:13.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.522]                 }
[15:32:13.522]                 NAMES <- toupper(added)
[15:32:13.522]                 for (kk in seq_along(NAMES)) {
[15:32:13.522]                   name <- added[[kk]]
[15:32:13.522]                   NAME <- NAMES[[kk]]
[15:32:13.522]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.522]                     next
[15:32:13.522]                   args[[name]] <- ""
[15:32:13.522]                 }
[15:32:13.522]                 NAMES <- toupper(removed)
[15:32:13.522]                 for (kk in seq_along(NAMES)) {
[15:32:13.522]                   name <- removed[[kk]]
[15:32:13.522]                   NAME <- NAMES[[kk]]
[15:32:13.522]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.522]                     next
[15:32:13.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.522]                 }
[15:32:13.522]                 if (length(args) > 0) 
[15:32:13.522]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.522]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.522]             }
[15:32:13.522]             else {
[15:32:13.522]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.522]             }
[15:32:13.522]             {
[15:32:13.522]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.522]                   0L) {
[15:32:13.522]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.522]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.522]                   base::options(opts)
[15:32:13.522]                 }
[15:32:13.522]                 {
[15:32:13.522]                   {
[15:32:13.522]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.522]                     NULL
[15:32:13.522]                   }
[15:32:13.522]                   options(future.plan = NULL)
[15:32:13.522]                   if (is.na(NA_character_)) 
[15:32:13.522]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.522]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.522]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.522]                     .init = FALSE)
[15:32:13.522]                 }
[15:32:13.522]             }
[15:32:13.522]         }
[15:32:13.522]     })
[15:32:13.522]     if (TRUE) {
[15:32:13.522]         base::sink(type = "output", split = FALSE)
[15:32:13.522]         if (TRUE) {
[15:32:13.522]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.522]         }
[15:32:13.522]         else {
[15:32:13.522]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.522]         }
[15:32:13.522]         base::close(...future.stdout)
[15:32:13.522]         ...future.stdout <- NULL
[15:32:13.522]     }
[15:32:13.522]     ...future.result$conditions <- ...future.conditions
[15:32:13.522]     ...future.result$finished <- base::Sys.time()
[15:32:13.522]     ...future.result
[15:32:13.522] }
[15:32:13.530] Exporting 5 global objects (1.85 KiB) to cluster node #1 ...
[15:32:13.530] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ...
[15:32:13.531] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ... DONE
[15:32:13.531] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:13.532] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:13.532] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:13.533] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:13.533] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ...
[15:32:13.534] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ... DONE
[15:32:13.534] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.534] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.535] Exporting 5 global objects (1.85 KiB) to cluster node #1 ... DONE
[15:32:13.536] MultisessionFuture started
[15:32:13.536] - Launch lazy future ... done
[15:32:13.537] run() for 'MultisessionFuture' ... done
[15:32:13.537] Created future:
[15:32:13.565] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.565] - Validating connection of MultisessionFuture
[15:32:13.566] - received message: FutureResult
[15:32:13.566] - Received FutureResult
[15:32:13.567] - Erased future from FutureRegistry
[15:32:13.567] result() for ClusterFuture ...
[15:32:13.567] - result already collected: FutureResult
[15:32:13.568] result() for ClusterFuture ... done
[15:32:13.568] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.537] MultisessionFuture:
[15:32:13.537] Label: 'future_mapply-2'
[15:32:13.537] Expression:
[15:32:13.537] {
[15:32:13.537]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.537]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.537]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.537]         on.exit(options(oopts), add = TRUE)
[15:32:13.537]     }
[15:32:13.537]     {
[15:32:13.537]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:13.537]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:13.537]                 inherits = FALSE)
[15:32:13.537]             ...future.FUN(...)
[15:32:13.537]         }
[15:32:13.537]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:13.537]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:13.537]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.537]         do.call(mapply, args = args)
[15:32:13.537]     }
[15:32:13.537] }
[15:32:13.537] Lazy evaluation: FALSE
[15:32:13.537] Asynchronous evaluation: TRUE
[15:32:13.537] Local evaluation: TRUE
[15:32:13.537] Environment: R_GlobalEnv
[15:32:13.537] Capture standard output: TRUE
[15:32:13.537] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.537] Globals: 5 objects totaling 1.85 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 56 bytes, list '...future.seeds_ii' of 80 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.537] Packages: <none>
[15:32:13.537] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:13.537] Resolved: TRUE
[15:32:13.537] Value: <not collected>
[15:32:13.537] Conditions captured: <none>
[15:32:13.537] Early signaling: FALSE
[15:32:13.537] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.537] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.569] Chunk #2 of 2 ... DONE
[15:32:13.569] Launching 2 futures (chunks) ... DONE
[15:32:13.570] Resolving 2 futures (chunks) ...
[15:32:13.570] resolve() on list ...
[15:32:13.570]  recursive: 0
[15:32:13.571]  length: 2
[15:32:13.571] 
[15:32:13.571] Future #1
[15:32:13.572] result() for ClusterFuture ...
[15:32:13.572] - result already collected: FutureResult
[15:32:13.572] result() for ClusterFuture ... done
[15:32:13.573] result() for ClusterFuture ...
[15:32:13.573] - result already collected: FutureResult
[15:32:13.573] result() for ClusterFuture ... done
[15:32:13.574] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:13.574] - nx: 2
[15:32:13.574] - relay: TRUE
[15:32:13.574] - stdout: TRUE
[15:32:13.575] - signal: TRUE
[15:32:13.575] - resignal: FALSE
[15:32:13.575] - force: TRUE
[15:32:13.576] - relayed: [n=2] FALSE, FALSE
[15:32:13.576] - queued futures: [n=2] FALSE, FALSE
[15:32:13.576]  - until=1
[15:32:13.577]  - relaying element #1
[15:32:13.577] result() for ClusterFuture ...
[15:32:13.577] - result already collected: FutureResult
[15:32:13.578] result() for ClusterFuture ... done
[15:32:13.578] result() for ClusterFuture ...
[15:32:13.578] - result already collected: FutureResult
[15:32:13.579] result() for ClusterFuture ... done
[15:32:13.579] result() for ClusterFuture ...
[15:32:13.579] - result already collected: FutureResult
[15:32:13.580] result() for ClusterFuture ... done
[15:32:13.580] result() for ClusterFuture ...
[15:32:13.580] - result already collected: FutureResult
[15:32:13.581] result() for ClusterFuture ... done
[15:32:13.581] - relayed: [n=2] TRUE, FALSE
[15:32:13.581] - queued futures: [n=2] TRUE, FALSE
[15:32:13.581] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:13.582]  length: 1 (resolved future 1)
[15:32:13.582] Future #2
[15:32:13.583] result() for ClusterFuture ...
[15:32:13.583] - result already collected: FutureResult
[15:32:13.583] result() for ClusterFuture ... done
[15:32:13.584] result() for ClusterFuture ...
[15:32:13.584] - result already collected: FutureResult
[15:32:13.584] result() for ClusterFuture ... done
[15:32:13.585] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:13.585] - nx: 2
[15:32:13.585] - relay: TRUE
[15:32:13.586] - stdout: TRUE
[15:32:13.586] - signal: TRUE
[15:32:13.586] - resignal: FALSE
[15:32:13.586] - force: TRUE
[15:32:13.587] - relayed: [n=2] TRUE, FALSE
[15:32:13.587] - queued futures: [n=2] TRUE, FALSE
[15:32:13.587]  - until=2
[15:32:13.588]  - relaying element #2
[15:32:13.588] result() for ClusterFuture ...
[15:32:13.588] - result already collected: FutureResult
[15:32:13.589] result() for ClusterFuture ... done
[15:32:13.589] result() for ClusterFuture ...
[15:32:13.589] - result already collected: FutureResult
[15:32:13.590] result() for ClusterFuture ... done
[15:32:13.590] result() for ClusterFuture ...
[15:32:13.590] - result already collected: FutureResult
[15:32:13.591] result() for ClusterFuture ... done
[15:32:13.591] result() for ClusterFuture ...
[15:32:13.591] - result already collected: FutureResult
[15:32:13.592] result() for ClusterFuture ... done
[15:32:13.592] - relayed: [n=2] TRUE, TRUE
[15:32:13.592] - queued futures: [n=2] TRUE, TRUE
[15:32:13.593] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:13.593]  length: 0 (resolved future 2)
[15:32:13.593] Relaying remaining futures
[15:32:13.594] signalConditionsASAP(NULL, pos=0) ...
[15:32:13.594] - nx: 2
[15:32:13.594] - relay: TRUE
[15:32:13.594] - stdout: TRUE
[15:32:13.595] - signal: TRUE
[15:32:13.595] - resignal: FALSE
[15:32:13.595] - force: TRUE
[15:32:13.596] - relayed: [n=2] TRUE, TRUE
[15:32:13.596] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:13.596] - relayed: [n=2] TRUE, TRUE
[15:32:13.597] - queued futures: [n=2] TRUE, TRUE
[15:32:13.597] signalConditionsASAP(NULL, pos=0) ... done
[15:32:13.597] resolve() on list ... DONE
[15:32:13.598] result() for ClusterFuture ...
[15:32:13.598] - result already collected: FutureResult
[15:32:13.598] result() for ClusterFuture ... done
[15:32:13.599] result() for ClusterFuture ...
[15:32:13.599] - result already collected: FutureResult
[15:32:13.599] result() for ClusterFuture ... done
[15:32:13.600] result() for ClusterFuture ...
[15:32:13.600] - result already collected: FutureResult
[15:32:13.600] result() for ClusterFuture ... done
[15:32:13.601] result() for ClusterFuture ...
[15:32:13.601] - result already collected: FutureResult
[15:32:13.601] result() for ClusterFuture ... done
[15:32:13.602]  - Number of value chunks collected: 2
[15:32:13.602] Resolving 2 futures (chunks) ... DONE
[15:32:13.602] Reducing values from 2 chunks ...
[15:32:13.603]  - Number of values collected after concatenation: 2
[15:32:13.603]  - Number of values expected: 2
[15:32:13.603] Reducing values from 2 chunks ... DONE
[15:32:13.604] future_mapply() ... DONE
[15:32:13.604] future_mapply() ...
[15:32:13.609] Number of chunks: 2
[15:32:13.610] getGlobalsAndPackagesXApply() ...
[15:32:13.610]  - future.globals: TRUE
[15:32:13.610] getGlobalsAndPackages() ...
[15:32:13.611] Searching for globals...
[15:32:13.613] - globals found: [1] 'FUN'
[15:32:13.614] Searching for globals ... DONE
[15:32:13.614] Resolving globals: FALSE
[15:32:13.615] The total size of the 1 globals is 1.66 KiB (1704 bytes)
[15:32:13.616] The total size of the 1 globals exported for future expression ('FUN(y = 3:4)') is 1.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.66 KiB of class 'function')
[15:32:13.616] - globals: [1] 'FUN'
[15:32:13.616] 
[15:32:13.617] getGlobalsAndPackages() ... DONE
[15:32:13.617]  - globals found/used: [n=1] 'FUN'
[15:32:13.617]  - needed namespaces: [n=0] 
[15:32:13.617] Finding globals ... DONE
[15:32:13.618] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:13.618] List of 2
[15:32:13.618]  $ ...future.FUN:function (x, y)  
[15:32:13.618]  $ MoreArgs     :List of 1
[15:32:13.618]   ..$ y: int [1:2] 3 4
[15:32:13.618]  - attr(*, "where")=List of 2
[15:32:13.618]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:13.618]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:13.618]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:13.618]  - attr(*, "resolved")= logi FALSE
[15:32:13.618]  - attr(*, "total_size")= num NA
[15:32:13.629] Packages to be attached in all futures: [n=0] 
[15:32:13.629] getGlobalsAndPackagesXApply() ... DONE
[15:32:13.630] Number of futures (= number of chunks): 2
[15:32:13.630] Launching 2 futures (chunks) ...
[15:32:13.631] Chunk #1 of 2 ...
[15:32:13.631]  - Finding globals in '...' for chunk #1 ...
[15:32:13.631] getGlobalsAndPackages() ...
[15:32:13.632] Searching for globals...
[15:32:13.632] 
[15:32:13.633] Searching for globals ... DONE
[15:32:13.633] - globals: [0] <none>
[15:32:13.633] getGlobalsAndPackages() ... DONE
[15:32:13.633]    + additional globals found: [n=0] 
[15:32:13.634]    + additional namespaces needed: [n=0] 
[15:32:13.634]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:13.634]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.635]  - seeds: <none>
[15:32:13.635]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.635] getGlobalsAndPackages() ...
[15:32:13.636] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.636] Resolving globals: FALSE
[15:32:13.637] The total size of the 5 globals is 1.77 KiB (1816 bytes)
[15:32:13.638] 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 1.77 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), 'MoreArgs' (56 bytes of class 'list') and '...future.elements_ii' (56 bytes of class 'list')
[15:32:13.639] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.639] 
[15:32:13.639] getGlobalsAndPackages() ... DONE
[15:32:13.640] run() for 'Future' ...
[15:32:13.640] - state: 'created'
[15:32:13.641] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.662] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.662] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.663]   - Field: 'node'
[15:32:13.663]   - Field: 'label'
[15:32:13.663]   - Field: 'local'
[15:32:13.664]   - Field: 'owner'
[15:32:13.664]   - Field: 'envir'
[15:32:13.664]   - Field: 'workers'
[15:32:13.665]   - Field: 'packages'
[15:32:13.665]   - Field: 'gc'
[15:32:13.665]   - Field: 'conditions'
[15:32:13.666]   - Field: 'persistent'
[15:32:13.666]   - Field: 'expr'
[15:32:13.666]   - Field: 'uuid'
[15:32:13.667]   - Field: 'seed'
[15:32:13.667]   - Field: 'version'
[15:32:13.667]   - Field: 'result'
[15:32:13.668]   - Field: 'asynchronous'
[15:32:13.668]   - Field: 'calls'
[15:32:13.668]   - Field: 'globals'
[15:32:13.669]   - Field: 'stdout'
[15:32:13.669]   - Field: 'earlySignal'
[15:32:13.669]   - Field: 'lazy'
[15:32:13.670]   - Field: 'state'
[15:32:13.670] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.670] - Launch lazy future ...
[15:32:13.671] Packages needed by the future expression (n = 0): <none>
[15:32:13.672] Packages needed by future strategies (n = 0): <none>
[15:32:13.673] {
[15:32:13.673]     {
[15:32:13.673]         {
[15:32:13.673]             ...future.startTime <- base::Sys.time()
[15:32:13.673]             {
[15:32:13.673]                 {
[15:32:13.673]                   {
[15:32:13.673]                     {
[15:32:13.673]                       base::local({
[15:32:13.673]                         has_future <- base::requireNamespace("future", 
[15:32:13.673]                           quietly = TRUE)
[15:32:13.673]                         if (has_future) {
[15:32:13.673]                           ns <- base::getNamespace("future")
[15:32:13.673]                           version <- ns[[".package"]][["version"]]
[15:32:13.673]                           if (is.null(version)) 
[15:32:13.673]                             version <- utils::packageVersion("future")
[15:32:13.673]                         }
[15:32:13.673]                         else {
[15:32:13.673]                           version <- NULL
[15:32:13.673]                         }
[15:32:13.673]                         if (!has_future || version < "1.8.0") {
[15:32:13.673]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.673]                             "", base::R.version$version.string), 
[15:32:13.673]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.673]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.673]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.673]                               "release", "version")], collapse = " "), 
[15:32:13.673]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.673]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.673]                             info)
[15:32:13.673]                           info <- base::paste(info, collapse = "; ")
[15:32:13.673]                           if (!has_future) {
[15:32:13.673]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.673]                               info)
[15:32:13.673]                           }
[15:32:13.673]                           else {
[15:32:13.673]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.673]                               info, version)
[15:32:13.673]                           }
[15:32:13.673]                           base::stop(msg)
[15:32:13.673]                         }
[15:32:13.673]                       })
[15:32:13.673]                     }
[15:32:13.673]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.673]                     base::options(mc.cores = 1L)
[15:32:13.673]                   }
[15:32:13.673]                   ...future.strategy.old <- future::plan("list")
[15:32:13.673]                   options(future.plan = NULL)
[15:32:13.673]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.673]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.673]                 }
[15:32:13.673]                 ...future.workdir <- getwd()
[15:32:13.673]             }
[15:32:13.673]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.673]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.673]         }
[15:32:13.673]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.673]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.673]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.673]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.673]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.673]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.673]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.673]             base::names(...future.oldOptions))
[15:32:13.673]     }
[15:32:13.673]     if (FALSE) {
[15:32:13.673]     }
[15:32:13.673]     else {
[15:32:13.673]         if (TRUE) {
[15:32:13.673]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.673]                 open = "w")
[15:32:13.673]         }
[15:32:13.673]         else {
[15:32:13.673]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.673]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.673]         }
[15:32:13.673]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.673]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.673]             base::sink(type = "output", split = FALSE)
[15:32:13.673]             base::close(...future.stdout)
[15:32:13.673]         }, add = TRUE)
[15:32:13.673]     }
[15:32:13.673]     ...future.frame <- base::sys.nframe()
[15:32:13.673]     ...future.conditions <- base::list()
[15:32:13.673]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.673]     if (FALSE) {
[15:32:13.673]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.673]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.673]     }
[15:32:13.673]     ...future.result <- base::tryCatch({
[15:32:13.673]         base::withCallingHandlers({
[15:32:13.673]             ...future.value <- base::withVisible(base::local({
[15:32:13.673]                 ...future.makeSendCondition <- base::local({
[15:32:13.673]                   sendCondition <- NULL
[15:32:13.673]                   function(frame = 1L) {
[15:32:13.673]                     if (is.function(sendCondition)) 
[15:32:13.673]                       return(sendCondition)
[15:32:13.673]                     ns <- getNamespace("parallel")
[15:32:13.673]                     if (exists("sendData", mode = "function", 
[15:32:13.673]                       envir = ns)) {
[15:32:13.673]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.673]                         envir = ns)
[15:32:13.673]                       envir <- sys.frame(frame)
[15:32:13.673]                       master <- NULL
[15:32:13.673]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.673]                         !identical(envir, emptyenv())) {
[15:32:13.673]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.673]                           inherits = FALSE)) {
[15:32:13.673]                           master <- get("master", mode = "list", 
[15:32:13.673]                             envir = envir, inherits = FALSE)
[15:32:13.673]                           if (inherits(master, c("SOCKnode", 
[15:32:13.673]                             "SOCK0node"))) {
[15:32:13.673]                             sendCondition <<- function(cond) {
[15:32:13.673]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.673]                                 success = TRUE)
[15:32:13.673]                               parallel_sendData(master, data)
[15:32:13.673]                             }
[15:32:13.673]                             return(sendCondition)
[15:32:13.673]                           }
[15:32:13.673]                         }
[15:32:13.673]                         frame <- frame + 1L
[15:32:13.673]                         envir <- sys.frame(frame)
[15:32:13.673]                       }
[15:32:13.673]                     }
[15:32:13.673]                     sendCondition <<- function(cond) NULL
[15:32:13.673]                   }
[15:32:13.673]                 })
[15:32:13.673]                 withCallingHandlers({
[15:32:13.673]                   {
[15:32:13.673]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.673]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.673]                       ...future.globals.maxSize)) {
[15:32:13.673]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.673]                       on.exit(options(oopts), add = TRUE)
[15:32:13.673]                     }
[15:32:13.673]                     {
[15:32:13.673]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.673]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.673]                         USE.NAMES = FALSE)
[15:32:13.673]                       do.call(mapply, args = args)
[15:32:13.673]                     }
[15:32:13.673]                   }
[15:32:13.673]                 }, immediateCondition = function(cond) {
[15:32:13.673]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.673]                   sendCondition(cond)
[15:32:13.673]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.673]                   {
[15:32:13.673]                     inherits <- base::inherits
[15:32:13.673]                     invokeRestart <- base::invokeRestart
[15:32:13.673]                     is.null <- base::is.null
[15:32:13.673]                     muffled <- FALSE
[15:32:13.673]                     if (inherits(cond, "message")) {
[15:32:13.673]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.673]                       if (muffled) 
[15:32:13.673]                         invokeRestart("muffleMessage")
[15:32:13.673]                     }
[15:32:13.673]                     else if (inherits(cond, "warning")) {
[15:32:13.673]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.673]                       if (muffled) 
[15:32:13.673]                         invokeRestart("muffleWarning")
[15:32:13.673]                     }
[15:32:13.673]                     else if (inherits(cond, "condition")) {
[15:32:13.673]                       if (!is.null(pattern)) {
[15:32:13.673]                         computeRestarts <- base::computeRestarts
[15:32:13.673]                         grepl <- base::grepl
[15:32:13.673]                         restarts <- computeRestarts(cond)
[15:32:13.673]                         for (restart in restarts) {
[15:32:13.673]                           name <- restart$name
[15:32:13.673]                           if (is.null(name)) 
[15:32:13.673]                             next
[15:32:13.673]                           if (!grepl(pattern, name)) 
[15:32:13.673]                             next
[15:32:13.673]                           invokeRestart(restart)
[15:32:13.673]                           muffled <- TRUE
[15:32:13.673]                           break
[15:32:13.673]                         }
[15:32:13.673]                       }
[15:32:13.673]                     }
[15:32:13.673]                     invisible(muffled)
[15:32:13.673]                   }
[15:32:13.673]                   muffleCondition(cond)
[15:32:13.673]                 })
[15:32:13.673]             }))
[15:32:13.673]             future::FutureResult(value = ...future.value$value, 
[15:32:13.673]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.673]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.673]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.673]                     ...future.globalenv.names))
[15:32:13.673]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.673]         }, condition = base::local({
[15:32:13.673]             c <- base::c
[15:32:13.673]             inherits <- base::inherits
[15:32:13.673]             invokeRestart <- base::invokeRestart
[15:32:13.673]             length <- base::length
[15:32:13.673]             list <- base::list
[15:32:13.673]             seq.int <- base::seq.int
[15:32:13.673]             signalCondition <- base::signalCondition
[15:32:13.673]             sys.calls <- base::sys.calls
[15:32:13.673]             `[[` <- base::`[[`
[15:32:13.673]             `+` <- base::`+`
[15:32:13.673]             `<<-` <- base::`<<-`
[15:32:13.673]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.673]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.673]                   3L)]
[15:32:13.673]             }
[15:32:13.673]             function(cond) {
[15:32:13.673]                 is_error <- inherits(cond, "error")
[15:32:13.673]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.673]                   NULL)
[15:32:13.673]                 if (is_error) {
[15:32:13.673]                   sessionInformation <- function() {
[15:32:13.673]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.673]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.673]                       search = base::search(), system = base::Sys.info())
[15:32:13.673]                   }
[15:32:13.673]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.673]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.673]                     cond$call), session = sessionInformation(), 
[15:32:13.673]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.673]                   signalCondition(cond)
[15:32:13.673]                 }
[15:32:13.673]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.673]                 "immediateCondition"))) {
[15:32:13.673]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.673]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.673]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.673]                   if (TRUE && !signal) {
[15:32:13.673]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.673]                     {
[15:32:13.673]                       inherits <- base::inherits
[15:32:13.673]                       invokeRestart <- base::invokeRestart
[15:32:13.673]                       is.null <- base::is.null
[15:32:13.673]                       muffled <- FALSE
[15:32:13.673]                       if (inherits(cond, "message")) {
[15:32:13.673]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.673]                         if (muffled) 
[15:32:13.673]                           invokeRestart("muffleMessage")
[15:32:13.673]                       }
[15:32:13.673]                       else if (inherits(cond, "warning")) {
[15:32:13.673]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.673]                         if (muffled) 
[15:32:13.673]                           invokeRestart("muffleWarning")
[15:32:13.673]                       }
[15:32:13.673]                       else if (inherits(cond, "condition")) {
[15:32:13.673]                         if (!is.null(pattern)) {
[15:32:13.673]                           computeRestarts <- base::computeRestarts
[15:32:13.673]                           grepl <- base::grepl
[15:32:13.673]                           restarts <- computeRestarts(cond)
[15:32:13.673]                           for (restart in restarts) {
[15:32:13.673]                             name <- restart$name
[15:32:13.673]                             if (is.null(name)) 
[15:32:13.673]                               next
[15:32:13.673]                             if (!grepl(pattern, name)) 
[15:32:13.673]                               next
[15:32:13.673]                             invokeRestart(restart)
[15:32:13.673]                             muffled <- TRUE
[15:32:13.673]                             break
[15:32:13.673]                           }
[15:32:13.673]                         }
[15:32:13.673]                       }
[15:32:13.673]                       invisible(muffled)
[15:32:13.673]                     }
[15:32:13.673]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.673]                   }
[15:32:13.673]                 }
[15:32:13.673]                 else {
[15:32:13.673]                   if (TRUE) {
[15:32:13.673]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.673]                     {
[15:32:13.673]                       inherits <- base::inherits
[15:32:13.673]                       invokeRestart <- base::invokeRestart
[15:32:13.673]                       is.null <- base::is.null
[15:32:13.673]                       muffled <- FALSE
[15:32:13.673]                       if (inherits(cond, "message")) {
[15:32:13.673]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.673]                         if (muffled) 
[15:32:13.673]                           invokeRestart("muffleMessage")
[15:32:13.673]                       }
[15:32:13.673]                       else if (inherits(cond, "warning")) {
[15:32:13.673]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.673]                         if (muffled) 
[15:32:13.673]                           invokeRestart("muffleWarning")
[15:32:13.673]                       }
[15:32:13.673]                       else if (inherits(cond, "condition")) {
[15:32:13.673]                         if (!is.null(pattern)) {
[15:32:13.673]                           computeRestarts <- base::computeRestarts
[15:32:13.673]                           grepl <- base::grepl
[15:32:13.673]                           restarts <- computeRestarts(cond)
[15:32:13.673]                           for (restart in restarts) {
[15:32:13.673]                             name <- restart$name
[15:32:13.673]                             if (is.null(name)) 
[15:32:13.673]                               next
[15:32:13.673]                             if (!grepl(pattern, name)) 
[15:32:13.673]                               next
[15:32:13.673]                             invokeRestart(restart)
[15:32:13.673]                             muffled <- TRUE
[15:32:13.673]                             break
[15:32:13.673]                           }
[15:32:13.673]                         }
[15:32:13.673]                       }
[15:32:13.673]                       invisible(muffled)
[15:32:13.673]                     }
[15:32:13.673]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.673]                   }
[15:32:13.673]                 }
[15:32:13.673]             }
[15:32:13.673]         }))
[15:32:13.673]     }, error = function(ex) {
[15:32:13.673]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.673]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.673]                 ...future.rng), started = ...future.startTime, 
[15:32:13.673]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.673]             version = "1.8"), class = "FutureResult")
[15:32:13.673]     }, finally = {
[15:32:13.673]         if (!identical(...future.workdir, getwd())) 
[15:32:13.673]             setwd(...future.workdir)
[15:32:13.673]         {
[15:32:13.673]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.673]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.673]             }
[15:32:13.673]             base::options(...future.oldOptions)
[15:32:13.673]             if (.Platform$OS.type == "windows") {
[15:32:13.673]                 old_names <- names(...future.oldEnvVars)
[15:32:13.673]                 envs <- base::Sys.getenv()
[15:32:13.673]                 names <- names(envs)
[15:32:13.673]                 common <- intersect(names, old_names)
[15:32:13.673]                 added <- setdiff(names, old_names)
[15:32:13.673]                 removed <- setdiff(old_names, names)
[15:32:13.673]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.673]                   envs[common]]
[15:32:13.673]                 NAMES <- toupper(changed)
[15:32:13.673]                 args <- list()
[15:32:13.673]                 for (kk in seq_along(NAMES)) {
[15:32:13.673]                   name <- changed[[kk]]
[15:32:13.673]                   NAME <- NAMES[[kk]]
[15:32:13.673]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.673]                     next
[15:32:13.673]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.673]                 }
[15:32:13.673]                 NAMES <- toupper(added)
[15:32:13.673]                 for (kk in seq_along(NAMES)) {
[15:32:13.673]                   name <- added[[kk]]
[15:32:13.673]                   NAME <- NAMES[[kk]]
[15:32:13.673]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.673]                     next
[15:32:13.673]                   args[[name]] <- ""
[15:32:13.673]                 }
[15:32:13.673]                 NAMES <- toupper(removed)
[15:32:13.673]                 for (kk in seq_along(NAMES)) {
[15:32:13.673]                   name <- removed[[kk]]
[15:32:13.673]                   NAME <- NAMES[[kk]]
[15:32:13.673]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.673]                     next
[15:32:13.673]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.673]                 }
[15:32:13.673]                 if (length(args) > 0) 
[15:32:13.673]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.673]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.673]             }
[15:32:13.673]             else {
[15:32:13.673]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.673]             }
[15:32:13.673]             {
[15:32:13.673]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.673]                   0L) {
[15:32:13.673]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.673]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.673]                   base::options(opts)
[15:32:13.673]                 }
[15:32:13.673]                 {
[15:32:13.673]                   {
[15:32:13.673]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.673]                     NULL
[15:32:13.673]                   }
[15:32:13.673]                   options(future.plan = NULL)
[15:32:13.673]                   if (is.na(NA_character_)) 
[15:32:13.673]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.673]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.673]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.673]                     .init = FALSE)
[15:32:13.673]                 }
[15:32:13.673]             }
[15:32:13.673]         }
[15:32:13.673]     })
[15:32:13.673]     if (TRUE) {
[15:32:13.673]         base::sink(type = "output", split = FALSE)
[15:32:13.673]         if (TRUE) {
[15:32:13.673]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.673]         }
[15:32:13.673]         else {
[15:32:13.673]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.673]         }
[15:32:13.673]         base::close(...future.stdout)
[15:32:13.673]         ...future.stdout <- NULL
[15:32:13.673]     }
[15:32:13.673]     ...future.result$conditions <- ...future.conditions
[15:32:13.673]     ...future.result$finished <- base::Sys.time()
[15:32:13.673]     ...future.result
[15:32:13.673] }
[15:32:13.684] Exporting 5 global objects (1.77 KiB) to cluster node #1 ...
[15:32:13.685] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ...
[15:32:13.685] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ... DONE
[15:32:13.686] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:13.687] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:13.687] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:13.688] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:13.688] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.689] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.689] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.690] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.690] Exporting 5 global objects (1.77 KiB) to cluster node #1 ... DONE
[15:32:13.692] MultisessionFuture started
[15:32:13.692] - Launch lazy future ... done
[15:32:13.692] run() for 'MultisessionFuture' ... done
[15:32:13.693] Created future:
[15:32:13.724] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.725] - Validating connection of MultisessionFuture
[15:32:13.725] - received message: FutureResult
[15:32:13.726] - Received FutureResult
[15:32:13.726] - Erased future from FutureRegistry
[15:32:13.726] result() for ClusterFuture ...
[15:32:13.726] - result already collected: FutureResult
[15:32:13.727] result() for ClusterFuture ... done
[15:32:13.727] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.693] MultisessionFuture:
[15:32:13.693] Label: 'future_.mapply-1'
[15:32:13.693] Expression:
[15:32:13.693] {
[15:32:13.693]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.693]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.693]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.693]         on.exit(options(oopts), add = TRUE)
[15:32:13.693]     }
[15:32:13.693]     {
[15:32:13.693]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.693]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.693]         do.call(mapply, args = args)
[15:32:13.693]     }
[15:32:13.693] }
[15:32:13.693] Lazy evaluation: FALSE
[15:32:13.693] Asynchronous evaluation: TRUE
[15:32:13.693] Local evaluation: TRUE
[15:32:13.693] Environment: R_GlobalEnv
[15:32:13.693] Capture standard output: TRUE
[15:32:13.693] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.693] Globals: 5 objects totaling 1.77 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.693] Packages: <none>
[15:32:13.693] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.693] Resolved: TRUE
[15:32:13.693] Value: <not collected>
[15:32:13.693] Conditions captured: <none>
[15:32:13.693] Early signaling: FALSE
[15:32:13.693] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.693] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.728] Chunk #1 of 2 ... DONE
[15:32:13.728] Chunk #2 of 2 ...
[15:32:13.728]  - Finding globals in '...' for chunk #2 ...
[15:32:13.729] getGlobalsAndPackages() ...
[15:32:13.729] Searching for globals...
[15:32:13.730] 
[15:32:13.730] Searching for globals ... DONE
[15:32:13.730] - globals: [0] <none>
[15:32:13.730] getGlobalsAndPackages() ... DONE
[15:32:13.731]    + additional globals found: [n=0] 
[15:32:13.731]    + additional namespaces needed: [n=0] 
[15:32:13.731]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:13.731]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.732]  - seeds: <none>
[15:32:13.732]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.732] getGlobalsAndPackages() ...
[15:32:13.733] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.733] Resolving globals: FALSE
[15:32:13.734] The total size of the 5 globals is 1.77 KiB (1816 bytes)
[15:32:13.735] 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 1.77 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.66 KiB of class 'function'), 'MoreArgs' (56 bytes of class 'list') and '...future.elements_ii' (56 bytes of class 'list')
[15:32:13.735] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.736] 
[15:32:13.736] getGlobalsAndPackages() ... DONE
[15:32:13.737] run() for 'Future' ...
[15:32:13.737] - state: 'created'
[15:32:13.737] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.755] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.756] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.756]   - Field: 'node'
[15:32:13.756]   - Field: 'label'
[15:32:13.757]   - Field: 'local'
[15:32:13.757]   - Field: 'owner'
[15:32:13.757]   - Field: 'envir'
[15:32:13.757]   - Field: 'workers'
[15:32:13.758]   - Field: 'packages'
[15:32:13.758]   - Field: 'gc'
[15:32:13.758]   - Field: 'conditions'
[15:32:13.759]   - Field: 'persistent'
[15:32:13.759]   - Field: 'expr'
[15:32:13.759]   - Field: 'uuid'
[15:32:13.760]   - Field: 'seed'
[15:32:13.760]   - Field: 'version'
[15:32:13.760]   - Field: 'result'
[15:32:13.761]   - Field: 'asynchronous'
[15:32:13.761]   - Field: 'calls'
[15:32:13.761]   - Field: 'globals'
[15:32:13.761]   - Field: 'stdout'
[15:32:13.762]   - Field: 'earlySignal'
[15:32:13.762]   - Field: 'lazy'
[15:32:13.762]   - Field: 'state'
[15:32:13.763] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.763] - Launch lazy future ...
[15:32:13.763] Packages needed by the future expression (n = 0): <none>
[15:32:13.764] Packages needed by future strategies (n = 0): <none>
[15:32:13.765] {
[15:32:13.765]     {
[15:32:13.765]         {
[15:32:13.765]             ...future.startTime <- base::Sys.time()
[15:32:13.765]             {
[15:32:13.765]                 {
[15:32:13.765]                   {
[15:32:13.765]                     {
[15:32:13.765]                       base::local({
[15:32:13.765]                         has_future <- base::requireNamespace("future", 
[15:32:13.765]                           quietly = TRUE)
[15:32:13.765]                         if (has_future) {
[15:32:13.765]                           ns <- base::getNamespace("future")
[15:32:13.765]                           version <- ns[[".package"]][["version"]]
[15:32:13.765]                           if (is.null(version)) 
[15:32:13.765]                             version <- utils::packageVersion("future")
[15:32:13.765]                         }
[15:32:13.765]                         else {
[15:32:13.765]                           version <- NULL
[15:32:13.765]                         }
[15:32:13.765]                         if (!has_future || version < "1.8.0") {
[15:32:13.765]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.765]                             "", base::R.version$version.string), 
[15:32:13.765]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.765]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.765]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.765]                               "release", "version")], collapse = " "), 
[15:32:13.765]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.765]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.765]                             info)
[15:32:13.765]                           info <- base::paste(info, collapse = "; ")
[15:32:13.765]                           if (!has_future) {
[15:32:13.765]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.765]                               info)
[15:32:13.765]                           }
[15:32:13.765]                           else {
[15:32:13.765]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.765]                               info, version)
[15:32:13.765]                           }
[15:32:13.765]                           base::stop(msg)
[15:32:13.765]                         }
[15:32:13.765]                       })
[15:32:13.765]                     }
[15:32:13.765]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.765]                     base::options(mc.cores = 1L)
[15:32:13.765]                   }
[15:32:13.765]                   ...future.strategy.old <- future::plan("list")
[15:32:13.765]                   options(future.plan = NULL)
[15:32:13.765]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.765]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.765]                 }
[15:32:13.765]                 ...future.workdir <- getwd()
[15:32:13.765]             }
[15:32:13.765]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.765]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.765]         }
[15:32:13.765]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.765]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.765]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.765]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.765]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.765]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.765]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.765]             base::names(...future.oldOptions))
[15:32:13.765]     }
[15:32:13.765]     if (FALSE) {
[15:32:13.765]     }
[15:32:13.765]     else {
[15:32:13.765]         if (TRUE) {
[15:32:13.765]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.765]                 open = "w")
[15:32:13.765]         }
[15:32:13.765]         else {
[15:32:13.765]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.765]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.765]         }
[15:32:13.765]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.765]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.765]             base::sink(type = "output", split = FALSE)
[15:32:13.765]             base::close(...future.stdout)
[15:32:13.765]         }, add = TRUE)
[15:32:13.765]     }
[15:32:13.765]     ...future.frame <- base::sys.nframe()
[15:32:13.765]     ...future.conditions <- base::list()
[15:32:13.765]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.765]     if (FALSE) {
[15:32:13.765]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.765]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.765]     }
[15:32:13.765]     ...future.result <- base::tryCatch({
[15:32:13.765]         base::withCallingHandlers({
[15:32:13.765]             ...future.value <- base::withVisible(base::local({
[15:32:13.765]                 ...future.makeSendCondition <- base::local({
[15:32:13.765]                   sendCondition <- NULL
[15:32:13.765]                   function(frame = 1L) {
[15:32:13.765]                     if (is.function(sendCondition)) 
[15:32:13.765]                       return(sendCondition)
[15:32:13.765]                     ns <- getNamespace("parallel")
[15:32:13.765]                     if (exists("sendData", mode = "function", 
[15:32:13.765]                       envir = ns)) {
[15:32:13.765]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.765]                         envir = ns)
[15:32:13.765]                       envir <- sys.frame(frame)
[15:32:13.765]                       master <- NULL
[15:32:13.765]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.765]                         !identical(envir, emptyenv())) {
[15:32:13.765]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.765]                           inherits = FALSE)) {
[15:32:13.765]                           master <- get("master", mode = "list", 
[15:32:13.765]                             envir = envir, inherits = FALSE)
[15:32:13.765]                           if (inherits(master, c("SOCKnode", 
[15:32:13.765]                             "SOCK0node"))) {
[15:32:13.765]                             sendCondition <<- function(cond) {
[15:32:13.765]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.765]                                 success = TRUE)
[15:32:13.765]                               parallel_sendData(master, data)
[15:32:13.765]                             }
[15:32:13.765]                             return(sendCondition)
[15:32:13.765]                           }
[15:32:13.765]                         }
[15:32:13.765]                         frame <- frame + 1L
[15:32:13.765]                         envir <- sys.frame(frame)
[15:32:13.765]                       }
[15:32:13.765]                     }
[15:32:13.765]                     sendCondition <<- function(cond) NULL
[15:32:13.765]                   }
[15:32:13.765]                 })
[15:32:13.765]                 withCallingHandlers({
[15:32:13.765]                   {
[15:32:13.765]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.765]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.765]                       ...future.globals.maxSize)) {
[15:32:13.765]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.765]                       on.exit(options(oopts), add = TRUE)
[15:32:13.765]                     }
[15:32:13.765]                     {
[15:32:13.765]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.765]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.765]                         USE.NAMES = FALSE)
[15:32:13.765]                       do.call(mapply, args = args)
[15:32:13.765]                     }
[15:32:13.765]                   }
[15:32:13.765]                 }, immediateCondition = function(cond) {
[15:32:13.765]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.765]                   sendCondition(cond)
[15:32:13.765]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.765]                   {
[15:32:13.765]                     inherits <- base::inherits
[15:32:13.765]                     invokeRestart <- base::invokeRestart
[15:32:13.765]                     is.null <- base::is.null
[15:32:13.765]                     muffled <- FALSE
[15:32:13.765]                     if (inherits(cond, "message")) {
[15:32:13.765]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.765]                       if (muffled) 
[15:32:13.765]                         invokeRestart("muffleMessage")
[15:32:13.765]                     }
[15:32:13.765]                     else if (inherits(cond, "warning")) {
[15:32:13.765]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.765]                       if (muffled) 
[15:32:13.765]                         invokeRestart("muffleWarning")
[15:32:13.765]                     }
[15:32:13.765]                     else if (inherits(cond, "condition")) {
[15:32:13.765]                       if (!is.null(pattern)) {
[15:32:13.765]                         computeRestarts <- base::computeRestarts
[15:32:13.765]                         grepl <- base::grepl
[15:32:13.765]                         restarts <- computeRestarts(cond)
[15:32:13.765]                         for (restart in restarts) {
[15:32:13.765]                           name <- restart$name
[15:32:13.765]                           if (is.null(name)) 
[15:32:13.765]                             next
[15:32:13.765]                           if (!grepl(pattern, name)) 
[15:32:13.765]                             next
[15:32:13.765]                           invokeRestart(restart)
[15:32:13.765]                           muffled <- TRUE
[15:32:13.765]                           break
[15:32:13.765]                         }
[15:32:13.765]                       }
[15:32:13.765]                     }
[15:32:13.765]                     invisible(muffled)
[15:32:13.765]                   }
[15:32:13.765]                   muffleCondition(cond)
[15:32:13.765]                 })
[15:32:13.765]             }))
[15:32:13.765]             future::FutureResult(value = ...future.value$value, 
[15:32:13.765]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.765]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.765]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.765]                     ...future.globalenv.names))
[15:32:13.765]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.765]         }, condition = base::local({
[15:32:13.765]             c <- base::c
[15:32:13.765]             inherits <- base::inherits
[15:32:13.765]             invokeRestart <- base::invokeRestart
[15:32:13.765]             length <- base::length
[15:32:13.765]             list <- base::list
[15:32:13.765]             seq.int <- base::seq.int
[15:32:13.765]             signalCondition <- base::signalCondition
[15:32:13.765]             sys.calls <- base::sys.calls
[15:32:13.765]             `[[` <- base::`[[`
[15:32:13.765]             `+` <- base::`+`
[15:32:13.765]             `<<-` <- base::`<<-`
[15:32:13.765]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.765]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.765]                   3L)]
[15:32:13.765]             }
[15:32:13.765]             function(cond) {
[15:32:13.765]                 is_error <- inherits(cond, "error")
[15:32:13.765]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.765]                   NULL)
[15:32:13.765]                 if (is_error) {
[15:32:13.765]                   sessionInformation <- function() {
[15:32:13.765]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.765]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.765]                       search = base::search(), system = base::Sys.info())
[15:32:13.765]                   }
[15:32:13.765]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.765]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.765]                     cond$call), session = sessionInformation(), 
[15:32:13.765]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.765]                   signalCondition(cond)
[15:32:13.765]                 }
[15:32:13.765]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.765]                 "immediateCondition"))) {
[15:32:13.765]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.765]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.765]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.765]                   if (TRUE && !signal) {
[15:32:13.765]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.765]                     {
[15:32:13.765]                       inherits <- base::inherits
[15:32:13.765]                       invokeRestart <- base::invokeRestart
[15:32:13.765]                       is.null <- base::is.null
[15:32:13.765]                       muffled <- FALSE
[15:32:13.765]                       if (inherits(cond, "message")) {
[15:32:13.765]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.765]                         if (muffled) 
[15:32:13.765]                           invokeRestart("muffleMessage")
[15:32:13.765]                       }
[15:32:13.765]                       else if (inherits(cond, "warning")) {
[15:32:13.765]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.765]                         if (muffled) 
[15:32:13.765]                           invokeRestart("muffleWarning")
[15:32:13.765]                       }
[15:32:13.765]                       else if (inherits(cond, "condition")) {
[15:32:13.765]                         if (!is.null(pattern)) {
[15:32:13.765]                           computeRestarts <- base::computeRestarts
[15:32:13.765]                           grepl <- base::grepl
[15:32:13.765]                           restarts <- computeRestarts(cond)
[15:32:13.765]                           for (restart in restarts) {
[15:32:13.765]                             name <- restart$name
[15:32:13.765]                             if (is.null(name)) 
[15:32:13.765]                               next
[15:32:13.765]                             if (!grepl(pattern, name)) 
[15:32:13.765]                               next
[15:32:13.765]                             invokeRestart(restart)
[15:32:13.765]                             muffled <- TRUE
[15:32:13.765]                             break
[15:32:13.765]                           }
[15:32:13.765]                         }
[15:32:13.765]                       }
[15:32:13.765]                       invisible(muffled)
[15:32:13.765]                     }
[15:32:13.765]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.765]                   }
[15:32:13.765]                 }
[15:32:13.765]                 else {
[15:32:13.765]                   if (TRUE) {
[15:32:13.765]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.765]                     {
[15:32:13.765]                       inherits <- base::inherits
[15:32:13.765]                       invokeRestart <- base::invokeRestart
[15:32:13.765]                       is.null <- base::is.null
[15:32:13.765]                       muffled <- FALSE
[15:32:13.765]                       if (inherits(cond, "message")) {
[15:32:13.765]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.765]                         if (muffled) 
[15:32:13.765]                           invokeRestart("muffleMessage")
[15:32:13.765]                       }
[15:32:13.765]                       else if (inherits(cond, "warning")) {
[15:32:13.765]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.765]                         if (muffled) 
[15:32:13.765]                           invokeRestart("muffleWarning")
[15:32:13.765]                       }
[15:32:13.765]                       else if (inherits(cond, "condition")) {
[15:32:13.765]                         if (!is.null(pattern)) {
[15:32:13.765]                           computeRestarts <- base::computeRestarts
[15:32:13.765]                           grepl <- base::grepl
[15:32:13.765]                           restarts <- computeRestarts(cond)
[15:32:13.765]                           for (restart in restarts) {
[15:32:13.765]                             name <- restart$name
[15:32:13.765]                             if (is.null(name)) 
[15:32:13.765]                               next
[15:32:13.765]                             if (!grepl(pattern, name)) 
[15:32:13.765]                               next
[15:32:13.765]                             invokeRestart(restart)
[15:32:13.765]                             muffled <- TRUE
[15:32:13.765]                             break
[15:32:13.765]                           }
[15:32:13.765]                         }
[15:32:13.765]                       }
[15:32:13.765]                       invisible(muffled)
[15:32:13.765]                     }
[15:32:13.765]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.765]                   }
[15:32:13.765]                 }
[15:32:13.765]             }
[15:32:13.765]         }))
[15:32:13.765]     }, error = function(ex) {
[15:32:13.765]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.765]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.765]                 ...future.rng), started = ...future.startTime, 
[15:32:13.765]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.765]             version = "1.8"), class = "FutureResult")
[15:32:13.765]     }, finally = {
[15:32:13.765]         if (!identical(...future.workdir, getwd())) 
[15:32:13.765]             setwd(...future.workdir)
[15:32:13.765]         {
[15:32:13.765]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.765]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.765]             }
[15:32:13.765]             base::options(...future.oldOptions)
[15:32:13.765]             if (.Platform$OS.type == "windows") {
[15:32:13.765]                 old_names <- names(...future.oldEnvVars)
[15:32:13.765]                 envs <- base::Sys.getenv()
[15:32:13.765]                 names <- names(envs)
[15:32:13.765]                 common <- intersect(names, old_names)
[15:32:13.765]                 added <- setdiff(names, old_names)
[15:32:13.765]                 removed <- setdiff(old_names, names)
[15:32:13.765]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.765]                   envs[common]]
[15:32:13.765]                 NAMES <- toupper(changed)
[15:32:13.765]                 args <- list()
[15:32:13.765]                 for (kk in seq_along(NAMES)) {
[15:32:13.765]                   name <- changed[[kk]]
[15:32:13.765]                   NAME <- NAMES[[kk]]
[15:32:13.765]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.765]                     next
[15:32:13.765]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.765]                 }
[15:32:13.765]                 NAMES <- toupper(added)
[15:32:13.765]                 for (kk in seq_along(NAMES)) {
[15:32:13.765]                   name <- added[[kk]]
[15:32:13.765]                   NAME <- NAMES[[kk]]
[15:32:13.765]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.765]                     next
[15:32:13.765]                   args[[name]] <- ""
[15:32:13.765]                 }
[15:32:13.765]                 NAMES <- toupper(removed)
[15:32:13.765]                 for (kk in seq_along(NAMES)) {
[15:32:13.765]                   name <- removed[[kk]]
[15:32:13.765]                   NAME <- NAMES[[kk]]
[15:32:13.765]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.765]                     next
[15:32:13.765]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.765]                 }
[15:32:13.765]                 if (length(args) > 0) 
[15:32:13.765]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.765]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.765]             }
[15:32:13.765]             else {
[15:32:13.765]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.765]             }
[15:32:13.765]             {
[15:32:13.765]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.765]                   0L) {
[15:32:13.765]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.765]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.765]                   base::options(opts)
[15:32:13.765]                 }
[15:32:13.765]                 {
[15:32:13.765]                   {
[15:32:13.765]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.765]                     NULL
[15:32:13.765]                   }
[15:32:13.765]                   options(future.plan = NULL)
[15:32:13.765]                   if (is.na(NA_character_)) 
[15:32:13.765]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.765]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.765]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.765]                     .init = FALSE)
[15:32:13.765]                 }
[15:32:13.765]             }
[15:32:13.765]         }
[15:32:13.765]     })
[15:32:13.765]     if (TRUE) {
[15:32:13.765]         base::sink(type = "output", split = FALSE)
[15:32:13.765]         if (TRUE) {
[15:32:13.765]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.765]         }
[15:32:13.765]         else {
[15:32:13.765]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.765]         }
[15:32:13.765]         base::close(...future.stdout)
[15:32:13.765]         ...future.stdout <- NULL
[15:32:13.765]     }
[15:32:13.765]     ...future.result$conditions <- ...future.conditions
[15:32:13.765]     ...future.result$finished <- base::Sys.time()
[15:32:13.765]     ...future.result
[15:32:13.765] }
[15:32:13.774] Exporting 5 global objects (1.77 KiB) to cluster node #1 ...
[15:32:13.775] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ...
[15:32:13.776] Exporting '...future.FUN' (1.66 KiB) to cluster node #1 ... DONE
[15:32:13.776] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:13.777] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:13.777] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:13.777] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:13.778] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.778] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.778] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.779] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.779] Exporting 5 global objects (1.77 KiB) to cluster node #1 ... DONE
[15:32:13.780] MultisessionFuture started
[15:32:13.780] - Launch lazy future ... done
[15:32:13.780] run() for 'MultisessionFuture' ... done
[15:32:13.780] Created future:
[15:32:13.795] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.796] - Validating connection of MultisessionFuture
[15:32:13.796] - received message: FutureResult
[15:32:13.796] - Received FutureResult
[15:32:13.797] - Erased future from FutureRegistry
[15:32:13.797] result() for ClusterFuture ...
[15:32:13.797] - result already collected: FutureResult
[15:32:13.797] result() for ClusterFuture ... done
[15:32:13.797] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.780] MultisessionFuture:
[15:32:13.780] Label: 'future_.mapply-2'
[15:32:13.780] Expression:
[15:32:13.780] {
[15:32:13.780]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.780]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.780]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.780]         on.exit(options(oopts), add = TRUE)
[15:32:13.780]     }
[15:32:13.780]     {
[15:32:13.780]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.780]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.780]         do.call(mapply, args = args)
[15:32:13.780]     }
[15:32:13.780] }
[15:32:13.780] Lazy evaluation: FALSE
[15:32:13.780] Asynchronous evaluation: TRUE
[15:32:13.780] Local evaluation: TRUE
[15:32:13.780] Environment: R_GlobalEnv
[15:32:13.780] Capture standard output: TRUE
[15:32:13.780] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.780] Globals: 5 objects totaling 1.77 KiB (function '...future.FUN' of 1.66 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:13.780] Packages: <none>
[15:32:13.780] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.780] Resolved: TRUE
[15:32:13.780] Value: <not collected>
[15:32:13.780] Conditions captured: <none>
[15:32:13.780] Early signaling: FALSE
[15:32:13.780] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.780] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.798] Chunk #2 of 2 ... DONE
[15:32:13.798] Launching 2 futures (chunks) ... DONE
[15:32:13.798] Resolving 2 futures (chunks) ...
[15:32:13.798] resolve() on list ...
[15:32:13.798]  recursive: 0
[15:32:13.799]  length: 2
[15:32:13.799] 
[15:32:13.799] Future #1
[15:32:13.799] result() for ClusterFuture ...
[15:32:13.799] - result already collected: FutureResult
[15:32:13.799] result() for ClusterFuture ... done
[15:32:13.800] result() for ClusterFuture ...
[15:32:13.800] - result already collected: FutureResult
[15:32:13.800] result() for ClusterFuture ... done
[15:32:13.800] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:13.800] - nx: 2
[15:32:13.800] - relay: TRUE
[15:32:13.801] - stdout: TRUE
[15:32:13.801] - signal: TRUE
[15:32:13.801] - resignal: FALSE
[15:32:13.801] - force: TRUE
[15:32:13.801] - relayed: [n=2] FALSE, FALSE
[15:32:13.801] - queued futures: [n=2] FALSE, FALSE
[15:32:13.802]  - until=1
[15:32:13.802]  - relaying element #1
[15:32:13.802] result() for ClusterFuture ...
[15:32:13.802] - result already collected: FutureResult
[15:32:13.802] result() for ClusterFuture ... done
[15:32:13.802] result() for ClusterFuture ...
[15:32:13.803] - result already collected: FutureResult
[15:32:13.803] result() for ClusterFuture ... done
[15:32:13.803] result() for ClusterFuture ...
[15:32:13.803] - result already collected: FutureResult
[15:32:13.803] result() for ClusterFuture ... done
[15:32:13.803] result() for ClusterFuture ...
[15:32:13.804] - result already collected: FutureResult
[15:32:13.804] result() for ClusterFuture ... done
[15:32:13.804] - relayed: [n=2] TRUE, FALSE
[15:32:13.804] - queued futures: [n=2] TRUE, FALSE
[15:32:13.804] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:13.804]  length: 1 (resolved future 1)
[15:32:13.805] Future #2
[15:32:13.805] result() for ClusterFuture ...
[15:32:13.805] - result already collected: FutureResult
[15:32:13.805] result() for ClusterFuture ... done
[15:32:13.805] result() for ClusterFuture ...
[15:32:13.805] - result already collected: FutureResult
[15:32:13.806] result() for ClusterFuture ... done
[15:32:13.806] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:13.806] - nx: 2
[15:32:13.806] - relay: TRUE
[15:32:13.806] - stdout: TRUE
[15:32:13.806] - signal: TRUE
[15:32:13.807] - resignal: FALSE
[15:32:13.807] - force: TRUE
[15:32:13.807] - relayed: [n=2] TRUE, FALSE
[15:32:13.807] - queued futures: [n=2] TRUE, FALSE
[15:32:13.807]  - until=2
[15:32:13.807]  - relaying element #2
[15:32:13.808] result() for ClusterFuture ...
[15:32:13.808] - result already collected: FutureResult
[15:32:13.808] result() for ClusterFuture ... done
[15:32:13.808] result() for ClusterFuture ...
[15:32:13.808] - result already collected: FutureResult
[15:32:13.808] result() for ClusterFuture ... done
[15:32:13.809] result() for ClusterFuture ...
[15:32:13.809] - result already collected: FutureResult
[15:32:13.809] result() for ClusterFuture ... done
[15:32:13.809] result() for ClusterFuture ...
[15:32:13.809] - result already collected: FutureResult
[15:32:13.809] result() for ClusterFuture ... done
[15:32:13.809] - relayed: [n=2] TRUE, TRUE
[15:32:13.810] - queued futures: [n=2] TRUE, TRUE
[15:32:13.810] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:13.810]  length: 0 (resolved future 2)
[15:32:13.810] Relaying remaining futures
[15:32:13.810] signalConditionsASAP(NULL, pos=0) ...
[15:32:13.810] - nx: 2
[15:32:13.811] - relay: TRUE
[15:32:13.811] - stdout: TRUE
[15:32:13.811] - signal: TRUE
[15:32:13.811] - resignal: FALSE
[15:32:13.811] - force: TRUE
[15:32:13.811] - relayed: [n=2] TRUE, TRUE
[15:32:13.812] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:13.812] - relayed: [n=2] TRUE, TRUE
[15:32:13.812] - queued futures: [n=2] TRUE, TRUE
[15:32:13.813] signalConditionsASAP(NULL, pos=0) ... done
[15:32:13.813] resolve() on list ... DONE
[15:32:13.813] result() for ClusterFuture ...
[15:32:13.813] - result already collected: FutureResult
[15:32:13.814] result() for ClusterFuture ... done
[15:32:13.814] result() for ClusterFuture ...
[15:32:13.814] - result already collected: FutureResult
[15:32:13.814] result() for ClusterFuture ... done
[15:32:13.815] result() for ClusterFuture ...
[15:32:13.815] - result already collected: FutureResult
[15:32:13.815] result() for ClusterFuture ... done
[15:32:13.815] result() for ClusterFuture ...
[15:32:13.816] - result already collected: FutureResult
[15:32:13.816] result() for ClusterFuture ... done
[15:32:13.816]  - Number of value chunks collected: 2
[15:32:13.816] Resolving 2 futures (chunks) ... DONE
[15:32:13.817] Reducing values from 2 chunks ...
[15:32:13.817]  - Number of values collected after concatenation: 2
[15:32:13.817]  - Number of values expected: 2
[15:32:13.817] Reducing values from 2 chunks ... DONE
[15:32:13.818] future_mapply() ... DONE
- Recycle arguments to same length ...
[15:32:13.818] future_mapply() ...
[15:32:13.823] Number of chunks: 2
[15:32:13.823] getGlobalsAndPackagesXApply() ...
[15:32:13.823]  - future.globals: TRUE
[15:32:13.823] getGlobalsAndPackages() ...
[15:32:13.824] Searching for globals...
[15:32:13.825] - globals found: [1] 'FUN'
[15:32:13.825] Searching for globals ... DONE
[15:32:13.826] Resolving globals: FALSE
[15:32:13.826] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:13.827] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:13.827] - globals: [1] 'FUN'
[15:32:13.827] 
[15:32:13.828] getGlobalsAndPackages() ... DONE
[15:32:13.828]  - globals found/used: [n=1] 'FUN'
[15:32:13.828]  - needed namespaces: [n=0] 
[15:32:13.828] Finding globals ... DONE
[15:32:13.829] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:13.829] List of 2
[15:32:13.829]  $ ...future.FUN:function (x, ...)  
[15:32:13.829]  $ MoreArgs     : NULL
[15:32:13.829]  - attr(*, "where")=List of 2
[15:32:13.829]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:13.829]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:13.829]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:13.829]  - attr(*, "resolved")= logi FALSE
[15:32:13.829]  - attr(*, "total_size")= num NA
[15:32:13.834] Packages to be attached in all futures: [n=0] 
[15:32:13.834] getGlobalsAndPackagesXApply() ... DONE
[15:32:13.835] Number of futures (= number of chunks): 2
[15:32:13.835] Launching 2 futures (chunks) ...
[15:32:13.835] Chunk #1 of 2 ...
[15:32:13.836]  - Finding globals in '...' for chunk #1 ...
[15:32:13.836] getGlobalsAndPackages() ...
[15:32:13.836] Searching for globals...
[15:32:13.837] 
[15:32:13.837] Searching for globals ... DONE
[15:32:13.837] - globals: [0] <none>
[15:32:13.837] getGlobalsAndPackages() ... DONE
[15:32:13.838]    + additional globals found: [n=0] 
[15:32:13.838]    + additional namespaces needed: [n=0] 
[15:32:13.838]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:13.838]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.839]  - seeds: <none>
[15:32:13.839]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.839] getGlobalsAndPackages() ...
[15:32:13.840] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.840] Resolving globals: FALSE
[15:32:13.841] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:13.842] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:13.842] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.843] 
[15:32:13.843] getGlobalsAndPackages() ... DONE
[15:32:13.843] run() for 'Future' ...
[15:32:13.844] - state: 'created'
[15:32:13.844] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.862] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.862] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.863]   - Field: 'node'
[15:32:13.863]   - Field: 'label'
[15:32:13.863]   - Field: 'local'
[15:32:13.864]   - Field: 'owner'
[15:32:13.864]   - Field: 'envir'
[15:32:13.864]   - Field: 'workers'
[15:32:13.865]   - Field: 'packages'
[15:32:13.865]   - Field: 'gc'
[15:32:13.865]   - Field: 'conditions'
[15:32:13.865]   - Field: 'persistent'
[15:32:13.866]   - Field: 'expr'
[15:32:13.866]   - Field: 'uuid'
[15:32:13.866]   - Field: 'seed'
[15:32:13.867]   - Field: 'version'
[15:32:13.867]   - Field: 'result'
[15:32:13.867]   - Field: 'asynchronous'
[15:32:13.867]   - Field: 'calls'
[15:32:13.868]   - Field: 'globals'
[15:32:13.868]   - Field: 'stdout'
[15:32:13.868]   - Field: 'earlySignal'
[15:32:13.869]   - Field: 'lazy'
[15:32:13.869]   - Field: 'state'
[15:32:13.869] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.869] - Launch lazy future ...
[15:32:13.870] Packages needed by the future expression (n = 0): <none>
[15:32:13.870] Packages needed by future strategies (n = 0): <none>
[15:32:13.871] {
[15:32:13.871]     {
[15:32:13.871]         {
[15:32:13.871]             ...future.startTime <- base::Sys.time()
[15:32:13.871]             {
[15:32:13.871]                 {
[15:32:13.871]                   {
[15:32:13.871]                     {
[15:32:13.871]                       base::local({
[15:32:13.871]                         has_future <- base::requireNamespace("future", 
[15:32:13.871]                           quietly = TRUE)
[15:32:13.871]                         if (has_future) {
[15:32:13.871]                           ns <- base::getNamespace("future")
[15:32:13.871]                           version <- ns[[".package"]][["version"]]
[15:32:13.871]                           if (is.null(version)) 
[15:32:13.871]                             version <- utils::packageVersion("future")
[15:32:13.871]                         }
[15:32:13.871]                         else {
[15:32:13.871]                           version <- NULL
[15:32:13.871]                         }
[15:32:13.871]                         if (!has_future || version < "1.8.0") {
[15:32:13.871]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.871]                             "", base::R.version$version.string), 
[15:32:13.871]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.871]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.871]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.871]                               "release", "version")], collapse = " "), 
[15:32:13.871]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.871]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.871]                             info)
[15:32:13.871]                           info <- base::paste(info, collapse = "; ")
[15:32:13.871]                           if (!has_future) {
[15:32:13.871]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.871]                               info)
[15:32:13.871]                           }
[15:32:13.871]                           else {
[15:32:13.871]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.871]                               info, version)
[15:32:13.871]                           }
[15:32:13.871]                           base::stop(msg)
[15:32:13.871]                         }
[15:32:13.871]                       })
[15:32:13.871]                     }
[15:32:13.871]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.871]                     base::options(mc.cores = 1L)
[15:32:13.871]                   }
[15:32:13.871]                   ...future.strategy.old <- future::plan("list")
[15:32:13.871]                   options(future.plan = NULL)
[15:32:13.871]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.871]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.871]                 }
[15:32:13.871]                 ...future.workdir <- getwd()
[15:32:13.871]             }
[15:32:13.871]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.871]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.871]         }
[15:32:13.871]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.871]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.871]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.871]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.871]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.871]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.871]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.871]             base::names(...future.oldOptions))
[15:32:13.871]     }
[15:32:13.871]     if (FALSE) {
[15:32:13.871]     }
[15:32:13.871]     else {
[15:32:13.871]         if (TRUE) {
[15:32:13.871]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.871]                 open = "w")
[15:32:13.871]         }
[15:32:13.871]         else {
[15:32:13.871]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.871]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.871]         }
[15:32:13.871]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.871]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.871]             base::sink(type = "output", split = FALSE)
[15:32:13.871]             base::close(...future.stdout)
[15:32:13.871]         }, add = TRUE)
[15:32:13.871]     }
[15:32:13.871]     ...future.frame <- base::sys.nframe()
[15:32:13.871]     ...future.conditions <- base::list()
[15:32:13.871]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.871]     if (FALSE) {
[15:32:13.871]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.871]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.871]     }
[15:32:13.871]     ...future.result <- base::tryCatch({
[15:32:13.871]         base::withCallingHandlers({
[15:32:13.871]             ...future.value <- base::withVisible(base::local({
[15:32:13.871]                 ...future.makeSendCondition <- base::local({
[15:32:13.871]                   sendCondition <- NULL
[15:32:13.871]                   function(frame = 1L) {
[15:32:13.871]                     if (is.function(sendCondition)) 
[15:32:13.871]                       return(sendCondition)
[15:32:13.871]                     ns <- getNamespace("parallel")
[15:32:13.871]                     if (exists("sendData", mode = "function", 
[15:32:13.871]                       envir = ns)) {
[15:32:13.871]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.871]                         envir = ns)
[15:32:13.871]                       envir <- sys.frame(frame)
[15:32:13.871]                       master <- NULL
[15:32:13.871]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.871]                         !identical(envir, emptyenv())) {
[15:32:13.871]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.871]                           inherits = FALSE)) {
[15:32:13.871]                           master <- get("master", mode = "list", 
[15:32:13.871]                             envir = envir, inherits = FALSE)
[15:32:13.871]                           if (inherits(master, c("SOCKnode", 
[15:32:13.871]                             "SOCK0node"))) {
[15:32:13.871]                             sendCondition <<- function(cond) {
[15:32:13.871]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.871]                                 success = TRUE)
[15:32:13.871]                               parallel_sendData(master, data)
[15:32:13.871]                             }
[15:32:13.871]                             return(sendCondition)
[15:32:13.871]                           }
[15:32:13.871]                         }
[15:32:13.871]                         frame <- frame + 1L
[15:32:13.871]                         envir <- sys.frame(frame)
[15:32:13.871]                       }
[15:32:13.871]                     }
[15:32:13.871]                     sendCondition <<- function(cond) NULL
[15:32:13.871]                   }
[15:32:13.871]                 })
[15:32:13.871]                 withCallingHandlers({
[15:32:13.871]                   {
[15:32:13.871]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.871]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.871]                       ...future.globals.maxSize)) {
[15:32:13.871]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.871]                       on.exit(options(oopts), add = TRUE)
[15:32:13.871]                     }
[15:32:13.871]                     {
[15:32:13.871]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.871]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.871]                         USE.NAMES = FALSE)
[15:32:13.871]                       do.call(mapply, args = args)
[15:32:13.871]                     }
[15:32:13.871]                   }
[15:32:13.871]                 }, immediateCondition = function(cond) {
[15:32:13.871]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.871]                   sendCondition(cond)
[15:32:13.871]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.871]                   {
[15:32:13.871]                     inherits <- base::inherits
[15:32:13.871]                     invokeRestart <- base::invokeRestart
[15:32:13.871]                     is.null <- base::is.null
[15:32:13.871]                     muffled <- FALSE
[15:32:13.871]                     if (inherits(cond, "message")) {
[15:32:13.871]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.871]                       if (muffled) 
[15:32:13.871]                         invokeRestart("muffleMessage")
[15:32:13.871]                     }
[15:32:13.871]                     else if (inherits(cond, "warning")) {
[15:32:13.871]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.871]                       if (muffled) 
[15:32:13.871]                         invokeRestart("muffleWarning")
[15:32:13.871]                     }
[15:32:13.871]                     else if (inherits(cond, "condition")) {
[15:32:13.871]                       if (!is.null(pattern)) {
[15:32:13.871]                         computeRestarts <- base::computeRestarts
[15:32:13.871]                         grepl <- base::grepl
[15:32:13.871]                         restarts <- computeRestarts(cond)
[15:32:13.871]                         for (restart in restarts) {
[15:32:13.871]                           name <- restart$name
[15:32:13.871]                           if (is.null(name)) 
[15:32:13.871]                             next
[15:32:13.871]                           if (!grepl(pattern, name)) 
[15:32:13.871]                             next
[15:32:13.871]                           invokeRestart(restart)
[15:32:13.871]                           muffled <- TRUE
[15:32:13.871]                           break
[15:32:13.871]                         }
[15:32:13.871]                       }
[15:32:13.871]                     }
[15:32:13.871]                     invisible(muffled)
[15:32:13.871]                   }
[15:32:13.871]                   muffleCondition(cond)
[15:32:13.871]                 })
[15:32:13.871]             }))
[15:32:13.871]             future::FutureResult(value = ...future.value$value, 
[15:32:13.871]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.871]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.871]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.871]                     ...future.globalenv.names))
[15:32:13.871]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.871]         }, condition = base::local({
[15:32:13.871]             c <- base::c
[15:32:13.871]             inherits <- base::inherits
[15:32:13.871]             invokeRestart <- base::invokeRestart
[15:32:13.871]             length <- base::length
[15:32:13.871]             list <- base::list
[15:32:13.871]             seq.int <- base::seq.int
[15:32:13.871]             signalCondition <- base::signalCondition
[15:32:13.871]             sys.calls <- base::sys.calls
[15:32:13.871]             `[[` <- base::`[[`
[15:32:13.871]             `+` <- base::`+`
[15:32:13.871]             `<<-` <- base::`<<-`
[15:32:13.871]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.871]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.871]                   3L)]
[15:32:13.871]             }
[15:32:13.871]             function(cond) {
[15:32:13.871]                 is_error <- inherits(cond, "error")
[15:32:13.871]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.871]                   NULL)
[15:32:13.871]                 if (is_error) {
[15:32:13.871]                   sessionInformation <- function() {
[15:32:13.871]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.871]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.871]                       search = base::search(), system = base::Sys.info())
[15:32:13.871]                   }
[15:32:13.871]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.871]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.871]                     cond$call), session = sessionInformation(), 
[15:32:13.871]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.871]                   signalCondition(cond)
[15:32:13.871]                 }
[15:32:13.871]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.871]                 "immediateCondition"))) {
[15:32:13.871]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.871]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.871]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.871]                   if (TRUE && !signal) {
[15:32:13.871]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.871]                     {
[15:32:13.871]                       inherits <- base::inherits
[15:32:13.871]                       invokeRestart <- base::invokeRestart
[15:32:13.871]                       is.null <- base::is.null
[15:32:13.871]                       muffled <- FALSE
[15:32:13.871]                       if (inherits(cond, "message")) {
[15:32:13.871]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.871]                         if (muffled) 
[15:32:13.871]                           invokeRestart("muffleMessage")
[15:32:13.871]                       }
[15:32:13.871]                       else if (inherits(cond, "warning")) {
[15:32:13.871]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.871]                         if (muffled) 
[15:32:13.871]                           invokeRestart("muffleWarning")
[15:32:13.871]                       }
[15:32:13.871]                       else if (inherits(cond, "condition")) {
[15:32:13.871]                         if (!is.null(pattern)) {
[15:32:13.871]                           computeRestarts <- base::computeRestarts
[15:32:13.871]                           grepl <- base::grepl
[15:32:13.871]                           restarts <- computeRestarts(cond)
[15:32:13.871]                           for (restart in restarts) {
[15:32:13.871]                             name <- restart$name
[15:32:13.871]                             if (is.null(name)) 
[15:32:13.871]                               next
[15:32:13.871]                             if (!grepl(pattern, name)) 
[15:32:13.871]                               next
[15:32:13.871]                             invokeRestart(restart)
[15:32:13.871]                             muffled <- TRUE
[15:32:13.871]                             break
[15:32:13.871]                           }
[15:32:13.871]                         }
[15:32:13.871]                       }
[15:32:13.871]                       invisible(muffled)
[15:32:13.871]                     }
[15:32:13.871]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.871]                   }
[15:32:13.871]                 }
[15:32:13.871]                 else {
[15:32:13.871]                   if (TRUE) {
[15:32:13.871]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.871]                     {
[15:32:13.871]                       inherits <- base::inherits
[15:32:13.871]                       invokeRestart <- base::invokeRestart
[15:32:13.871]                       is.null <- base::is.null
[15:32:13.871]                       muffled <- FALSE
[15:32:13.871]                       if (inherits(cond, "message")) {
[15:32:13.871]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.871]                         if (muffled) 
[15:32:13.871]                           invokeRestart("muffleMessage")
[15:32:13.871]                       }
[15:32:13.871]                       else if (inherits(cond, "warning")) {
[15:32:13.871]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.871]                         if (muffled) 
[15:32:13.871]                           invokeRestart("muffleWarning")
[15:32:13.871]                       }
[15:32:13.871]                       else if (inherits(cond, "condition")) {
[15:32:13.871]                         if (!is.null(pattern)) {
[15:32:13.871]                           computeRestarts <- base::computeRestarts
[15:32:13.871]                           grepl <- base::grepl
[15:32:13.871]                           restarts <- computeRestarts(cond)
[15:32:13.871]                           for (restart in restarts) {
[15:32:13.871]                             name <- restart$name
[15:32:13.871]                             if (is.null(name)) 
[15:32:13.871]                               next
[15:32:13.871]                             if (!grepl(pattern, name)) 
[15:32:13.871]                               next
[15:32:13.871]                             invokeRestart(restart)
[15:32:13.871]                             muffled <- TRUE
[15:32:13.871]                             break
[15:32:13.871]                           }
[15:32:13.871]                         }
[15:32:13.871]                       }
[15:32:13.871]                       invisible(muffled)
[15:32:13.871]                     }
[15:32:13.871]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.871]                   }
[15:32:13.871]                 }
[15:32:13.871]             }
[15:32:13.871]         }))
[15:32:13.871]     }, error = function(ex) {
[15:32:13.871]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.871]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.871]                 ...future.rng), started = ...future.startTime, 
[15:32:13.871]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.871]             version = "1.8"), class = "FutureResult")
[15:32:13.871]     }, finally = {
[15:32:13.871]         if (!identical(...future.workdir, getwd())) 
[15:32:13.871]             setwd(...future.workdir)
[15:32:13.871]         {
[15:32:13.871]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.871]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.871]             }
[15:32:13.871]             base::options(...future.oldOptions)
[15:32:13.871]             if (.Platform$OS.type == "windows") {
[15:32:13.871]                 old_names <- names(...future.oldEnvVars)
[15:32:13.871]                 envs <- base::Sys.getenv()
[15:32:13.871]                 names <- names(envs)
[15:32:13.871]                 common <- intersect(names, old_names)
[15:32:13.871]                 added <- setdiff(names, old_names)
[15:32:13.871]                 removed <- setdiff(old_names, names)
[15:32:13.871]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.871]                   envs[common]]
[15:32:13.871]                 NAMES <- toupper(changed)
[15:32:13.871]                 args <- list()
[15:32:13.871]                 for (kk in seq_along(NAMES)) {
[15:32:13.871]                   name <- changed[[kk]]
[15:32:13.871]                   NAME <- NAMES[[kk]]
[15:32:13.871]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.871]                     next
[15:32:13.871]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.871]                 }
[15:32:13.871]                 NAMES <- toupper(added)
[15:32:13.871]                 for (kk in seq_along(NAMES)) {
[15:32:13.871]                   name <- added[[kk]]
[15:32:13.871]                   NAME <- NAMES[[kk]]
[15:32:13.871]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.871]                     next
[15:32:13.871]                   args[[name]] <- ""
[15:32:13.871]                 }
[15:32:13.871]                 NAMES <- toupper(removed)
[15:32:13.871]                 for (kk in seq_along(NAMES)) {
[15:32:13.871]                   name <- removed[[kk]]
[15:32:13.871]                   NAME <- NAMES[[kk]]
[15:32:13.871]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.871]                     next
[15:32:13.871]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.871]                 }
[15:32:13.871]                 if (length(args) > 0) 
[15:32:13.871]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.871]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.871]             }
[15:32:13.871]             else {
[15:32:13.871]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.871]             }
[15:32:13.871]             {
[15:32:13.871]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.871]                   0L) {
[15:32:13.871]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.871]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.871]                   base::options(opts)
[15:32:13.871]                 }
[15:32:13.871]                 {
[15:32:13.871]                   {
[15:32:13.871]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.871]                     NULL
[15:32:13.871]                   }
[15:32:13.871]                   options(future.plan = NULL)
[15:32:13.871]                   if (is.na(NA_character_)) 
[15:32:13.871]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.871]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.871]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.871]                     .init = FALSE)
[15:32:13.871]                 }
[15:32:13.871]             }
[15:32:13.871]         }
[15:32:13.871]     })
[15:32:13.871]     if (TRUE) {
[15:32:13.871]         base::sink(type = "output", split = FALSE)
[15:32:13.871]         if (TRUE) {
[15:32:13.871]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.871]         }
[15:32:13.871]         else {
[15:32:13.871]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.871]         }
[15:32:13.871]         base::close(...future.stdout)
[15:32:13.871]         ...future.stdout <- NULL
[15:32:13.871]     }
[15:32:13.871]     ...future.result$conditions <- ...future.conditions
[15:32:13.871]     ...future.result$finished <- base::Sys.time()
[15:32:13.871]     ...future.result
[15:32:13.871] }
[15:32:13.881] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:13.881] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:13.882] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:13.882] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:13.882] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:13.883] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:13.883] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:13.883] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.884] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.884] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.884] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.885] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:13.885] MultisessionFuture started
[15:32:13.885] - Launch lazy future ... done
[15:32:13.886] run() for 'MultisessionFuture' ... done
[15:32:13.886] Created future:
[15:32:13.916] receiveMessageFromWorker() for ClusterFuture ...
[15:32:13.917] - Validating connection of MultisessionFuture
[15:32:13.918] - received message: FutureResult
[15:32:13.918] - Received FutureResult
[15:32:13.918] - Erased future from FutureRegistry
[15:32:13.919] result() for ClusterFuture ...
[15:32:13.919] - result already collected: FutureResult
[15:32:13.919] result() for ClusterFuture ... done
[15:32:13.920] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.886] MultisessionFuture:
[15:32:13.886] Label: 'future_mapply-1'
[15:32:13.886] Expression:
[15:32:13.886] {
[15:32:13.886]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.886]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.886]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.886]         on.exit(options(oopts), add = TRUE)
[15:32:13.886]     }
[15:32:13.886]     {
[15:32:13.886]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.886]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.886]         do.call(mapply, args = args)
[15:32:13.886]     }
[15:32:13.886] }
[15:32:13.886] Lazy evaluation: FALSE
[15:32:13.886] Asynchronous evaluation: TRUE
[15:32:13.886] Local evaluation: TRUE
[15:32:13.886] Environment: R_GlobalEnv
[15:32:13.886] Capture standard output: TRUE
[15:32:13.886] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.886] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:13.886] Packages: <none>
[15:32:13.886] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.886] Resolved: TRUE
[15:32:13.886] Value: <not collected>
[15:32:13.886] Conditions captured: <none>
[15:32:13.886] Early signaling: FALSE
[15:32:13.886] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.886] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.920] Chunk #1 of 2 ... DONE
[15:32:13.921] Chunk #2 of 2 ...
[15:32:13.921]  - Finding globals in '...' for chunk #2 ...
[15:32:13.921] getGlobalsAndPackages() ...
[15:32:13.922] Searching for globals...
[15:32:13.923] 
[15:32:13.923] Searching for globals ... DONE
[15:32:13.923] - globals: [0] <none>
[15:32:13.923] getGlobalsAndPackages() ... DONE
[15:32:13.924]    + additional globals found: [n=0] 
[15:32:13.924]    + additional namespaces needed: [n=0] 
[15:32:13.924]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:13.925]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:13.925]  - seeds: <none>
[15:32:13.925]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.926] getGlobalsAndPackages() ...
[15:32:13.926] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.926] Resolving globals: FALSE
[15:32:13.927] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:13.929] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:13.929] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:13.929] 
[15:32:13.930] getGlobalsAndPackages() ... DONE
[15:32:13.930] run() for 'Future' ...
[15:32:13.931] - state: 'created'
[15:32:13.931] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:13.951] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:13.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:13.952]   - Field: 'node'
[15:32:13.952]   - Field: 'label'
[15:32:13.952]   - Field: 'local'
[15:32:13.953]   - Field: 'owner'
[15:32:13.953]   - Field: 'envir'
[15:32:13.953]   - Field: 'workers'
[15:32:13.953]   - Field: 'packages'
[15:32:13.954]   - Field: 'gc'
[15:32:13.954]   - Field: 'conditions'
[15:32:13.954]   - Field: 'persistent'
[15:32:13.955]   - Field: 'expr'
[15:32:13.955]   - Field: 'uuid'
[15:32:13.955]   - Field: 'seed'
[15:32:13.956]   - Field: 'version'
[15:32:13.956]   - Field: 'result'
[15:32:13.956]   - Field: 'asynchronous'
[15:32:13.957]   - Field: 'calls'
[15:32:13.957]   - Field: 'globals'
[15:32:13.957]   - Field: 'stdout'
[15:32:13.958]   - Field: 'earlySignal'
[15:32:13.958]   - Field: 'lazy'
[15:32:13.958]   - Field: 'state'
[15:32:13.959] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:13.959] - Launch lazy future ...
[15:32:13.960] Packages needed by the future expression (n = 0): <none>
[15:32:13.960] Packages needed by future strategies (n = 0): <none>
[15:32:13.961] {
[15:32:13.961]     {
[15:32:13.961]         {
[15:32:13.961]             ...future.startTime <- base::Sys.time()
[15:32:13.961]             {
[15:32:13.961]                 {
[15:32:13.961]                   {
[15:32:13.961]                     {
[15:32:13.961]                       base::local({
[15:32:13.961]                         has_future <- base::requireNamespace("future", 
[15:32:13.961]                           quietly = TRUE)
[15:32:13.961]                         if (has_future) {
[15:32:13.961]                           ns <- base::getNamespace("future")
[15:32:13.961]                           version <- ns[[".package"]][["version"]]
[15:32:13.961]                           if (is.null(version)) 
[15:32:13.961]                             version <- utils::packageVersion("future")
[15:32:13.961]                         }
[15:32:13.961]                         else {
[15:32:13.961]                           version <- NULL
[15:32:13.961]                         }
[15:32:13.961]                         if (!has_future || version < "1.8.0") {
[15:32:13.961]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:13.961]                             "", base::R.version$version.string), 
[15:32:13.961]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:13.961]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:13.961]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:13.961]                               "release", "version")], collapse = " "), 
[15:32:13.961]                             hostname = base::Sys.info()[["nodename"]])
[15:32:13.961]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:13.961]                             info)
[15:32:13.961]                           info <- base::paste(info, collapse = "; ")
[15:32:13.961]                           if (!has_future) {
[15:32:13.961]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:13.961]                               info)
[15:32:13.961]                           }
[15:32:13.961]                           else {
[15:32:13.961]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:13.961]                               info, version)
[15:32:13.961]                           }
[15:32:13.961]                           base::stop(msg)
[15:32:13.961]                         }
[15:32:13.961]                       })
[15:32:13.961]                     }
[15:32:13.961]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:13.961]                     base::options(mc.cores = 1L)
[15:32:13.961]                   }
[15:32:13.961]                   ...future.strategy.old <- future::plan("list")
[15:32:13.961]                   options(future.plan = NULL)
[15:32:13.961]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.961]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:13.961]                 }
[15:32:13.961]                 ...future.workdir <- getwd()
[15:32:13.961]             }
[15:32:13.961]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:13.961]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:13.961]         }
[15:32:13.961]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:13.961]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:13.961]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:13.961]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:13.961]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:13.961]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:13.961]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:13.961]             base::names(...future.oldOptions))
[15:32:13.961]     }
[15:32:13.961]     if (FALSE) {
[15:32:13.961]     }
[15:32:13.961]     else {
[15:32:13.961]         if (TRUE) {
[15:32:13.961]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:13.961]                 open = "w")
[15:32:13.961]         }
[15:32:13.961]         else {
[15:32:13.961]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:13.961]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:13.961]         }
[15:32:13.961]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:13.961]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:13.961]             base::sink(type = "output", split = FALSE)
[15:32:13.961]             base::close(...future.stdout)
[15:32:13.961]         }, add = TRUE)
[15:32:13.961]     }
[15:32:13.961]     ...future.frame <- base::sys.nframe()
[15:32:13.961]     ...future.conditions <- base::list()
[15:32:13.961]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:13.961]     if (FALSE) {
[15:32:13.961]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:13.961]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:13.961]     }
[15:32:13.961]     ...future.result <- base::tryCatch({
[15:32:13.961]         base::withCallingHandlers({
[15:32:13.961]             ...future.value <- base::withVisible(base::local({
[15:32:13.961]                 ...future.makeSendCondition <- base::local({
[15:32:13.961]                   sendCondition <- NULL
[15:32:13.961]                   function(frame = 1L) {
[15:32:13.961]                     if (is.function(sendCondition)) 
[15:32:13.961]                       return(sendCondition)
[15:32:13.961]                     ns <- getNamespace("parallel")
[15:32:13.961]                     if (exists("sendData", mode = "function", 
[15:32:13.961]                       envir = ns)) {
[15:32:13.961]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:13.961]                         envir = ns)
[15:32:13.961]                       envir <- sys.frame(frame)
[15:32:13.961]                       master <- NULL
[15:32:13.961]                       while (!identical(envir, .GlobalEnv) && 
[15:32:13.961]                         !identical(envir, emptyenv())) {
[15:32:13.961]                         if (exists("master", mode = "list", envir = envir, 
[15:32:13.961]                           inherits = FALSE)) {
[15:32:13.961]                           master <- get("master", mode = "list", 
[15:32:13.961]                             envir = envir, inherits = FALSE)
[15:32:13.961]                           if (inherits(master, c("SOCKnode", 
[15:32:13.961]                             "SOCK0node"))) {
[15:32:13.961]                             sendCondition <<- function(cond) {
[15:32:13.961]                               data <- list(type = "VALUE", value = cond, 
[15:32:13.961]                                 success = TRUE)
[15:32:13.961]                               parallel_sendData(master, data)
[15:32:13.961]                             }
[15:32:13.961]                             return(sendCondition)
[15:32:13.961]                           }
[15:32:13.961]                         }
[15:32:13.961]                         frame <- frame + 1L
[15:32:13.961]                         envir <- sys.frame(frame)
[15:32:13.961]                       }
[15:32:13.961]                     }
[15:32:13.961]                     sendCondition <<- function(cond) NULL
[15:32:13.961]                   }
[15:32:13.961]                 })
[15:32:13.961]                 withCallingHandlers({
[15:32:13.961]                   {
[15:32:13.961]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.961]                     if (!identical(...future.globals.maxSize.org, 
[15:32:13.961]                       ...future.globals.maxSize)) {
[15:32:13.961]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.961]                       on.exit(options(oopts), add = TRUE)
[15:32:13.961]                     }
[15:32:13.961]                     {
[15:32:13.961]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.961]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:13.961]                         USE.NAMES = FALSE)
[15:32:13.961]                       do.call(mapply, args = args)
[15:32:13.961]                     }
[15:32:13.961]                   }
[15:32:13.961]                 }, immediateCondition = function(cond) {
[15:32:13.961]                   sendCondition <- ...future.makeSendCondition()
[15:32:13.961]                   sendCondition(cond)
[15:32:13.961]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.961]                   {
[15:32:13.961]                     inherits <- base::inherits
[15:32:13.961]                     invokeRestart <- base::invokeRestart
[15:32:13.961]                     is.null <- base::is.null
[15:32:13.961]                     muffled <- FALSE
[15:32:13.961]                     if (inherits(cond, "message")) {
[15:32:13.961]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:13.961]                       if (muffled) 
[15:32:13.961]                         invokeRestart("muffleMessage")
[15:32:13.961]                     }
[15:32:13.961]                     else if (inherits(cond, "warning")) {
[15:32:13.961]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:13.961]                       if (muffled) 
[15:32:13.961]                         invokeRestart("muffleWarning")
[15:32:13.961]                     }
[15:32:13.961]                     else if (inherits(cond, "condition")) {
[15:32:13.961]                       if (!is.null(pattern)) {
[15:32:13.961]                         computeRestarts <- base::computeRestarts
[15:32:13.961]                         grepl <- base::grepl
[15:32:13.961]                         restarts <- computeRestarts(cond)
[15:32:13.961]                         for (restart in restarts) {
[15:32:13.961]                           name <- restart$name
[15:32:13.961]                           if (is.null(name)) 
[15:32:13.961]                             next
[15:32:13.961]                           if (!grepl(pattern, name)) 
[15:32:13.961]                             next
[15:32:13.961]                           invokeRestart(restart)
[15:32:13.961]                           muffled <- TRUE
[15:32:13.961]                           break
[15:32:13.961]                         }
[15:32:13.961]                       }
[15:32:13.961]                     }
[15:32:13.961]                     invisible(muffled)
[15:32:13.961]                   }
[15:32:13.961]                   muffleCondition(cond)
[15:32:13.961]                 })
[15:32:13.961]             }))
[15:32:13.961]             future::FutureResult(value = ...future.value$value, 
[15:32:13.961]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.961]                   ...future.rng), globalenv = if (FALSE) 
[15:32:13.961]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:13.961]                     ...future.globalenv.names))
[15:32:13.961]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:13.961]         }, condition = base::local({
[15:32:13.961]             c <- base::c
[15:32:13.961]             inherits <- base::inherits
[15:32:13.961]             invokeRestart <- base::invokeRestart
[15:32:13.961]             length <- base::length
[15:32:13.961]             list <- base::list
[15:32:13.961]             seq.int <- base::seq.int
[15:32:13.961]             signalCondition <- base::signalCondition
[15:32:13.961]             sys.calls <- base::sys.calls
[15:32:13.961]             `[[` <- base::`[[`
[15:32:13.961]             `+` <- base::`+`
[15:32:13.961]             `<<-` <- base::`<<-`
[15:32:13.961]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:13.961]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:13.961]                   3L)]
[15:32:13.961]             }
[15:32:13.961]             function(cond) {
[15:32:13.961]                 is_error <- inherits(cond, "error")
[15:32:13.961]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:13.961]                   NULL)
[15:32:13.961]                 if (is_error) {
[15:32:13.961]                   sessionInformation <- function() {
[15:32:13.961]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:13.961]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:13.961]                       search = base::search(), system = base::Sys.info())
[15:32:13.961]                   }
[15:32:13.961]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.961]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:13.961]                     cond$call), session = sessionInformation(), 
[15:32:13.961]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:13.961]                   signalCondition(cond)
[15:32:13.961]                 }
[15:32:13.961]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:13.961]                 "immediateCondition"))) {
[15:32:13.961]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:13.961]                   ...future.conditions[[length(...future.conditions) + 
[15:32:13.961]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:13.961]                   if (TRUE && !signal) {
[15:32:13.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.961]                     {
[15:32:13.961]                       inherits <- base::inherits
[15:32:13.961]                       invokeRestart <- base::invokeRestart
[15:32:13.961]                       is.null <- base::is.null
[15:32:13.961]                       muffled <- FALSE
[15:32:13.961]                       if (inherits(cond, "message")) {
[15:32:13.961]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.961]                         if (muffled) 
[15:32:13.961]                           invokeRestart("muffleMessage")
[15:32:13.961]                       }
[15:32:13.961]                       else if (inherits(cond, "warning")) {
[15:32:13.961]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.961]                         if (muffled) 
[15:32:13.961]                           invokeRestart("muffleWarning")
[15:32:13.961]                       }
[15:32:13.961]                       else if (inherits(cond, "condition")) {
[15:32:13.961]                         if (!is.null(pattern)) {
[15:32:13.961]                           computeRestarts <- base::computeRestarts
[15:32:13.961]                           grepl <- base::grepl
[15:32:13.961]                           restarts <- computeRestarts(cond)
[15:32:13.961]                           for (restart in restarts) {
[15:32:13.961]                             name <- restart$name
[15:32:13.961]                             if (is.null(name)) 
[15:32:13.961]                               next
[15:32:13.961]                             if (!grepl(pattern, name)) 
[15:32:13.961]                               next
[15:32:13.961]                             invokeRestart(restart)
[15:32:13.961]                             muffled <- TRUE
[15:32:13.961]                             break
[15:32:13.961]                           }
[15:32:13.961]                         }
[15:32:13.961]                       }
[15:32:13.961]                       invisible(muffled)
[15:32:13.961]                     }
[15:32:13.961]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.961]                   }
[15:32:13.961]                 }
[15:32:13.961]                 else {
[15:32:13.961]                   if (TRUE) {
[15:32:13.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:13.961]                     {
[15:32:13.961]                       inherits <- base::inherits
[15:32:13.961]                       invokeRestart <- base::invokeRestart
[15:32:13.961]                       is.null <- base::is.null
[15:32:13.961]                       muffled <- FALSE
[15:32:13.961]                       if (inherits(cond, "message")) {
[15:32:13.961]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:13.961]                         if (muffled) 
[15:32:13.961]                           invokeRestart("muffleMessage")
[15:32:13.961]                       }
[15:32:13.961]                       else if (inherits(cond, "warning")) {
[15:32:13.961]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:13.961]                         if (muffled) 
[15:32:13.961]                           invokeRestart("muffleWarning")
[15:32:13.961]                       }
[15:32:13.961]                       else if (inherits(cond, "condition")) {
[15:32:13.961]                         if (!is.null(pattern)) {
[15:32:13.961]                           computeRestarts <- base::computeRestarts
[15:32:13.961]                           grepl <- base::grepl
[15:32:13.961]                           restarts <- computeRestarts(cond)
[15:32:13.961]                           for (restart in restarts) {
[15:32:13.961]                             name <- restart$name
[15:32:13.961]                             if (is.null(name)) 
[15:32:13.961]                               next
[15:32:13.961]                             if (!grepl(pattern, name)) 
[15:32:13.961]                               next
[15:32:13.961]                             invokeRestart(restart)
[15:32:13.961]                             muffled <- TRUE
[15:32:13.961]                             break
[15:32:13.961]                           }
[15:32:13.961]                         }
[15:32:13.961]                       }
[15:32:13.961]                       invisible(muffled)
[15:32:13.961]                     }
[15:32:13.961]                     muffleCondition(cond, pattern = "^muffle")
[15:32:13.961]                   }
[15:32:13.961]                 }
[15:32:13.961]             }
[15:32:13.961]         }))
[15:32:13.961]     }, error = function(ex) {
[15:32:13.961]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:13.961]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:13.961]                 ...future.rng), started = ...future.startTime, 
[15:32:13.961]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:13.961]             version = "1.8"), class = "FutureResult")
[15:32:13.961]     }, finally = {
[15:32:13.961]         if (!identical(...future.workdir, getwd())) 
[15:32:13.961]             setwd(...future.workdir)
[15:32:13.961]         {
[15:32:13.961]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:13.961]                 ...future.oldOptions$nwarnings <- NULL
[15:32:13.961]             }
[15:32:13.961]             base::options(...future.oldOptions)
[15:32:13.961]             if (.Platform$OS.type == "windows") {
[15:32:13.961]                 old_names <- names(...future.oldEnvVars)
[15:32:13.961]                 envs <- base::Sys.getenv()
[15:32:13.961]                 names <- names(envs)
[15:32:13.961]                 common <- intersect(names, old_names)
[15:32:13.961]                 added <- setdiff(names, old_names)
[15:32:13.961]                 removed <- setdiff(old_names, names)
[15:32:13.961]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:13.961]                   envs[common]]
[15:32:13.961]                 NAMES <- toupper(changed)
[15:32:13.961]                 args <- list()
[15:32:13.961]                 for (kk in seq_along(NAMES)) {
[15:32:13.961]                   name <- changed[[kk]]
[15:32:13.961]                   NAME <- NAMES[[kk]]
[15:32:13.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.961]                     next
[15:32:13.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.961]                 }
[15:32:13.961]                 NAMES <- toupper(added)
[15:32:13.961]                 for (kk in seq_along(NAMES)) {
[15:32:13.961]                   name <- added[[kk]]
[15:32:13.961]                   NAME <- NAMES[[kk]]
[15:32:13.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.961]                     next
[15:32:13.961]                   args[[name]] <- ""
[15:32:13.961]                 }
[15:32:13.961]                 NAMES <- toupper(removed)
[15:32:13.961]                 for (kk in seq_along(NAMES)) {
[15:32:13.961]                   name <- removed[[kk]]
[15:32:13.961]                   NAME <- NAMES[[kk]]
[15:32:13.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:13.961]                     next
[15:32:13.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:13.961]                 }
[15:32:13.961]                 if (length(args) > 0) 
[15:32:13.961]                   base::do.call(base::Sys.setenv, args = args)
[15:32:13.961]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:13.961]             }
[15:32:13.961]             else {
[15:32:13.961]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:13.961]             }
[15:32:13.961]             {
[15:32:13.961]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:13.961]                   0L) {
[15:32:13.961]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:13.961]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:13.961]                   base::options(opts)
[15:32:13.961]                 }
[15:32:13.961]                 {
[15:32:13.961]                   {
[15:32:13.961]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:13.961]                     NULL
[15:32:13.961]                   }
[15:32:13.961]                   options(future.plan = NULL)
[15:32:13.961]                   if (is.na(NA_character_)) 
[15:32:13.961]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:13.961]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:13.961]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:13.961]                     .init = FALSE)
[15:32:13.961]                 }
[15:32:13.961]             }
[15:32:13.961]         }
[15:32:13.961]     })
[15:32:13.961]     if (TRUE) {
[15:32:13.961]         base::sink(type = "output", split = FALSE)
[15:32:13.961]         if (TRUE) {
[15:32:13.961]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:13.961]         }
[15:32:13.961]         else {
[15:32:13.961]             ...future.result["stdout"] <- base::list(NULL)
[15:32:13.961]         }
[15:32:13.961]         base::close(...future.stdout)
[15:32:13.961]         ...future.stdout <- NULL
[15:32:13.961]     }
[15:32:13.961]     ...future.result$conditions <- ...future.conditions
[15:32:13.961]     ...future.result$finished <- base::Sys.time()
[15:32:13.961]     ...future.result
[15:32:13.961] }
[15:32:13.971] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:13.972] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:13.973] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:13.974] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:13.975] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:13.975] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:13.976] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:13.976] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:13.981] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:13.982] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:13.982] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:13.982] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:13.983] MultisessionFuture started
[15:32:13.983] - Launch lazy future ... done
[15:32:13.984] run() for 'MultisessionFuture' ... done
[15:32:13.984] Created future:
[15:32:14.011] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.012] - Validating connection of MultisessionFuture
[15:32:14.013] - received message: FutureResult
[15:32:14.013] - Received FutureResult
[15:32:14.013] - Erased future from FutureRegistry
[15:32:14.014] result() for ClusterFuture ...
[15:32:14.014] - result already collected: FutureResult
[15:32:14.014] result() for ClusterFuture ... done
[15:32:14.014] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:13.984] MultisessionFuture:
[15:32:13.984] Label: 'future_mapply-2'
[15:32:13.984] Expression:
[15:32:13.984] {
[15:32:13.984]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:13.984]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:13.984]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:13.984]         on.exit(options(oopts), add = TRUE)
[15:32:13.984]     }
[15:32:13.984]     {
[15:32:13.984]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:13.984]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:13.984]         do.call(mapply, args = args)
[15:32:13.984]     }
[15:32:13.984] }
[15:32:13.984] Lazy evaluation: FALSE
[15:32:13.984] Asynchronous evaluation: TRUE
[15:32:13.984] Local evaluation: TRUE
[15:32:13.984] Environment: R_GlobalEnv
[15:32:13.984] Capture standard output: TRUE
[15:32:13.984] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:13.984] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:13.984] Packages: <none>
[15:32:13.984] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:13.984] Resolved: TRUE
[15:32:13.984] Value: <not collected>
[15:32:13.984] Conditions captured: <none>
[15:32:13.984] Early signaling: FALSE
[15:32:13.984] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:13.984] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.015] Chunk #2 of 2 ... DONE
[15:32:14.016] Launching 2 futures (chunks) ... DONE
[15:32:14.016] Resolving 2 futures (chunks) ...
[15:32:14.016] resolve() on list ...
[15:32:14.016]  recursive: 0
[15:32:14.016]  length: 2
[15:32:14.016] 
[15:32:14.017] Future #1
[15:32:14.017] result() for ClusterFuture ...
[15:32:14.017] - result already collected: FutureResult
[15:32:14.017] result() for ClusterFuture ... done
[15:32:14.017] result() for ClusterFuture ...
[15:32:14.017] - result already collected: FutureResult
[15:32:14.018] result() for ClusterFuture ... done
[15:32:14.018] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:14.018] - nx: 2
[15:32:14.018] - relay: TRUE
[15:32:14.018] - stdout: TRUE
[15:32:14.018] - signal: TRUE
[15:32:14.019] - resignal: FALSE
[15:32:14.019] - force: TRUE
[15:32:14.019] - relayed: [n=2] FALSE, FALSE
[15:32:14.019] - queued futures: [n=2] FALSE, FALSE
[15:32:14.019]  - until=1
[15:32:14.019]  - relaying element #1
[15:32:14.019] result() for ClusterFuture ...
[15:32:14.020] - result already collected: FutureResult
[15:32:14.020] result() for ClusterFuture ... done
[15:32:14.020] result() for ClusterFuture ...
[15:32:14.020] - result already collected: FutureResult
[15:32:14.020] result() for ClusterFuture ... done
[15:32:14.021] result() for ClusterFuture ...
[15:32:14.021] - result already collected: FutureResult
[15:32:14.021] result() for ClusterFuture ... done
[15:32:14.021] result() for ClusterFuture ...
[15:32:14.021] - result already collected: FutureResult
[15:32:14.021] result() for ClusterFuture ... done
[15:32:14.021] - relayed: [n=2] TRUE, FALSE
[15:32:14.022] - queued futures: [n=2] TRUE, FALSE
[15:32:14.022] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:14.022]  length: 1 (resolved future 1)
[15:32:14.022] Future #2
[15:32:14.022] result() for ClusterFuture ...
[15:32:14.022] - result already collected: FutureResult
[15:32:14.023] result() for ClusterFuture ... done
[15:32:14.023] result() for ClusterFuture ...
[15:32:14.023] - result already collected: FutureResult
[15:32:14.023] result() for ClusterFuture ... done
[15:32:14.023] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:14.024] - nx: 2
[15:32:14.024] - relay: TRUE
[15:32:14.024] - stdout: TRUE
[15:32:14.024] - signal: TRUE
[15:32:14.024] - resignal: FALSE
[15:32:14.024] - force: TRUE
[15:32:14.024] - relayed: [n=2] TRUE, FALSE
[15:32:14.025] - queued futures: [n=2] TRUE, FALSE
[15:32:14.025]  - until=2
[15:32:14.025]  - relaying element #2
[15:32:14.025] result() for ClusterFuture ...
[15:32:14.025] - result already collected: FutureResult
[15:32:14.025] result() for ClusterFuture ... done
[15:32:14.026] result() for ClusterFuture ...
[15:32:14.026] - result already collected: FutureResult
[15:32:14.026] result() for ClusterFuture ... done
[15:32:14.026] result() for ClusterFuture ...
[15:32:14.026] - result already collected: FutureResult
[15:32:14.026] result() for ClusterFuture ... done
[15:32:14.027] result() for ClusterFuture ...
[15:32:14.027] - result already collected: FutureResult
[15:32:14.027] result() for ClusterFuture ... done
[15:32:14.027] - relayed: [n=2] TRUE, TRUE
[15:32:14.027] - queued futures: [n=2] TRUE, TRUE
[15:32:14.027] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:14.027]  length: 0 (resolved future 2)
[15:32:14.028] Relaying remaining futures
[15:32:14.028] signalConditionsASAP(NULL, pos=0) ...
[15:32:14.028] - nx: 2
[15:32:14.028] - relay: TRUE
[15:32:14.028] - stdout: TRUE
[15:32:14.029] - signal: TRUE
[15:32:14.029] - resignal: FALSE
[15:32:14.029] - force: TRUE
[15:32:14.029] - relayed: [n=2] TRUE, TRUE
[15:32:14.030] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:14.030] - relayed: [n=2] TRUE, TRUE
[15:32:14.030] - queued futures: [n=2] TRUE, TRUE
[15:32:14.031] signalConditionsASAP(NULL, pos=0) ... done
[15:32:14.031] resolve() on list ... DONE
[15:32:14.031] result() for ClusterFuture ...
[15:32:14.031] - result already collected: FutureResult
[15:32:14.032] result() for ClusterFuture ... done
[15:32:14.032] result() for ClusterFuture ...
[15:32:14.032] - result already collected: FutureResult
[15:32:14.033] result() for ClusterFuture ... done
[15:32:14.033] result() for ClusterFuture ...
[15:32:14.033] - result already collected: FutureResult
[15:32:14.033] result() for ClusterFuture ... done
[15:32:14.034] result() for ClusterFuture ...
[15:32:14.034] - result already collected: FutureResult
[15:32:14.034] result() for ClusterFuture ... done
[15:32:14.035]  - Number of value chunks collected: 2
[15:32:14.035] Resolving 2 futures (chunks) ... DONE
[15:32:14.035] Reducing values from 2 chunks ...
[15:32:14.035]  - Number of values collected after concatenation: 4
[15:32:14.036]  - Number of values expected: 4
[15:32:14.036] Reducing values from 2 chunks ... DONE
[15:32:14.036] future_mapply() ... DONE
- Parallel RNG ...
[15:32:14.037] future_mapply() ...
[15:32:14.037] Generating random seeds ...
[15:32:14.037] Generating random seed streams for 4 elements ...
[15:32:14.038] Generating random seed streams for 4 elements ... DONE
[15:32:14.038] Generating random seeds ... DONE
[15:32:14.038] Will set RNG state on exit: 10407, 1359119798, -1333166412, 2049143215, -1477704665, -1862268708, -145351801
[15:32:14.043] Number of chunks: 2
[15:32:14.043] getGlobalsAndPackagesXApply() ...
[15:32:14.043]  - future.globals: TRUE
[15:32:14.044] getGlobalsAndPackages() ...
[15:32:14.044] Searching for globals...
[15:32:14.046] - globals found: [3] 'FUN', '.Call', 'C_runif'
[15:32:14.046] Searching for globals ... DONE
[15:32:14.046] Resolving globals: FALSE
[15:32:14.047] The total size of the 1 globals is 2.04 KiB (2088 bytes)
[15:32:14.048] The total size of the 1 globals exported for future expression ('FUN(min = 1)') is 2.04 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (2.04 KiB of class 'function')
[15:32:14.048] - globals: [1] 'FUN'
[15:32:14.048] - packages: [1] 'stats'
[15:32:14.048] getGlobalsAndPackages() ... DONE
[15:32:14.048]  - globals found/used: [n=1] 'FUN'
[15:32:14.049]  - needed namespaces: [n=1] 'stats'
[15:32:14.049] Finding globals ... DONE
[15:32:14.049] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:14.049] List of 2
[15:32:14.049]  $ ...future.FUN:function (n, min = 0, max = 1)  
[15:32:14.049]  $ MoreArgs     :List of 1
[15:32:14.049]   ..$ min: num 1
[15:32:14.049]  - attr(*, "where")=List of 2
[15:32:14.049]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:14.049]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:14.049]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:14.049]  - attr(*, "resolved")= logi FALSE
[15:32:14.049]  - attr(*, "total_size")= num NA
[15:32:14.053] Packages to be attached in all futures: [n=1] 'stats'
[15:32:14.053] getGlobalsAndPackagesXApply() ... DONE
[15:32:14.053] Number of futures (= number of chunks): 2
[15:32:14.053] Launching 2 futures (chunks) ...
[15:32:14.054] Chunk #1 of 2 ...
[15:32:14.054]  - Finding globals in '...' for chunk #1 ...
[15:32:14.054] getGlobalsAndPackages() ...
[15:32:14.054] Searching for globals...
[15:32:14.055] 
[15:32:14.055] Searching for globals ... DONE
[15:32:14.055] - globals: [0] <none>
[15:32:14.055] getGlobalsAndPackages() ... DONE
[15:32:14.055]    + additional globals found: [n=0] 
[15:32:14.055]    + additional namespaces needed: [n=0] 
[15:32:14.056]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:14.056]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.056]  - seeds: [2] <seeds>
[15:32:14.056]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.056] getGlobalsAndPackages() ...
[15:32:14.056] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.057] Resolving globals: FALSE
[15:32:14.057] The total size of the 5 globals is 2.47 KiB (2528 bytes)
[15:32:14.058] 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 2.47 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (2.04 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and '...future.seeds_ii' (160 bytes of class 'list')
[15:32:14.058] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.059] - packages: [1] 'stats'
[15:32:14.059] getGlobalsAndPackages() ... DONE
[15:32:14.059] run() for 'Future' ...
[15:32:14.059] - state: 'created'
[15:32:14.060] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.081] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.081] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.082]   - Field: 'node'
[15:32:14.082]   - Field: 'label'
[15:32:14.083]   - Field: 'local'
[15:32:14.083]   - Field: 'owner'
[15:32:14.084]   - Field: 'envir'
[15:32:14.084]   - Field: 'workers'
[15:32:14.084]   - Field: 'packages'
[15:32:14.085]   - Field: 'gc'
[15:32:14.085]   - Field: 'conditions'
[15:32:14.086]   - Field: 'persistent'
[15:32:14.086]   - Field: 'expr'
[15:32:14.086]   - Field: 'uuid'
[15:32:14.087]   - Field: 'seed'
[15:32:14.087]   - Field: 'version'
[15:32:14.088]   - Field: 'result'
[15:32:14.088]   - Field: 'asynchronous'
[15:32:14.088]   - Field: 'calls'
[15:32:14.089]   - Field: 'globals'
[15:32:14.089]   - Field: 'stdout'
[15:32:14.089]   - Field: 'earlySignal'
[15:32:14.090]   - Field: 'lazy'
[15:32:14.090]   - Field: 'state'
[15:32:14.091] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.091] - Launch lazy future ...
[15:32:14.092] Packages needed by the future expression (n = 1): 'stats'
[15:32:14.092] Packages needed by future strategies (n = 0): <none>
[15:32:14.094] {
[15:32:14.094]     {
[15:32:14.094]         {
[15:32:14.094]             ...future.startTime <- base::Sys.time()
[15:32:14.094]             {
[15:32:14.094]                 {
[15:32:14.094]                   {
[15:32:14.094]                     {
[15:32:14.094]                       {
[15:32:14.094]                         base::local({
[15:32:14.094]                           has_future <- base::requireNamespace("future", 
[15:32:14.094]                             quietly = TRUE)
[15:32:14.094]                           if (has_future) {
[15:32:14.094]                             ns <- base::getNamespace("future")
[15:32:14.094]                             version <- ns[[".package"]][["version"]]
[15:32:14.094]                             if (is.null(version)) 
[15:32:14.094]                               version <- utils::packageVersion("future")
[15:32:14.094]                           }
[15:32:14.094]                           else {
[15:32:14.094]                             version <- NULL
[15:32:14.094]                           }
[15:32:14.094]                           if (!has_future || version < "1.8.0") {
[15:32:14.094]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.094]                               "", base::R.version$version.string), 
[15:32:14.094]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:14.094]                                 base::R.version$platform, 8 * 
[15:32:14.094]                                   base::.Machine$sizeof.pointer), 
[15:32:14.094]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.094]                                 "release", "version")], collapse = " "), 
[15:32:14.094]                               hostname = base::Sys.info()[["nodename"]])
[15:32:14.094]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.094]                               info)
[15:32:14.094]                             info <- base::paste(info, collapse = "; ")
[15:32:14.094]                             if (!has_future) {
[15:32:14.094]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.094]                                 info)
[15:32:14.094]                             }
[15:32:14.094]                             else {
[15:32:14.094]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.094]                                 info, version)
[15:32:14.094]                             }
[15:32:14.094]                             base::stop(msg)
[15:32:14.094]                           }
[15:32:14.094]                         })
[15:32:14.094]                       }
[15:32:14.094]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.094]                       base::options(mc.cores = 1L)
[15:32:14.094]                     }
[15:32:14.094]                     base::local({
[15:32:14.094]                       for (pkg in "stats") {
[15:32:14.094]                         base::loadNamespace(pkg)
[15:32:14.094]                         base::library(pkg, character.only = TRUE)
[15:32:14.094]                       }
[15:32:14.094]                     })
[15:32:14.094]                   }
[15:32:14.094]                   ...future.strategy.old <- future::plan("list")
[15:32:14.094]                   options(future.plan = NULL)
[15:32:14.094]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.094]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.094]                 }
[15:32:14.094]                 ...future.workdir <- getwd()
[15:32:14.094]             }
[15:32:14.094]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.094]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.094]         }
[15:32:14.094]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.094]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.094]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.094]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.094]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.094]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.094]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.094]             base::names(...future.oldOptions))
[15:32:14.094]     }
[15:32:14.094]     if (FALSE) {
[15:32:14.094]     }
[15:32:14.094]     else {
[15:32:14.094]         if (TRUE) {
[15:32:14.094]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.094]                 open = "w")
[15:32:14.094]         }
[15:32:14.094]         else {
[15:32:14.094]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.094]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.094]         }
[15:32:14.094]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.094]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.094]             base::sink(type = "output", split = FALSE)
[15:32:14.094]             base::close(...future.stdout)
[15:32:14.094]         }, add = TRUE)
[15:32:14.094]     }
[15:32:14.094]     ...future.frame <- base::sys.nframe()
[15:32:14.094]     ...future.conditions <- base::list()
[15:32:14.094]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.094]     if (FALSE) {
[15:32:14.094]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.094]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.094]     }
[15:32:14.094]     ...future.result <- base::tryCatch({
[15:32:14.094]         base::withCallingHandlers({
[15:32:14.094]             ...future.value <- base::withVisible(base::local({
[15:32:14.094]                 ...future.makeSendCondition <- base::local({
[15:32:14.094]                   sendCondition <- NULL
[15:32:14.094]                   function(frame = 1L) {
[15:32:14.094]                     if (is.function(sendCondition)) 
[15:32:14.094]                       return(sendCondition)
[15:32:14.094]                     ns <- getNamespace("parallel")
[15:32:14.094]                     if (exists("sendData", mode = "function", 
[15:32:14.094]                       envir = ns)) {
[15:32:14.094]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.094]                         envir = ns)
[15:32:14.094]                       envir <- sys.frame(frame)
[15:32:14.094]                       master <- NULL
[15:32:14.094]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.094]                         !identical(envir, emptyenv())) {
[15:32:14.094]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.094]                           inherits = FALSE)) {
[15:32:14.094]                           master <- get("master", mode = "list", 
[15:32:14.094]                             envir = envir, inherits = FALSE)
[15:32:14.094]                           if (inherits(master, c("SOCKnode", 
[15:32:14.094]                             "SOCK0node"))) {
[15:32:14.094]                             sendCondition <<- function(cond) {
[15:32:14.094]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.094]                                 success = TRUE)
[15:32:14.094]                               parallel_sendData(master, data)
[15:32:14.094]                             }
[15:32:14.094]                             return(sendCondition)
[15:32:14.094]                           }
[15:32:14.094]                         }
[15:32:14.094]                         frame <- frame + 1L
[15:32:14.094]                         envir <- sys.frame(frame)
[15:32:14.094]                       }
[15:32:14.094]                     }
[15:32:14.094]                     sendCondition <<- function(cond) NULL
[15:32:14.094]                   }
[15:32:14.094]                 })
[15:32:14.094]                 withCallingHandlers({
[15:32:14.094]                   {
[15:32:14.094]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.094]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.094]                       ...future.globals.maxSize)) {
[15:32:14.094]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.094]                       on.exit(options(oopts), add = TRUE)
[15:32:14.094]                     }
[15:32:14.094]                     {
[15:32:14.094]                       ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:14.094]                         assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:14.094]                           envir = globalenv(), inherits = FALSE)
[15:32:14.094]                         ...future.FUN(...)
[15:32:14.094]                       }
[15:32:14.094]                       args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:14.094]                         list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:14.094]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.094]                         USE.NAMES = FALSE)
[15:32:14.094]                       do.call(mapply, args = args)
[15:32:14.094]                     }
[15:32:14.094]                   }
[15:32:14.094]                 }, immediateCondition = function(cond) {
[15:32:14.094]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.094]                   sendCondition(cond)
[15:32:14.094]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.094]                   {
[15:32:14.094]                     inherits <- base::inherits
[15:32:14.094]                     invokeRestart <- base::invokeRestart
[15:32:14.094]                     is.null <- base::is.null
[15:32:14.094]                     muffled <- FALSE
[15:32:14.094]                     if (inherits(cond, "message")) {
[15:32:14.094]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.094]                       if (muffled) 
[15:32:14.094]                         invokeRestart("muffleMessage")
[15:32:14.094]                     }
[15:32:14.094]                     else if (inherits(cond, "warning")) {
[15:32:14.094]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.094]                       if (muffled) 
[15:32:14.094]                         invokeRestart("muffleWarning")
[15:32:14.094]                     }
[15:32:14.094]                     else if (inherits(cond, "condition")) {
[15:32:14.094]                       if (!is.null(pattern)) {
[15:32:14.094]                         computeRestarts <- base::computeRestarts
[15:32:14.094]                         grepl <- base::grepl
[15:32:14.094]                         restarts <- computeRestarts(cond)
[15:32:14.094]                         for (restart in restarts) {
[15:32:14.094]                           name <- restart$name
[15:32:14.094]                           if (is.null(name)) 
[15:32:14.094]                             next
[15:32:14.094]                           if (!grepl(pattern, name)) 
[15:32:14.094]                             next
[15:32:14.094]                           invokeRestart(restart)
[15:32:14.094]                           muffled <- TRUE
[15:32:14.094]                           break
[15:32:14.094]                         }
[15:32:14.094]                       }
[15:32:14.094]                     }
[15:32:14.094]                     invisible(muffled)
[15:32:14.094]                   }
[15:32:14.094]                   muffleCondition(cond)
[15:32:14.094]                 })
[15:32:14.094]             }))
[15:32:14.094]             future::FutureResult(value = ...future.value$value, 
[15:32:14.094]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.094]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.094]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.094]                     ...future.globalenv.names))
[15:32:14.094]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.094]         }, condition = base::local({
[15:32:14.094]             c <- base::c
[15:32:14.094]             inherits <- base::inherits
[15:32:14.094]             invokeRestart <- base::invokeRestart
[15:32:14.094]             length <- base::length
[15:32:14.094]             list <- base::list
[15:32:14.094]             seq.int <- base::seq.int
[15:32:14.094]             signalCondition <- base::signalCondition
[15:32:14.094]             sys.calls <- base::sys.calls
[15:32:14.094]             `[[` <- base::`[[`
[15:32:14.094]             `+` <- base::`+`
[15:32:14.094]             `<<-` <- base::`<<-`
[15:32:14.094]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.094]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.094]                   3L)]
[15:32:14.094]             }
[15:32:14.094]             function(cond) {
[15:32:14.094]                 is_error <- inherits(cond, "error")
[15:32:14.094]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.094]                   NULL)
[15:32:14.094]                 if (is_error) {
[15:32:14.094]                   sessionInformation <- function() {
[15:32:14.094]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.094]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.094]                       search = base::search(), system = base::Sys.info())
[15:32:14.094]                   }
[15:32:14.094]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.094]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.094]                     cond$call), session = sessionInformation(), 
[15:32:14.094]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.094]                   signalCondition(cond)
[15:32:14.094]                 }
[15:32:14.094]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.094]                 "immediateCondition"))) {
[15:32:14.094]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.094]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.094]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.094]                   if (TRUE && !signal) {
[15:32:14.094]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.094]                     {
[15:32:14.094]                       inherits <- base::inherits
[15:32:14.094]                       invokeRestart <- base::invokeRestart
[15:32:14.094]                       is.null <- base::is.null
[15:32:14.094]                       muffled <- FALSE
[15:32:14.094]                       if (inherits(cond, "message")) {
[15:32:14.094]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.094]                         if (muffled) 
[15:32:14.094]                           invokeRestart("muffleMessage")
[15:32:14.094]                       }
[15:32:14.094]                       else if (inherits(cond, "warning")) {
[15:32:14.094]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.094]                         if (muffled) 
[15:32:14.094]                           invokeRestart("muffleWarning")
[15:32:14.094]                       }
[15:32:14.094]                       else if (inherits(cond, "condition")) {
[15:32:14.094]                         if (!is.null(pattern)) {
[15:32:14.094]                           computeRestarts <- base::computeRestarts
[15:32:14.094]                           grepl <- base::grepl
[15:32:14.094]                           restarts <- computeRestarts(cond)
[15:32:14.094]                           for (restart in restarts) {
[15:32:14.094]                             name <- restart$name
[15:32:14.094]                             if (is.null(name)) 
[15:32:14.094]                               next
[15:32:14.094]                             if (!grepl(pattern, name)) 
[15:32:14.094]                               next
[15:32:14.094]                             invokeRestart(restart)
[15:32:14.094]                             muffled <- TRUE
[15:32:14.094]                             break
[15:32:14.094]                           }
[15:32:14.094]                         }
[15:32:14.094]                       }
[15:32:14.094]                       invisible(muffled)
[15:32:14.094]                     }
[15:32:14.094]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.094]                   }
[15:32:14.094]                 }
[15:32:14.094]                 else {
[15:32:14.094]                   if (TRUE) {
[15:32:14.094]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.094]                     {
[15:32:14.094]                       inherits <- base::inherits
[15:32:14.094]                       invokeRestart <- base::invokeRestart
[15:32:14.094]                       is.null <- base::is.null
[15:32:14.094]                       muffled <- FALSE
[15:32:14.094]                       if (inherits(cond, "message")) {
[15:32:14.094]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.094]                         if (muffled) 
[15:32:14.094]                           invokeRestart("muffleMessage")
[15:32:14.094]                       }
[15:32:14.094]                       else if (inherits(cond, "warning")) {
[15:32:14.094]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.094]                         if (muffled) 
[15:32:14.094]                           invokeRestart("muffleWarning")
[15:32:14.094]                       }
[15:32:14.094]                       else if (inherits(cond, "condition")) {
[15:32:14.094]                         if (!is.null(pattern)) {
[15:32:14.094]                           computeRestarts <- base::computeRestarts
[15:32:14.094]                           grepl <- base::grepl
[15:32:14.094]                           restarts <- computeRestarts(cond)
[15:32:14.094]                           for (restart in restarts) {
[15:32:14.094]                             name <- restart$name
[15:32:14.094]                             if (is.null(name)) 
[15:32:14.094]                               next
[15:32:14.094]                             if (!grepl(pattern, name)) 
[15:32:14.094]                               next
[15:32:14.094]                             invokeRestart(restart)
[15:32:14.094]                             muffled <- TRUE
[15:32:14.094]                             break
[15:32:14.094]                           }
[15:32:14.094]                         }
[15:32:14.094]                       }
[15:32:14.094]                       invisible(muffled)
[15:32:14.094]                     }
[15:32:14.094]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.094]                   }
[15:32:14.094]                 }
[15:32:14.094]             }
[15:32:14.094]         }))
[15:32:14.094]     }, error = function(ex) {
[15:32:14.094]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.094]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.094]                 ...future.rng), started = ...future.startTime, 
[15:32:14.094]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.094]             version = "1.8"), class = "FutureResult")
[15:32:14.094]     }, finally = {
[15:32:14.094]         if (!identical(...future.workdir, getwd())) 
[15:32:14.094]             setwd(...future.workdir)
[15:32:14.094]         {
[15:32:14.094]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.094]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.094]             }
[15:32:14.094]             base::options(...future.oldOptions)
[15:32:14.094]             if (.Platform$OS.type == "windows") {
[15:32:14.094]                 old_names <- names(...future.oldEnvVars)
[15:32:14.094]                 envs <- base::Sys.getenv()
[15:32:14.094]                 names <- names(envs)
[15:32:14.094]                 common <- intersect(names, old_names)
[15:32:14.094]                 added <- setdiff(names, old_names)
[15:32:14.094]                 removed <- setdiff(old_names, names)
[15:32:14.094]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.094]                   envs[common]]
[15:32:14.094]                 NAMES <- toupper(changed)
[15:32:14.094]                 args <- list()
[15:32:14.094]                 for (kk in seq_along(NAMES)) {
[15:32:14.094]                   name <- changed[[kk]]
[15:32:14.094]                   NAME <- NAMES[[kk]]
[15:32:14.094]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.094]                     next
[15:32:14.094]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.094]                 }
[15:32:14.094]                 NAMES <- toupper(added)
[15:32:14.094]                 for (kk in seq_along(NAMES)) {
[15:32:14.094]                   name <- added[[kk]]
[15:32:14.094]                   NAME <- NAMES[[kk]]
[15:32:14.094]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.094]                     next
[15:32:14.094]                   args[[name]] <- ""
[15:32:14.094]                 }
[15:32:14.094]                 NAMES <- toupper(removed)
[15:32:14.094]                 for (kk in seq_along(NAMES)) {
[15:32:14.094]                   name <- removed[[kk]]
[15:32:14.094]                   NAME <- NAMES[[kk]]
[15:32:14.094]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.094]                     next
[15:32:14.094]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.094]                 }
[15:32:14.094]                 if (length(args) > 0) 
[15:32:14.094]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.094]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.094]             }
[15:32:14.094]             else {
[15:32:14.094]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.094]             }
[15:32:14.094]             {
[15:32:14.094]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.094]                   0L) {
[15:32:14.094]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.094]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.094]                   base::options(opts)
[15:32:14.094]                 }
[15:32:14.094]                 {
[15:32:14.094]                   {
[15:32:14.094]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.094]                     NULL
[15:32:14.094]                   }
[15:32:14.094]                   options(future.plan = NULL)
[15:32:14.094]                   if (is.na(NA_character_)) 
[15:32:14.094]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.094]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.094]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.094]                     .init = FALSE)
[15:32:14.094]                 }
[15:32:14.094]             }
[15:32:14.094]         }
[15:32:14.094]     })
[15:32:14.094]     if (TRUE) {
[15:32:14.094]         base::sink(type = "output", split = FALSE)
[15:32:14.094]         if (TRUE) {
[15:32:14.094]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.094]         }
[15:32:14.094]         else {
[15:32:14.094]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.094]         }
[15:32:14.094]         base::close(...future.stdout)
[15:32:14.094]         ...future.stdout <- NULL
[15:32:14.094]     }
[15:32:14.094]     ...future.result$conditions <- ...future.conditions
[15:32:14.094]     ...future.result$finished <- base::Sys.time()
[15:32:14.094]     ...future.result
[15:32:14.094] }
[15:32:14.106] Exporting 5 global objects (2.47 KiB) to cluster node #1 ...
[15:32:14.107] Exporting '...future.FUN' (2.04 KiB) to cluster node #1 ...
[15:32:14.107] Exporting '...future.FUN' (2.04 KiB) to cluster node #1 ... DONE
[15:32:14.108] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:14.109] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:14.110] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:14.111] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:14.111] Exporting '...future.seeds_ii' (160 bytes) to cluster node #1 ...
[15:32:14.112] Exporting '...future.seeds_ii' (160 bytes) to cluster node #1 ... DONE
[15:32:14.112] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.113] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.113] Exporting 5 global objects (2.47 KiB) to cluster node #1 ... DONE
[15:32:14.114] MultisessionFuture started
[15:32:14.114] - Launch lazy future ... done
[15:32:14.115] run() for 'MultisessionFuture' ... done
[15:32:14.115] Created future:
[15:32:14.140] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.141] - Validating connection of MultisessionFuture
[15:32:14.141] - received message: FutureResult
[15:32:14.141] - Received FutureResult
[15:32:14.142] - Erased future from FutureRegistry
[15:32:14.142] result() for ClusterFuture ...
[15:32:14.142] - result already collected: FutureResult
[15:32:14.142] result() for ClusterFuture ... done
[15:32:14.142] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.115] MultisessionFuture:
[15:32:14.115] Label: 'future_mapply-1'
[15:32:14.115] Expression:
[15:32:14.115] {
[15:32:14.115]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.115]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.115]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.115]         on.exit(options(oopts), add = TRUE)
[15:32:14.115]     }
[15:32:14.115]     {
[15:32:14.115]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:14.115]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:14.115]                 inherits = FALSE)
[15:32:14.115]             ...future.FUN(...)
[15:32:14.115]         }
[15:32:14.115]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:14.115]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:14.115]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.115]         do.call(mapply, args = args)
[15:32:14.115]     }
[15:32:14.115] }
[15:32:14.115] Lazy evaluation: FALSE
[15:32:14.115] Asynchronous evaluation: TRUE
[15:32:14.115] Local evaluation: TRUE
[15:32:14.115] Environment: R_GlobalEnv
[15:32:14.115] Capture standard output: TRUE
[15:32:14.115] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.115] Globals: 5 objects totaling 2.47 KiB (function '...future.FUN' of 2.04 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 224 bytes, list '...future.seeds_ii' of 160 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:14.115] Packages: 1 packages ('stats')
[15:32:14.115] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:14.115] Resolved: TRUE
[15:32:14.115] Value: <not collected>
[15:32:14.115] Conditions captured: <none>
[15:32:14.115] Early signaling: FALSE
[15:32:14.115] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.115] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.143] Chunk #1 of 2 ... DONE
[15:32:14.143] Chunk #2 of 2 ...
[15:32:14.143]  - Finding globals in '...' for chunk #2 ...
[15:32:14.143] getGlobalsAndPackages() ...
[15:32:14.144] Searching for globals...
[15:32:14.144] 
[15:32:14.144] Searching for globals ... DONE
[15:32:14.145] - globals: [0] <none>
[15:32:14.145] getGlobalsAndPackages() ... DONE
[15:32:14.145]    + additional globals found: [n=0] 
[15:32:14.145]    + additional namespaces needed: [n=0] 
[15:32:14.145]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:14.146]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.146]  - seeds: [2] <seeds>
[15:32:14.146]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.146] getGlobalsAndPackages() ...
[15:32:14.146] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.147] Resolving globals: FALSE
[15:32:14.147] The total size of the 5 globals is 2.47 KiB (2528 bytes)
[15:32:14.148] 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 2.47 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (2.04 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and '...future.seeds_ii' (160 bytes of class 'list')
[15:32:14.149] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.149] - packages: [1] 'stats'
[15:32:14.149] getGlobalsAndPackages() ... DONE
[15:32:14.150] run() for 'Future' ...
[15:32:14.150] - state: 'created'
[15:32:14.150] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.169] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.169] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.169]   - Field: 'node'
[15:32:14.170]   - Field: 'label'
[15:32:14.170]   - Field: 'local'
[15:32:14.170]   - Field: 'owner'
[15:32:14.170]   - Field: 'envir'
[15:32:14.171]   - Field: 'workers'
[15:32:14.171]   - Field: 'packages'
[15:32:14.171]   - Field: 'gc'
[15:32:14.172]   - Field: 'conditions'
[15:32:14.172]   - Field: 'persistent'
[15:32:14.172]   - Field: 'expr'
[15:32:14.173]   - Field: 'uuid'
[15:32:14.173]   - Field: 'seed'
[15:32:14.174]   - Field: 'version'
[15:32:14.174]   - Field: 'result'
[15:32:14.174]   - Field: 'asynchronous'
[15:32:14.175]   - Field: 'calls'
[15:32:14.175]   - Field: 'globals'
[15:32:14.176]   - Field: 'stdout'
[15:32:14.176]   - Field: 'earlySignal'
[15:32:14.176]   - Field: 'lazy'
[15:32:14.177]   - Field: 'state'
[15:32:14.177] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.178] - Launch lazy future ...
[15:32:14.178] Packages needed by the future expression (n = 1): 'stats'
[15:32:14.179] Packages needed by future strategies (n = 0): <none>
[15:32:14.180] {
[15:32:14.180]     {
[15:32:14.180]         {
[15:32:14.180]             ...future.startTime <- base::Sys.time()
[15:32:14.180]             {
[15:32:14.180]                 {
[15:32:14.180]                   {
[15:32:14.180]                     {
[15:32:14.180]                       {
[15:32:14.180]                         base::local({
[15:32:14.180]                           has_future <- base::requireNamespace("future", 
[15:32:14.180]                             quietly = TRUE)
[15:32:14.180]                           if (has_future) {
[15:32:14.180]                             ns <- base::getNamespace("future")
[15:32:14.180]                             version <- ns[[".package"]][["version"]]
[15:32:14.180]                             if (is.null(version)) 
[15:32:14.180]                               version <- utils::packageVersion("future")
[15:32:14.180]                           }
[15:32:14.180]                           else {
[15:32:14.180]                             version <- NULL
[15:32:14.180]                           }
[15:32:14.180]                           if (!has_future || version < "1.8.0") {
[15:32:14.180]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.180]                               "", base::R.version$version.string), 
[15:32:14.180]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:14.180]                                 base::R.version$platform, 8 * 
[15:32:14.180]                                   base::.Machine$sizeof.pointer), 
[15:32:14.180]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.180]                                 "release", "version")], collapse = " "), 
[15:32:14.180]                               hostname = base::Sys.info()[["nodename"]])
[15:32:14.180]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.180]                               info)
[15:32:14.180]                             info <- base::paste(info, collapse = "; ")
[15:32:14.180]                             if (!has_future) {
[15:32:14.180]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.180]                                 info)
[15:32:14.180]                             }
[15:32:14.180]                             else {
[15:32:14.180]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.180]                                 info, version)
[15:32:14.180]                             }
[15:32:14.180]                             base::stop(msg)
[15:32:14.180]                           }
[15:32:14.180]                         })
[15:32:14.180]                       }
[15:32:14.180]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.180]                       base::options(mc.cores = 1L)
[15:32:14.180]                     }
[15:32:14.180]                     base::local({
[15:32:14.180]                       for (pkg in "stats") {
[15:32:14.180]                         base::loadNamespace(pkg)
[15:32:14.180]                         base::library(pkg, character.only = TRUE)
[15:32:14.180]                       }
[15:32:14.180]                     })
[15:32:14.180]                   }
[15:32:14.180]                   ...future.strategy.old <- future::plan("list")
[15:32:14.180]                   options(future.plan = NULL)
[15:32:14.180]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.180]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.180]                 }
[15:32:14.180]                 ...future.workdir <- getwd()
[15:32:14.180]             }
[15:32:14.180]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.180]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.180]         }
[15:32:14.180]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.180]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.180]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.180]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.180]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.180]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.180]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.180]             base::names(...future.oldOptions))
[15:32:14.180]     }
[15:32:14.180]     if (FALSE) {
[15:32:14.180]     }
[15:32:14.180]     else {
[15:32:14.180]         if (TRUE) {
[15:32:14.180]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.180]                 open = "w")
[15:32:14.180]         }
[15:32:14.180]         else {
[15:32:14.180]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.180]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.180]         }
[15:32:14.180]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.180]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.180]             base::sink(type = "output", split = FALSE)
[15:32:14.180]             base::close(...future.stdout)
[15:32:14.180]         }, add = TRUE)
[15:32:14.180]     }
[15:32:14.180]     ...future.frame <- base::sys.nframe()
[15:32:14.180]     ...future.conditions <- base::list()
[15:32:14.180]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.180]     if (FALSE) {
[15:32:14.180]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.180]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.180]     }
[15:32:14.180]     ...future.result <- base::tryCatch({
[15:32:14.180]         base::withCallingHandlers({
[15:32:14.180]             ...future.value <- base::withVisible(base::local({
[15:32:14.180]                 ...future.makeSendCondition <- base::local({
[15:32:14.180]                   sendCondition <- NULL
[15:32:14.180]                   function(frame = 1L) {
[15:32:14.180]                     if (is.function(sendCondition)) 
[15:32:14.180]                       return(sendCondition)
[15:32:14.180]                     ns <- getNamespace("parallel")
[15:32:14.180]                     if (exists("sendData", mode = "function", 
[15:32:14.180]                       envir = ns)) {
[15:32:14.180]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.180]                         envir = ns)
[15:32:14.180]                       envir <- sys.frame(frame)
[15:32:14.180]                       master <- NULL
[15:32:14.180]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.180]                         !identical(envir, emptyenv())) {
[15:32:14.180]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.180]                           inherits = FALSE)) {
[15:32:14.180]                           master <- get("master", mode = "list", 
[15:32:14.180]                             envir = envir, inherits = FALSE)
[15:32:14.180]                           if (inherits(master, c("SOCKnode", 
[15:32:14.180]                             "SOCK0node"))) {
[15:32:14.180]                             sendCondition <<- function(cond) {
[15:32:14.180]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.180]                                 success = TRUE)
[15:32:14.180]                               parallel_sendData(master, data)
[15:32:14.180]                             }
[15:32:14.180]                             return(sendCondition)
[15:32:14.180]                           }
[15:32:14.180]                         }
[15:32:14.180]                         frame <- frame + 1L
[15:32:14.180]                         envir <- sys.frame(frame)
[15:32:14.180]                       }
[15:32:14.180]                     }
[15:32:14.180]                     sendCondition <<- function(cond) NULL
[15:32:14.180]                   }
[15:32:14.180]                 })
[15:32:14.180]                 withCallingHandlers({
[15:32:14.180]                   {
[15:32:14.180]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.180]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.180]                       ...future.globals.maxSize)) {
[15:32:14.180]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.180]                       on.exit(options(oopts), add = TRUE)
[15:32:14.180]                     }
[15:32:14.180]                     {
[15:32:14.180]                       ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:14.180]                         assign(".Random.seed", ...future.seeds_ii_jj, 
[15:32:14.180]                           envir = globalenv(), inherits = FALSE)
[15:32:14.180]                         ...future.FUN(...)
[15:32:14.180]                       }
[15:32:14.180]                       args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:14.180]                         list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:14.180]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.180]                         USE.NAMES = FALSE)
[15:32:14.180]                       do.call(mapply, args = args)
[15:32:14.180]                     }
[15:32:14.180]                   }
[15:32:14.180]                 }, immediateCondition = function(cond) {
[15:32:14.180]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.180]                   sendCondition(cond)
[15:32:14.180]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.180]                   {
[15:32:14.180]                     inherits <- base::inherits
[15:32:14.180]                     invokeRestart <- base::invokeRestart
[15:32:14.180]                     is.null <- base::is.null
[15:32:14.180]                     muffled <- FALSE
[15:32:14.180]                     if (inherits(cond, "message")) {
[15:32:14.180]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.180]                       if (muffled) 
[15:32:14.180]                         invokeRestart("muffleMessage")
[15:32:14.180]                     }
[15:32:14.180]                     else if (inherits(cond, "warning")) {
[15:32:14.180]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.180]                       if (muffled) 
[15:32:14.180]                         invokeRestart("muffleWarning")
[15:32:14.180]                     }
[15:32:14.180]                     else if (inherits(cond, "condition")) {
[15:32:14.180]                       if (!is.null(pattern)) {
[15:32:14.180]                         computeRestarts <- base::computeRestarts
[15:32:14.180]                         grepl <- base::grepl
[15:32:14.180]                         restarts <- computeRestarts(cond)
[15:32:14.180]                         for (restart in restarts) {
[15:32:14.180]                           name <- restart$name
[15:32:14.180]                           if (is.null(name)) 
[15:32:14.180]                             next
[15:32:14.180]                           if (!grepl(pattern, name)) 
[15:32:14.180]                             next
[15:32:14.180]                           invokeRestart(restart)
[15:32:14.180]                           muffled <- TRUE
[15:32:14.180]                           break
[15:32:14.180]                         }
[15:32:14.180]                       }
[15:32:14.180]                     }
[15:32:14.180]                     invisible(muffled)
[15:32:14.180]                   }
[15:32:14.180]                   muffleCondition(cond)
[15:32:14.180]                 })
[15:32:14.180]             }))
[15:32:14.180]             future::FutureResult(value = ...future.value$value, 
[15:32:14.180]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.180]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.180]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.180]                     ...future.globalenv.names))
[15:32:14.180]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.180]         }, condition = base::local({
[15:32:14.180]             c <- base::c
[15:32:14.180]             inherits <- base::inherits
[15:32:14.180]             invokeRestart <- base::invokeRestart
[15:32:14.180]             length <- base::length
[15:32:14.180]             list <- base::list
[15:32:14.180]             seq.int <- base::seq.int
[15:32:14.180]             signalCondition <- base::signalCondition
[15:32:14.180]             sys.calls <- base::sys.calls
[15:32:14.180]             `[[` <- base::`[[`
[15:32:14.180]             `+` <- base::`+`
[15:32:14.180]             `<<-` <- base::`<<-`
[15:32:14.180]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.180]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.180]                   3L)]
[15:32:14.180]             }
[15:32:14.180]             function(cond) {
[15:32:14.180]                 is_error <- inherits(cond, "error")
[15:32:14.180]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.180]                   NULL)
[15:32:14.180]                 if (is_error) {
[15:32:14.180]                   sessionInformation <- function() {
[15:32:14.180]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.180]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.180]                       search = base::search(), system = base::Sys.info())
[15:32:14.180]                   }
[15:32:14.180]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.180]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.180]                     cond$call), session = sessionInformation(), 
[15:32:14.180]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.180]                   signalCondition(cond)
[15:32:14.180]                 }
[15:32:14.180]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.180]                 "immediateCondition"))) {
[15:32:14.180]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.180]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.180]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.180]                   if (TRUE && !signal) {
[15:32:14.180]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.180]                     {
[15:32:14.180]                       inherits <- base::inherits
[15:32:14.180]                       invokeRestart <- base::invokeRestart
[15:32:14.180]                       is.null <- base::is.null
[15:32:14.180]                       muffled <- FALSE
[15:32:14.180]                       if (inherits(cond, "message")) {
[15:32:14.180]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.180]                         if (muffled) 
[15:32:14.180]                           invokeRestart("muffleMessage")
[15:32:14.180]                       }
[15:32:14.180]                       else if (inherits(cond, "warning")) {
[15:32:14.180]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.180]                         if (muffled) 
[15:32:14.180]                           invokeRestart("muffleWarning")
[15:32:14.180]                       }
[15:32:14.180]                       else if (inherits(cond, "condition")) {
[15:32:14.180]                         if (!is.null(pattern)) {
[15:32:14.180]                           computeRestarts <- base::computeRestarts
[15:32:14.180]                           grepl <- base::grepl
[15:32:14.180]                           restarts <- computeRestarts(cond)
[15:32:14.180]                           for (restart in restarts) {
[15:32:14.180]                             name <- restart$name
[15:32:14.180]                             if (is.null(name)) 
[15:32:14.180]                               next
[15:32:14.180]                             if (!grepl(pattern, name)) 
[15:32:14.180]                               next
[15:32:14.180]                             invokeRestart(restart)
[15:32:14.180]                             muffled <- TRUE
[15:32:14.180]                             break
[15:32:14.180]                           }
[15:32:14.180]                         }
[15:32:14.180]                       }
[15:32:14.180]                       invisible(muffled)
[15:32:14.180]                     }
[15:32:14.180]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.180]                   }
[15:32:14.180]                 }
[15:32:14.180]                 else {
[15:32:14.180]                   if (TRUE) {
[15:32:14.180]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.180]                     {
[15:32:14.180]                       inherits <- base::inherits
[15:32:14.180]                       invokeRestart <- base::invokeRestart
[15:32:14.180]                       is.null <- base::is.null
[15:32:14.180]                       muffled <- FALSE
[15:32:14.180]                       if (inherits(cond, "message")) {
[15:32:14.180]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.180]                         if (muffled) 
[15:32:14.180]                           invokeRestart("muffleMessage")
[15:32:14.180]                       }
[15:32:14.180]                       else if (inherits(cond, "warning")) {
[15:32:14.180]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.180]                         if (muffled) 
[15:32:14.180]                           invokeRestart("muffleWarning")
[15:32:14.180]                       }
[15:32:14.180]                       else if (inherits(cond, "condition")) {
[15:32:14.180]                         if (!is.null(pattern)) {
[15:32:14.180]                           computeRestarts <- base::computeRestarts
[15:32:14.180]                           grepl <- base::grepl
[15:32:14.180]                           restarts <- computeRestarts(cond)
[15:32:14.180]                           for (restart in restarts) {
[15:32:14.180]                             name <- restart$name
[15:32:14.180]                             if (is.null(name)) 
[15:32:14.180]                               next
[15:32:14.180]                             if (!grepl(pattern, name)) 
[15:32:14.180]                               next
[15:32:14.180]                             invokeRestart(restart)
[15:32:14.180]                             muffled <- TRUE
[15:32:14.180]                             break
[15:32:14.180]                           }
[15:32:14.180]                         }
[15:32:14.180]                       }
[15:32:14.180]                       invisible(muffled)
[15:32:14.180]                     }
[15:32:14.180]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.180]                   }
[15:32:14.180]                 }
[15:32:14.180]             }
[15:32:14.180]         }))
[15:32:14.180]     }, error = function(ex) {
[15:32:14.180]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.180]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.180]                 ...future.rng), started = ...future.startTime, 
[15:32:14.180]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.180]             version = "1.8"), class = "FutureResult")
[15:32:14.180]     }, finally = {
[15:32:14.180]         if (!identical(...future.workdir, getwd())) 
[15:32:14.180]             setwd(...future.workdir)
[15:32:14.180]         {
[15:32:14.180]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.180]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.180]             }
[15:32:14.180]             base::options(...future.oldOptions)
[15:32:14.180]             if (.Platform$OS.type == "windows") {
[15:32:14.180]                 old_names <- names(...future.oldEnvVars)
[15:32:14.180]                 envs <- base::Sys.getenv()
[15:32:14.180]                 names <- names(envs)
[15:32:14.180]                 common <- intersect(names, old_names)
[15:32:14.180]                 added <- setdiff(names, old_names)
[15:32:14.180]                 removed <- setdiff(old_names, names)
[15:32:14.180]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.180]                   envs[common]]
[15:32:14.180]                 NAMES <- toupper(changed)
[15:32:14.180]                 args <- list()
[15:32:14.180]                 for (kk in seq_along(NAMES)) {
[15:32:14.180]                   name <- changed[[kk]]
[15:32:14.180]                   NAME <- NAMES[[kk]]
[15:32:14.180]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.180]                     next
[15:32:14.180]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.180]                 }
[15:32:14.180]                 NAMES <- toupper(added)
[15:32:14.180]                 for (kk in seq_along(NAMES)) {
[15:32:14.180]                   name <- added[[kk]]
[15:32:14.180]                   NAME <- NAMES[[kk]]
[15:32:14.180]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.180]                     next
[15:32:14.180]                   args[[name]] <- ""
[15:32:14.180]                 }
[15:32:14.180]                 NAMES <- toupper(removed)
[15:32:14.180]                 for (kk in seq_along(NAMES)) {
[15:32:14.180]                   name <- removed[[kk]]
[15:32:14.180]                   NAME <- NAMES[[kk]]
[15:32:14.180]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.180]                     next
[15:32:14.180]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.180]                 }
[15:32:14.180]                 if (length(args) > 0) 
[15:32:14.180]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.180]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.180]             }
[15:32:14.180]             else {
[15:32:14.180]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.180]             }
[15:32:14.180]             {
[15:32:14.180]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.180]                   0L) {
[15:32:14.180]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.180]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.180]                   base::options(opts)
[15:32:14.180]                 }
[15:32:14.180]                 {
[15:32:14.180]                   {
[15:32:14.180]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.180]                     NULL
[15:32:14.180]                   }
[15:32:14.180]                   options(future.plan = NULL)
[15:32:14.180]                   if (is.na(NA_character_)) 
[15:32:14.180]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.180]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.180]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.180]                     .init = FALSE)
[15:32:14.180]                 }
[15:32:14.180]             }
[15:32:14.180]         }
[15:32:14.180]     })
[15:32:14.180]     if (TRUE) {
[15:32:14.180]         base::sink(type = "output", split = FALSE)
[15:32:14.180]         if (TRUE) {
[15:32:14.180]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.180]         }
[15:32:14.180]         else {
[15:32:14.180]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.180]         }
[15:32:14.180]         base::close(...future.stdout)
[15:32:14.180]         ...future.stdout <- NULL
[15:32:14.180]     }
[15:32:14.180]     ...future.result$conditions <- ...future.conditions
[15:32:14.180]     ...future.result$finished <- base::Sys.time()
[15:32:14.180]     ...future.result
[15:32:14.180] }
[15:32:14.191] Exporting 5 global objects (2.47 KiB) to cluster node #1 ...
[15:32:14.191] Exporting '...future.FUN' (2.04 KiB) to cluster node #1 ...
[15:32:14.192] Exporting '...future.FUN' (2.04 KiB) to cluster node #1 ... DONE
[15:32:14.192] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ...
[15:32:14.193] Exporting 'MoreArgs' (56 bytes) to cluster node #1 ... DONE
[15:32:14.193] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:14.194] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:14.194] Exporting '...future.seeds_ii' (160 bytes) to cluster node #1 ...
[15:32:14.195] Exporting '...future.seeds_ii' (160 bytes) to cluster node #1 ... DONE
[15:32:14.195] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.196] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.196] Exporting 5 global objects (2.47 KiB) to cluster node #1 ... DONE
[15:32:14.197] MultisessionFuture started
[15:32:14.197] - Launch lazy future ... done
[15:32:14.197] run() for 'MultisessionFuture' ... done
[15:32:14.198] Created future:
[15:32:14.221] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.222] - Validating connection of MultisessionFuture
[15:32:14.222] - received message: FutureResult
[15:32:14.222] - Received FutureResult
[15:32:14.223] - Erased future from FutureRegistry
[15:32:14.223] result() for ClusterFuture ...
[15:32:14.223] - result already collected: FutureResult
[15:32:14.223] result() for ClusterFuture ... done
[15:32:14.224] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.198] MultisessionFuture:
[15:32:14.198] Label: 'future_mapply-2'
[15:32:14.198] Expression:
[15:32:14.198] {
[15:32:14.198]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.198]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.198]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.198]         on.exit(options(oopts), add = TRUE)
[15:32:14.198]     }
[15:32:14.198]     {
[15:32:14.198]         ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
[15:32:14.198]             assign(".Random.seed", ...future.seeds_ii_jj, envir = globalenv(), 
[15:32:14.198]                 inherits = FALSE)
[15:32:14.198]             ...future.FUN(...)
[15:32:14.198]         }
[15:32:14.198]         args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
[15:32:14.198]             list(...future.seeds_ii_jj = ...future.seeds_ii), 
[15:32:14.198]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.198]         do.call(mapply, args = args)
[15:32:14.198]     }
[15:32:14.198] }
[15:32:14.198] Lazy evaluation: FALSE
[15:32:14.198] Asynchronous evaluation: TRUE
[15:32:14.198] Local evaluation: TRUE
[15:32:14.198] Environment: R_GlobalEnv
[15:32:14.198] Capture standard output: TRUE
[15:32:14.198] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.198] Globals: 5 objects totaling 2.47 KiB (function '...future.FUN' of 2.04 KiB, list 'MoreArgs' of 56 bytes, list '...future.elements_ii' of 224 bytes, list '...future.seeds_ii' of 160 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:14.198] Packages: 1 packages ('stats')
[15:32:14.198] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:32:14.198] Resolved: TRUE
[15:32:14.198] Value: <not collected>
[15:32:14.198] Conditions captured: <none>
[15:32:14.198] Early signaling: FALSE
[15:32:14.198] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.198] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.225] Chunk #2 of 2 ... DONE
[15:32:14.225] Launching 2 futures (chunks) ... DONE
[15:32:14.225] Resolving 2 futures (chunks) ...
[15:32:14.225] resolve() on list ...
[15:32:14.226]  recursive: 0
[15:32:14.226]  length: 2
[15:32:14.226] 
[15:32:14.226] Future #1
[15:32:14.226] result() for ClusterFuture ...
[15:32:14.227] - result already collected: FutureResult
[15:32:14.227] result() for ClusterFuture ... done
[15:32:14.227] result() for ClusterFuture ...
[15:32:14.227] - result already collected: FutureResult
[15:32:14.228] result() for ClusterFuture ... done
[15:32:14.228] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:14.228] - nx: 2
[15:32:14.228] - relay: TRUE
[15:32:14.228] - stdout: TRUE
[15:32:14.229] - signal: TRUE
[15:32:14.229] - resignal: FALSE
[15:32:14.229] - force: TRUE
[15:32:14.229] - relayed: [n=2] FALSE, FALSE
[15:32:14.230] - queued futures: [n=2] FALSE, FALSE
[15:32:14.230]  - until=1
[15:32:14.230]  - relaying element #1
[15:32:14.231] result() for ClusterFuture ...
[15:32:14.231] - result already collected: FutureResult
[15:32:14.231] result() for ClusterFuture ... done
[15:32:14.231] result() for ClusterFuture ...
[15:32:14.232] - result already collected: FutureResult
[15:32:14.232] result() for ClusterFuture ... done
[15:32:14.232] result() for ClusterFuture ...
[15:32:14.233] - result already collected: FutureResult
[15:32:14.233] result() for ClusterFuture ... done
[15:32:14.233] result() for ClusterFuture ...
[15:32:14.234] - result already collected: FutureResult
[15:32:14.234] result() for ClusterFuture ... done
[15:32:14.234] - relayed: [n=2] TRUE, FALSE
[15:32:14.234] - queued futures: [n=2] TRUE, FALSE
[15:32:14.235] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:14.235]  length: 1 (resolved future 1)
[15:32:14.235] Future #2
[15:32:14.235] result() for ClusterFuture ...
[15:32:14.236] - result already collected: FutureResult
[15:32:14.236] result() for ClusterFuture ... done
[15:32:14.236] result() for ClusterFuture ...
[15:32:14.237] - result already collected: FutureResult
[15:32:14.237] result() for ClusterFuture ... done
[15:32:14.237] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:14.237] - nx: 2
[15:32:14.238] - relay: TRUE
[15:32:14.238] - stdout: TRUE
[15:32:14.238] - signal: TRUE
[15:32:14.239] - resignal: FALSE
[15:32:14.239] - force: TRUE
[15:32:14.239] - relayed: [n=2] TRUE, FALSE
[15:32:14.239] - queued futures: [n=2] TRUE, FALSE
[15:32:14.240]  - until=2
[15:32:14.240]  - relaying element #2
[15:32:14.240] result() for ClusterFuture ...
[15:32:14.241] - result already collected: FutureResult
[15:32:14.241] result() for ClusterFuture ... done
[15:32:14.241] result() for ClusterFuture ...
[15:32:14.241] - result already collected: FutureResult
[15:32:14.242] result() for ClusterFuture ... done
[15:32:14.242] result() for ClusterFuture ...
[15:32:14.242] - result already collected: FutureResult
[15:32:14.243] result() for ClusterFuture ... done
[15:32:14.243] result() for ClusterFuture ...
[15:32:14.243] - result already collected: FutureResult
[15:32:14.243] result() for ClusterFuture ... done
[15:32:14.244] - relayed: [n=2] TRUE, TRUE
[15:32:14.244] - queued futures: [n=2] TRUE, TRUE
[15:32:14.244] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:14.245]  length: 0 (resolved future 2)
[15:32:14.245] Relaying remaining futures
[15:32:14.245] signalConditionsASAP(NULL, pos=0) ...
[15:32:14.245] - nx: 2
[15:32:14.246] - relay: TRUE
[15:32:14.246] - stdout: TRUE
[15:32:14.246] - signal: TRUE
[15:32:14.246] - resignal: FALSE
[15:32:14.247] - force: TRUE
[15:32:14.247] - relayed: [n=2] TRUE, TRUE
[15:32:14.247] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:14.248] - relayed: [n=2] TRUE, TRUE
[15:32:14.248] - queued futures: [n=2] TRUE, TRUE
[15:32:14.248] signalConditionsASAP(NULL, pos=0) ... done
[15:32:14.248] resolve() on list ... DONE
[15:32:14.249] result() for ClusterFuture ...
[15:32:14.249] - result already collected: FutureResult
[15:32:14.249] result() for ClusterFuture ... done
[15:32:14.250] result() for ClusterFuture ...
[15:32:14.250] - result already collected: FutureResult
[15:32:14.250] result() for ClusterFuture ... done
[15:32:14.251] result() for ClusterFuture ...
[15:32:14.251] - result already collected: FutureResult
[15:32:14.251] result() for ClusterFuture ... done
[15:32:14.251] result() for ClusterFuture ...
[15:32:14.252] - result already collected: FutureResult
[15:32:14.252] result() for ClusterFuture ... done
[15:32:14.252]  - Number of value chunks collected: 2
[15:32:14.252] Resolving 2 futures (chunks) ... DONE
[15:32:14.253] Reducing values from 2 chunks ...
[15:32:14.253]  - Number of values collected after concatenation: 4
[15:32:14.253]  - Number of values expected: 4
[15:32:14.254] Reducing values from 2 chunks ... DONE
[15:32:14.254] future_mapply() ... DONE
[[1]]
[1] 1.752502

[[2]]
[1] 2.765950 2.044156

[[3]]
[1] 1.419503 3.529684 1.023802

[[4]]
[1] 4.494280 3.546145 1.402837 4.295444

- future_Map() ...
[15:32:14.255] future_mapply() ...
[15:32:14.260] Number of chunks: 2
[15:32:14.260] getGlobalsAndPackagesXApply() ...
[15:32:14.260]  - future.globals: TRUE
[15:32:14.261] getGlobalsAndPackages() ...
[15:32:14.261] Searching for globals...
[15:32:14.263] - globals found: [2] 'FUN', 'UseMethod'
[15:32:14.263] Searching for globals ... DONE
[15:32:14.264] Resolving globals: FALSE
[15:32:14.265] The total size of the 1 globals is 1.38 KiB (1416 bytes)
[15:32:14.265] The total size of the 1 globals exported for future expression ('FUN()') is 1.38 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.38 KiB of class 'function')
[15:32:14.266] - globals: [1] 'FUN'
[15:32:14.266] - packages: [1] 'stats'
[15:32:14.267] getGlobalsAndPackages() ... DONE
[15:32:14.267]  - globals found/used: [n=1] 'FUN'
[15:32:14.267]  - needed namespaces: [n=1] 'stats'
[15:32:14.267] Finding globals ... DONE
[15:32:14.268] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:14.268] List of 2
[15:32:14.268]  $ ...future.FUN:function (x, w, ...)  
[15:32:14.268]  $ MoreArgs     : NULL
[15:32:14.268]  - attr(*, "where")=List of 2
[15:32:14.268]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:14.268]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:14.268]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:14.268]  - attr(*, "resolved")= logi FALSE
[15:32:14.268]  - attr(*, "total_size")= num NA
[15:32:14.273] Packages to be attached in all futures: [n=1] 'stats'
[15:32:14.274] getGlobalsAndPackagesXApply() ... DONE
[15:32:14.274] Number of futures (= number of chunks): 2
[15:32:14.275] Launching 2 futures (chunks) ...
[15:32:14.275] Chunk #1 of 2 ...
[15:32:14.275]  - Finding globals in '...' for chunk #1 ...
[15:32:14.275] getGlobalsAndPackages() ...
[15:32:14.276] Searching for globals...
[15:32:14.276] 
[15:32:14.277] Searching for globals ... DONE
[15:32:14.277] - globals: [0] <none>
[15:32:14.277] getGlobalsAndPackages() ... DONE
[15:32:14.278]    + additional globals found: [n=0] 
[15:32:14.278]    + additional namespaces needed: [n=0] 
[15:32:14.278]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:14.279]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.279]  - seeds: <none>
[15:32:14.279]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.280] getGlobalsAndPackages() ...
[15:32:14.280] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.280] Resolving globals: FALSE
[15:32:14.281] The total size of the 5 globals is 2.07 KiB (2120 bytes)
[15:32:14.283] 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 2.07 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.38 KiB of class 'function'), '...future.elements_ii' (704 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:14.283] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.283] - packages: [1] 'stats'
[15:32:14.284] getGlobalsAndPackages() ... DONE
[15:32:14.284] run() for 'Future' ...
[15:32:14.285] - state: 'created'
[15:32:14.290] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.308] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.308] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.308]   - Field: 'node'
[15:32:14.308]   - Field: 'label'
[15:32:14.309]   - Field: 'local'
[15:32:14.309]   - Field: 'owner'
[15:32:14.309]   - Field: 'envir'
[15:32:14.309]   - Field: 'workers'
[15:32:14.309]   - Field: 'packages'
[15:32:14.309]   - Field: 'gc'
[15:32:14.310]   - Field: 'conditions'
[15:32:14.310]   - Field: 'persistent'
[15:32:14.310]   - Field: 'expr'
[15:32:14.310]   - Field: 'uuid'
[15:32:14.310]   - Field: 'seed'
[15:32:14.311]   - Field: 'version'
[15:32:14.311]   - Field: 'result'
[15:32:14.311]   - Field: 'asynchronous'
[15:32:14.311]   - Field: 'calls'
[15:32:14.311]   - Field: 'globals'
[15:32:14.312]   - Field: 'stdout'
[15:32:14.312]   - Field: 'earlySignal'
[15:32:14.312]   - Field: 'lazy'
[15:32:14.312]   - Field: 'state'
[15:32:14.312] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.312] - Launch lazy future ...
[15:32:14.313] Packages needed by the future expression (n = 1): 'stats'
[15:32:14.313] Packages needed by future strategies (n = 0): <none>
[15:32:14.314] {
[15:32:14.314]     {
[15:32:14.314]         {
[15:32:14.314]             ...future.startTime <- base::Sys.time()
[15:32:14.314]             {
[15:32:14.314]                 {
[15:32:14.314]                   {
[15:32:14.314]                     {
[15:32:14.314]                       {
[15:32:14.314]                         base::local({
[15:32:14.314]                           has_future <- base::requireNamespace("future", 
[15:32:14.314]                             quietly = TRUE)
[15:32:14.314]                           if (has_future) {
[15:32:14.314]                             ns <- base::getNamespace("future")
[15:32:14.314]                             version <- ns[[".package"]][["version"]]
[15:32:14.314]                             if (is.null(version)) 
[15:32:14.314]                               version <- utils::packageVersion("future")
[15:32:14.314]                           }
[15:32:14.314]                           else {
[15:32:14.314]                             version <- NULL
[15:32:14.314]                           }
[15:32:14.314]                           if (!has_future || version < "1.8.0") {
[15:32:14.314]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.314]                               "", base::R.version$version.string), 
[15:32:14.314]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:14.314]                                 base::R.version$platform, 8 * 
[15:32:14.314]                                   base::.Machine$sizeof.pointer), 
[15:32:14.314]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.314]                                 "release", "version")], collapse = " "), 
[15:32:14.314]                               hostname = base::Sys.info()[["nodename"]])
[15:32:14.314]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.314]                               info)
[15:32:14.314]                             info <- base::paste(info, collapse = "; ")
[15:32:14.314]                             if (!has_future) {
[15:32:14.314]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.314]                                 info)
[15:32:14.314]                             }
[15:32:14.314]                             else {
[15:32:14.314]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.314]                                 info, version)
[15:32:14.314]                             }
[15:32:14.314]                             base::stop(msg)
[15:32:14.314]                           }
[15:32:14.314]                         })
[15:32:14.314]                       }
[15:32:14.314]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.314]                       base::options(mc.cores = 1L)
[15:32:14.314]                     }
[15:32:14.314]                     base::local({
[15:32:14.314]                       for (pkg in "stats") {
[15:32:14.314]                         base::loadNamespace(pkg)
[15:32:14.314]                         base::library(pkg, character.only = TRUE)
[15:32:14.314]                       }
[15:32:14.314]                     })
[15:32:14.314]                   }
[15:32:14.314]                   ...future.strategy.old <- future::plan("list")
[15:32:14.314]                   options(future.plan = NULL)
[15:32:14.314]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.314]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.314]                 }
[15:32:14.314]                 ...future.workdir <- getwd()
[15:32:14.314]             }
[15:32:14.314]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.314]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.314]         }
[15:32:14.314]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.314]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.314]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.314]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.314]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.314]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.314]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.314]             base::names(...future.oldOptions))
[15:32:14.314]     }
[15:32:14.314]     if (FALSE) {
[15:32:14.314]     }
[15:32:14.314]     else {
[15:32:14.314]         if (TRUE) {
[15:32:14.314]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.314]                 open = "w")
[15:32:14.314]         }
[15:32:14.314]         else {
[15:32:14.314]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.314]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.314]         }
[15:32:14.314]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.314]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.314]             base::sink(type = "output", split = FALSE)
[15:32:14.314]             base::close(...future.stdout)
[15:32:14.314]         }, add = TRUE)
[15:32:14.314]     }
[15:32:14.314]     ...future.frame <- base::sys.nframe()
[15:32:14.314]     ...future.conditions <- base::list()
[15:32:14.314]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.314]     if (FALSE) {
[15:32:14.314]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.314]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.314]     }
[15:32:14.314]     ...future.result <- base::tryCatch({
[15:32:14.314]         base::withCallingHandlers({
[15:32:14.314]             ...future.value <- base::withVisible(base::local({
[15:32:14.314]                 ...future.makeSendCondition <- base::local({
[15:32:14.314]                   sendCondition <- NULL
[15:32:14.314]                   function(frame = 1L) {
[15:32:14.314]                     if (is.function(sendCondition)) 
[15:32:14.314]                       return(sendCondition)
[15:32:14.314]                     ns <- getNamespace("parallel")
[15:32:14.314]                     if (exists("sendData", mode = "function", 
[15:32:14.314]                       envir = ns)) {
[15:32:14.314]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.314]                         envir = ns)
[15:32:14.314]                       envir <- sys.frame(frame)
[15:32:14.314]                       master <- NULL
[15:32:14.314]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.314]                         !identical(envir, emptyenv())) {
[15:32:14.314]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.314]                           inherits = FALSE)) {
[15:32:14.314]                           master <- get("master", mode = "list", 
[15:32:14.314]                             envir = envir, inherits = FALSE)
[15:32:14.314]                           if (inherits(master, c("SOCKnode", 
[15:32:14.314]                             "SOCK0node"))) {
[15:32:14.314]                             sendCondition <<- function(cond) {
[15:32:14.314]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.314]                                 success = TRUE)
[15:32:14.314]                               parallel_sendData(master, data)
[15:32:14.314]                             }
[15:32:14.314]                             return(sendCondition)
[15:32:14.314]                           }
[15:32:14.314]                         }
[15:32:14.314]                         frame <- frame + 1L
[15:32:14.314]                         envir <- sys.frame(frame)
[15:32:14.314]                       }
[15:32:14.314]                     }
[15:32:14.314]                     sendCondition <<- function(cond) NULL
[15:32:14.314]                   }
[15:32:14.314]                 })
[15:32:14.314]                 withCallingHandlers({
[15:32:14.314]                   {
[15:32:14.314]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.314]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.314]                       ...future.globals.maxSize)) {
[15:32:14.314]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.314]                       on.exit(options(oopts), add = TRUE)
[15:32:14.314]                     }
[15:32:14.314]                     {
[15:32:14.314]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.314]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.314]                         USE.NAMES = FALSE)
[15:32:14.314]                       do.call(mapply, args = args)
[15:32:14.314]                     }
[15:32:14.314]                   }
[15:32:14.314]                 }, immediateCondition = function(cond) {
[15:32:14.314]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.314]                   sendCondition(cond)
[15:32:14.314]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.314]                   {
[15:32:14.314]                     inherits <- base::inherits
[15:32:14.314]                     invokeRestart <- base::invokeRestart
[15:32:14.314]                     is.null <- base::is.null
[15:32:14.314]                     muffled <- FALSE
[15:32:14.314]                     if (inherits(cond, "message")) {
[15:32:14.314]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.314]                       if (muffled) 
[15:32:14.314]                         invokeRestart("muffleMessage")
[15:32:14.314]                     }
[15:32:14.314]                     else if (inherits(cond, "warning")) {
[15:32:14.314]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.314]                       if (muffled) 
[15:32:14.314]                         invokeRestart("muffleWarning")
[15:32:14.314]                     }
[15:32:14.314]                     else if (inherits(cond, "condition")) {
[15:32:14.314]                       if (!is.null(pattern)) {
[15:32:14.314]                         computeRestarts <- base::computeRestarts
[15:32:14.314]                         grepl <- base::grepl
[15:32:14.314]                         restarts <- computeRestarts(cond)
[15:32:14.314]                         for (restart in restarts) {
[15:32:14.314]                           name <- restart$name
[15:32:14.314]                           if (is.null(name)) 
[15:32:14.314]                             next
[15:32:14.314]                           if (!grepl(pattern, name)) 
[15:32:14.314]                             next
[15:32:14.314]                           invokeRestart(restart)
[15:32:14.314]                           muffled <- TRUE
[15:32:14.314]                           break
[15:32:14.314]                         }
[15:32:14.314]                       }
[15:32:14.314]                     }
[15:32:14.314]                     invisible(muffled)
[15:32:14.314]                   }
[15:32:14.314]                   muffleCondition(cond)
[15:32:14.314]                 })
[15:32:14.314]             }))
[15:32:14.314]             future::FutureResult(value = ...future.value$value, 
[15:32:14.314]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.314]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.314]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.314]                     ...future.globalenv.names))
[15:32:14.314]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.314]         }, condition = base::local({
[15:32:14.314]             c <- base::c
[15:32:14.314]             inherits <- base::inherits
[15:32:14.314]             invokeRestart <- base::invokeRestart
[15:32:14.314]             length <- base::length
[15:32:14.314]             list <- base::list
[15:32:14.314]             seq.int <- base::seq.int
[15:32:14.314]             signalCondition <- base::signalCondition
[15:32:14.314]             sys.calls <- base::sys.calls
[15:32:14.314]             `[[` <- base::`[[`
[15:32:14.314]             `+` <- base::`+`
[15:32:14.314]             `<<-` <- base::`<<-`
[15:32:14.314]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.314]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.314]                   3L)]
[15:32:14.314]             }
[15:32:14.314]             function(cond) {
[15:32:14.314]                 is_error <- inherits(cond, "error")
[15:32:14.314]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.314]                   NULL)
[15:32:14.314]                 if (is_error) {
[15:32:14.314]                   sessionInformation <- function() {
[15:32:14.314]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.314]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.314]                       search = base::search(), system = base::Sys.info())
[15:32:14.314]                   }
[15:32:14.314]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.314]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.314]                     cond$call), session = sessionInformation(), 
[15:32:14.314]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.314]                   signalCondition(cond)
[15:32:14.314]                 }
[15:32:14.314]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.314]                 "immediateCondition"))) {
[15:32:14.314]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.314]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.314]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.314]                   if (TRUE && !signal) {
[15:32:14.314]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.314]                     {
[15:32:14.314]                       inherits <- base::inherits
[15:32:14.314]                       invokeRestart <- base::invokeRestart
[15:32:14.314]                       is.null <- base::is.null
[15:32:14.314]                       muffled <- FALSE
[15:32:14.314]                       if (inherits(cond, "message")) {
[15:32:14.314]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.314]                         if (muffled) 
[15:32:14.314]                           invokeRestart("muffleMessage")
[15:32:14.314]                       }
[15:32:14.314]                       else if (inherits(cond, "warning")) {
[15:32:14.314]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.314]                         if (muffled) 
[15:32:14.314]                           invokeRestart("muffleWarning")
[15:32:14.314]                       }
[15:32:14.314]                       else if (inherits(cond, "condition")) {
[15:32:14.314]                         if (!is.null(pattern)) {
[15:32:14.314]                           computeRestarts <- base::computeRestarts
[15:32:14.314]                           grepl <- base::grepl
[15:32:14.314]                           restarts <- computeRestarts(cond)
[15:32:14.314]                           for (restart in restarts) {
[15:32:14.314]                             name <- restart$name
[15:32:14.314]                             if (is.null(name)) 
[15:32:14.314]                               next
[15:32:14.314]                             if (!grepl(pattern, name)) 
[15:32:14.314]                               next
[15:32:14.314]                             invokeRestart(restart)
[15:32:14.314]                             muffled <- TRUE
[15:32:14.314]                             break
[15:32:14.314]                           }
[15:32:14.314]                         }
[15:32:14.314]                       }
[15:32:14.314]                       invisible(muffled)
[15:32:14.314]                     }
[15:32:14.314]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.314]                   }
[15:32:14.314]                 }
[15:32:14.314]                 else {
[15:32:14.314]                   if (TRUE) {
[15:32:14.314]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.314]                     {
[15:32:14.314]                       inherits <- base::inherits
[15:32:14.314]                       invokeRestart <- base::invokeRestart
[15:32:14.314]                       is.null <- base::is.null
[15:32:14.314]                       muffled <- FALSE
[15:32:14.314]                       if (inherits(cond, "message")) {
[15:32:14.314]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.314]                         if (muffled) 
[15:32:14.314]                           invokeRestart("muffleMessage")
[15:32:14.314]                       }
[15:32:14.314]                       else if (inherits(cond, "warning")) {
[15:32:14.314]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.314]                         if (muffled) 
[15:32:14.314]                           invokeRestart("muffleWarning")
[15:32:14.314]                       }
[15:32:14.314]                       else if (inherits(cond, "condition")) {
[15:32:14.314]                         if (!is.null(pattern)) {
[15:32:14.314]                           computeRestarts <- base::computeRestarts
[15:32:14.314]                           grepl <- base::grepl
[15:32:14.314]                           restarts <- computeRestarts(cond)
[15:32:14.314]                           for (restart in restarts) {
[15:32:14.314]                             name <- restart$name
[15:32:14.314]                             if (is.null(name)) 
[15:32:14.314]                               next
[15:32:14.314]                             if (!grepl(pattern, name)) 
[15:32:14.314]                               next
[15:32:14.314]                             invokeRestart(restart)
[15:32:14.314]                             muffled <- TRUE
[15:32:14.314]                             break
[15:32:14.314]                           }
[15:32:14.314]                         }
[15:32:14.314]                       }
[15:32:14.314]                       invisible(muffled)
[15:32:14.314]                     }
[15:32:14.314]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.314]                   }
[15:32:14.314]                 }
[15:32:14.314]             }
[15:32:14.314]         }))
[15:32:14.314]     }, error = function(ex) {
[15:32:14.314]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.314]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.314]                 ...future.rng), started = ...future.startTime, 
[15:32:14.314]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.314]             version = "1.8"), class = "FutureResult")
[15:32:14.314]     }, finally = {
[15:32:14.314]         if (!identical(...future.workdir, getwd())) 
[15:32:14.314]             setwd(...future.workdir)
[15:32:14.314]         {
[15:32:14.314]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.314]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.314]             }
[15:32:14.314]             base::options(...future.oldOptions)
[15:32:14.314]             if (.Platform$OS.type == "windows") {
[15:32:14.314]                 old_names <- names(...future.oldEnvVars)
[15:32:14.314]                 envs <- base::Sys.getenv()
[15:32:14.314]                 names <- names(envs)
[15:32:14.314]                 common <- intersect(names, old_names)
[15:32:14.314]                 added <- setdiff(names, old_names)
[15:32:14.314]                 removed <- setdiff(old_names, names)
[15:32:14.314]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.314]                   envs[common]]
[15:32:14.314]                 NAMES <- toupper(changed)
[15:32:14.314]                 args <- list()
[15:32:14.314]                 for (kk in seq_along(NAMES)) {
[15:32:14.314]                   name <- changed[[kk]]
[15:32:14.314]                   NAME <- NAMES[[kk]]
[15:32:14.314]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.314]                     next
[15:32:14.314]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.314]                 }
[15:32:14.314]                 NAMES <- toupper(added)
[15:32:14.314]                 for (kk in seq_along(NAMES)) {
[15:32:14.314]                   name <- added[[kk]]
[15:32:14.314]                   NAME <- NAMES[[kk]]
[15:32:14.314]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.314]                     next
[15:32:14.314]                   args[[name]] <- ""
[15:32:14.314]                 }
[15:32:14.314]                 NAMES <- toupper(removed)
[15:32:14.314]                 for (kk in seq_along(NAMES)) {
[15:32:14.314]                   name <- removed[[kk]]
[15:32:14.314]                   NAME <- NAMES[[kk]]
[15:32:14.314]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.314]                     next
[15:32:14.314]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.314]                 }
[15:32:14.314]                 if (length(args) > 0) 
[15:32:14.314]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.314]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.314]             }
[15:32:14.314]             else {
[15:32:14.314]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.314]             }
[15:32:14.314]             {
[15:32:14.314]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.314]                   0L) {
[15:32:14.314]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.314]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.314]                   base::options(opts)
[15:32:14.314]                 }
[15:32:14.314]                 {
[15:32:14.314]                   {
[15:32:14.314]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.314]                     NULL
[15:32:14.314]                   }
[15:32:14.314]                   options(future.plan = NULL)
[15:32:14.314]                   if (is.na(NA_character_)) 
[15:32:14.314]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.314]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.314]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.314]                     .init = FALSE)
[15:32:14.314]                 }
[15:32:14.314]             }
[15:32:14.314]         }
[15:32:14.314]     })
[15:32:14.314]     if (TRUE) {
[15:32:14.314]         base::sink(type = "output", split = FALSE)
[15:32:14.314]         if (TRUE) {
[15:32:14.314]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.314]         }
[15:32:14.314]         else {
[15:32:14.314]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.314]         }
[15:32:14.314]         base::close(...future.stdout)
[15:32:14.314]         ...future.stdout <- NULL
[15:32:14.314]     }
[15:32:14.314]     ...future.result$conditions <- ...future.conditions
[15:32:14.314]     ...future.result$finished <- base::Sys.time()
[15:32:14.314]     ...future.result
[15:32:14.314] }
[15:32:14.320] Exporting 5 global objects (2.07 KiB) to cluster node #1 ...
[15:32:14.320] Exporting '...future.FUN' (1.38 KiB) to cluster node #1 ...
[15:32:14.321] Exporting '...future.FUN' (1.38 KiB) to cluster node #1 ... DONE
[15:32:14.321] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:14.322] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:14.322] Exporting '...future.elements_ii' (704 bytes) to cluster node #1 ...
[15:32:14.322] Exporting '...future.elements_ii' (704 bytes) to cluster node #1 ... DONE
[15:32:14.323] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:14.324] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:14.324] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.325] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.325] Exporting 5 global objects (2.07 KiB) to cluster node #1 ... DONE
[15:32:14.326] MultisessionFuture started
[15:32:14.326] - Launch lazy future ... done
[15:32:14.326] run() for 'MultisessionFuture' ... done
[15:32:14.327] Created future:
[15:32:14.350] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.350] - Validating connection of MultisessionFuture
[15:32:14.351] - received message: FutureResult
[15:32:14.351] - Received FutureResult
[15:32:14.351] - Erased future from FutureRegistry
[15:32:14.352] result() for ClusterFuture ...
[15:32:14.352] - result already collected: FutureResult
[15:32:14.352] result() for ClusterFuture ... done
[15:32:14.352] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.327] MultisessionFuture:
[15:32:14.327] Label: 'future_Map-1'
[15:32:14.327] Expression:
[15:32:14.327] {
[15:32:14.327]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.327]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.327]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.327]         on.exit(options(oopts), add = TRUE)
[15:32:14.327]     }
[15:32:14.327]     {
[15:32:14.327]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.327]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.327]         do.call(mapply, args = args)
[15:32:14.327]     }
[15:32:14.327] }
[15:32:14.327] Lazy evaluation: FALSE
[15:32:14.327] Asynchronous evaluation: TRUE
[15:32:14.327] Local evaluation: TRUE
[15:32:14.327] Environment: R_GlobalEnv
[15:32:14.327] Capture standard output: TRUE
[15:32:14.327] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.327] Globals: 5 objects totaling 2.07 KiB (function '...future.FUN' of 1.38 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 704 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:14.327] Packages: 1 packages ('stats')
[15:32:14.327] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:14.327] Resolved: TRUE
[15:32:14.327] Value: <not collected>
[15:32:14.327] Conditions captured: <none>
[15:32:14.327] Early signaling: FALSE
[15:32:14.327] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.327] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.353] Chunk #1 of 2 ... DONE
[15:32:14.354] Chunk #2 of 2 ...
[15:32:14.354]  - Finding globals in '...' for chunk #2 ...
[15:32:14.354] getGlobalsAndPackages() ...
[15:32:14.354] Searching for globals...
[15:32:14.355] 
[15:32:14.355] Searching for globals ... DONE
[15:32:14.356] - globals: [0] <none>
[15:32:14.356] getGlobalsAndPackages() ... DONE
[15:32:14.356]    + additional globals found: [n=0] 
[15:32:14.356]    + additional namespaces needed: [n=0] 
[15:32:14.357]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:14.357]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.357]  - seeds: <none>
[15:32:14.358]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.358] getGlobalsAndPackages() ...
[15:32:14.358] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.358] Resolving globals: FALSE
[15:32:14.360] The total size of the 5 globals is 2.41 KiB (2472 bytes)
[15:32:14.361] 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 2.41 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (1.38 KiB of class 'function'), '...future.elements_ii' (1.03 KiB of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:14.361] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.362] - packages: [1] 'stats'
[15:32:14.362] getGlobalsAndPackages() ... DONE
[15:32:14.363] run() for 'Future' ...
[15:32:14.363] - state: 'created'
[15:32:14.363] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.386] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.386] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.387]   - Field: 'node'
[15:32:14.387]   - Field: 'label'
[15:32:14.387]   - Field: 'local'
[15:32:14.388]   - Field: 'owner'
[15:32:14.388]   - Field: 'envir'
[15:32:14.388]   - Field: 'workers'
[15:32:14.389]   - Field: 'packages'
[15:32:14.389]   - Field: 'gc'
[15:32:14.390]   - Field: 'conditions'
[15:32:14.390]   - Field: 'persistent'
[15:32:14.390]   - Field: 'expr'
[15:32:14.391]   - Field: 'uuid'
[15:32:14.391]   - Field: 'seed'
[15:32:14.391]   - Field: 'version'
[15:32:14.392]   - Field: 'result'
[15:32:14.392]   - Field: 'asynchronous'
[15:32:14.392]   - Field: 'calls'
[15:32:14.393]   - Field: 'globals'
[15:32:14.393]   - Field: 'stdout'
[15:32:14.393]   - Field: 'earlySignal'
[15:32:14.394]   - Field: 'lazy'
[15:32:14.394]   - Field: 'state'
[15:32:14.394] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.395] - Launch lazy future ...
[15:32:14.396] Packages needed by the future expression (n = 1): 'stats'
[15:32:14.396] Packages needed by future strategies (n = 0): <none>
[15:32:14.397] {
[15:32:14.397]     {
[15:32:14.397]         {
[15:32:14.397]             ...future.startTime <- base::Sys.time()
[15:32:14.397]             {
[15:32:14.397]                 {
[15:32:14.397]                   {
[15:32:14.397]                     {
[15:32:14.397]                       {
[15:32:14.397]                         base::local({
[15:32:14.397]                           has_future <- base::requireNamespace("future", 
[15:32:14.397]                             quietly = TRUE)
[15:32:14.397]                           if (has_future) {
[15:32:14.397]                             ns <- base::getNamespace("future")
[15:32:14.397]                             version <- ns[[".package"]][["version"]]
[15:32:14.397]                             if (is.null(version)) 
[15:32:14.397]                               version <- utils::packageVersion("future")
[15:32:14.397]                           }
[15:32:14.397]                           else {
[15:32:14.397]                             version <- NULL
[15:32:14.397]                           }
[15:32:14.397]                           if (!has_future || version < "1.8.0") {
[15:32:14.397]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.397]                               "", base::R.version$version.string), 
[15:32:14.397]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:14.397]                                 base::R.version$platform, 8 * 
[15:32:14.397]                                   base::.Machine$sizeof.pointer), 
[15:32:14.397]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.397]                                 "release", "version")], collapse = " "), 
[15:32:14.397]                               hostname = base::Sys.info()[["nodename"]])
[15:32:14.397]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.397]                               info)
[15:32:14.397]                             info <- base::paste(info, collapse = "; ")
[15:32:14.397]                             if (!has_future) {
[15:32:14.397]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.397]                                 info)
[15:32:14.397]                             }
[15:32:14.397]                             else {
[15:32:14.397]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.397]                                 info, version)
[15:32:14.397]                             }
[15:32:14.397]                             base::stop(msg)
[15:32:14.397]                           }
[15:32:14.397]                         })
[15:32:14.397]                       }
[15:32:14.397]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.397]                       base::options(mc.cores = 1L)
[15:32:14.397]                     }
[15:32:14.397]                     base::local({
[15:32:14.397]                       for (pkg in "stats") {
[15:32:14.397]                         base::loadNamespace(pkg)
[15:32:14.397]                         base::library(pkg, character.only = TRUE)
[15:32:14.397]                       }
[15:32:14.397]                     })
[15:32:14.397]                   }
[15:32:14.397]                   ...future.strategy.old <- future::plan("list")
[15:32:14.397]                   options(future.plan = NULL)
[15:32:14.397]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.397]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.397]                 }
[15:32:14.397]                 ...future.workdir <- getwd()
[15:32:14.397]             }
[15:32:14.397]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.397]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.397]         }
[15:32:14.397]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.397]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.397]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.397]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.397]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.397]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.397]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.397]             base::names(...future.oldOptions))
[15:32:14.397]     }
[15:32:14.397]     if (FALSE) {
[15:32:14.397]     }
[15:32:14.397]     else {
[15:32:14.397]         if (TRUE) {
[15:32:14.397]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.397]                 open = "w")
[15:32:14.397]         }
[15:32:14.397]         else {
[15:32:14.397]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.397]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.397]         }
[15:32:14.397]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.397]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.397]             base::sink(type = "output", split = FALSE)
[15:32:14.397]             base::close(...future.stdout)
[15:32:14.397]         }, add = TRUE)
[15:32:14.397]     }
[15:32:14.397]     ...future.frame <- base::sys.nframe()
[15:32:14.397]     ...future.conditions <- base::list()
[15:32:14.397]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.397]     if (FALSE) {
[15:32:14.397]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.397]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.397]     }
[15:32:14.397]     ...future.result <- base::tryCatch({
[15:32:14.397]         base::withCallingHandlers({
[15:32:14.397]             ...future.value <- base::withVisible(base::local({
[15:32:14.397]                 ...future.makeSendCondition <- base::local({
[15:32:14.397]                   sendCondition <- NULL
[15:32:14.397]                   function(frame = 1L) {
[15:32:14.397]                     if (is.function(sendCondition)) 
[15:32:14.397]                       return(sendCondition)
[15:32:14.397]                     ns <- getNamespace("parallel")
[15:32:14.397]                     if (exists("sendData", mode = "function", 
[15:32:14.397]                       envir = ns)) {
[15:32:14.397]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.397]                         envir = ns)
[15:32:14.397]                       envir <- sys.frame(frame)
[15:32:14.397]                       master <- NULL
[15:32:14.397]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.397]                         !identical(envir, emptyenv())) {
[15:32:14.397]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.397]                           inherits = FALSE)) {
[15:32:14.397]                           master <- get("master", mode = "list", 
[15:32:14.397]                             envir = envir, inherits = FALSE)
[15:32:14.397]                           if (inherits(master, c("SOCKnode", 
[15:32:14.397]                             "SOCK0node"))) {
[15:32:14.397]                             sendCondition <<- function(cond) {
[15:32:14.397]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.397]                                 success = TRUE)
[15:32:14.397]                               parallel_sendData(master, data)
[15:32:14.397]                             }
[15:32:14.397]                             return(sendCondition)
[15:32:14.397]                           }
[15:32:14.397]                         }
[15:32:14.397]                         frame <- frame + 1L
[15:32:14.397]                         envir <- sys.frame(frame)
[15:32:14.397]                       }
[15:32:14.397]                     }
[15:32:14.397]                     sendCondition <<- function(cond) NULL
[15:32:14.397]                   }
[15:32:14.397]                 })
[15:32:14.397]                 withCallingHandlers({
[15:32:14.397]                   {
[15:32:14.397]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.397]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.397]                       ...future.globals.maxSize)) {
[15:32:14.397]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.397]                       on.exit(options(oopts), add = TRUE)
[15:32:14.397]                     }
[15:32:14.397]                     {
[15:32:14.397]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.397]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.397]                         USE.NAMES = FALSE)
[15:32:14.397]                       do.call(mapply, args = args)
[15:32:14.397]                     }
[15:32:14.397]                   }
[15:32:14.397]                 }, immediateCondition = function(cond) {
[15:32:14.397]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.397]                   sendCondition(cond)
[15:32:14.397]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.397]                   {
[15:32:14.397]                     inherits <- base::inherits
[15:32:14.397]                     invokeRestart <- base::invokeRestart
[15:32:14.397]                     is.null <- base::is.null
[15:32:14.397]                     muffled <- FALSE
[15:32:14.397]                     if (inherits(cond, "message")) {
[15:32:14.397]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.397]                       if (muffled) 
[15:32:14.397]                         invokeRestart("muffleMessage")
[15:32:14.397]                     }
[15:32:14.397]                     else if (inherits(cond, "warning")) {
[15:32:14.397]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.397]                       if (muffled) 
[15:32:14.397]                         invokeRestart("muffleWarning")
[15:32:14.397]                     }
[15:32:14.397]                     else if (inherits(cond, "condition")) {
[15:32:14.397]                       if (!is.null(pattern)) {
[15:32:14.397]                         computeRestarts <- base::computeRestarts
[15:32:14.397]                         grepl <- base::grepl
[15:32:14.397]                         restarts <- computeRestarts(cond)
[15:32:14.397]                         for (restart in restarts) {
[15:32:14.397]                           name <- restart$name
[15:32:14.397]                           if (is.null(name)) 
[15:32:14.397]                             next
[15:32:14.397]                           if (!grepl(pattern, name)) 
[15:32:14.397]                             next
[15:32:14.397]                           invokeRestart(restart)
[15:32:14.397]                           muffled <- TRUE
[15:32:14.397]                           break
[15:32:14.397]                         }
[15:32:14.397]                       }
[15:32:14.397]                     }
[15:32:14.397]                     invisible(muffled)
[15:32:14.397]                   }
[15:32:14.397]                   muffleCondition(cond)
[15:32:14.397]                 })
[15:32:14.397]             }))
[15:32:14.397]             future::FutureResult(value = ...future.value$value, 
[15:32:14.397]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.397]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.397]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.397]                     ...future.globalenv.names))
[15:32:14.397]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.397]         }, condition = base::local({
[15:32:14.397]             c <- base::c
[15:32:14.397]             inherits <- base::inherits
[15:32:14.397]             invokeRestart <- base::invokeRestart
[15:32:14.397]             length <- base::length
[15:32:14.397]             list <- base::list
[15:32:14.397]             seq.int <- base::seq.int
[15:32:14.397]             signalCondition <- base::signalCondition
[15:32:14.397]             sys.calls <- base::sys.calls
[15:32:14.397]             `[[` <- base::`[[`
[15:32:14.397]             `+` <- base::`+`
[15:32:14.397]             `<<-` <- base::`<<-`
[15:32:14.397]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.397]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.397]                   3L)]
[15:32:14.397]             }
[15:32:14.397]             function(cond) {
[15:32:14.397]                 is_error <- inherits(cond, "error")
[15:32:14.397]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.397]                   NULL)
[15:32:14.397]                 if (is_error) {
[15:32:14.397]                   sessionInformation <- function() {
[15:32:14.397]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.397]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.397]                       search = base::search(), system = base::Sys.info())
[15:32:14.397]                   }
[15:32:14.397]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.397]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.397]                     cond$call), session = sessionInformation(), 
[15:32:14.397]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.397]                   signalCondition(cond)
[15:32:14.397]                 }
[15:32:14.397]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.397]                 "immediateCondition"))) {
[15:32:14.397]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.397]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.397]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.397]                   if (TRUE && !signal) {
[15:32:14.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.397]                     {
[15:32:14.397]                       inherits <- base::inherits
[15:32:14.397]                       invokeRestart <- base::invokeRestart
[15:32:14.397]                       is.null <- base::is.null
[15:32:14.397]                       muffled <- FALSE
[15:32:14.397]                       if (inherits(cond, "message")) {
[15:32:14.397]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.397]                         if (muffled) 
[15:32:14.397]                           invokeRestart("muffleMessage")
[15:32:14.397]                       }
[15:32:14.397]                       else if (inherits(cond, "warning")) {
[15:32:14.397]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.397]                         if (muffled) 
[15:32:14.397]                           invokeRestart("muffleWarning")
[15:32:14.397]                       }
[15:32:14.397]                       else if (inherits(cond, "condition")) {
[15:32:14.397]                         if (!is.null(pattern)) {
[15:32:14.397]                           computeRestarts <- base::computeRestarts
[15:32:14.397]                           grepl <- base::grepl
[15:32:14.397]                           restarts <- computeRestarts(cond)
[15:32:14.397]                           for (restart in restarts) {
[15:32:14.397]                             name <- restart$name
[15:32:14.397]                             if (is.null(name)) 
[15:32:14.397]                               next
[15:32:14.397]                             if (!grepl(pattern, name)) 
[15:32:14.397]                               next
[15:32:14.397]                             invokeRestart(restart)
[15:32:14.397]                             muffled <- TRUE
[15:32:14.397]                             break
[15:32:14.397]                           }
[15:32:14.397]                         }
[15:32:14.397]                       }
[15:32:14.397]                       invisible(muffled)
[15:32:14.397]                     }
[15:32:14.397]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.397]                   }
[15:32:14.397]                 }
[15:32:14.397]                 else {
[15:32:14.397]                   if (TRUE) {
[15:32:14.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.397]                     {
[15:32:14.397]                       inherits <- base::inherits
[15:32:14.397]                       invokeRestart <- base::invokeRestart
[15:32:14.397]                       is.null <- base::is.null
[15:32:14.397]                       muffled <- FALSE
[15:32:14.397]                       if (inherits(cond, "message")) {
[15:32:14.397]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.397]                         if (muffled) 
[15:32:14.397]                           invokeRestart("muffleMessage")
[15:32:14.397]                       }
[15:32:14.397]                       else if (inherits(cond, "warning")) {
[15:32:14.397]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.397]                         if (muffled) 
[15:32:14.397]                           invokeRestart("muffleWarning")
[15:32:14.397]                       }
[15:32:14.397]                       else if (inherits(cond, "condition")) {
[15:32:14.397]                         if (!is.null(pattern)) {
[15:32:14.397]                           computeRestarts <- base::computeRestarts
[15:32:14.397]                           grepl <- base::grepl
[15:32:14.397]                           restarts <- computeRestarts(cond)
[15:32:14.397]                           for (restart in restarts) {
[15:32:14.397]                             name <- restart$name
[15:32:14.397]                             if (is.null(name)) 
[15:32:14.397]                               next
[15:32:14.397]                             if (!grepl(pattern, name)) 
[15:32:14.397]                               next
[15:32:14.397]                             invokeRestart(restart)
[15:32:14.397]                             muffled <- TRUE
[15:32:14.397]                             break
[15:32:14.397]                           }
[15:32:14.397]                         }
[15:32:14.397]                       }
[15:32:14.397]                       invisible(muffled)
[15:32:14.397]                     }
[15:32:14.397]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.397]                   }
[15:32:14.397]                 }
[15:32:14.397]             }
[15:32:14.397]         }))
[15:32:14.397]     }, error = function(ex) {
[15:32:14.397]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.397]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.397]                 ...future.rng), started = ...future.startTime, 
[15:32:14.397]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.397]             version = "1.8"), class = "FutureResult")
[15:32:14.397]     }, finally = {
[15:32:14.397]         if (!identical(...future.workdir, getwd())) 
[15:32:14.397]             setwd(...future.workdir)
[15:32:14.397]         {
[15:32:14.397]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.397]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.397]             }
[15:32:14.397]             base::options(...future.oldOptions)
[15:32:14.397]             if (.Platform$OS.type == "windows") {
[15:32:14.397]                 old_names <- names(...future.oldEnvVars)
[15:32:14.397]                 envs <- base::Sys.getenv()
[15:32:14.397]                 names <- names(envs)
[15:32:14.397]                 common <- intersect(names, old_names)
[15:32:14.397]                 added <- setdiff(names, old_names)
[15:32:14.397]                 removed <- setdiff(old_names, names)
[15:32:14.397]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.397]                   envs[common]]
[15:32:14.397]                 NAMES <- toupper(changed)
[15:32:14.397]                 args <- list()
[15:32:14.397]                 for (kk in seq_along(NAMES)) {
[15:32:14.397]                   name <- changed[[kk]]
[15:32:14.397]                   NAME <- NAMES[[kk]]
[15:32:14.397]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.397]                     next
[15:32:14.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.397]                 }
[15:32:14.397]                 NAMES <- toupper(added)
[15:32:14.397]                 for (kk in seq_along(NAMES)) {
[15:32:14.397]                   name <- added[[kk]]
[15:32:14.397]                   NAME <- NAMES[[kk]]
[15:32:14.397]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.397]                     next
[15:32:14.397]                   args[[name]] <- ""
[15:32:14.397]                 }
[15:32:14.397]                 NAMES <- toupper(removed)
[15:32:14.397]                 for (kk in seq_along(NAMES)) {
[15:32:14.397]                   name <- removed[[kk]]
[15:32:14.397]                   NAME <- NAMES[[kk]]
[15:32:14.397]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.397]                     next
[15:32:14.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.397]                 }
[15:32:14.397]                 if (length(args) > 0) 
[15:32:14.397]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.397]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.397]             }
[15:32:14.397]             else {
[15:32:14.397]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.397]             }
[15:32:14.397]             {
[15:32:14.397]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.397]                   0L) {
[15:32:14.397]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.397]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.397]                   base::options(opts)
[15:32:14.397]                 }
[15:32:14.397]                 {
[15:32:14.397]                   {
[15:32:14.397]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.397]                     NULL
[15:32:14.397]                   }
[15:32:14.397]                   options(future.plan = NULL)
[15:32:14.397]                   if (is.na(NA_character_)) 
[15:32:14.397]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.397]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.397]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.397]                     .init = FALSE)
[15:32:14.397]                 }
[15:32:14.397]             }
[15:32:14.397]         }
[15:32:14.397]     })
[15:32:14.397]     if (TRUE) {
[15:32:14.397]         base::sink(type = "output", split = FALSE)
[15:32:14.397]         if (TRUE) {
[15:32:14.397]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.397]         }
[15:32:14.397]         else {
[15:32:14.397]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.397]         }
[15:32:14.397]         base::close(...future.stdout)
[15:32:14.397]         ...future.stdout <- NULL
[15:32:14.397]     }
[15:32:14.397]     ...future.result$conditions <- ...future.conditions
[15:32:14.397]     ...future.result$finished <- base::Sys.time()
[15:32:14.397]     ...future.result
[15:32:14.397] }
[15:32:14.409] Exporting 5 global objects (2.41 KiB) to cluster node #1 ...
[15:32:14.409] Exporting '...future.FUN' (1.38 KiB) to cluster node #1 ...
[15:32:14.410] Exporting '...future.FUN' (1.38 KiB) to cluster node #1 ... DONE
[15:32:14.411] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:14.411] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:14.412] Exporting '...future.elements_ii' (1.03 KiB) to cluster node #1 ...
[15:32:14.413] Exporting '...future.elements_ii' (1.03 KiB) to cluster node #1 ... DONE
[15:32:14.413] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:14.414] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:14.414] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.415] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.415] Exporting 5 global objects (2.41 KiB) to cluster node #1 ... DONE
[15:32:14.417] MultisessionFuture started
[15:32:14.417] - Launch lazy future ... done
[15:32:14.417] run() for 'MultisessionFuture' ... done
[15:32:14.418] Created future:
[15:32:14.433] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.434] - Validating connection of MultisessionFuture
[15:32:14.434] - received message: FutureResult
[15:32:14.435] - Received FutureResult
[15:32:14.435] - Erased future from FutureRegistry
[15:32:14.435] result() for ClusterFuture ...
[15:32:14.436] - result already collected: FutureResult
[15:32:14.436] result() for ClusterFuture ... done
[15:32:14.436] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.418] MultisessionFuture:
[15:32:14.418] Label: 'future_Map-2'
[15:32:14.418] Expression:
[15:32:14.418] {
[15:32:14.418]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.418]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.418]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.418]         on.exit(options(oopts), add = TRUE)
[15:32:14.418]     }
[15:32:14.418]     {
[15:32:14.418]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.418]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.418]         do.call(mapply, args = args)
[15:32:14.418]     }
[15:32:14.418] }
[15:32:14.418] Lazy evaluation: FALSE
[15:32:14.418] Asynchronous evaluation: TRUE
[15:32:14.418] Local evaluation: TRUE
[15:32:14.418] Environment: R_GlobalEnv
[15:32:14.418] Capture standard output: TRUE
[15:32:14.418] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.418] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 1.38 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 1.03 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:14.418] Packages: 1 packages ('stats')
[15:32:14.418] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:14.418] Resolved: TRUE
[15:32:14.418] Value: <not collected>
[15:32:14.418] Conditions captured: <none>
[15:32:14.418] Early signaling: FALSE
[15:32:14.418] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.418] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.437] Chunk #2 of 2 ... DONE
[15:32:14.437] Launching 2 futures (chunks) ... DONE
[15:32:14.438] Resolving 2 futures (chunks) ...
[15:32:14.438] resolve() on list ...
[15:32:14.438]  recursive: 0
[15:32:14.439]  length: 2
[15:32:14.439] 
[15:32:14.439] Future #1
[15:32:14.439] result() for ClusterFuture ...
[15:32:14.440] - result already collected: FutureResult
[15:32:14.440] result() for ClusterFuture ... done
[15:32:14.440] result() for ClusterFuture ...
[15:32:14.441] - result already collected: FutureResult
[15:32:14.441] result() for ClusterFuture ... done
[15:32:14.441] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:14.441] - nx: 2
[15:32:14.442] - relay: TRUE
[15:32:14.442] - stdout: TRUE
[15:32:14.442] - signal: TRUE
[15:32:14.443] - resignal: FALSE
[15:32:14.443] - force: TRUE
[15:32:14.443] - relayed: [n=2] FALSE, FALSE
[15:32:14.443] - queued futures: [n=2] FALSE, FALSE
[15:32:14.444]  - until=1
[15:32:14.444]  - relaying element #1
[15:32:14.444] result() for ClusterFuture ...
[15:32:14.444] - result already collected: FutureResult
[15:32:14.445] result() for ClusterFuture ... done
[15:32:14.445] result() for ClusterFuture ...
[15:32:14.445] - result already collected: FutureResult
[15:32:14.446] result() for ClusterFuture ... done
[15:32:14.446] result() for ClusterFuture ...
[15:32:14.446] - result already collected: FutureResult
[15:32:14.446] result() for ClusterFuture ... done
[15:32:14.447] result() for ClusterFuture ...
[15:32:14.447] - result already collected: FutureResult
[15:32:14.447] result() for ClusterFuture ... done
[15:32:14.448] - relayed: [n=2] TRUE, FALSE
[15:32:14.448] - queued futures: [n=2] TRUE, FALSE
[15:32:14.448] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:14.448]  length: 1 (resolved future 1)
[15:32:14.449] Future #2
[15:32:14.449] result() for ClusterFuture ...
[15:32:14.449] - result already collected: FutureResult
[15:32:14.450] result() for ClusterFuture ... done
[15:32:14.450] result() for ClusterFuture ...
[15:32:14.450] - result already collected: FutureResult
[15:32:14.450] result() for ClusterFuture ... done
[15:32:14.451] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:14.451] - nx: 2
[15:32:14.451] - relay: TRUE
[15:32:14.452] - stdout: TRUE
[15:32:14.452] - signal: TRUE
[15:32:14.452] - resignal: FALSE
[15:32:14.452] - force: TRUE
[15:32:14.453] - relayed: [n=2] TRUE, FALSE
[15:32:14.453] - queued futures: [n=2] TRUE, FALSE
[15:32:14.453]  - until=2
[15:32:14.453]  - relaying element #2
[15:32:14.453] result() for ClusterFuture ...
[15:32:14.453] - result already collected: FutureResult
[15:32:14.454] result() for ClusterFuture ... done
[15:32:14.454] result() for ClusterFuture ...
[15:32:14.454] - result already collected: FutureResult
[15:32:14.454] result() for ClusterFuture ... done
[15:32:14.454] result() for ClusterFuture ...
[15:32:14.455] - result already collected: FutureResult
[15:32:14.455] result() for ClusterFuture ... done
[15:32:14.455] result() for ClusterFuture ...
[15:32:14.455] - result already collected: FutureResult
[15:32:14.455] result() for ClusterFuture ... done
[15:32:14.456] - relayed: [n=2] TRUE, TRUE
[15:32:14.456] - queued futures: [n=2] TRUE, TRUE
[15:32:14.456] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:14.456]  length: 0 (resolved future 2)
[15:32:14.457] Relaying remaining futures
[15:32:14.457] signalConditionsASAP(NULL, pos=0) ...
[15:32:14.457] - nx: 2
[15:32:14.457] - relay: TRUE
[15:32:14.457] - stdout: TRUE
[15:32:14.458] - signal: TRUE
[15:32:14.458] - resignal: FALSE
[15:32:14.458] - force: TRUE
[15:32:14.458] - relayed: [n=2] TRUE, TRUE
[15:32:14.458] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:14.458] - relayed: [n=2] TRUE, TRUE
[15:32:14.459] - queued futures: [n=2] TRUE, TRUE
[15:32:14.459] signalConditionsASAP(NULL, pos=0) ... done
[15:32:14.459] resolve() on list ... DONE
[15:32:14.459] result() for ClusterFuture ...
[15:32:14.459] - result already collected: FutureResult
[15:32:14.460] result() for ClusterFuture ... done
[15:32:14.460] result() for ClusterFuture ...
[15:32:14.460] - result already collected: FutureResult
[15:32:14.460] result() for ClusterFuture ... done
[15:32:14.460] result() for ClusterFuture ...
[15:32:14.460] - result already collected: FutureResult
[15:32:14.461] result() for ClusterFuture ... done
[15:32:14.461] result() for ClusterFuture ...
[15:32:14.461] - result already collected: FutureResult
[15:32:14.461] result() for ClusterFuture ... done
[15:32:14.461]  - Number of value chunks collected: 2
[15:32:14.461] Resolving 2 futures (chunks) ... DONE
[15:32:14.462] Reducing values from 2 chunks ...
[15:32:14.462]  - Number of values collected after concatenation: 5
[15:32:14.462]  - Number of values expected: 5
[15:32:14.462] Reducing values from 2 chunks ... DONE
[15:32:14.462] future_mapply() ... DONE
- future_mapply() - 'max-or-0-if' recycling rule ...
[15:32:14.465] future_mapply() ...
[15:32:14.469] Number of chunks: 2
[15:32:14.469] getGlobalsAndPackagesXApply() ...
[15:32:14.469]  - future.globals: TRUE
[15:32:14.469] getGlobalsAndPackages() ...
[15:32:14.470] Searching for globals...
[15:32:14.471] - globals found: [1] 'FUN'
[15:32:14.471] Searching for globals ... DONE
[15:32:14.471] Resolving globals: FALSE
[15:32:14.471] The total size of the 1 globals is 56 bytes (56 bytes)
[15:32:14.472] The total size of the 1 globals exported for future expression ('FUN()') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (56 bytes of class 'function')
[15:32:14.472] - globals: [1] 'FUN'
[15:32:14.472] 
[15:32:14.473] getGlobalsAndPackages() ... DONE
[15:32:14.473]  - globals found/used: [n=1] 'FUN'
[15:32:14.473]  - needed namespaces: [n=0] 
[15:32:14.473] Finding globals ... DONE
[15:32:14.473] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:14.474] List of 2
[15:32:14.474]  $ ...future.FUN:function (e1, e2)  
[15:32:14.474]  $ MoreArgs     : NULL
[15:32:14.474]  - attr(*, "where")=List of 2
[15:32:14.474]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:14.474]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:14.474]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:14.474]  - attr(*, "resolved")= logi FALSE
[15:32:14.474]  - attr(*, "total_size")= num NA
[15:32:14.478] Packages to be attached in all futures: [n=0] 
[15:32:14.478] getGlobalsAndPackagesXApply() ... DONE
[15:32:14.479] Number of futures (= number of chunks): 2
[15:32:14.479] Launching 2 futures (chunks) ...
[15:32:14.479] Chunk #1 of 2 ...
[15:32:14.480]  - Finding globals in '...' for chunk #1 ...
[15:32:14.480] getGlobalsAndPackages() ...
[15:32:14.480] Searching for globals...
[15:32:14.481] 
[15:32:14.481] Searching for globals ... DONE
[15:32:14.481] - globals: [0] <none>
[15:32:14.482] getGlobalsAndPackages() ... DONE
[15:32:14.482]    + additional globals found: [n=0] 
[15:32:14.482]    + additional namespaces needed: [n=0] 
[15:32:14.483]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:14.483]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.483]  - seeds: <none>
[15:32:14.483]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.484] getGlobalsAndPackages() ...
[15:32:14.484] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.484] Resolving globals: FALSE
[15:32:14.485] The total size of the 5 globals is 168 bytes (168 bytes)
[15:32:14.487] 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 168 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (112 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:14.487] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.487] 
[15:32:14.487] getGlobalsAndPackages() ... DONE
[15:32:14.488] run() for 'Future' ...
[15:32:14.488] - state: 'created'
[15:32:14.489] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.507] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.508] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.508]   - Field: 'node'
[15:32:14.508]   - Field: 'label'
[15:32:14.509]   - Field: 'local'
[15:32:14.509]   - Field: 'owner'
[15:32:14.509]   - Field: 'envir'
[15:32:14.510]   - Field: 'workers'
[15:32:14.510]   - Field: 'packages'
[15:32:14.510]   - Field: 'gc'
[15:32:14.511]   - Field: 'conditions'
[15:32:14.511]   - Field: 'persistent'
[15:32:14.511]   - Field: 'expr'
[15:32:14.511]   - Field: 'uuid'
[15:32:14.512]   - Field: 'seed'
[15:32:14.512]   - Field: 'version'
[15:32:14.512]   - Field: 'result'
[15:32:14.513]   - Field: 'asynchronous'
[15:32:14.513]   - Field: 'calls'
[15:32:14.513]   - Field: 'globals'
[15:32:14.514]   - Field: 'stdout'
[15:32:14.514]   - Field: 'earlySignal'
[15:32:14.514]   - Field: 'lazy'
[15:32:14.514]   - Field: 'state'
[15:32:14.515] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.515] - Launch lazy future ...
[15:32:14.516] Packages needed by the future expression (n = 0): <none>
[15:32:14.516] Packages needed by future strategies (n = 0): <none>
[15:32:14.517] {
[15:32:14.517]     {
[15:32:14.517]         {
[15:32:14.517]             ...future.startTime <- base::Sys.time()
[15:32:14.517]             {
[15:32:14.517]                 {
[15:32:14.517]                   {
[15:32:14.517]                     {
[15:32:14.517]                       base::local({
[15:32:14.517]                         has_future <- base::requireNamespace("future", 
[15:32:14.517]                           quietly = TRUE)
[15:32:14.517]                         if (has_future) {
[15:32:14.517]                           ns <- base::getNamespace("future")
[15:32:14.517]                           version <- ns[[".package"]][["version"]]
[15:32:14.517]                           if (is.null(version)) 
[15:32:14.517]                             version <- utils::packageVersion("future")
[15:32:14.517]                         }
[15:32:14.517]                         else {
[15:32:14.517]                           version <- NULL
[15:32:14.517]                         }
[15:32:14.517]                         if (!has_future || version < "1.8.0") {
[15:32:14.517]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.517]                             "", base::R.version$version.string), 
[15:32:14.517]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:14.517]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:14.517]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.517]                               "release", "version")], collapse = " "), 
[15:32:14.517]                             hostname = base::Sys.info()[["nodename"]])
[15:32:14.517]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.517]                             info)
[15:32:14.517]                           info <- base::paste(info, collapse = "; ")
[15:32:14.517]                           if (!has_future) {
[15:32:14.517]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.517]                               info)
[15:32:14.517]                           }
[15:32:14.517]                           else {
[15:32:14.517]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.517]                               info, version)
[15:32:14.517]                           }
[15:32:14.517]                           base::stop(msg)
[15:32:14.517]                         }
[15:32:14.517]                       })
[15:32:14.517]                     }
[15:32:14.517]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.517]                     base::options(mc.cores = 1L)
[15:32:14.517]                   }
[15:32:14.517]                   ...future.strategy.old <- future::plan("list")
[15:32:14.517]                   options(future.plan = NULL)
[15:32:14.517]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.517]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.517]                 }
[15:32:14.517]                 ...future.workdir <- getwd()
[15:32:14.517]             }
[15:32:14.517]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.517]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.517]         }
[15:32:14.517]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.517]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.517]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.517]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.517]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.517]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.517]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.517]             base::names(...future.oldOptions))
[15:32:14.517]     }
[15:32:14.517]     if (FALSE) {
[15:32:14.517]     }
[15:32:14.517]     else {
[15:32:14.517]         if (TRUE) {
[15:32:14.517]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.517]                 open = "w")
[15:32:14.517]         }
[15:32:14.517]         else {
[15:32:14.517]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.517]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.517]         }
[15:32:14.517]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.517]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.517]             base::sink(type = "output", split = FALSE)
[15:32:14.517]             base::close(...future.stdout)
[15:32:14.517]         }, add = TRUE)
[15:32:14.517]     }
[15:32:14.517]     ...future.frame <- base::sys.nframe()
[15:32:14.517]     ...future.conditions <- base::list()
[15:32:14.517]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.517]     if (FALSE) {
[15:32:14.517]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.517]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.517]     }
[15:32:14.517]     ...future.result <- base::tryCatch({
[15:32:14.517]         base::withCallingHandlers({
[15:32:14.517]             ...future.value <- base::withVisible(base::local({
[15:32:14.517]                 ...future.makeSendCondition <- base::local({
[15:32:14.517]                   sendCondition <- NULL
[15:32:14.517]                   function(frame = 1L) {
[15:32:14.517]                     if (is.function(sendCondition)) 
[15:32:14.517]                       return(sendCondition)
[15:32:14.517]                     ns <- getNamespace("parallel")
[15:32:14.517]                     if (exists("sendData", mode = "function", 
[15:32:14.517]                       envir = ns)) {
[15:32:14.517]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.517]                         envir = ns)
[15:32:14.517]                       envir <- sys.frame(frame)
[15:32:14.517]                       master <- NULL
[15:32:14.517]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.517]                         !identical(envir, emptyenv())) {
[15:32:14.517]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.517]                           inherits = FALSE)) {
[15:32:14.517]                           master <- get("master", mode = "list", 
[15:32:14.517]                             envir = envir, inherits = FALSE)
[15:32:14.517]                           if (inherits(master, c("SOCKnode", 
[15:32:14.517]                             "SOCK0node"))) {
[15:32:14.517]                             sendCondition <<- function(cond) {
[15:32:14.517]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.517]                                 success = TRUE)
[15:32:14.517]                               parallel_sendData(master, data)
[15:32:14.517]                             }
[15:32:14.517]                             return(sendCondition)
[15:32:14.517]                           }
[15:32:14.517]                         }
[15:32:14.517]                         frame <- frame + 1L
[15:32:14.517]                         envir <- sys.frame(frame)
[15:32:14.517]                       }
[15:32:14.517]                     }
[15:32:14.517]                     sendCondition <<- function(cond) NULL
[15:32:14.517]                   }
[15:32:14.517]                 })
[15:32:14.517]                 withCallingHandlers({
[15:32:14.517]                   {
[15:32:14.517]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.517]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.517]                       ...future.globals.maxSize)) {
[15:32:14.517]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.517]                       on.exit(options(oopts), add = TRUE)
[15:32:14.517]                     }
[15:32:14.517]                     {
[15:32:14.517]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.517]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.517]                         USE.NAMES = FALSE)
[15:32:14.517]                       do.call(mapply, args = args)
[15:32:14.517]                     }
[15:32:14.517]                   }
[15:32:14.517]                 }, immediateCondition = function(cond) {
[15:32:14.517]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.517]                   sendCondition(cond)
[15:32:14.517]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.517]                   {
[15:32:14.517]                     inherits <- base::inherits
[15:32:14.517]                     invokeRestart <- base::invokeRestart
[15:32:14.517]                     is.null <- base::is.null
[15:32:14.517]                     muffled <- FALSE
[15:32:14.517]                     if (inherits(cond, "message")) {
[15:32:14.517]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.517]                       if (muffled) 
[15:32:14.517]                         invokeRestart("muffleMessage")
[15:32:14.517]                     }
[15:32:14.517]                     else if (inherits(cond, "warning")) {
[15:32:14.517]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.517]                       if (muffled) 
[15:32:14.517]                         invokeRestart("muffleWarning")
[15:32:14.517]                     }
[15:32:14.517]                     else if (inherits(cond, "condition")) {
[15:32:14.517]                       if (!is.null(pattern)) {
[15:32:14.517]                         computeRestarts <- base::computeRestarts
[15:32:14.517]                         grepl <- base::grepl
[15:32:14.517]                         restarts <- computeRestarts(cond)
[15:32:14.517]                         for (restart in restarts) {
[15:32:14.517]                           name <- restart$name
[15:32:14.517]                           if (is.null(name)) 
[15:32:14.517]                             next
[15:32:14.517]                           if (!grepl(pattern, name)) 
[15:32:14.517]                             next
[15:32:14.517]                           invokeRestart(restart)
[15:32:14.517]                           muffled <- TRUE
[15:32:14.517]                           break
[15:32:14.517]                         }
[15:32:14.517]                       }
[15:32:14.517]                     }
[15:32:14.517]                     invisible(muffled)
[15:32:14.517]                   }
[15:32:14.517]                   muffleCondition(cond)
[15:32:14.517]                 })
[15:32:14.517]             }))
[15:32:14.517]             future::FutureResult(value = ...future.value$value, 
[15:32:14.517]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.517]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.517]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.517]                     ...future.globalenv.names))
[15:32:14.517]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.517]         }, condition = base::local({
[15:32:14.517]             c <- base::c
[15:32:14.517]             inherits <- base::inherits
[15:32:14.517]             invokeRestart <- base::invokeRestart
[15:32:14.517]             length <- base::length
[15:32:14.517]             list <- base::list
[15:32:14.517]             seq.int <- base::seq.int
[15:32:14.517]             signalCondition <- base::signalCondition
[15:32:14.517]             sys.calls <- base::sys.calls
[15:32:14.517]             `[[` <- base::`[[`
[15:32:14.517]             `+` <- base::`+`
[15:32:14.517]             `<<-` <- base::`<<-`
[15:32:14.517]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.517]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.517]                   3L)]
[15:32:14.517]             }
[15:32:14.517]             function(cond) {
[15:32:14.517]                 is_error <- inherits(cond, "error")
[15:32:14.517]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.517]                   NULL)
[15:32:14.517]                 if (is_error) {
[15:32:14.517]                   sessionInformation <- function() {
[15:32:14.517]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.517]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.517]                       search = base::search(), system = base::Sys.info())
[15:32:14.517]                   }
[15:32:14.517]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.517]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.517]                     cond$call), session = sessionInformation(), 
[15:32:14.517]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.517]                   signalCondition(cond)
[15:32:14.517]                 }
[15:32:14.517]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.517]                 "immediateCondition"))) {
[15:32:14.517]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.517]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.517]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.517]                   if (TRUE && !signal) {
[15:32:14.517]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.517]                     {
[15:32:14.517]                       inherits <- base::inherits
[15:32:14.517]                       invokeRestart <- base::invokeRestart
[15:32:14.517]                       is.null <- base::is.null
[15:32:14.517]                       muffled <- FALSE
[15:32:14.517]                       if (inherits(cond, "message")) {
[15:32:14.517]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.517]                         if (muffled) 
[15:32:14.517]                           invokeRestart("muffleMessage")
[15:32:14.517]                       }
[15:32:14.517]                       else if (inherits(cond, "warning")) {
[15:32:14.517]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.517]                         if (muffled) 
[15:32:14.517]                           invokeRestart("muffleWarning")
[15:32:14.517]                       }
[15:32:14.517]                       else if (inherits(cond, "condition")) {
[15:32:14.517]                         if (!is.null(pattern)) {
[15:32:14.517]                           computeRestarts <- base::computeRestarts
[15:32:14.517]                           grepl <- base::grepl
[15:32:14.517]                           restarts <- computeRestarts(cond)
[15:32:14.517]                           for (restart in restarts) {
[15:32:14.517]                             name <- restart$name
[15:32:14.517]                             if (is.null(name)) 
[15:32:14.517]                               next
[15:32:14.517]                             if (!grepl(pattern, name)) 
[15:32:14.517]                               next
[15:32:14.517]                             invokeRestart(restart)
[15:32:14.517]                             muffled <- TRUE
[15:32:14.517]                             break
[15:32:14.517]                           }
[15:32:14.517]                         }
[15:32:14.517]                       }
[15:32:14.517]                       invisible(muffled)
[15:32:14.517]                     }
[15:32:14.517]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.517]                   }
[15:32:14.517]                 }
[15:32:14.517]                 else {
[15:32:14.517]                   if (TRUE) {
[15:32:14.517]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.517]                     {
[15:32:14.517]                       inherits <- base::inherits
[15:32:14.517]                       invokeRestart <- base::invokeRestart
[15:32:14.517]                       is.null <- base::is.null
[15:32:14.517]                       muffled <- FALSE
[15:32:14.517]                       if (inherits(cond, "message")) {
[15:32:14.517]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.517]                         if (muffled) 
[15:32:14.517]                           invokeRestart("muffleMessage")
[15:32:14.517]                       }
[15:32:14.517]                       else if (inherits(cond, "warning")) {
[15:32:14.517]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.517]                         if (muffled) 
[15:32:14.517]                           invokeRestart("muffleWarning")
[15:32:14.517]                       }
[15:32:14.517]                       else if (inherits(cond, "condition")) {
[15:32:14.517]                         if (!is.null(pattern)) {
[15:32:14.517]                           computeRestarts <- base::computeRestarts
[15:32:14.517]                           grepl <- base::grepl
[15:32:14.517]                           restarts <- computeRestarts(cond)
[15:32:14.517]                           for (restart in restarts) {
[15:32:14.517]                             name <- restart$name
[15:32:14.517]                             if (is.null(name)) 
[15:32:14.517]                               next
[15:32:14.517]                             if (!grepl(pattern, name)) 
[15:32:14.517]                               next
[15:32:14.517]                             invokeRestart(restart)
[15:32:14.517]                             muffled <- TRUE
[15:32:14.517]                             break
[15:32:14.517]                           }
[15:32:14.517]                         }
[15:32:14.517]                       }
[15:32:14.517]                       invisible(muffled)
[15:32:14.517]                     }
[15:32:14.517]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.517]                   }
[15:32:14.517]                 }
[15:32:14.517]             }
[15:32:14.517]         }))
[15:32:14.517]     }, error = function(ex) {
[15:32:14.517]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.517]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.517]                 ...future.rng), started = ...future.startTime, 
[15:32:14.517]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.517]             version = "1.8"), class = "FutureResult")
[15:32:14.517]     }, finally = {
[15:32:14.517]         if (!identical(...future.workdir, getwd())) 
[15:32:14.517]             setwd(...future.workdir)
[15:32:14.517]         {
[15:32:14.517]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.517]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.517]             }
[15:32:14.517]             base::options(...future.oldOptions)
[15:32:14.517]             if (.Platform$OS.type == "windows") {
[15:32:14.517]                 old_names <- names(...future.oldEnvVars)
[15:32:14.517]                 envs <- base::Sys.getenv()
[15:32:14.517]                 names <- names(envs)
[15:32:14.517]                 common <- intersect(names, old_names)
[15:32:14.517]                 added <- setdiff(names, old_names)
[15:32:14.517]                 removed <- setdiff(old_names, names)
[15:32:14.517]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.517]                   envs[common]]
[15:32:14.517]                 NAMES <- toupper(changed)
[15:32:14.517]                 args <- list()
[15:32:14.517]                 for (kk in seq_along(NAMES)) {
[15:32:14.517]                   name <- changed[[kk]]
[15:32:14.517]                   NAME <- NAMES[[kk]]
[15:32:14.517]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.517]                     next
[15:32:14.517]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.517]                 }
[15:32:14.517]                 NAMES <- toupper(added)
[15:32:14.517]                 for (kk in seq_along(NAMES)) {
[15:32:14.517]                   name <- added[[kk]]
[15:32:14.517]                   NAME <- NAMES[[kk]]
[15:32:14.517]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.517]                     next
[15:32:14.517]                   args[[name]] <- ""
[15:32:14.517]                 }
[15:32:14.517]                 NAMES <- toupper(removed)
[15:32:14.517]                 for (kk in seq_along(NAMES)) {
[15:32:14.517]                   name <- removed[[kk]]
[15:32:14.517]                   NAME <- NAMES[[kk]]
[15:32:14.517]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.517]                     next
[15:32:14.517]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.517]                 }
[15:32:14.517]                 if (length(args) > 0) 
[15:32:14.517]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.517]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.517]             }
[15:32:14.517]             else {
[15:32:14.517]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.517]             }
[15:32:14.517]             {
[15:32:14.517]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.517]                   0L) {
[15:32:14.517]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.517]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.517]                   base::options(opts)
[15:32:14.517]                 }
[15:32:14.517]                 {
[15:32:14.517]                   {
[15:32:14.517]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.517]                     NULL
[15:32:14.517]                   }
[15:32:14.517]                   options(future.plan = NULL)
[15:32:14.517]                   if (is.na(NA_character_)) 
[15:32:14.517]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.517]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.517]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.517]                     .init = FALSE)
[15:32:14.517]                 }
[15:32:14.517]             }
[15:32:14.517]         }
[15:32:14.517]     })
[15:32:14.517]     if (TRUE) {
[15:32:14.517]         base::sink(type = "output", split = FALSE)
[15:32:14.517]         if (TRUE) {
[15:32:14.517]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.517]         }
[15:32:14.517]         else {
[15:32:14.517]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.517]         }
[15:32:14.517]         base::close(...future.stdout)
[15:32:14.517]         ...future.stdout <- NULL
[15:32:14.517]     }
[15:32:14.517]     ...future.result$conditions <- ...future.conditions
[15:32:14.517]     ...future.result$finished <- base::Sys.time()
[15:32:14.517]     ...future.result
[15:32:14.517] }
[15:32:14.527] Exporting 5 global objects (168 bytes) to cluster node #1 ...
[15:32:14.527] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:14.528] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:14.529] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:14.529] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:14.530] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:14.530] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:14.531] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:14.531] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:14.531] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.532] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.532] Exporting 5 global objects (168 bytes) to cluster node #1 ... DONE
[15:32:14.533] MultisessionFuture started
[15:32:14.533] - Launch lazy future ... done
[15:32:14.533] run() for 'MultisessionFuture' ... done
[15:32:14.533] Created future:
[15:32:14.559] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.560] - Validating connection of MultisessionFuture
[15:32:14.560] - received message: FutureResult
[15:32:14.561] - Received FutureResult
[15:32:14.561] - Erased future from FutureRegistry
[15:32:14.561] result() for ClusterFuture ...
[15:32:14.561] - result already collected: FutureResult
[15:32:14.562] result() for ClusterFuture ... done
[15:32:14.562] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.534] MultisessionFuture:
[15:32:14.534] Label: 'future_Map-1'
[15:32:14.534] Expression:
[15:32:14.534] {
[15:32:14.534]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.534]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.534]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.534]         on.exit(options(oopts), add = TRUE)
[15:32:14.534]     }
[15:32:14.534]     {
[15:32:14.534]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.534]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.534]         do.call(mapply, args = args)
[15:32:14.534]     }
[15:32:14.534] }
[15:32:14.534] Lazy evaluation: FALSE
[15:32:14.534] Asynchronous evaluation: TRUE
[15:32:14.534] Local evaluation: TRUE
[15:32:14.534] Environment: R_GlobalEnv
[15:32:14.534] Capture standard output: TRUE
[15:32:14.534] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.534] Globals: 5 objects totaling 168 bytes (function '...future.FUN' of 56 bytes, 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:32:14.534] Packages: <none>
[15:32:14.534] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:14.534] Resolved: TRUE
[15:32:14.534] Value: <not collected>
[15:32:14.534] Conditions captured: <none>
[15:32:14.534] Early signaling: FALSE
[15:32:14.534] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.534] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.563] Chunk #1 of 2 ... DONE
[15:32:14.563] Chunk #2 of 2 ...
[15:32:14.564]  - Finding globals in '...' for chunk #2 ...
[15:32:14.564] getGlobalsAndPackages() ...
[15:32:14.564] Searching for globals...
[15:32:14.565] 
[15:32:14.565] Searching for globals ... DONE
[15:32:14.565] - globals: [0] <none>
[15:32:14.566] getGlobalsAndPackages() ... DONE
[15:32:14.566]    + additional globals found: [n=0] 
[15:32:14.566]    + additional namespaces needed: [n=0] 
[15:32:14.566]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:14.567]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.567]  - seeds: <none>
[15:32:14.567]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.568] getGlobalsAndPackages() ...
[15:32:14.568] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.568] Resolving globals: FALSE
[15:32:14.569] The total size of the 5 globals is 280 bytes (280 bytes)
[15:32:14.570] 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 280 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.elements_ii' (224 bytes of class 'list'), '...future.FUN' (56 bytes of class 'function') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:14.571] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.571] 
[15:32:14.571] getGlobalsAndPackages() ... DONE
[15:32:14.572] run() for 'Future' ...
[15:32:14.572] - state: 'created'
[15:32:14.573] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.589] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.590] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.590]   - Field: 'node'
[15:32:14.590]   - Field: 'label'
[15:32:14.590]   - Field: 'local'
[15:32:14.590]   - Field: 'owner'
[15:32:14.591]   - Field: 'envir'
[15:32:14.591]   - Field: 'workers'
[15:32:14.591]   - Field: 'packages'
[15:32:14.591]   - Field: 'gc'
[15:32:14.592]   - Field: 'conditions'
[15:32:14.592]   - Field: 'persistent'
[15:32:14.592]   - Field: 'expr'
[15:32:14.592]   - Field: 'uuid'
[15:32:14.592]   - Field: 'seed'
[15:32:14.593]   - Field: 'version'
[15:32:14.593]   - Field: 'result'
[15:32:14.593]   - Field: 'asynchronous'
[15:32:14.593]   - Field: 'calls'
[15:32:14.593]   - Field: 'globals'
[15:32:14.594]   - Field: 'stdout'
[15:32:14.594]   - Field: 'earlySignal'
[15:32:14.594]   - Field: 'lazy'
[15:32:14.594]   - Field: 'state'
[15:32:14.595] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.595] - Launch lazy future ...
[15:32:14.596] Packages needed by the future expression (n = 0): <none>
[15:32:14.596] Packages needed by future strategies (n = 0): <none>
[15:32:14.597] {
[15:32:14.597]     {
[15:32:14.597]         {
[15:32:14.597]             ...future.startTime <- base::Sys.time()
[15:32:14.597]             {
[15:32:14.597]                 {
[15:32:14.597]                   {
[15:32:14.597]                     {
[15:32:14.597]                       base::local({
[15:32:14.597]                         has_future <- base::requireNamespace("future", 
[15:32:14.597]                           quietly = TRUE)
[15:32:14.597]                         if (has_future) {
[15:32:14.597]                           ns <- base::getNamespace("future")
[15:32:14.597]                           version <- ns[[".package"]][["version"]]
[15:32:14.597]                           if (is.null(version)) 
[15:32:14.597]                             version <- utils::packageVersion("future")
[15:32:14.597]                         }
[15:32:14.597]                         else {
[15:32:14.597]                           version <- NULL
[15:32:14.597]                         }
[15:32:14.597]                         if (!has_future || version < "1.8.0") {
[15:32:14.597]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.597]                             "", base::R.version$version.string), 
[15:32:14.597]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:14.597]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:14.597]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.597]                               "release", "version")], collapse = " "), 
[15:32:14.597]                             hostname = base::Sys.info()[["nodename"]])
[15:32:14.597]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.597]                             info)
[15:32:14.597]                           info <- base::paste(info, collapse = "; ")
[15:32:14.597]                           if (!has_future) {
[15:32:14.597]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.597]                               info)
[15:32:14.597]                           }
[15:32:14.597]                           else {
[15:32:14.597]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.597]                               info, version)
[15:32:14.597]                           }
[15:32:14.597]                           base::stop(msg)
[15:32:14.597]                         }
[15:32:14.597]                       })
[15:32:14.597]                     }
[15:32:14.597]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.597]                     base::options(mc.cores = 1L)
[15:32:14.597]                   }
[15:32:14.597]                   ...future.strategy.old <- future::plan("list")
[15:32:14.597]                   options(future.plan = NULL)
[15:32:14.597]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.597]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.597]                 }
[15:32:14.597]                 ...future.workdir <- getwd()
[15:32:14.597]             }
[15:32:14.597]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.597]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.597]         }
[15:32:14.597]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.597]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.597]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.597]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.597]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.597]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.597]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.597]             base::names(...future.oldOptions))
[15:32:14.597]     }
[15:32:14.597]     if (FALSE) {
[15:32:14.597]     }
[15:32:14.597]     else {
[15:32:14.597]         if (TRUE) {
[15:32:14.597]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.597]                 open = "w")
[15:32:14.597]         }
[15:32:14.597]         else {
[15:32:14.597]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.597]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.597]         }
[15:32:14.597]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.597]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.597]             base::sink(type = "output", split = FALSE)
[15:32:14.597]             base::close(...future.stdout)
[15:32:14.597]         }, add = TRUE)
[15:32:14.597]     }
[15:32:14.597]     ...future.frame <- base::sys.nframe()
[15:32:14.597]     ...future.conditions <- base::list()
[15:32:14.597]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.597]     if (FALSE) {
[15:32:14.597]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.597]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.597]     }
[15:32:14.597]     ...future.result <- base::tryCatch({
[15:32:14.597]         base::withCallingHandlers({
[15:32:14.597]             ...future.value <- base::withVisible(base::local({
[15:32:14.597]                 ...future.makeSendCondition <- base::local({
[15:32:14.597]                   sendCondition <- NULL
[15:32:14.597]                   function(frame = 1L) {
[15:32:14.597]                     if (is.function(sendCondition)) 
[15:32:14.597]                       return(sendCondition)
[15:32:14.597]                     ns <- getNamespace("parallel")
[15:32:14.597]                     if (exists("sendData", mode = "function", 
[15:32:14.597]                       envir = ns)) {
[15:32:14.597]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.597]                         envir = ns)
[15:32:14.597]                       envir <- sys.frame(frame)
[15:32:14.597]                       master <- NULL
[15:32:14.597]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.597]                         !identical(envir, emptyenv())) {
[15:32:14.597]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.597]                           inherits = FALSE)) {
[15:32:14.597]                           master <- get("master", mode = "list", 
[15:32:14.597]                             envir = envir, inherits = FALSE)
[15:32:14.597]                           if (inherits(master, c("SOCKnode", 
[15:32:14.597]                             "SOCK0node"))) {
[15:32:14.597]                             sendCondition <<- function(cond) {
[15:32:14.597]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.597]                                 success = TRUE)
[15:32:14.597]                               parallel_sendData(master, data)
[15:32:14.597]                             }
[15:32:14.597]                             return(sendCondition)
[15:32:14.597]                           }
[15:32:14.597]                         }
[15:32:14.597]                         frame <- frame + 1L
[15:32:14.597]                         envir <- sys.frame(frame)
[15:32:14.597]                       }
[15:32:14.597]                     }
[15:32:14.597]                     sendCondition <<- function(cond) NULL
[15:32:14.597]                   }
[15:32:14.597]                 })
[15:32:14.597]                 withCallingHandlers({
[15:32:14.597]                   {
[15:32:14.597]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.597]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.597]                       ...future.globals.maxSize)) {
[15:32:14.597]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.597]                       on.exit(options(oopts), add = TRUE)
[15:32:14.597]                     }
[15:32:14.597]                     {
[15:32:14.597]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.597]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.597]                         USE.NAMES = FALSE)
[15:32:14.597]                       do.call(mapply, args = args)
[15:32:14.597]                     }
[15:32:14.597]                   }
[15:32:14.597]                 }, immediateCondition = function(cond) {
[15:32:14.597]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.597]                   sendCondition(cond)
[15:32:14.597]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.597]                   {
[15:32:14.597]                     inherits <- base::inherits
[15:32:14.597]                     invokeRestart <- base::invokeRestart
[15:32:14.597]                     is.null <- base::is.null
[15:32:14.597]                     muffled <- FALSE
[15:32:14.597]                     if (inherits(cond, "message")) {
[15:32:14.597]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.597]                       if (muffled) 
[15:32:14.597]                         invokeRestart("muffleMessage")
[15:32:14.597]                     }
[15:32:14.597]                     else if (inherits(cond, "warning")) {
[15:32:14.597]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.597]                       if (muffled) 
[15:32:14.597]                         invokeRestart("muffleWarning")
[15:32:14.597]                     }
[15:32:14.597]                     else if (inherits(cond, "condition")) {
[15:32:14.597]                       if (!is.null(pattern)) {
[15:32:14.597]                         computeRestarts <- base::computeRestarts
[15:32:14.597]                         grepl <- base::grepl
[15:32:14.597]                         restarts <- computeRestarts(cond)
[15:32:14.597]                         for (restart in restarts) {
[15:32:14.597]                           name <- restart$name
[15:32:14.597]                           if (is.null(name)) 
[15:32:14.597]                             next
[15:32:14.597]                           if (!grepl(pattern, name)) 
[15:32:14.597]                             next
[15:32:14.597]                           invokeRestart(restart)
[15:32:14.597]                           muffled <- TRUE
[15:32:14.597]                           break
[15:32:14.597]                         }
[15:32:14.597]                       }
[15:32:14.597]                     }
[15:32:14.597]                     invisible(muffled)
[15:32:14.597]                   }
[15:32:14.597]                   muffleCondition(cond)
[15:32:14.597]                 })
[15:32:14.597]             }))
[15:32:14.597]             future::FutureResult(value = ...future.value$value, 
[15:32:14.597]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.597]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.597]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.597]                     ...future.globalenv.names))
[15:32:14.597]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.597]         }, condition = base::local({
[15:32:14.597]             c <- base::c
[15:32:14.597]             inherits <- base::inherits
[15:32:14.597]             invokeRestart <- base::invokeRestart
[15:32:14.597]             length <- base::length
[15:32:14.597]             list <- base::list
[15:32:14.597]             seq.int <- base::seq.int
[15:32:14.597]             signalCondition <- base::signalCondition
[15:32:14.597]             sys.calls <- base::sys.calls
[15:32:14.597]             `[[` <- base::`[[`
[15:32:14.597]             `+` <- base::`+`
[15:32:14.597]             `<<-` <- base::`<<-`
[15:32:14.597]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.597]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.597]                   3L)]
[15:32:14.597]             }
[15:32:14.597]             function(cond) {
[15:32:14.597]                 is_error <- inherits(cond, "error")
[15:32:14.597]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.597]                   NULL)
[15:32:14.597]                 if (is_error) {
[15:32:14.597]                   sessionInformation <- function() {
[15:32:14.597]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.597]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.597]                       search = base::search(), system = base::Sys.info())
[15:32:14.597]                   }
[15:32:14.597]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.597]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.597]                     cond$call), session = sessionInformation(), 
[15:32:14.597]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.597]                   signalCondition(cond)
[15:32:14.597]                 }
[15:32:14.597]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.597]                 "immediateCondition"))) {
[15:32:14.597]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.597]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.597]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.597]                   if (TRUE && !signal) {
[15:32:14.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.597]                     {
[15:32:14.597]                       inherits <- base::inherits
[15:32:14.597]                       invokeRestart <- base::invokeRestart
[15:32:14.597]                       is.null <- base::is.null
[15:32:14.597]                       muffled <- FALSE
[15:32:14.597]                       if (inherits(cond, "message")) {
[15:32:14.597]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.597]                         if (muffled) 
[15:32:14.597]                           invokeRestart("muffleMessage")
[15:32:14.597]                       }
[15:32:14.597]                       else if (inherits(cond, "warning")) {
[15:32:14.597]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.597]                         if (muffled) 
[15:32:14.597]                           invokeRestart("muffleWarning")
[15:32:14.597]                       }
[15:32:14.597]                       else if (inherits(cond, "condition")) {
[15:32:14.597]                         if (!is.null(pattern)) {
[15:32:14.597]                           computeRestarts <- base::computeRestarts
[15:32:14.597]                           grepl <- base::grepl
[15:32:14.597]                           restarts <- computeRestarts(cond)
[15:32:14.597]                           for (restart in restarts) {
[15:32:14.597]                             name <- restart$name
[15:32:14.597]                             if (is.null(name)) 
[15:32:14.597]                               next
[15:32:14.597]                             if (!grepl(pattern, name)) 
[15:32:14.597]                               next
[15:32:14.597]                             invokeRestart(restart)
[15:32:14.597]                             muffled <- TRUE
[15:32:14.597]                             break
[15:32:14.597]                           }
[15:32:14.597]                         }
[15:32:14.597]                       }
[15:32:14.597]                       invisible(muffled)
[15:32:14.597]                     }
[15:32:14.597]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.597]                   }
[15:32:14.597]                 }
[15:32:14.597]                 else {
[15:32:14.597]                   if (TRUE) {
[15:32:14.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.597]                     {
[15:32:14.597]                       inherits <- base::inherits
[15:32:14.597]                       invokeRestart <- base::invokeRestart
[15:32:14.597]                       is.null <- base::is.null
[15:32:14.597]                       muffled <- FALSE
[15:32:14.597]                       if (inherits(cond, "message")) {
[15:32:14.597]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.597]                         if (muffled) 
[15:32:14.597]                           invokeRestart("muffleMessage")
[15:32:14.597]                       }
[15:32:14.597]                       else if (inherits(cond, "warning")) {
[15:32:14.597]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.597]                         if (muffled) 
[15:32:14.597]                           invokeRestart("muffleWarning")
[15:32:14.597]                       }
[15:32:14.597]                       else if (inherits(cond, "condition")) {
[15:32:14.597]                         if (!is.null(pattern)) {
[15:32:14.597]                           computeRestarts <- base::computeRestarts
[15:32:14.597]                           grepl <- base::grepl
[15:32:14.597]                           restarts <- computeRestarts(cond)
[15:32:14.597]                           for (restart in restarts) {
[15:32:14.597]                             name <- restart$name
[15:32:14.597]                             if (is.null(name)) 
[15:32:14.597]                               next
[15:32:14.597]                             if (!grepl(pattern, name)) 
[15:32:14.597]                               next
[15:32:14.597]                             invokeRestart(restart)
[15:32:14.597]                             muffled <- TRUE
[15:32:14.597]                             break
[15:32:14.597]                           }
[15:32:14.597]                         }
[15:32:14.597]                       }
[15:32:14.597]                       invisible(muffled)
[15:32:14.597]                     }
[15:32:14.597]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.597]                   }
[15:32:14.597]                 }
[15:32:14.597]             }
[15:32:14.597]         }))
[15:32:14.597]     }, error = function(ex) {
[15:32:14.597]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.597]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.597]                 ...future.rng), started = ...future.startTime, 
[15:32:14.597]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.597]             version = "1.8"), class = "FutureResult")
[15:32:14.597]     }, finally = {
[15:32:14.597]         if (!identical(...future.workdir, getwd())) 
[15:32:14.597]             setwd(...future.workdir)
[15:32:14.597]         {
[15:32:14.597]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.597]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.597]             }
[15:32:14.597]             base::options(...future.oldOptions)
[15:32:14.597]             if (.Platform$OS.type == "windows") {
[15:32:14.597]                 old_names <- names(...future.oldEnvVars)
[15:32:14.597]                 envs <- base::Sys.getenv()
[15:32:14.597]                 names <- names(envs)
[15:32:14.597]                 common <- intersect(names, old_names)
[15:32:14.597]                 added <- setdiff(names, old_names)
[15:32:14.597]                 removed <- setdiff(old_names, names)
[15:32:14.597]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.597]                   envs[common]]
[15:32:14.597]                 NAMES <- toupper(changed)
[15:32:14.597]                 args <- list()
[15:32:14.597]                 for (kk in seq_along(NAMES)) {
[15:32:14.597]                   name <- changed[[kk]]
[15:32:14.597]                   NAME <- NAMES[[kk]]
[15:32:14.597]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.597]                     next
[15:32:14.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.597]                 }
[15:32:14.597]                 NAMES <- toupper(added)
[15:32:14.597]                 for (kk in seq_along(NAMES)) {
[15:32:14.597]                   name <- added[[kk]]
[15:32:14.597]                   NAME <- NAMES[[kk]]
[15:32:14.597]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.597]                     next
[15:32:14.597]                   args[[name]] <- ""
[15:32:14.597]                 }
[15:32:14.597]                 NAMES <- toupper(removed)
[15:32:14.597]                 for (kk in seq_along(NAMES)) {
[15:32:14.597]                   name <- removed[[kk]]
[15:32:14.597]                   NAME <- NAMES[[kk]]
[15:32:14.597]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.597]                     next
[15:32:14.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.597]                 }
[15:32:14.597]                 if (length(args) > 0) 
[15:32:14.597]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.597]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.597]             }
[15:32:14.597]             else {
[15:32:14.597]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.597]             }
[15:32:14.597]             {
[15:32:14.597]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.597]                   0L) {
[15:32:14.597]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.597]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.597]                   base::options(opts)
[15:32:14.597]                 }
[15:32:14.597]                 {
[15:32:14.597]                   {
[15:32:14.597]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.597]                     NULL
[15:32:14.597]                   }
[15:32:14.597]                   options(future.plan = NULL)
[15:32:14.597]                   if (is.na(NA_character_)) 
[15:32:14.597]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.597]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.597]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.597]                     .init = FALSE)
[15:32:14.597]                 }
[15:32:14.597]             }
[15:32:14.597]         }
[15:32:14.597]     })
[15:32:14.597]     if (TRUE) {
[15:32:14.597]         base::sink(type = "output", split = FALSE)
[15:32:14.597]         if (TRUE) {
[15:32:14.597]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.597]         }
[15:32:14.597]         else {
[15:32:14.597]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.597]         }
[15:32:14.597]         base::close(...future.stdout)
[15:32:14.597]         ...future.stdout <- NULL
[15:32:14.597]     }
[15:32:14.597]     ...future.result$conditions <- ...future.conditions
[15:32:14.597]     ...future.result$finished <- base::Sys.time()
[15:32:14.597]     ...future.result
[15:32:14.597] }
[15:32:14.603] Exporting 5 global objects (280 bytes) to cluster node #1 ...
[15:32:14.603] Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
[15:32:14.604] Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:14.605] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:14.605] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:14.606] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ...
[15:32:14.606] Exporting '...future.elements_ii' (224 bytes) to cluster node #1 ... DONE
[15:32:14.607] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:14.607] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:14.607] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.608] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.608] Exporting 5 global objects (280 bytes) to cluster node #1 ... DONE
[15:32:14.609] MultisessionFuture started
[15:32:14.610] - Launch lazy future ... done
[15:32:14.610] run() for 'MultisessionFuture' ... done
[15:32:14.610] Created future:
[15:32:14.631] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.632] - Validating connection of MultisessionFuture
[15:32:14.632] - received message: FutureResult
[15:32:14.633] - Received FutureResult
[15:32:14.633] - Erased future from FutureRegistry
[15:32:14.633] result() for ClusterFuture ...
[15:32:14.634] - result already collected: FutureResult
[15:32:14.634] result() for ClusterFuture ... done
[15:32:14.634] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.611] MultisessionFuture:
[15:32:14.611] Label: 'future_Map-2'
[15:32:14.611] Expression:
[15:32:14.611] {
[15:32:14.611]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.611]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.611]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.611]         on.exit(options(oopts), add = TRUE)
[15:32:14.611]     }
[15:32:14.611]     {
[15:32:14.611]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.611]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.611]         do.call(mapply, args = args)
[15:32:14.611]     }
[15:32:14.611] }
[15:32:14.611] Lazy evaluation: FALSE
[15:32:14.611] Asynchronous evaluation: TRUE
[15:32:14.611] Local evaluation: TRUE
[15:32:14.611] Environment: R_GlobalEnv
[15:32:14.611] Capture standard output: TRUE
[15:32:14.611] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.611] Globals: 5 objects totaling 280 bytes (function '...future.FUN' of 56 bytes, 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:14.611] Packages: <none>
[15:32:14.611] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:14.611] Resolved: TRUE
[15:32:14.611] Value: <not collected>
[15:32:14.611] Conditions captured: <none>
[15:32:14.611] Early signaling: FALSE
[15:32:14.611] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.611] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.635] Chunk #2 of 2 ... DONE
[15:32:14.635] Launching 2 futures (chunks) ... DONE
[15:32:14.636] Resolving 2 futures (chunks) ...
[15:32:14.636] resolve() on list ...
[15:32:14.641]  recursive: 0
[15:32:14.641]  length: 2
[15:32:14.641] 
[15:32:14.642] Future #1
[15:32:14.642] result() for ClusterFuture ...
[15:32:14.642] - result already collected: FutureResult
[15:32:14.642] result() for ClusterFuture ... done
[15:32:14.643] result() for ClusterFuture ...
[15:32:14.643] - result already collected: FutureResult
[15:32:14.643] result() for ClusterFuture ... done
[15:32:14.644] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:14.644] - nx: 2
[15:32:14.644] - relay: TRUE
[15:32:14.645] - stdout: TRUE
[15:32:14.645] - signal: TRUE
[15:32:14.645] - resignal: FALSE
[15:32:14.646] - force: TRUE
[15:32:14.646] - relayed: [n=2] FALSE, FALSE
[15:32:14.646] - queued futures: [n=2] FALSE, FALSE
[15:32:14.646]  - until=1
[15:32:14.647]  - relaying element #1
[15:32:14.647] result() for ClusterFuture ...
[15:32:14.647] - result already collected: FutureResult
[15:32:14.648] result() for ClusterFuture ... done
[15:32:14.648] result() for ClusterFuture ...
[15:32:14.648] - result already collected: FutureResult
[15:32:14.649] result() for ClusterFuture ... done
[15:32:14.649] result() for ClusterFuture ...
[15:32:14.649] - result already collected: FutureResult
[15:32:14.650] result() for ClusterFuture ... done
[15:32:14.650] result() for ClusterFuture ...
[15:32:14.650] - result already collected: FutureResult
[15:32:14.650] result() for ClusterFuture ... done
[15:32:14.651] - relayed: [n=2] TRUE, FALSE
[15:32:14.651] - queued futures: [n=2] TRUE, FALSE
[15:32:14.651] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:14.652]  length: 1 (resolved future 1)
[15:32:14.652] Future #2
[15:32:14.652] result() for ClusterFuture ...
[15:32:14.653] - result already collected: FutureResult
[15:32:14.653] result() for ClusterFuture ... done
[15:32:14.653] result() for ClusterFuture ...
[15:32:14.654] - result already collected: FutureResult
[15:32:14.654] result() for ClusterFuture ... done
[15:32:14.654] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:14.655] - nx: 2
[15:32:14.655] - relay: TRUE
[15:32:14.655] - stdout: TRUE
[15:32:14.655] - signal: TRUE
[15:32:14.656] - resignal: FALSE
[15:32:14.656] - force: TRUE
[15:32:14.656] - relayed: [n=2] TRUE, FALSE
[15:32:14.657] - queued futures: [n=2] TRUE, FALSE
[15:32:14.657]  - until=2
[15:32:14.657]  - relaying element #2
[15:32:14.658] result() for ClusterFuture ...
[15:32:14.658] - result already collected: FutureResult
[15:32:14.658] result() for ClusterFuture ... done
[15:32:14.658] result() for ClusterFuture ...
[15:32:14.659] - result already collected: FutureResult
[15:32:14.659] result() for ClusterFuture ... done
[15:32:14.659] result() for ClusterFuture ...
[15:32:14.660] - result already collected: FutureResult
[15:32:14.660] result() for ClusterFuture ... done
[15:32:14.660] result() for ClusterFuture ...
[15:32:14.661] - result already collected: FutureResult
[15:32:14.661] result() for ClusterFuture ... done
[15:32:14.661] - relayed: [n=2] TRUE, TRUE
[15:32:14.662] - queued futures: [n=2] TRUE, TRUE
[15:32:14.662] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:14.662]  length: 0 (resolved future 2)
[15:32:14.663] Relaying remaining futures
[15:32:14.663] signalConditionsASAP(NULL, pos=0) ...
[15:32:14.663] - nx: 2
[15:32:14.663] - relay: TRUE
[15:32:14.664] - stdout: TRUE
[15:32:14.664] - signal: TRUE
[15:32:14.664] - resignal: FALSE
[15:32:14.665] - force: TRUE
[15:32:14.665] - relayed: [n=2] TRUE, TRUE
[15:32:14.665] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:14.666] - relayed: [n=2] TRUE, TRUE
[15:32:14.666] - queued futures: [n=2] TRUE, TRUE
[15:32:14.666] signalConditionsASAP(NULL, pos=0) ... done
[15:32:14.667] resolve() on list ... DONE
[15:32:14.667] result() for ClusterFuture ...
[15:32:14.667] - result already collected: FutureResult
[15:32:14.667] result() for ClusterFuture ... done
[15:32:14.668] result() for ClusterFuture ...
[15:32:14.668] - result already collected: FutureResult
[15:32:14.668] result() for ClusterFuture ... done
[15:32:14.669] result() for ClusterFuture ...
[15:32:14.669] - result already collected: FutureResult
[15:32:14.669] result() for ClusterFuture ... done
[15:32:14.670] result() for ClusterFuture ...
[15:32:14.670] - result already collected: FutureResult
[15:32:14.670] result() for ClusterFuture ... done
[15:32:14.671]  - Number of value chunks collected: 2
[15:32:14.671] Resolving 2 futures (chunks) ... DONE
[15:32:14.671] Reducing values from 2 chunks ...
[15:32:14.672]  - Number of values collected after concatenation: 3
[15:32:14.672]  - Number of values expected: 3
[15:32:14.672] Reducing values from 2 chunks ... DONE
[15:32:14.673] future_mapply() ... DONE
- future_mapply(x, ...) where x[[i]] subsets via S3 method ...
[15:32:14.674] future_mapply() ...
[15:32:14.678] Number of chunks: 2
[15:32:14.679] getGlobalsAndPackagesXApply() ...
[15:32:14.679]  - future.globals: TRUE
[15:32:14.679] getGlobalsAndPackages() ...
[15:32:14.679] Searching for globals...
[15:32:14.681] - globals found: [1] 'FUN'
[15:32:14.682] Searching for globals ... DONE
[15:32:14.682] Resolving globals: FALSE
[15:32:14.683] The total size of the 1 globals is 848 bytes (848 bytes)
[15:32:14.683] The total size of the 1 globals exported for future expression ('FUN()') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:32:14.684] - globals: [1] 'FUN'
[15:32:14.684] 
[15:32:14.684] getGlobalsAndPackages() ... DONE
[15:32:14.685]  - globals found/used: [n=1] 'FUN'
[15:32:14.685]  - needed namespaces: [n=0] 
[15:32:14.685] Finding globals ... DONE
[15:32:14.686] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[15:32:14.686] List of 2
[15:32:14.686]  $ ...future.FUN:function (x)  
[15:32:14.686]  $ MoreArgs     : NULL
[15:32:14.686]  - attr(*, "where")=List of 2
[15:32:14.686]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:14.686]   ..$ MoreArgs     :<environment: R_EmptyEnv> 
[15:32:14.686]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:14.686]  - attr(*, "resolved")= logi FALSE
[15:32:14.686]  - attr(*, "total_size")= num NA
[15:32:14.692] Packages to be attached in all futures: [n=0] 
[15:32:14.692] getGlobalsAndPackagesXApply() ... DONE
[15:32:14.692] Number of futures (= number of chunks): 2
[15:32:14.693] Launching 2 futures (chunks) ...
[15:32:14.693] Chunk #1 of 2 ...
[15:32:14.694]  - Finding globals in '...' for chunk #1 ...
[15:32:14.694] getGlobalsAndPackages() ...
[15:32:14.694] Searching for globals...
[15:32:14.695] 
[15:32:14.695] Searching for globals ... DONE
[15:32:14.696] - globals: [0] <none>
[15:32:14.696] getGlobalsAndPackages() ... DONE
[15:32:14.696]    + additional globals found: [n=0] 
[15:32:14.696]    + additional namespaces needed: [n=0] 
[15:32:14.697]  - Finding globals in '...' for chunk #1 ... DONE
[15:32:14.697]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.697]  - seeds: <none>
[15:32:14.698]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.698] getGlobalsAndPackages() ...
[15:32:14.698] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.699] Resolving globals: FALSE
[15:32:14.700] The total size of the 5 globals is 904 bytes (904 bytes)
[15:32:14.701] 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 904 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (56 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:14.701] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.702] 
[15:32:14.702] getGlobalsAndPackages() ... DONE
[15:32:14.703] run() for 'Future' ...
[15:32:14.703] - state: 'created'
[15:32:14.703] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.725] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.726] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.726]   - Field: 'node'
[15:32:14.726]   - Field: 'label'
[15:32:14.727]   - Field: 'local'
[15:32:14.727]   - Field: 'owner'
[15:32:14.727]   - Field: 'envir'
[15:32:14.728]   - Field: 'workers'
[15:32:14.728]   - Field: 'packages'
[15:32:14.728]   - Field: 'gc'
[15:32:14.729]   - Field: 'conditions'
[15:32:14.729]   - Field: 'persistent'
[15:32:14.729]   - Field: 'expr'
[15:32:14.730]   - Field: 'uuid'
[15:32:14.730]   - Field: 'seed'
[15:32:14.730]   - Field: 'version'
[15:32:14.731]   - Field: 'result'
[15:32:14.731]   - Field: 'asynchronous'
[15:32:14.731]   - Field: 'calls'
[15:32:14.732]   - Field: 'globals'
[15:32:14.732]   - Field: 'stdout'
[15:32:14.732]   - Field: 'earlySignal'
[15:32:14.733]   - Field: 'lazy'
[15:32:14.733]   - Field: 'state'
[15:32:14.733] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.734] - Launch lazy future ...
[15:32:14.734] Packages needed by the future expression (n = 0): <none>
[15:32:14.735] Packages needed by future strategies (n = 0): <none>
[15:32:14.736] {
[15:32:14.736]     {
[15:32:14.736]         {
[15:32:14.736]             ...future.startTime <- base::Sys.time()
[15:32:14.736]             {
[15:32:14.736]                 {
[15:32:14.736]                   {
[15:32:14.736]                     {
[15:32:14.736]                       base::local({
[15:32:14.736]                         has_future <- base::requireNamespace("future", 
[15:32:14.736]                           quietly = TRUE)
[15:32:14.736]                         if (has_future) {
[15:32:14.736]                           ns <- base::getNamespace("future")
[15:32:14.736]                           version <- ns[[".package"]][["version"]]
[15:32:14.736]                           if (is.null(version)) 
[15:32:14.736]                             version <- utils::packageVersion("future")
[15:32:14.736]                         }
[15:32:14.736]                         else {
[15:32:14.736]                           version <- NULL
[15:32:14.736]                         }
[15:32:14.736]                         if (!has_future || version < "1.8.0") {
[15:32:14.736]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.736]                             "", base::R.version$version.string), 
[15:32:14.736]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:14.736]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:14.736]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.736]                               "release", "version")], collapse = " "), 
[15:32:14.736]                             hostname = base::Sys.info()[["nodename"]])
[15:32:14.736]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.736]                             info)
[15:32:14.736]                           info <- base::paste(info, collapse = "; ")
[15:32:14.736]                           if (!has_future) {
[15:32:14.736]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.736]                               info)
[15:32:14.736]                           }
[15:32:14.736]                           else {
[15:32:14.736]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.736]                               info, version)
[15:32:14.736]                           }
[15:32:14.736]                           base::stop(msg)
[15:32:14.736]                         }
[15:32:14.736]                       })
[15:32:14.736]                     }
[15:32:14.736]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.736]                     base::options(mc.cores = 1L)
[15:32:14.736]                   }
[15:32:14.736]                   ...future.strategy.old <- future::plan("list")
[15:32:14.736]                   options(future.plan = NULL)
[15:32:14.736]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.736]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.736]                 }
[15:32:14.736]                 ...future.workdir <- getwd()
[15:32:14.736]             }
[15:32:14.736]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.736]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.736]         }
[15:32:14.736]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.736]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.736]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.736]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.736]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.736]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.736]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.736]             base::names(...future.oldOptions))
[15:32:14.736]     }
[15:32:14.736]     if (FALSE) {
[15:32:14.736]     }
[15:32:14.736]     else {
[15:32:14.736]         if (TRUE) {
[15:32:14.736]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.736]                 open = "w")
[15:32:14.736]         }
[15:32:14.736]         else {
[15:32:14.736]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.736]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.736]         }
[15:32:14.736]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.736]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.736]             base::sink(type = "output", split = FALSE)
[15:32:14.736]             base::close(...future.stdout)
[15:32:14.736]         }, add = TRUE)
[15:32:14.736]     }
[15:32:14.736]     ...future.frame <- base::sys.nframe()
[15:32:14.736]     ...future.conditions <- base::list()
[15:32:14.736]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.736]     if (FALSE) {
[15:32:14.736]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.736]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.736]     }
[15:32:14.736]     ...future.result <- base::tryCatch({
[15:32:14.736]         base::withCallingHandlers({
[15:32:14.736]             ...future.value <- base::withVisible(base::local({
[15:32:14.736]                 ...future.makeSendCondition <- base::local({
[15:32:14.736]                   sendCondition <- NULL
[15:32:14.736]                   function(frame = 1L) {
[15:32:14.736]                     if (is.function(sendCondition)) 
[15:32:14.736]                       return(sendCondition)
[15:32:14.736]                     ns <- getNamespace("parallel")
[15:32:14.736]                     if (exists("sendData", mode = "function", 
[15:32:14.736]                       envir = ns)) {
[15:32:14.736]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.736]                         envir = ns)
[15:32:14.736]                       envir <- sys.frame(frame)
[15:32:14.736]                       master <- NULL
[15:32:14.736]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.736]                         !identical(envir, emptyenv())) {
[15:32:14.736]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.736]                           inherits = FALSE)) {
[15:32:14.736]                           master <- get("master", mode = "list", 
[15:32:14.736]                             envir = envir, inherits = FALSE)
[15:32:14.736]                           if (inherits(master, c("SOCKnode", 
[15:32:14.736]                             "SOCK0node"))) {
[15:32:14.736]                             sendCondition <<- function(cond) {
[15:32:14.736]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.736]                                 success = TRUE)
[15:32:14.736]                               parallel_sendData(master, data)
[15:32:14.736]                             }
[15:32:14.736]                             return(sendCondition)
[15:32:14.736]                           }
[15:32:14.736]                         }
[15:32:14.736]                         frame <- frame + 1L
[15:32:14.736]                         envir <- sys.frame(frame)
[15:32:14.736]                       }
[15:32:14.736]                     }
[15:32:14.736]                     sendCondition <<- function(cond) NULL
[15:32:14.736]                   }
[15:32:14.736]                 })
[15:32:14.736]                 withCallingHandlers({
[15:32:14.736]                   {
[15:32:14.736]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.736]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.736]                       ...future.globals.maxSize)) {
[15:32:14.736]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.736]                       on.exit(options(oopts), add = TRUE)
[15:32:14.736]                     }
[15:32:14.736]                     {
[15:32:14.736]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.736]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.736]                         USE.NAMES = FALSE)
[15:32:14.736]                       do.call(mapply, args = args)
[15:32:14.736]                     }
[15:32:14.736]                   }
[15:32:14.736]                 }, immediateCondition = function(cond) {
[15:32:14.736]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.736]                   sendCondition(cond)
[15:32:14.736]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.736]                   {
[15:32:14.736]                     inherits <- base::inherits
[15:32:14.736]                     invokeRestart <- base::invokeRestart
[15:32:14.736]                     is.null <- base::is.null
[15:32:14.736]                     muffled <- FALSE
[15:32:14.736]                     if (inherits(cond, "message")) {
[15:32:14.736]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.736]                       if (muffled) 
[15:32:14.736]                         invokeRestart("muffleMessage")
[15:32:14.736]                     }
[15:32:14.736]                     else if (inherits(cond, "warning")) {
[15:32:14.736]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.736]                       if (muffled) 
[15:32:14.736]                         invokeRestart("muffleWarning")
[15:32:14.736]                     }
[15:32:14.736]                     else if (inherits(cond, "condition")) {
[15:32:14.736]                       if (!is.null(pattern)) {
[15:32:14.736]                         computeRestarts <- base::computeRestarts
[15:32:14.736]                         grepl <- base::grepl
[15:32:14.736]                         restarts <- computeRestarts(cond)
[15:32:14.736]                         for (restart in restarts) {
[15:32:14.736]                           name <- restart$name
[15:32:14.736]                           if (is.null(name)) 
[15:32:14.736]                             next
[15:32:14.736]                           if (!grepl(pattern, name)) 
[15:32:14.736]                             next
[15:32:14.736]                           invokeRestart(restart)
[15:32:14.736]                           muffled <- TRUE
[15:32:14.736]                           break
[15:32:14.736]                         }
[15:32:14.736]                       }
[15:32:14.736]                     }
[15:32:14.736]                     invisible(muffled)
[15:32:14.736]                   }
[15:32:14.736]                   muffleCondition(cond)
[15:32:14.736]                 })
[15:32:14.736]             }))
[15:32:14.736]             future::FutureResult(value = ...future.value$value, 
[15:32:14.736]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.736]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.736]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.736]                     ...future.globalenv.names))
[15:32:14.736]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.736]         }, condition = base::local({
[15:32:14.736]             c <- base::c
[15:32:14.736]             inherits <- base::inherits
[15:32:14.736]             invokeRestart <- base::invokeRestart
[15:32:14.736]             length <- base::length
[15:32:14.736]             list <- base::list
[15:32:14.736]             seq.int <- base::seq.int
[15:32:14.736]             signalCondition <- base::signalCondition
[15:32:14.736]             sys.calls <- base::sys.calls
[15:32:14.736]             `[[` <- base::`[[`
[15:32:14.736]             `+` <- base::`+`
[15:32:14.736]             `<<-` <- base::`<<-`
[15:32:14.736]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.736]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.736]                   3L)]
[15:32:14.736]             }
[15:32:14.736]             function(cond) {
[15:32:14.736]                 is_error <- inherits(cond, "error")
[15:32:14.736]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.736]                   NULL)
[15:32:14.736]                 if (is_error) {
[15:32:14.736]                   sessionInformation <- function() {
[15:32:14.736]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.736]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.736]                       search = base::search(), system = base::Sys.info())
[15:32:14.736]                   }
[15:32:14.736]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.736]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.736]                     cond$call), session = sessionInformation(), 
[15:32:14.736]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.736]                   signalCondition(cond)
[15:32:14.736]                 }
[15:32:14.736]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.736]                 "immediateCondition"))) {
[15:32:14.736]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.736]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.736]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.736]                   if (TRUE && !signal) {
[15:32:14.736]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.736]                     {
[15:32:14.736]                       inherits <- base::inherits
[15:32:14.736]                       invokeRestart <- base::invokeRestart
[15:32:14.736]                       is.null <- base::is.null
[15:32:14.736]                       muffled <- FALSE
[15:32:14.736]                       if (inherits(cond, "message")) {
[15:32:14.736]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.736]                         if (muffled) 
[15:32:14.736]                           invokeRestart("muffleMessage")
[15:32:14.736]                       }
[15:32:14.736]                       else if (inherits(cond, "warning")) {
[15:32:14.736]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.736]                         if (muffled) 
[15:32:14.736]                           invokeRestart("muffleWarning")
[15:32:14.736]                       }
[15:32:14.736]                       else if (inherits(cond, "condition")) {
[15:32:14.736]                         if (!is.null(pattern)) {
[15:32:14.736]                           computeRestarts <- base::computeRestarts
[15:32:14.736]                           grepl <- base::grepl
[15:32:14.736]                           restarts <- computeRestarts(cond)
[15:32:14.736]                           for (restart in restarts) {
[15:32:14.736]                             name <- restart$name
[15:32:14.736]                             if (is.null(name)) 
[15:32:14.736]                               next
[15:32:14.736]                             if (!grepl(pattern, name)) 
[15:32:14.736]                               next
[15:32:14.736]                             invokeRestart(restart)
[15:32:14.736]                             muffled <- TRUE
[15:32:14.736]                             break
[15:32:14.736]                           }
[15:32:14.736]                         }
[15:32:14.736]                       }
[15:32:14.736]                       invisible(muffled)
[15:32:14.736]                     }
[15:32:14.736]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.736]                   }
[15:32:14.736]                 }
[15:32:14.736]                 else {
[15:32:14.736]                   if (TRUE) {
[15:32:14.736]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.736]                     {
[15:32:14.736]                       inherits <- base::inherits
[15:32:14.736]                       invokeRestart <- base::invokeRestart
[15:32:14.736]                       is.null <- base::is.null
[15:32:14.736]                       muffled <- FALSE
[15:32:14.736]                       if (inherits(cond, "message")) {
[15:32:14.736]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.736]                         if (muffled) 
[15:32:14.736]                           invokeRestart("muffleMessage")
[15:32:14.736]                       }
[15:32:14.736]                       else if (inherits(cond, "warning")) {
[15:32:14.736]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.736]                         if (muffled) 
[15:32:14.736]                           invokeRestart("muffleWarning")
[15:32:14.736]                       }
[15:32:14.736]                       else if (inherits(cond, "condition")) {
[15:32:14.736]                         if (!is.null(pattern)) {
[15:32:14.736]                           computeRestarts <- base::computeRestarts
[15:32:14.736]                           grepl <- base::grepl
[15:32:14.736]                           restarts <- computeRestarts(cond)
[15:32:14.736]                           for (restart in restarts) {
[15:32:14.736]                             name <- restart$name
[15:32:14.736]                             if (is.null(name)) 
[15:32:14.736]                               next
[15:32:14.736]                             if (!grepl(pattern, name)) 
[15:32:14.736]                               next
[15:32:14.736]                             invokeRestart(restart)
[15:32:14.736]                             muffled <- TRUE
[15:32:14.736]                             break
[15:32:14.736]                           }
[15:32:14.736]                         }
[15:32:14.736]                       }
[15:32:14.736]                       invisible(muffled)
[15:32:14.736]                     }
[15:32:14.736]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.736]                   }
[15:32:14.736]                 }
[15:32:14.736]             }
[15:32:14.736]         }))
[15:32:14.736]     }, error = function(ex) {
[15:32:14.736]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.736]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.736]                 ...future.rng), started = ...future.startTime, 
[15:32:14.736]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.736]             version = "1.8"), class = "FutureResult")
[15:32:14.736]     }, finally = {
[15:32:14.736]         if (!identical(...future.workdir, getwd())) 
[15:32:14.736]             setwd(...future.workdir)
[15:32:14.736]         {
[15:32:14.736]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.736]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.736]             }
[15:32:14.736]             base::options(...future.oldOptions)
[15:32:14.736]             if (.Platform$OS.type == "windows") {
[15:32:14.736]                 old_names <- names(...future.oldEnvVars)
[15:32:14.736]                 envs <- base::Sys.getenv()
[15:32:14.736]                 names <- names(envs)
[15:32:14.736]                 common <- intersect(names, old_names)
[15:32:14.736]                 added <- setdiff(names, old_names)
[15:32:14.736]                 removed <- setdiff(old_names, names)
[15:32:14.736]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.736]                   envs[common]]
[15:32:14.736]                 NAMES <- toupper(changed)
[15:32:14.736]                 args <- list()
[15:32:14.736]                 for (kk in seq_along(NAMES)) {
[15:32:14.736]                   name <- changed[[kk]]
[15:32:14.736]                   NAME <- NAMES[[kk]]
[15:32:14.736]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.736]                     next
[15:32:14.736]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.736]                 }
[15:32:14.736]                 NAMES <- toupper(added)
[15:32:14.736]                 for (kk in seq_along(NAMES)) {
[15:32:14.736]                   name <- added[[kk]]
[15:32:14.736]                   NAME <- NAMES[[kk]]
[15:32:14.736]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.736]                     next
[15:32:14.736]                   args[[name]] <- ""
[15:32:14.736]                 }
[15:32:14.736]                 NAMES <- toupper(removed)
[15:32:14.736]                 for (kk in seq_along(NAMES)) {
[15:32:14.736]                   name <- removed[[kk]]
[15:32:14.736]                   NAME <- NAMES[[kk]]
[15:32:14.736]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.736]                     next
[15:32:14.736]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.736]                 }
[15:32:14.736]                 if (length(args) > 0) 
[15:32:14.736]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.736]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.736]             }
[15:32:14.736]             else {
[15:32:14.736]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.736]             }
[15:32:14.736]             {
[15:32:14.736]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.736]                   0L) {
[15:32:14.736]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.736]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.736]                   base::options(opts)
[15:32:14.736]                 }
[15:32:14.736]                 {
[15:32:14.736]                   {
[15:32:14.736]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.736]                     NULL
[15:32:14.736]                   }
[15:32:14.736]                   options(future.plan = NULL)
[15:32:14.736]                   if (is.na(NA_character_)) 
[15:32:14.736]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.736]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.736]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.736]                     .init = FALSE)
[15:32:14.736]                 }
[15:32:14.736]             }
[15:32:14.736]         }
[15:32:14.736]     })
[15:32:14.736]     if (TRUE) {
[15:32:14.736]         base::sink(type = "output", split = FALSE)
[15:32:14.736]         if (TRUE) {
[15:32:14.736]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.736]         }
[15:32:14.736]         else {
[15:32:14.736]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.736]         }
[15:32:14.736]         base::close(...future.stdout)
[15:32:14.736]         ...future.stdout <- NULL
[15:32:14.736]     }
[15:32:14.736]     ...future.result$conditions <- ...future.conditions
[15:32:14.736]     ...future.result$finished <- base::Sys.time()
[15:32:14.736]     ...future.result
[15:32:14.736] }
[15:32:14.747] Exporting 5 global objects (904 bytes) to cluster node #1 ...
[15:32:14.747] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:14.748] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:14.748] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:14.749] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:14.750] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:14.750] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:14.750] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:14.751] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:14.752] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.753] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.753] Exporting 5 global objects (904 bytes) to cluster node #1 ... DONE
[15:32:14.754] MultisessionFuture started
[15:32:14.754] - Launch lazy future ... done
[15:32:14.755] run() for 'MultisessionFuture' ... done
[15:32:14.755] Created future:
[15:32:14.773] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.774] - Validating connection of MultisessionFuture
[15:32:14.774] - received message: FutureResult
[15:32:14.774] - Received FutureResult
[15:32:14.775] - Erased future from FutureRegistry
[15:32:14.775] result() for ClusterFuture ...
[15:32:14.775] - result already collected: FutureResult
[15:32:14.776] result() for ClusterFuture ... done
[15:32:14.776] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.755] MultisessionFuture:
[15:32:14.755] Label: 'future_mapply-1'
[15:32:14.755] Expression:
[15:32:14.755] {
[15:32:14.755]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.755]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.755]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.755]         on.exit(options(oopts), add = TRUE)
[15:32:14.755]     }
[15:32:14.755]     {
[15:32:14.755]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.755]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.755]         do.call(mapply, args = args)
[15:32:14.755]     }
[15:32:14.755] }
[15:32:14.755] Lazy evaluation: FALSE
[15:32:14.755] Asynchronous evaluation: TRUE
[15:32:14.755] Local evaluation: TRUE
[15:32:14.755] Environment: R_GlobalEnv
[15:32:14.755] Capture standard output: TRUE
[15:32:14.755] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.755] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:14.755] Packages: <none>
[15:32:14.755] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:14.755] Resolved: TRUE
[15:32:14.755] Value: <not collected>
[15:32:14.755] Conditions captured: <none>
[15:32:14.755] Early signaling: FALSE
[15:32:14.755] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.755] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.777] Chunk #1 of 2 ... DONE
[15:32:14.777] Chunk #2 of 2 ...
[15:32:14.777]  - Finding globals in '...' for chunk #2 ...
[15:32:14.778] getGlobalsAndPackages() ...
[15:32:14.778] Searching for globals...
[15:32:14.779] 
[15:32:14.779] Searching for globals ... DONE
[15:32:14.779] - globals: [0] <none>
[15:32:14.779] getGlobalsAndPackages() ... DONE
[15:32:14.780]    + additional globals found: [n=0] 
[15:32:14.780]    + additional namespaces needed: [n=0] 
[15:32:14.780]  - Finding globals in '...' for chunk #2 ... DONE
[15:32:14.781]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:14.781]  - seeds: <none>
[15:32:14.781]  - All globals exported: [n=5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.782] getGlobalsAndPackages() ...
[15:32:14.782] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.782] Resolving globals: FALSE
[15:32:14.784] The total size of the 5 globals is 904 bytes (904 bytes)
[15:32:14.786] 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 904 bytes.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (848 bytes of class 'function'), '...future.elements_ii' (56 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[15:32:14.786] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:14.787] 
[15:32:14.787] getGlobalsAndPackages() ... DONE
[15:32:14.788] run() for 'Future' ...
[15:32:14.788] - state: 'created'
[15:32:14.789] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:14.806] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.807] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:14.807]   - Field: 'node'
[15:32:14.807]   - Field: 'label'
[15:32:14.808]   - Field: 'local'
[15:32:14.808]   - Field: 'owner'
[15:32:14.808]   - Field: 'envir'
[15:32:14.809]   - Field: 'workers'
[15:32:14.809]   - Field: 'packages'
[15:32:14.809]   - Field: 'gc'
[15:32:14.809]   - Field: 'conditions'
[15:32:14.810]   - Field: 'persistent'
[15:32:14.810]   - Field: 'expr'
[15:32:14.810]   - Field: 'uuid'
[15:32:14.811]   - Field: 'seed'
[15:32:14.811]   - Field: 'version'
[15:32:14.811]   - Field: 'result'
[15:32:14.811]   - Field: 'asynchronous'
[15:32:14.812]   - Field: 'calls'
[15:32:14.812]   - Field: 'globals'
[15:32:14.812]   - Field: 'stdout'
[15:32:14.813]   - Field: 'earlySignal'
[15:32:14.813]   - Field: 'lazy'
[15:32:14.813]   - Field: 'state'
[15:32:14.814] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:14.814] - Launch lazy future ...
[15:32:14.815] Packages needed by the future expression (n = 0): <none>
[15:32:14.815] Packages needed by future strategies (n = 0): <none>
[15:32:14.816] {
[15:32:14.816]     {
[15:32:14.816]         {
[15:32:14.816]             ...future.startTime <- base::Sys.time()
[15:32:14.816]             {
[15:32:14.816]                 {
[15:32:14.816]                   {
[15:32:14.816]                     {
[15:32:14.816]                       base::local({
[15:32:14.816]                         has_future <- base::requireNamespace("future", 
[15:32:14.816]                           quietly = TRUE)
[15:32:14.816]                         if (has_future) {
[15:32:14.816]                           ns <- base::getNamespace("future")
[15:32:14.816]                           version <- ns[[".package"]][["version"]]
[15:32:14.816]                           if (is.null(version)) 
[15:32:14.816]                             version <- utils::packageVersion("future")
[15:32:14.816]                         }
[15:32:14.816]                         else {
[15:32:14.816]                           version <- NULL
[15:32:14.816]                         }
[15:32:14.816]                         if (!has_future || version < "1.8.0") {
[15:32:14.816]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:14.816]                             "", base::R.version$version.string), 
[15:32:14.816]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:14.816]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:14.816]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:14.816]                               "release", "version")], collapse = " "), 
[15:32:14.816]                             hostname = base::Sys.info()[["nodename"]])
[15:32:14.816]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:14.816]                             info)
[15:32:14.816]                           info <- base::paste(info, collapse = "; ")
[15:32:14.816]                           if (!has_future) {
[15:32:14.816]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:14.816]                               info)
[15:32:14.816]                           }
[15:32:14.816]                           else {
[15:32:14.816]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:14.816]                               info, version)
[15:32:14.816]                           }
[15:32:14.816]                           base::stop(msg)
[15:32:14.816]                         }
[15:32:14.816]                       })
[15:32:14.816]                     }
[15:32:14.816]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:14.816]                     base::options(mc.cores = 1L)
[15:32:14.816]                   }
[15:32:14.816]                   ...future.strategy.old <- future::plan("list")
[15:32:14.816]                   options(future.plan = NULL)
[15:32:14.816]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.816]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:14.816]                 }
[15:32:14.816]                 ...future.workdir <- getwd()
[15:32:14.816]             }
[15:32:14.816]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:14.816]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:14.816]         }
[15:32:14.816]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:14.816]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:14.816]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:14.816]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:14.816]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:14.816]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:14.816]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:14.816]             base::names(...future.oldOptions))
[15:32:14.816]     }
[15:32:14.816]     if (FALSE) {
[15:32:14.816]     }
[15:32:14.816]     else {
[15:32:14.816]         if (TRUE) {
[15:32:14.816]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:14.816]                 open = "w")
[15:32:14.816]         }
[15:32:14.816]         else {
[15:32:14.816]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:14.816]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:14.816]         }
[15:32:14.816]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:14.816]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:14.816]             base::sink(type = "output", split = FALSE)
[15:32:14.816]             base::close(...future.stdout)
[15:32:14.816]         }, add = TRUE)
[15:32:14.816]     }
[15:32:14.816]     ...future.frame <- base::sys.nframe()
[15:32:14.816]     ...future.conditions <- base::list()
[15:32:14.816]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:14.816]     if (FALSE) {
[15:32:14.816]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:14.816]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:14.816]     }
[15:32:14.816]     ...future.result <- base::tryCatch({
[15:32:14.816]         base::withCallingHandlers({
[15:32:14.816]             ...future.value <- base::withVisible(base::local({
[15:32:14.816]                 ...future.makeSendCondition <- base::local({
[15:32:14.816]                   sendCondition <- NULL
[15:32:14.816]                   function(frame = 1L) {
[15:32:14.816]                     if (is.function(sendCondition)) 
[15:32:14.816]                       return(sendCondition)
[15:32:14.816]                     ns <- getNamespace("parallel")
[15:32:14.816]                     if (exists("sendData", mode = "function", 
[15:32:14.816]                       envir = ns)) {
[15:32:14.816]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:14.816]                         envir = ns)
[15:32:14.816]                       envir <- sys.frame(frame)
[15:32:14.816]                       master <- NULL
[15:32:14.816]                       while (!identical(envir, .GlobalEnv) && 
[15:32:14.816]                         !identical(envir, emptyenv())) {
[15:32:14.816]                         if (exists("master", mode = "list", envir = envir, 
[15:32:14.816]                           inherits = FALSE)) {
[15:32:14.816]                           master <- get("master", mode = "list", 
[15:32:14.816]                             envir = envir, inherits = FALSE)
[15:32:14.816]                           if (inherits(master, c("SOCKnode", 
[15:32:14.816]                             "SOCK0node"))) {
[15:32:14.816]                             sendCondition <<- function(cond) {
[15:32:14.816]                               data <- list(type = "VALUE", value = cond, 
[15:32:14.816]                                 success = TRUE)
[15:32:14.816]                               parallel_sendData(master, data)
[15:32:14.816]                             }
[15:32:14.816]                             return(sendCondition)
[15:32:14.816]                           }
[15:32:14.816]                         }
[15:32:14.816]                         frame <- frame + 1L
[15:32:14.816]                         envir <- sys.frame(frame)
[15:32:14.816]                       }
[15:32:14.816]                     }
[15:32:14.816]                     sendCondition <<- function(cond) NULL
[15:32:14.816]                   }
[15:32:14.816]                 })
[15:32:14.816]                 withCallingHandlers({
[15:32:14.816]                   {
[15:32:14.816]                     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.816]                     if (!identical(...future.globals.maxSize.org, 
[15:32:14.816]                       ...future.globals.maxSize)) {
[15:32:14.816]                       oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.816]                       on.exit(options(oopts), add = TRUE)
[15:32:14.816]                     }
[15:32:14.816]                     {
[15:32:14.816]                       args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.816]                         MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
[15:32:14.816]                         USE.NAMES = FALSE)
[15:32:14.816]                       do.call(mapply, args = args)
[15:32:14.816]                     }
[15:32:14.816]                   }
[15:32:14.816]                 }, immediateCondition = function(cond) {
[15:32:14.816]                   sendCondition <- ...future.makeSendCondition()
[15:32:14.816]                   sendCondition(cond)
[15:32:14.816]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.816]                   {
[15:32:14.816]                     inherits <- base::inherits
[15:32:14.816]                     invokeRestart <- base::invokeRestart
[15:32:14.816]                     is.null <- base::is.null
[15:32:14.816]                     muffled <- FALSE
[15:32:14.816]                     if (inherits(cond, "message")) {
[15:32:14.816]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:14.816]                       if (muffled) 
[15:32:14.816]                         invokeRestart("muffleMessage")
[15:32:14.816]                     }
[15:32:14.816]                     else if (inherits(cond, "warning")) {
[15:32:14.816]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:14.816]                       if (muffled) 
[15:32:14.816]                         invokeRestart("muffleWarning")
[15:32:14.816]                     }
[15:32:14.816]                     else if (inherits(cond, "condition")) {
[15:32:14.816]                       if (!is.null(pattern)) {
[15:32:14.816]                         computeRestarts <- base::computeRestarts
[15:32:14.816]                         grepl <- base::grepl
[15:32:14.816]                         restarts <- computeRestarts(cond)
[15:32:14.816]                         for (restart in restarts) {
[15:32:14.816]                           name <- restart$name
[15:32:14.816]                           if (is.null(name)) 
[15:32:14.816]                             next
[15:32:14.816]                           if (!grepl(pattern, name)) 
[15:32:14.816]                             next
[15:32:14.816]                           invokeRestart(restart)
[15:32:14.816]                           muffled <- TRUE
[15:32:14.816]                           break
[15:32:14.816]                         }
[15:32:14.816]                       }
[15:32:14.816]                     }
[15:32:14.816]                     invisible(muffled)
[15:32:14.816]                   }
[15:32:14.816]                   muffleCondition(cond)
[15:32:14.816]                 })
[15:32:14.816]             }))
[15:32:14.816]             future::FutureResult(value = ...future.value$value, 
[15:32:14.816]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.816]                   ...future.rng), globalenv = if (FALSE) 
[15:32:14.816]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:14.816]                     ...future.globalenv.names))
[15:32:14.816]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:14.816]         }, condition = base::local({
[15:32:14.816]             c <- base::c
[15:32:14.816]             inherits <- base::inherits
[15:32:14.816]             invokeRestart <- base::invokeRestart
[15:32:14.816]             length <- base::length
[15:32:14.816]             list <- base::list
[15:32:14.816]             seq.int <- base::seq.int
[15:32:14.816]             signalCondition <- base::signalCondition
[15:32:14.816]             sys.calls <- base::sys.calls
[15:32:14.816]             `[[` <- base::`[[`
[15:32:14.816]             `+` <- base::`+`
[15:32:14.816]             `<<-` <- base::`<<-`
[15:32:14.816]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:14.816]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:14.816]                   3L)]
[15:32:14.816]             }
[15:32:14.816]             function(cond) {
[15:32:14.816]                 is_error <- inherits(cond, "error")
[15:32:14.816]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:14.816]                   NULL)
[15:32:14.816]                 if (is_error) {
[15:32:14.816]                   sessionInformation <- function() {
[15:32:14.816]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:14.816]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:14.816]                       search = base::search(), system = base::Sys.info())
[15:32:14.816]                   }
[15:32:14.816]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.816]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:14.816]                     cond$call), session = sessionInformation(), 
[15:32:14.816]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:14.816]                   signalCondition(cond)
[15:32:14.816]                 }
[15:32:14.816]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:14.816]                 "immediateCondition"))) {
[15:32:14.816]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:14.816]                   ...future.conditions[[length(...future.conditions) + 
[15:32:14.816]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:14.816]                   if (TRUE && !signal) {
[15:32:14.816]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.816]                     {
[15:32:14.816]                       inherits <- base::inherits
[15:32:14.816]                       invokeRestart <- base::invokeRestart
[15:32:14.816]                       is.null <- base::is.null
[15:32:14.816]                       muffled <- FALSE
[15:32:14.816]                       if (inherits(cond, "message")) {
[15:32:14.816]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.816]                         if (muffled) 
[15:32:14.816]                           invokeRestart("muffleMessage")
[15:32:14.816]                       }
[15:32:14.816]                       else if (inherits(cond, "warning")) {
[15:32:14.816]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.816]                         if (muffled) 
[15:32:14.816]                           invokeRestart("muffleWarning")
[15:32:14.816]                       }
[15:32:14.816]                       else if (inherits(cond, "condition")) {
[15:32:14.816]                         if (!is.null(pattern)) {
[15:32:14.816]                           computeRestarts <- base::computeRestarts
[15:32:14.816]                           grepl <- base::grepl
[15:32:14.816]                           restarts <- computeRestarts(cond)
[15:32:14.816]                           for (restart in restarts) {
[15:32:14.816]                             name <- restart$name
[15:32:14.816]                             if (is.null(name)) 
[15:32:14.816]                               next
[15:32:14.816]                             if (!grepl(pattern, name)) 
[15:32:14.816]                               next
[15:32:14.816]                             invokeRestart(restart)
[15:32:14.816]                             muffled <- TRUE
[15:32:14.816]                             break
[15:32:14.816]                           }
[15:32:14.816]                         }
[15:32:14.816]                       }
[15:32:14.816]                       invisible(muffled)
[15:32:14.816]                     }
[15:32:14.816]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.816]                   }
[15:32:14.816]                 }
[15:32:14.816]                 else {
[15:32:14.816]                   if (TRUE) {
[15:32:14.816]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:14.816]                     {
[15:32:14.816]                       inherits <- base::inherits
[15:32:14.816]                       invokeRestart <- base::invokeRestart
[15:32:14.816]                       is.null <- base::is.null
[15:32:14.816]                       muffled <- FALSE
[15:32:14.816]                       if (inherits(cond, "message")) {
[15:32:14.816]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:14.816]                         if (muffled) 
[15:32:14.816]                           invokeRestart("muffleMessage")
[15:32:14.816]                       }
[15:32:14.816]                       else if (inherits(cond, "warning")) {
[15:32:14.816]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:14.816]                         if (muffled) 
[15:32:14.816]                           invokeRestart("muffleWarning")
[15:32:14.816]                       }
[15:32:14.816]                       else if (inherits(cond, "condition")) {
[15:32:14.816]                         if (!is.null(pattern)) {
[15:32:14.816]                           computeRestarts <- base::computeRestarts
[15:32:14.816]                           grepl <- base::grepl
[15:32:14.816]                           restarts <- computeRestarts(cond)
[15:32:14.816]                           for (restart in restarts) {
[15:32:14.816]                             name <- restart$name
[15:32:14.816]                             if (is.null(name)) 
[15:32:14.816]                               next
[15:32:14.816]                             if (!grepl(pattern, name)) 
[15:32:14.816]                               next
[15:32:14.816]                             invokeRestart(restart)
[15:32:14.816]                             muffled <- TRUE
[15:32:14.816]                             break
[15:32:14.816]                           }
[15:32:14.816]                         }
[15:32:14.816]                       }
[15:32:14.816]                       invisible(muffled)
[15:32:14.816]                     }
[15:32:14.816]                     muffleCondition(cond, pattern = "^muffle")
[15:32:14.816]                   }
[15:32:14.816]                 }
[15:32:14.816]             }
[15:32:14.816]         }))
[15:32:14.816]     }, error = function(ex) {
[15:32:14.816]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:14.816]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:14.816]                 ...future.rng), started = ...future.startTime, 
[15:32:14.816]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:14.816]             version = "1.8"), class = "FutureResult")
[15:32:14.816]     }, finally = {
[15:32:14.816]         if (!identical(...future.workdir, getwd())) 
[15:32:14.816]             setwd(...future.workdir)
[15:32:14.816]         {
[15:32:14.816]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:14.816]                 ...future.oldOptions$nwarnings <- NULL
[15:32:14.816]             }
[15:32:14.816]             base::options(...future.oldOptions)
[15:32:14.816]             if (.Platform$OS.type == "windows") {
[15:32:14.816]                 old_names <- names(...future.oldEnvVars)
[15:32:14.816]                 envs <- base::Sys.getenv()
[15:32:14.816]                 names <- names(envs)
[15:32:14.816]                 common <- intersect(names, old_names)
[15:32:14.816]                 added <- setdiff(names, old_names)
[15:32:14.816]                 removed <- setdiff(old_names, names)
[15:32:14.816]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:14.816]                   envs[common]]
[15:32:14.816]                 NAMES <- toupper(changed)
[15:32:14.816]                 args <- list()
[15:32:14.816]                 for (kk in seq_along(NAMES)) {
[15:32:14.816]                   name <- changed[[kk]]
[15:32:14.816]                   NAME <- NAMES[[kk]]
[15:32:14.816]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.816]                     next
[15:32:14.816]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.816]                 }
[15:32:14.816]                 NAMES <- toupper(added)
[15:32:14.816]                 for (kk in seq_along(NAMES)) {
[15:32:14.816]                   name <- added[[kk]]
[15:32:14.816]                   NAME <- NAMES[[kk]]
[15:32:14.816]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.816]                     next
[15:32:14.816]                   args[[name]] <- ""
[15:32:14.816]                 }
[15:32:14.816]                 NAMES <- toupper(removed)
[15:32:14.816]                 for (kk in seq_along(NAMES)) {
[15:32:14.816]                   name <- removed[[kk]]
[15:32:14.816]                   NAME <- NAMES[[kk]]
[15:32:14.816]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:14.816]                     next
[15:32:14.816]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:14.816]                 }
[15:32:14.816]                 if (length(args) > 0) 
[15:32:14.816]                   base::do.call(base::Sys.setenv, args = args)
[15:32:14.816]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:14.816]             }
[15:32:14.816]             else {
[15:32:14.816]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:14.816]             }
[15:32:14.816]             {
[15:32:14.816]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:14.816]                   0L) {
[15:32:14.816]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:14.816]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:14.816]                   base::options(opts)
[15:32:14.816]                 }
[15:32:14.816]                 {
[15:32:14.816]                   {
[15:32:14.816]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:14.816]                     NULL
[15:32:14.816]                   }
[15:32:14.816]                   options(future.plan = NULL)
[15:32:14.816]                   if (is.na(NA_character_)) 
[15:32:14.816]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:14.816]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:14.816]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:14.816]                     .init = FALSE)
[15:32:14.816]                 }
[15:32:14.816]             }
[15:32:14.816]         }
[15:32:14.816]     })
[15:32:14.816]     if (TRUE) {
[15:32:14.816]         base::sink(type = "output", split = FALSE)
[15:32:14.816]         if (TRUE) {
[15:32:14.816]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:14.816]         }
[15:32:14.816]         else {
[15:32:14.816]             ...future.result["stdout"] <- base::list(NULL)
[15:32:14.816]         }
[15:32:14.816]         base::close(...future.stdout)
[15:32:14.816]         ...future.stdout <- NULL
[15:32:14.816]     }
[15:32:14.816]     ...future.result$conditions <- ...future.conditions
[15:32:14.816]     ...future.result$finished <- base::Sys.time()
[15:32:14.816]     ...future.result
[15:32:14.816] }
[15:32:14.826] Exporting 5 global objects (904 bytes) to cluster node #1 ...
[15:32:14.827] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:32:14.827] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:14.828] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
[15:32:14.828] Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
[15:32:14.828] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:14.829] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:14.829] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:14.829] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:14.830] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:14.830] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:14.830] Exporting 5 global objects (904 bytes) to cluster node #1 ... DONE
[15:32:14.831] MultisessionFuture started
[15:32:14.831] - Launch lazy future ... done
[15:32:14.831] run() for 'MultisessionFuture' ... done
[15:32:14.832] Created future:
[15:32:14.851] receiveMessageFromWorker() for ClusterFuture ...
[15:32:14.852] - Validating connection of MultisessionFuture
[15:32:14.852] - received message: FutureResult
[15:32:14.852] - Received FutureResult
[15:32:14.853] - Erased future from FutureRegistry
[15:32:14.853] result() for ClusterFuture ...
[15:32:14.853] - result already collected: FutureResult
[15:32:14.853] result() for ClusterFuture ... done
[15:32:14.854] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:14.832] MultisessionFuture:
[15:32:14.832] Label: 'future_mapply-2'
[15:32:14.832] Expression:
[15:32:14.832] {
[15:32:14.832]     ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:14.832]     if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:14.832]         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:14.832]         on.exit(options(oopts), add = TRUE)
[15:32:14.832]     }
[15:32:14.832]     {
[15:32:14.832]         args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
[15:32:14.832]             MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[15:32:14.832]         do.call(mapply, args = args)
[15:32:14.832]     }
[15:32:14.832] }
[15:32:14.832] Lazy evaluation: FALSE
[15:32:14.832] Asynchronous evaluation: TRUE
[15:32:14.832] Local evaluation: TRUE
[15:32:14.832] Environment: R_GlobalEnv
[15:32:14.832] Capture standard output: TRUE
[15:32:14.832] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:14.832] Globals: 5 objects totaling 904 bytes (function '...future.FUN' of 848 bytes, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:14.832] Packages: <none>
[15:32:14.832] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:14.832] Resolved: TRUE
[15:32:14.832] Value: <not collected>
[15:32:14.832] Conditions captured: <none>
[15:32:14.832] Early signaling: FALSE
[15:32:14.832] Owner process: 4c5fcdc5-7901-b04f-79b8-96fa0b80b15a
[15:32:14.832] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:14.854] Chunk #2 of 2 ... DONE
[15:32:14.855] Launching 2 futures (chunks) ... DONE
[15:32:14.855] Resolving 2 futures (chunks) ...
[15:32:14.855] resolve() on list ...
[15:32:14.855]  recursive: 0
[15:32:14.856]  length: 2
[15:32:14.856] 
[15:32:14.856] Future #1
[15:32:14.856] result() for ClusterFuture ...
[15:32:14.857] - result already collected: FutureResult
[15:32:14.857] result() for ClusterFuture ... done
[15:32:14.857] result() for ClusterFuture ...
[15:32:14.857] - result already collected: FutureResult
[15:32:14.858] result() for ClusterFuture ... done
[15:32:14.858] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:14.858] - nx: 2
[15:32:14.859] - relay: TRUE
[15:32:14.859] - stdout: TRUE
[15:32:14.859] - signal: TRUE
[15:32:14.859] - resignal: FALSE
[15:32:14.860] - force: TRUE
[15:32:14.860] - relayed: [n=2] FALSE, FALSE
[15:32:14.860] - queued futures: [n=2] FALSE, FALSE
[15:32:14.860]  - until=1
[15:32:14.861]  - relaying element #1
[15:32:14.861] result() for ClusterFuture ...
[15:32:14.861] - result already collected: FutureResult
[15:32:14.861] result() for ClusterFuture ... done
[15:32:14.862] result() for ClusterFuture ...
[15:32:14.862] - result already collected: FutureResult
[15:32:14.862] result() for ClusterFuture ... done
[15:32:14.862] result() for ClusterFuture ...
[15:32:14.863] - result already collected: FutureResult
[15:32:14.863] result() for ClusterFuture ... done
[15:32:14.863] result() for ClusterFuture ...
[15:32:14.863] - result already collected: FutureResult
[15:32:14.864] result() for ClusterFuture ... done
[15:32:14.864] - relayed: [n=2] TRUE, FALSE
[15:32:14.864] - queued futures: [n=2] TRUE, FALSE
[15:32:14.865] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:14.865]  length: 1 (resolved future 1)
[15:32:14.865] Future #2
[15:32:14.865] result() for ClusterFuture ...
[15:32:14.866] - result already collected: FutureResult
[15:32:14.866] result() for ClusterFuture ... done
[15:32:14.866] result() for ClusterFuture ...
[15:32:14.866] - result already collected: FutureResult
[15:32:14.867] result() for ClusterFuture ... done
[15:32:14.867] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:14.867] - nx: 2
[15:32:14.867] - relay: TRUE
[15:32:14.868] - stdout: TRUE
[15:32:14.868] - signal: TRUE
[15:32:14.868] - resignal: FALSE
[15:32:14.868] - force: TRUE
[15:32:14.869] - relayed: [n=2] TRUE, FALSE
[15:32:14.869] - queued futures: [n=2] TRUE, FALSE
[15:32:14.869]  - until=2
[15:32:14.869]  - relaying element #2
[15:32:14.870] result() for ClusterFuture ...
[15:32:14.870] - result already collected: FutureResult
[15:32:14.870] result() for ClusterFuture ... done
[15:32:14.870] result() for ClusterFuture ...
[15:32:14.871] - result already collected: FutureResult
[15:32:14.871] result() for ClusterFuture ... done
[15:32:14.871] result() for ClusterFuture ...
[15:32:14.872] - result already collected: FutureResult
[15:32:14.872] result() for ClusterFuture ... done
[15:32:14.872] result() for ClusterFuture ...
[15:32:14.872] - result already collected: FutureResult
[15:32:14.873] result() for ClusterFuture ... done
[15:32:14.873] - relayed: [n=2] TRUE, TRUE
[15:32:14.873] - queued futures: [n=2] TRUE, TRUE
[15:32:14.873] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:14.874]  length: 0 (resolved future 2)
[15:32:14.874] Relaying remaining futures
[15:32:14.874] signalConditionsASAP(NULL, pos=0) ...
[15:32:14.874] - nx: 2
[15:32:14.875] - relay: TRUE
[15:32:14.875] - stdout: TRUE
[15:32:14.875] - signal: TRUE
[15:32:14.875] - resignal: FALSE
[15:32:14.876] - force: TRUE
[15:32:14.876] - relayed: [n=2] TRUE, TRUE
[15:32:14.876] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:14.876] - relayed: [n=2] TRUE, TRUE
[15:32:14.877] - queued futures: [n=2] TRUE, TRUE
[15:32:14.877] signalConditionsASAP(NULL, pos=0) ... done
[15:32:14.877] resolve() on list ... DONE
[15:32:14.878] result() for ClusterFuture ...
[15:32:14.878] - result already collected: FutureResult
[15:32:14.878] result() for ClusterFuture ... done
[15:32:14.878] result() for ClusterFuture ...
[15:32:14.879] - result already collected: FutureResult
[15:32:14.879] result() for ClusterFuture ... done
[15:32:14.879] result() for ClusterFuture ...
[15:32:14.879] - result already collected: FutureResult
[15:32:14.880] result() for ClusterFuture ... done
[15:32:14.880] result() for ClusterFuture ...
[15:32:14.880] - result already collected: FutureResult
[15:32:14.880] result() for ClusterFuture ... done
[15:32:14.881]  - Number of value chunks collected: 2
[15:32:14.881] Resolving 2 futures (chunks) ... DONE
[15:32:14.881] Reducing values from 2 chunks ...
[15:32:14.881]  - Number of values collected after concatenation: 2
[15:32:14.882]  - Number of values expected: 2
[15:32:14.882] Reducing values from 2 chunks ... DONE
[15:32:14.882] future_mapply() ... DONE
[15:32:14.883] plan(): Setting new future strategy stack:
[15:32:14.883] List of future strategies:
[15:32:14.883] 1. sequential:
[15:32:14.883]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:14.883]    - tweaked: FALSE
[15:32:14.883]    - call: plan(sequential)
[15:32:14.885] plan(): nbrOfWorkers() = 1
*** strategy = 'multisession' ... done
> 
> message("- Empty input [non parallel] ...")
- Empty input [non parallel] ...
> y0 <- mapply(search)
> y1 <- future_mapply(search)
> stopifnot(identical(y1, y0))
> 
> y0 <- mapply(list, integer(0L))
> y1 <- future_mapply(list, integer(0L))
> stopifnot(identical(y1, y0))
> 
> message("*** future_mapply() - special cases ...")
*** future_mapply() - special cases ...
> 
> X <- list()
> names(X) <- character(0L)
> 
> y <- future_mapply(FUN = identity, X)
> stopifnot(length(y) == 0L, !is.null(names(y)), identical(y, X))
> 
> y <- future_mapply(FUN = identity, X, X)
> stopifnot(length(y) == 0L, !is.null(names(y)), identical(y, X))
> 
> message("*** future_mapply() - special cases ... DONE")
*** future_mapply() - special cases ... DONE
> 
> message("*** future_mapply() ... DONE")
*** future_mapply() ... DONE
> 
> source("incl/end.R")
[15:32:14.887] plan(): Setting new future strategy stack:
[15:32:14.887] List of future strategies:
[15:32:14.887] 1. FutureStrategy:
[15:32:14.887]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:14.887]    - tweaked: FALSE
[15:32:14.887]    - call: future::plan(oplan)
[15:32:14.888] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   7.01    0.26    9.26