R Under development (unstable) (2024-10-26 r87273 ucrt) -- "Unsuffered Consequences"
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
[18:40:50.410] plan(): Setting new future strategy stack:
[18:40:50.411] List of future strategies:
[18:40:50.411] 1. sequential:
[18:40:50.411]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.411]    - tweaked: FALSE
[18:40:50.411]    - call: future::plan("sequential")
[18:40:50.424] plan(): nbrOfWorkers() = 1
> library("listenv")
> 
> all_equal_but_call <- function(target, current, ...) {
+   attr(target, "call") <- NULL
+   attr(current, "call") <- NULL
+   all.equal(target = target, current = current, ...)
+ }
> 
> message("*** future_by() ...")
*** future_by() ...
> 
> ## ---------------------------------------------------------
> ## by()
> ## ---------------------------------------------------------
> if (require("datasets") && require("stats")) { ## warpbreaks & lm()
+   ## Use a local variable to test that it is properly exported, because
+   ## 'warpbreaks' is available in all R sessions
+   data <- warpbreaks
+   
+   y0 <- by(data[, 1:2], INDICES = data[,"tension"], FUN = summary)
+   y1 <- by(data[, 1], INDICES = data[, -1], FUN = summary, digits = 2L)
+   y2 <- by(data, INDICES = data[,"tension"], FUN = function(x, ...) {
+     lm(breaks ~ wool, data = x, ...)
+   }, singular.ok = FALSE)
+   
+   ## now suppose we want to extract the coefficients by group
+   tmp <- with(data, by(data, INDICES = tension, FUN = function(x) {
+     lm(breaks ~ wool, data = x)
+   }))
+   y3 <- sapply(tmp, coef)
+ 
+   ## Source: {r-source}/tests/reg-tests-1d.R
+   by2 <- function(data, INDICES, FUN) {
+     by(data, INDICES = INDICES, FUN = FUN)
+   }
+   future_by2 <- function(data, INDICES, FUN) {
+     future_by(data, INDICES = INDICES, FUN = FUN)
+   }
+   y4 <- by2(data, INDICES = data[,"tension"], FUN = summary)
+ 
+   for (cores in 1:availCores) {
+     message(sprintf("Testing with %d cores ...", cores))
+     options(mc.cores = cores)
+     strategies <- supportedStrategies(cores)
+   
+     for (strategy in supportedStrategies()) {
+       message(sprintf("- plan('%s') ...", strategy))
+       plan(strategy)
+     
+       y0f <- future_by(data[, 1:2], INDICES = data[,"tension"], FUN = summary)
+       stopifnot(all_equal_but_call(y0f, y0, check.attributes = FALSE))
+       
+       y1f <- future_by(data[, 1], INDICES = data[, -1], FUN = summary, digits = 2L)
+       stopifnot(all_equal_but_call(y1f, y1))
+       
+       y2f <- future_by(data, INDICES = data[,"tension"], FUN = function(x, ...) {
+         lm(breaks ~ wool, data = x, ...)
+       }, singular.ok = FALSE)
+       stopifnot(all_equal_but_call(y2f, y2))
+       
+       ## now suppose we want to extract the coefficients by group
+       tmp <- with(data, future_by(data, INDICES = tension, FUN = function(x) {
+         lm(breaks ~ wool, data = x)
+       }))
+       y3f <- sapply(tmp, coef)
+       stopifnot(all_equal_but_call(y3f, y3))
+       
+       y4f <- future_by2(data, INDICES = data[,"tension"], FUN = summary)
+       stopifnot(all_equal_but_call(y4f, y4))
+ 
+       ## Deprecated /HB 2022-10-24
+       y4f2 <- future_by2(data, INDICES = data[,"tension"], FUN = "summary")
+       stopifnot(all_equal_but_call(y4f2, y4))
+ 
+       res <- tryCatch({
+         y4f2 <- future_by2(data, INDICES = data[,"tension"], FUN = "summary")
+       }, warning = identity)
+       stopifnot(inherits(res, "warning"))
+       if (getRversion() >= "3.6.0") {
+         stopifnot(inherits(res, "deprecatedWarning"))
+       }
+     } ## for (strategy ...)
+     
+     message(sprintf("Testing with %d cores ... DONE", cores))
+   } ## for (cores ...)
+ } ## if (require("stats"))
Testing with 1 cores ...
- plan('sequential') ...
[18:40:50.490] plan(): Setting new future strategy stack:
[18:40:50.490] List of future strategies:
[18:40:50.490] 1. sequential:
[18:40:50.490]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.490]    - tweaked: FALSE
[18:40:50.490]    - call: plan(strategy)
[18:40:50.503] plan(): nbrOfWorkers() = 1
[18:40:50.504] future_by_internal() ...
[18:40:50.504] future_lapply() ...
[18:40:50.509] Number of chunks: 1
[18:40:50.509] getGlobalsAndPackagesXApply() ...
[18:40:50.509]  - future.globals: TRUE
[18:40:50.510] getGlobalsAndPackages() ...
[18:40:50.510] Searching for globals...
[18:40:50.512] - globals found: [2] 'FUN', 'UseMethod'
[18:40:50.513] Searching for globals ... DONE
[18:40:50.513] Resolving globals: FALSE
[18:40:50.514] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:50.515] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:50.515] - globals: [1] 'FUN'
[18:40:50.515] 
[18:40:50.515] getGlobalsAndPackages() ... DONE
[18:40:50.515]  - globals found/used: [n=1] 'FUN'
[18:40:50.515]  - needed namespaces: [n=0] 
[18:40:50.516] Finding globals ... DONE
[18:40:50.516]  - use_args: TRUE
[18:40:50.516]  - Getting '...' globals ...
[18:40:50.517] resolve() on list ...
[18:40:50.517]  recursive: 0
[18:40:50.517]  length: 1
[18:40:50.518]  elements: '...'
[18:40:50.518]  length: 0 (resolved future 1)
[18:40:50.518] resolve() on list ... DONE
[18:40:50.518]    - '...' content: [n=0] 
[18:40:50.518] List of 1
[18:40:50.518]  $ ...: list()
[18:40:50.518]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.518]  - attr(*, "where")=List of 1
[18:40:50.518]   ..$ ...:<environment: 0x000001cd4da285e0> 
[18:40:50.518]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.518]  - attr(*, "resolved")= logi TRUE
[18:40:50.518]  - attr(*, "total_size")= num NA
[18:40:50.524]  - Getting '...' globals ... DONE
[18:40:50.525] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:50.525] List of 2
[18:40:50.525]  $ ...future.FUN:function (object, ...)  
[18:40:50.525]  $ ...          : list()
[18:40:50.525]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.525]  - attr(*, "where")=List of 2
[18:40:50.525]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.525]   ..$ ...          :<environment: 0x000001cd4da285e0> 
[18:40:50.525]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.525]  - attr(*, "resolved")= logi FALSE
[18:40:50.525]  - attr(*, "total_size")= int 15670
[18:40:50.528] Packages to be attached in all futures: [n=0] 
[18:40:50.528] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.529] Number of futures (= number of chunks): 1
[18:40:50.529] Launching 1 futures (chunks) ...
[18:40:50.529] Chunk #1 of 1 ...
[18:40:50.529]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.530] getGlobalsAndPackages() ...
[18:40:50.530] Searching for globals...
[18:40:50.530] 
[18:40:50.530] Searching for globals ... DONE
[18:40:50.531] - globals: [0] <none>
[18:40:50.531] getGlobalsAndPackages() ... DONE
[18:40:50.531]    + additional globals found: [n=0] 
[18:40:50.531]    + additional namespaces needed: [n=0] 
[18:40:50.531]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.532]  - seeds: <none>
[18:40:50.532]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.532] getGlobalsAndPackages() ...
[18:40:50.532] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.532] Resolving globals: FALSE
[18:40:50.533] Tweak future expression to call with '...' arguments ...
[18:40:50.533] {
[18:40:50.533]     do.call(function(...) {
[18:40:50.533]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.533]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.533]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.533]             on.exit(options(oopts), add = TRUE)
[18:40:50.533]         }
[18:40:50.533]         {
[18:40:50.533]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.533]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.533]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.533]             })
[18:40:50.533]         }
[18:40:50.533]     }, args = future.call.arguments)
[18:40:50.533] }
[18:40:50.533] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.534] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.534] 
[18:40:50.534] getGlobalsAndPackages() ... DONE
[18:40:50.535] run() for 'Future' ...
[18:40:50.535] - state: 'created'
[18:40:50.535] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:50.536] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.536] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.536]   - Field: 'label'
[18:40:50.536]   - Field: 'local'
[18:40:50.536]   - Field: 'owner'
[18:40:50.537]   - Field: 'envir'
[18:40:50.537]   - Field: 'packages'
[18:40:50.537]   - Field: 'gc'
[18:40:50.537]   - Field: 'conditions'
[18:40:50.537]   - Field: 'expr'
[18:40:50.538]   - Field: 'uuid'
[18:40:50.538]   - Field: 'seed'
[18:40:50.538]   - Field: 'version'
[18:40:50.538]   - Field: 'result'
[18:40:50.538]   - Field: 'asynchronous'
[18:40:50.538]   - Field: 'calls'
[18:40:50.539]   - Field: 'globals'
[18:40:50.539]   - Field: 'stdout'
[18:40:50.539]   - Field: 'earlySignal'
[18:40:50.539]   - Field: 'lazy'
[18:40:50.539]   - Field: 'state'
[18:40:50.539] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.540] - Launch lazy future ...
[18:40:50.540] Packages needed by the future expression (n = 0): <none>
[18:40:50.541] Packages needed by future strategies (n = 0): <none>
[18:40:50.541] {
[18:40:50.541]     {
[18:40:50.541]         {
[18:40:50.541]             ...future.startTime <- base::Sys.time()
[18:40:50.541]             {
[18:40:50.541]                 {
[18:40:50.541]                   {
[18:40:50.541]                     base::local({
[18:40:50.541]                       has_future <- base::requireNamespace("future", 
[18:40:50.541]                         quietly = TRUE)
[18:40:50.541]                       if (has_future) {
[18:40:50.541]                         ns <- base::getNamespace("future")
[18:40:50.541]                         version <- ns[[".package"]][["version"]]
[18:40:50.541]                         if (is.null(version)) 
[18:40:50.541]                           version <- utils::packageVersion("future")
[18:40:50.541]                       }
[18:40:50.541]                       else {
[18:40:50.541]                         version <- NULL
[18:40:50.541]                       }
[18:40:50.541]                       if (!has_future || version < "1.8.0") {
[18:40:50.541]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.541]                           "", base::R.version$version.string), 
[18:40:50.541]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:50.541]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.541]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.541]                             "release", "version")], collapse = " "), 
[18:40:50.541]                           hostname = base::Sys.info()[["nodename"]])
[18:40:50.541]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.541]                           info)
[18:40:50.541]                         info <- base::paste(info, collapse = "; ")
[18:40:50.541]                         if (!has_future) {
[18:40:50.541]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.541]                             info)
[18:40:50.541]                         }
[18:40:50.541]                         else {
[18:40:50.541]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.541]                             info, version)
[18:40:50.541]                         }
[18:40:50.541]                         base::stop(msg)
[18:40:50.541]                       }
[18:40:50.541]                     })
[18:40:50.541]                   }
[18:40:50.541]                   ...future.strategy.old <- future::plan("list")
[18:40:50.541]                   options(future.plan = NULL)
[18:40:50.541]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.541]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.541]                 }
[18:40:50.541]                 ...future.workdir <- getwd()
[18:40:50.541]             }
[18:40:50.541]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.541]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.541]         }
[18:40:50.541]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.541]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.541]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.541]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.541]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.541]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.541]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.541]             base::names(...future.oldOptions))
[18:40:50.541]     }
[18:40:50.541]     if (FALSE) {
[18:40:50.541]     }
[18:40:50.541]     else {
[18:40:50.541]         if (TRUE) {
[18:40:50.541]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.541]                 open = "w")
[18:40:50.541]         }
[18:40:50.541]         else {
[18:40:50.541]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.541]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.541]         }
[18:40:50.541]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.541]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.541]             base::sink(type = "output", split = FALSE)
[18:40:50.541]             base::close(...future.stdout)
[18:40:50.541]         }, add = TRUE)
[18:40:50.541]     }
[18:40:50.541]     ...future.frame <- base::sys.nframe()
[18:40:50.541]     ...future.conditions <- base::list()
[18:40:50.541]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.541]     if (FALSE) {
[18:40:50.541]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.541]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.541]     }
[18:40:50.541]     ...future.result <- base::tryCatch({
[18:40:50.541]         base::withCallingHandlers({
[18:40:50.541]             ...future.value <- base::withVisible(base::local({
[18:40:50.541]                 do.call(function(...) {
[18:40:50.541]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.541]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.541]                     ...future.globals.maxSize)) {
[18:40:50.541]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.541]                     on.exit(options(oopts), add = TRUE)
[18:40:50.541]                   }
[18:40:50.541]                   {
[18:40:50.541]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.541]                       FUN = function(jj) {
[18:40:50.541]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.541]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.541]                       })
[18:40:50.541]                   }
[18:40:50.541]                 }, args = future.call.arguments)
[18:40:50.541]             }))
[18:40:50.541]             future::FutureResult(value = ...future.value$value, 
[18:40:50.541]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.541]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.541]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.541]                     ...future.globalenv.names))
[18:40:50.541]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.541]         }, condition = base::local({
[18:40:50.541]             c <- base::c
[18:40:50.541]             inherits <- base::inherits
[18:40:50.541]             invokeRestart <- base::invokeRestart
[18:40:50.541]             length <- base::length
[18:40:50.541]             list <- base::list
[18:40:50.541]             seq.int <- base::seq.int
[18:40:50.541]             signalCondition <- base::signalCondition
[18:40:50.541]             sys.calls <- base::sys.calls
[18:40:50.541]             `[[` <- base::`[[`
[18:40:50.541]             `+` <- base::`+`
[18:40:50.541]             `<<-` <- base::`<<-`
[18:40:50.541]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.541]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.541]                   3L)]
[18:40:50.541]             }
[18:40:50.541]             function(cond) {
[18:40:50.541]                 is_error <- inherits(cond, "error")
[18:40:50.541]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.541]                   NULL)
[18:40:50.541]                 if (is_error) {
[18:40:50.541]                   sessionInformation <- function() {
[18:40:50.541]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.541]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.541]                       search = base::search(), system = base::Sys.info())
[18:40:50.541]                   }
[18:40:50.541]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.541]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.541]                     cond$call), session = sessionInformation(), 
[18:40:50.541]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.541]                   signalCondition(cond)
[18:40:50.541]                 }
[18:40:50.541]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.541]                 "immediateCondition"))) {
[18:40:50.541]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.541]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.541]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.541]                   if (TRUE && !signal) {
[18:40:50.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.541]                     {
[18:40:50.541]                       inherits <- base::inherits
[18:40:50.541]                       invokeRestart <- base::invokeRestart
[18:40:50.541]                       is.null <- base::is.null
[18:40:50.541]                       muffled <- FALSE
[18:40:50.541]                       if (inherits(cond, "message")) {
[18:40:50.541]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.541]                         if (muffled) 
[18:40:50.541]                           invokeRestart("muffleMessage")
[18:40:50.541]                       }
[18:40:50.541]                       else if (inherits(cond, "warning")) {
[18:40:50.541]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.541]                         if (muffled) 
[18:40:50.541]                           invokeRestart("muffleWarning")
[18:40:50.541]                       }
[18:40:50.541]                       else if (inherits(cond, "condition")) {
[18:40:50.541]                         if (!is.null(pattern)) {
[18:40:50.541]                           computeRestarts <- base::computeRestarts
[18:40:50.541]                           grepl <- base::grepl
[18:40:50.541]                           restarts <- computeRestarts(cond)
[18:40:50.541]                           for (restart in restarts) {
[18:40:50.541]                             name <- restart$name
[18:40:50.541]                             if (is.null(name)) 
[18:40:50.541]                               next
[18:40:50.541]                             if (!grepl(pattern, name)) 
[18:40:50.541]                               next
[18:40:50.541]                             invokeRestart(restart)
[18:40:50.541]                             muffled <- TRUE
[18:40:50.541]                             break
[18:40:50.541]                           }
[18:40:50.541]                         }
[18:40:50.541]                       }
[18:40:50.541]                       invisible(muffled)
[18:40:50.541]                     }
[18:40:50.541]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.541]                   }
[18:40:50.541]                 }
[18:40:50.541]                 else {
[18:40:50.541]                   if (TRUE) {
[18:40:50.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.541]                     {
[18:40:50.541]                       inherits <- base::inherits
[18:40:50.541]                       invokeRestart <- base::invokeRestart
[18:40:50.541]                       is.null <- base::is.null
[18:40:50.541]                       muffled <- FALSE
[18:40:50.541]                       if (inherits(cond, "message")) {
[18:40:50.541]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.541]                         if (muffled) 
[18:40:50.541]                           invokeRestart("muffleMessage")
[18:40:50.541]                       }
[18:40:50.541]                       else if (inherits(cond, "warning")) {
[18:40:50.541]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.541]                         if (muffled) 
[18:40:50.541]                           invokeRestart("muffleWarning")
[18:40:50.541]                       }
[18:40:50.541]                       else if (inherits(cond, "condition")) {
[18:40:50.541]                         if (!is.null(pattern)) {
[18:40:50.541]                           computeRestarts <- base::computeRestarts
[18:40:50.541]                           grepl <- base::grepl
[18:40:50.541]                           restarts <- computeRestarts(cond)
[18:40:50.541]                           for (restart in restarts) {
[18:40:50.541]                             name <- restart$name
[18:40:50.541]                             if (is.null(name)) 
[18:40:50.541]                               next
[18:40:50.541]                             if (!grepl(pattern, name)) 
[18:40:50.541]                               next
[18:40:50.541]                             invokeRestart(restart)
[18:40:50.541]                             muffled <- TRUE
[18:40:50.541]                             break
[18:40:50.541]                           }
[18:40:50.541]                         }
[18:40:50.541]                       }
[18:40:50.541]                       invisible(muffled)
[18:40:50.541]                     }
[18:40:50.541]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.541]                   }
[18:40:50.541]                 }
[18:40:50.541]             }
[18:40:50.541]         }))
[18:40:50.541]     }, error = function(ex) {
[18:40:50.541]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.541]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.541]                 ...future.rng), started = ...future.startTime, 
[18:40:50.541]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.541]             version = "1.8"), class = "FutureResult")
[18:40:50.541]     }, finally = {
[18:40:50.541]         if (!identical(...future.workdir, getwd())) 
[18:40:50.541]             setwd(...future.workdir)
[18:40:50.541]         {
[18:40:50.541]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.541]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.541]             }
[18:40:50.541]             base::options(...future.oldOptions)
[18:40:50.541]             if (.Platform$OS.type == "windows") {
[18:40:50.541]                 old_names <- names(...future.oldEnvVars)
[18:40:50.541]                 envs <- base::Sys.getenv()
[18:40:50.541]                 names <- names(envs)
[18:40:50.541]                 common <- intersect(names, old_names)
[18:40:50.541]                 added <- setdiff(names, old_names)
[18:40:50.541]                 removed <- setdiff(old_names, names)
[18:40:50.541]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.541]                   envs[common]]
[18:40:50.541]                 NAMES <- toupper(changed)
[18:40:50.541]                 args <- list()
[18:40:50.541]                 for (kk in seq_along(NAMES)) {
[18:40:50.541]                   name <- changed[[kk]]
[18:40:50.541]                   NAME <- NAMES[[kk]]
[18:40:50.541]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.541]                     next
[18:40:50.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.541]                 }
[18:40:50.541]                 NAMES <- toupper(added)
[18:40:50.541]                 for (kk in seq_along(NAMES)) {
[18:40:50.541]                   name <- added[[kk]]
[18:40:50.541]                   NAME <- NAMES[[kk]]
[18:40:50.541]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.541]                     next
[18:40:50.541]                   args[[name]] <- ""
[18:40:50.541]                 }
[18:40:50.541]                 NAMES <- toupper(removed)
[18:40:50.541]                 for (kk in seq_along(NAMES)) {
[18:40:50.541]                   name <- removed[[kk]]
[18:40:50.541]                   NAME <- NAMES[[kk]]
[18:40:50.541]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.541]                     next
[18:40:50.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.541]                 }
[18:40:50.541]                 if (length(args) > 0) 
[18:40:50.541]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.541]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.541]             }
[18:40:50.541]             else {
[18:40:50.541]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.541]             }
[18:40:50.541]             {
[18:40:50.541]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.541]                   0L) {
[18:40:50.541]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.541]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.541]                   base::options(opts)
[18:40:50.541]                 }
[18:40:50.541]                 {
[18:40:50.541]                   {
[18:40:50.541]                     NULL
[18:40:50.541]                     RNGkind("Mersenne-Twister")
[18:40:50.541]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.541]                       inherits = FALSE)
[18:40:50.541]                   }
[18:40:50.541]                   options(future.plan = NULL)
[18:40:50.541]                   if (is.na(NA_character_)) 
[18:40:50.541]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.541]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.541]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.541]                     .init = FALSE)
[18:40:50.541]                 }
[18:40:50.541]             }
[18:40:50.541]         }
[18:40:50.541]     })
[18:40:50.541]     if (TRUE) {
[18:40:50.541]         base::sink(type = "output", split = FALSE)
[18:40:50.541]         if (TRUE) {
[18:40:50.541]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.541]         }
[18:40:50.541]         else {
[18:40:50.541]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.541]         }
[18:40:50.541]         base::close(...future.stdout)
[18:40:50.541]         ...future.stdout <- NULL
[18:40:50.541]     }
[18:40:50.541]     ...future.result$conditions <- ...future.conditions
[18:40:50.541]     ...future.result$finished <- base::Sys.time()
[18:40:50.541]     ...future.result
[18:40:50.541] }
[18:40:50.546] assign_globals() ...
[18:40:50.546] List of 5
[18:40:50.546]  $ ...future.FUN            :function (object, ...)  
[18:40:50.546]  $ future.call.arguments    : list()
[18:40:50.546]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.546]  $ ...future.elements_ii    :List of 3
[18:40:50.546]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:50.546]   .. ..$ breaks: num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:50.546]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.546]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:50.546]   .. ..$ breaks: num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:50.546]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.546]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:50.546]   .. ..$ breaks: num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:50.546]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.546]  $ ...future.seeds_ii       : NULL
[18:40:50.546]  $ ...future.globals.maxSize: NULL
[18:40:50.546]  - attr(*, "where")=List of 5
[18:40:50.546]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.546]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.546]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.546]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.546]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.546]  - attr(*, "resolved")= logi FALSE
[18:40:50.546]  - attr(*, "total_size")= num 15670
[18:40:50.546]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.546]  - attr(*, "already-done")= logi TRUE
[18:40:50.556] - copied '...future.FUN' to environment
[18:40:50.556] - copied 'future.call.arguments' to environment
[18:40:50.556] - copied '...future.elements_ii' to environment
[18:40:50.557] - copied '...future.seeds_ii' to environment
[18:40:50.557] - copied '...future.globals.maxSize' to environment
[18:40:50.557] assign_globals() ... done
[18:40:50.557] plan(): Setting new future strategy stack:
[18:40:50.558] List of future strategies:
[18:40:50.558] 1. sequential:
[18:40:50.558]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.558]    - tweaked: FALSE
[18:40:50.558]    - call: NULL
[18:40:50.558] plan(): nbrOfWorkers() = 1
[18:40:50.562] plan(): Setting new future strategy stack:
[18:40:50.562] List of future strategies:
[18:40:50.562] 1. sequential:
[18:40:50.562]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.562]    - tweaked: FALSE
[18:40:50.562]    - call: plan(strategy)
[18:40:50.562] plan(): nbrOfWorkers() = 1
[18:40:50.563] SequentialFuture started (and completed)
[18:40:50.563] - Launch lazy future ... done
[18:40:50.563] run() for 'SequentialFuture' ... done
[18:40:50.564] Created future:
[18:40:50.564] SequentialFuture:
[18:40:50.564] Label: 'future_by-1'
[18:40:50.564] Expression:
[18:40:50.564] {
[18:40:50.564]     do.call(function(...) {
[18:40:50.564]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.564]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.564]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.564]             on.exit(options(oopts), add = TRUE)
[18:40:50.564]         }
[18:40:50.564]         {
[18:40:50.564]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.564]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.564]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.564]             })
[18:40:50.564]         }
[18:40:50.564]     }, args = future.call.arguments)
[18:40:50.564] }
[18:40:50.564] Lazy evaluation: FALSE
[18:40:50.564] Asynchronous evaluation: FALSE
[18:40:50.564] Local evaluation: TRUE
[18:40:50.564] Environment: R_GlobalEnv
[18:40:50.564] Capture standard output: TRUE
[18:40:50.564] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:50.564] Globals: 5 objects totaling 1.90 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.48 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:50.564] Packages: <none>
[18:40:50.564] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:50.564] Resolved: TRUE
[18:40:50.564] Value: 1.16 KiB of class 'list'
[18:40:50.564] Early signaling: FALSE
[18:40:50.564] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:50.564] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.565] Chunk #1 of 1 ... DONE
[18:40:50.566] Launching 1 futures (chunks) ... DONE
[18:40:50.566] Resolving 1 futures (chunks) ...
[18:40:50.566] resolve() on list ...
[18:40:50.566]  recursive: 0
[18:40:50.566]  length: 1
[18:40:50.566] 
[18:40:50.567] resolved() for 'SequentialFuture' ...
[18:40:50.567] - state: 'finished'
[18:40:50.567] - run: TRUE
[18:40:50.567] - result: 'FutureResult'
[18:40:50.567] resolved() for 'SequentialFuture' ... done
[18:40:50.568] Future #1
[18:40:50.568] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:50.568] - nx: 1
[18:40:50.568] - relay: TRUE
[18:40:50.568] - stdout: TRUE
[18:40:50.569] - signal: TRUE
[18:40:50.569] - resignal: FALSE
[18:40:50.569] - force: TRUE
[18:40:50.569] - relayed: [n=1] FALSE
[18:40:50.569] - queued futures: [n=1] FALSE
[18:40:50.592]  - until=1
[18:40:50.592]  - relaying element #1
[18:40:50.593] - relayed: [n=1] TRUE
[18:40:50.593] - queued futures: [n=1] TRUE
[18:40:50.593] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:50.593]  length: 0 (resolved future 1)
[18:40:50.593] Relaying remaining futures
[18:40:50.594] signalConditionsASAP(NULL, pos=0) ...
[18:40:50.594] - nx: 1
[18:40:50.594] - relay: TRUE
[18:40:50.594] - stdout: TRUE
[18:40:50.594] - signal: TRUE
[18:40:50.594] - resignal: FALSE
[18:40:50.594] - force: TRUE
[18:40:50.595] - relayed: [n=1] TRUE
[18:40:50.595] - queued futures: [n=1] TRUE
 - flush all
[18:40:50.595] - relayed: [n=1] TRUE
[18:40:50.595] - queued futures: [n=1] TRUE
[18:40:50.595] signalConditionsASAP(NULL, pos=0) ... done
[18:40:50.595] resolve() on list ... DONE
[18:40:50.596]  - Number of value chunks collected: 1
[18:40:50.596] Resolving 1 futures (chunks) ... DONE
[18:40:50.596] Reducing values from 1 chunks ...
[18:40:50.596]  - Number of values collected after concatenation: 3
[18:40:50.596]  - Number of values expected: 3
[18:40:50.596] Reducing values from 1 chunks ... DONE
[18:40:50.597] future_lapply() ... DONE
[18:40:50.597] future_by_internal() ... DONE
[18:40:50.597] future_by_internal() ...
[18:40:50.598] future_lapply() ...
[18:40:50.598] Number of chunks: 1
[18:40:50.599] getGlobalsAndPackagesXApply() ...
[18:40:50.599]  - future.globals: TRUE
[18:40:50.599] getGlobalsAndPackages() ...
[18:40:50.599] Searching for globals...
[18:40:50.600] - globals found: [2] 'FUN', 'UseMethod'
[18:40:50.600] Searching for globals ... DONE
[18:40:50.601] Resolving globals: FALSE
[18:40:50.601] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:50.601] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:50.602] - globals: [1] 'FUN'
[18:40:50.602] 
[18:40:50.602] getGlobalsAndPackages() ... DONE
[18:40:50.602]  - globals found/used: [n=1] 'FUN'
[18:40:50.602]  - needed namespaces: [n=0] 
[18:40:50.602] Finding globals ... DONE
[18:40:50.603]  - use_args: TRUE
[18:40:50.603]  - Getting '...' globals ...
[18:40:50.603] resolve() on list ...
[18:40:50.603]  recursive: 0
[18:40:50.603]  length: 1
[18:40:50.604]  elements: '...'
[18:40:50.604]  length: 0 (resolved future 1)
[18:40:50.604] resolve() on list ... DONE
[18:40:50.604]    - '...' content: [n=1] 'digits'
[18:40:50.604] List of 1
[18:40:50.604]  $ ...:List of 1
[18:40:50.604]   ..$ digits: int 2
[18:40:50.604]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.604]  - attr(*, "where")=List of 1
[18:40:50.604]   ..$ ...:<environment: 0x000001cd4af93648> 
[18:40:50.604]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.604]  - attr(*, "resolved")= logi TRUE
[18:40:50.604]  - attr(*, "total_size")= num NA
[18:40:50.607]  - Getting '...' globals ... DONE
[18:40:50.608] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:50.608] List of 2
[18:40:50.608]  $ ...future.FUN:function (object, ...)  
[18:40:50.608]  $ ...          :List of 1
[18:40:50.608]   ..$ digits: int 2
[18:40:50.608]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.608]  - attr(*, "where")=List of 2
[18:40:50.608]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.608]   ..$ ...          :<environment: 0x000001cd4af93648> 
[18:40:50.608]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.608]  - attr(*, "resolved")= logi FALSE
[18:40:50.608]  - attr(*, "total_size")= int 13284
[18:40:50.634] Packages to be attached in all futures: [n=0] 
[18:40:50.634] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.634] Number of futures (= number of chunks): 1
[18:40:50.634] Launching 1 futures (chunks) ...
[18:40:50.634] Chunk #1 of 1 ...
[18:40:50.635]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.635] getGlobalsAndPackages() ...
[18:40:50.635] Searching for globals...
[18:40:50.635] 
[18:40:50.635] Searching for globals ... DONE
[18:40:50.636] - globals: [0] <none>
[18:40:50.636] getGlobalsAndPackages() ... DONE
[18:40:50.636]    + additional globals found: [n=0] 
[18:40:50.636]    + additional namespaces needed: [n=0] 
[18:40:50.636]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.636]  - seeds: <none>
[18:40:50.636]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.637] getGlobalsAndPackages() ...
[18:40:50.637] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.637] Resolving globals: FALSE
[18:40:50.637] Tweak future expression to call with '...' arguments ...
[18:40:50.637] {
[18:40:50.637]     do.call(function(...) {
[18:40:50.637]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.637]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.637]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.637]             on.exit(options(oopts), add = TRUE)
[18:40:50.637]         }
[18:40:50.637]         {
[18:40:50.637]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.637]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.637]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.637]             })
[18:40:50.637]         }
[18:40:50.637]     }, args = future.call.arguments)
[18:40:50.637] }
[18:40:50.638] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.638] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.638] 
[18:40:50.639] getGlobalsAndPackages() ... DONE
[18:40:50.639] run() for 'Future' ...
[18:40:50.639] - state: 'created'
[18:40:50.640] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:50.640] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.640] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.640]   - Field: 'label'
[18:40:50.640]   - Field: 'local'
[18:40:50.641]   - Field: 'owner'
[18:40:50.641]   - Field: 'envir'
[18:40:50.641]   - Field: 'packages'
[18:40:50.641]   - Field: 'gc'
[18:40:50.641]   - Field: 'conditions'
[18:40:50.641]   - Field: 'expr'
[18:40:50.642]   - Field: 'uuid'
[18:40:50.642]   - Field: 'seed'
[18:40:50.642]   - Field: 'version'
[18:40:50.642]   - Field: 'result'
[18:40:50.642]   - Field: 'asynchronous'
[18:40:50.642]   - Field: 'calls'
[18:40:50.643]   - Field: 'globals'
[18:40:50.643]   - Field: 'stdout'
[18:40:50.643]   - Field: 'earlySignal'
[18:40:50.643]   - Field: 'lazy'
[18:40:50.643]   - Field: 'state'
[18:40:50.643] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.644] - Launch lazy future ...
[18:40:50.644] Packages needed by the future expression (n = 0): <none>
[18:40:50.644] Packages needed by future strategies (n = 0): <none>
[18:40:50.645] {
[18:40:50.645]     {
[18:40:50.645]         {
[18:40:50.645]             ...future.startTime <- base::Sys.time()
[18:40:50.645]             {
[18:40:50.645]                 {
[18:40:50.645]                   {
[18:40:50.645]                     base::local({
[18:40:50.645]                       has_future <- base::requireNamespace("future", 
[18:40:50.645]                         quietly = TRUE)
[18:40:50.645]                       if (has_future) {
[18:40:50.645]                         ns <- base::getNamespace("future")
[18:40:50.645]                         version <- ns[[".package"]][["version"]]
[18:40:50.645]                         if (is.null(version)) 
[18:40:50.645]                           version <- utils::packageVersion("future")
[18:40:50.645]                       }
[18:40:50.645]                       else {
[18:40:50.645]                         version <- NULL
[18:40:50.645]                       }
[18:40:50.645]                       if (!has_future || version < "1.8.0") {
[18:40:50.645]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.645]                           "", base::R.version$version.string), 
[18:40:50.645]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:50.645]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.645]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.645]                             "release", "version")], collapse = " "), 
[18:40:50.645]                           hostname = base::Sys.info()[["nodename"]])
[18:40:50.645]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.645]                           info)
[18:40:50.645]                         info <- base::paste(info, collapse = "; ")
[18:40:50.645]                         if (!has_future) {
[18:40:50.645]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.645]                             info)
[18:40:50.645]                         }
[18:40:50.645]                         else {
[18:40:50.645]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.645]                             info, version)
[18:40:50.645]                         }
[18:40:50.645]                         base::stop(msg)
[18:40:50.645]                       }
[18:40:50.645]                     })
[18:40:50.645]                   }
[18:40:50.645]                   ...future.strategy.old <- future::plan("list")
[18:40:50.645]                   options(future.plan = NULL)
[18:40:50.645]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.645]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.645]                 }
[18:40:50.645]                 ...future.workdir <- getwd()
[18:40:50.645]             }
[18:40:50.645]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.645]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.645]         }
[18:40:50.645]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.645]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.645]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.645]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.645]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.645]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.645]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.645]             base::names(...future.oldOptions))
[18:40:50.645]     }
[18:40:50.645]     if (FALSE) {
[18:40:50.645]     }
[18:40:50.645]     else {
[18:40:50.645]         if (TRUE) {
[18:40:50.645]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.645]                 open = "w")
[18:40:50.645]         }
[18:40:50.645]         else {
[18:40:50.645]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.645]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.645]         }
[18:40:50.645]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.645]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.645]             base::sink(type = "output", split = FALSE)
[18:40:50.645]             base::close(...future.stdout)
[18:40:50.645]         }, add = TRUE)
[18:40:50.645]     }
[18:40:50.645]     ...future.frame <- base::sys.nframe()
[18:40:50.645]     ...future.conditions <- base::list()
[18:40:50.645]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.645]     if (FALSE) {
[18:40:50.645]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.645]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.645]     }
[18:40:50.645]     ...future.result <- base::tryCatch({
[18:40:50.645]         base::withCallingHandlers({
[18:40:50.645]             ...future.value <- base::withVisible(base::local({
[18:40:50.645]                 do.call(function(...) {
[18:40:50.645]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.645]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.645]                     ...future.globals.maxSize)) {
[18:40:50.645]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.645]                     on.exit(options(oopts), add = TRUE)
[18:40:50.645]                   }
[18:40:50.645]                   {
[18:40:50.645]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.645]                       FUN = function(jj) {
[18:40:50.645]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.645]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.645]                       })
[18:40:50.645]                   }
[18:40:50.645]                 }, args = future.call.arguments)
[18:40:50.645]             }))
[18:40:50.645]             future::FutureResult(value = ...future.value$value, 
[18:40:50.645]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.645]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.645]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.645]                     ...future.globalenv.names))
[18:40:50.645]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.645]         }, condition = base::local({
[18:40:50.645]             c <- base::c
[18:40:50.645]             inherits <- base::inherits
[18:40:50.645]             invokeRestart <- base::invokeRestart
[18:40:50.645]             length <- base::length
[18:40:50.645]             list <- base::list
[18:40:50.645]             seq.int <- base::seq.int
[18:40:50.645]             signalCondition <- base::signalCondition
[18:40:50.645]             sys.calls <- base::sys.calls
[18:40:50.645]             `[[` <- base::`[[`
[18:40:50.645]             `+` <- base::`+`
[18:40:50.645]             `<<-` <- base::`<<-`
[18:40:50.645]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.645]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.645]                   3L)]
[18:40:50.645]             }
[18:40:50.645]             function(cond) {
[18:40:50.645]                 is_error <- inherits(cond, "error")
[18:40:50.645]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.645]                   NULL)
[18:40:50.645]                 if (is_error) {
[18:40:50.645]                   sessionInformation <- function() {
[18:40:50.645]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.645]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.645]                       search = base::search(), system = base::Sys.info())
[18:40:50.645]                   }
[18:40:50.645]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.645]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.645]                     cond$call), session = sessionInformation(), 
[18:40:50.645]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.645]                   signalCondition(cond)
[18:40:50.645]                 }
[18:40:50.645]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.645]                 "immediateCondition"))) {
[18:40:50.645]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.645]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.645]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.645]                   if (TRUE && !signal) {
[18:40:50.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.645]                     {
[18:40:50.645]                       inherits <- base::inherits
[18:40:50.645]                       invokeRestart <- base::invokeRestart
[18:40:50.645]                       is.null <- base::is.null
[18:40:50.645]                       muffled <- FALSE
[18:40:50.645]                       if (inherits(cond, "message")) {
[18:40:50.645]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.645]                         if (muffled) 
[18:40:50.645]                           invokeRestart("muffleMessage")
[18:40:50.645]                       }
[18:40:50.645]                       else if (inherits(cond, "warning")) {
[18:40:50.645]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.645]                         if (muffled) 
[18:40:50.645]                           invokeRestart("muffleWarning")
[18:40:50.645]                       }
[18:40:50.645]                       else if (inherits(cond, "condition")) {
[18:40:50.645]                         if (!is.null(pattern)) {
[18:40:50.645]                           computeRestarts <- base::computeRestarts
[18:40:50.645]                           grepl <- base::grepl
[18:40:50.645]                           restarts <- computeRestarts(cond)
[18:40:50.645]                           for (restart in restarts) {
[18:40:50.645]                             name <- restart$name
[18:40:50.645]                             if (is.null(name)) 
[18:40:50.645]                               next
[18:40:50.645]                             if (!grepl(pattern, name)) 
[18:40:50.645]                               next
[18:40:50.645]                             invokeRestart(restart)
[18:40:50.645]                             muffled <- TRUE
[18:40:50.645]                             break
[18:40:50.645]                           }
[18:40:50.645]                         }
[18:40:50.645]                       }
[18:40:50.645]                       invisible(muffled)
[18:40:50.645]                     }
[18:40:50.645]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.645]                   }
[18:40:50.645]                 }
[18:40:50.645]                 else {
[18:40:50.645]                   if (TRUE) {
[18:40:50.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.645]                     {
[18:40:50.645]                       inherits <- base::inherits
[18:40:50.645]                       invokeRestart <- base::invokeRestart
[18:40:50.645]                       is.null <- base::is.null
[18:40:50.645]                       muffled <- FALSE
[18:40:50.645]                       if (inherits(cond, "message")) {
[18:40:50.645]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.645]                         if (muffled) 
[18:40:50.645]                           invokeRestart("muffleMessage")
[18:40:50.645]                       }
[18:40:50.645]                       else if (inherits(cond, "warning")) {
[18:40:50.645]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.645]                         if (muffled) 
[18:40:50.645]                           invokeRestart("muffleWarning")
[18:40:50.645]                       }
[18:40:50.645]                       else if (inherits(cond, "condition")) {
[18:40:50.645]                         if (!is.null(pattern)) {
[18:40:50.645]                           computeRestarts <- base::computeRestarts
[18:40:50.645]                           grepl <- base::grepl
[18:40:50.645]                           restarts <- computeRestarts(cond)
[18:40:50.645]                           for (restart in restarts) {
[18:40:50.645]                             name <- restart$name
[18:40:50.645]                             if (is.null(name)) 
[18:40:50.645]                               next
[18:40:50.645]                             if (!grepl(pattern, name)) 
[18:40:50.645]                               next
[18:40:50.645]                             invokeRestart(restart)
[18:40:50.645]                             muffled <- TRUE
[18:40:50.645]                             break
[18:40:50.645]                           }
[18:40:50.645]                         }
[18:40:50.645]                       }
[18:40:50.645]                       invisible(muffled)
[18:40:50.645]                     }
[18:40:50.645]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.645]                   }
[18:40:50.645]                 }
[18:40:50.645]             }
[18:40:50.645]         }))
[18:40:50.645]     }, error = function(ex) {
[18:40:50.645]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.645]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.645]                 ...future.rng), started = ...future.startTime, 
[18:40:50.645]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.645]             version = "1.8"), class = "FutureResult")
[18:40:50.645]     }, finally = {
[18:40:50.645]         if (!identical(...future.workdir, getwd())) 
[18:40:50.645]             setwd(...future.workdir)
[18:40:50.645]         {
[18:40:50.645]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.645]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.645]             }
[18:40:50.645]             base::options(...future.oldOptions)
[18:40:50.645]             if (.Platform$OS.type == "windows") {
[18:40:50.645]                 old_names <- names(...future.oldEnvVars)
[18:40:50.645]                 envs <- base::Sys.getenv()
[18:40:50.645]                 names <- names(envs)
[18:40:50.645]                 common <- intersect(names, old_names)
[18:40:50.645]                 added <- setdiff(names, old_names)
[18:40:50.645]                 removed <- setdiff(old_names, names)
[18:40:50.645]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.645]                   envs[common]]
[18:40:50.645]                 NAMES <- toupper(changed)
[18:40:50.645]                 args <- list()
[18:40:50.645]                 for (kk in seq_along(NAMES)) {
[18:40:50.645]                   name <- changed[[kk]]
[18:40:50.645]                   NAME <- NAMES[[kk]]
[18:40:50.645]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.645]                     next
[18:40:50.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.645]                 }
[18:40:50.645]                 NAMES <- toupper(added)
[18:40:50.645]                 for (kk in seq_along(NAMES)) {
[18:40:50.645]                   name <- added[[kk]]
[18:40:50.645]                   NAME <- NAMES[[kk]]
[18:40:50.645]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.645]                     next
[18:40:50.645]                   args[[name]] <- ""
[18:40:50.645]                 }
[18:40:50.645]                 NAMES <- toupper(removed)
[18:40:50.645]                 for (kk in seq_along(NAMES)) {
[18:40:50.645]                   name <- removed[[kk]]
[18:40:50.645]                   NAME <- NAMES[[kk]]
[18:40:50.645]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.645]                     next
[18:40:50.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.645]                 }
[18:40:50.645]                 if (length(args) > 0) 
[18:40:50.645]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.645]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.645]             }
[18:40:50.645]             else {
[18:40:50.645]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.645]             }
[18:40:50.645]             {
[18:40:50.645]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.645]                   0L) {
[18:40:50.645]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.645]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.645]                   base::options(opts)
[18:40:50.645]                 }
[18:40:50.645]                 {
[18:40:50.645]                   {
[18:40:50.645]                     NULL
[18:40:50.645]                     RNGkind("Mersenne-Twister")
[18:40:50.645]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.645]                       inherits = FALSE)
[18:40:50.645]                   }
[18:40:50.645]                   options(future.plan = NULL)
[18:40:50.645]                   if (is.na(NA_character_)) 
[18:40:50.645]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.645]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.645]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.645]                     .init = FALSE)
[18:40:50.645]                 }
[18:40:50.645]             }
[18:40:50.645]         }
[18:40:50.645]     })
[18:40:50.645]     if (TRUE) {
[18:40:50.645]         base::sink(type = "output", split = FALSE)
[18:40:50.645]         if (TRUE) {
[18:40:50.645]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.645]         }
[18:40:50.645]         else {
[18:40:50.645]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.645]         }
[18:40:50.645]         base::close(...future.stdout)
[18:40:50.645]         ...future.stdout <- NULL
[18:40:50.645]     }
[18:40:50.645]     ...future.result$conditions <- ...future.conditions
[18:40:50.645]     ...future.result$finished <- base::Sys.time()
[18:40:50.645]     ...future.result
[18:40:50.645] }
[18:40:50.648] assign_globals() ...
[18:40:50.649] List of 5
[18:40:50.649]  $ ...future.FUN            :function (object, ...)  
[18:40:50.649]  $ future.call.arguments    :List of 1
[18:40:50.649]   ..$ digits: int 2
[18:40:50.649]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.649]  $ ...future.elements_ii    :List of 6
[18:40:50.649]   ..$ : num [1:9] 26 30 54 25 70 52 51 26 67
[18:40:50.649]   ..$ : num [1:9] 27 14 29 19 29 31 41 20 44
[18:40:50.649]   ..$ : num [1:9] 18 21 29 17 12 18 35 30 36
[18:40:50.649]   ..$ : num [1:9] 42 26 19 16 39 28 21 39 29
[18:40:50.649]   ..$ : num [1:9] 36 21 24 18 10 43 28 15 26
[18:40:50.649]   ..$ : num [1:9] 20 21 24 17 13 15 15 16 28
[18:40:50.649]  $ ...future.seeds_ii       : NULL
[18:40:50.649]  $ ...future.globals.maxSize: NULL
[18:40:50.649]  - attr(*, "where")=List of 5
[18:40:50.649]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.649]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.649]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.649]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.649]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.649]  - attr(*, "resolved")= logi FALSE
[18:40:50.649]  - attr(*, "total_size")= num 13284
[18:40:50.649]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.649]  - attr(*, "already-done")= logi TRUE
[18:40:50.657] - copied '...future.FUN' to environment
[18:40:50.658] - copied 'future.call.arguments' to environment
[18:40:50.658] - copied '...future.elements_ii' to environment
[18:40:50.658] - copied '...future.seeds_ii' to environment
[18:40:50.658] - copied '...future.globals.maxSize' to environment
[18:40:50.658] assign_globals() ... done
[18:40:50.659] plan(): Setting new future strategy stack:
[18:40:50.659] List of future strategies:
[18:40:50.659] 1. sequential:
[18:40:50.659]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.659]    - tweaked: FALSE
[18:40:50.659]    - call: NULL
[18:40:50.660] plan(): nbrOfWorkers() = 1
[18:40:50.663] plan(): Setting new future strategy stack:
[18:40:50.663] List of future strategies:
[18:40:50.663] 1. sequential:
[18:40:50.663]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.663]    - tweaked: FALSE
[18:40:50.663]    - call: plan(strategy)
[18:40:50.664] plan(): nbrOfWorkers() = 1
[18:40:50.664] SequentialFuture started (and completed)
[18:40:50.665] - Launch lazy future ... done
[18:40:50.665] run() for 'SequentialFuture' ... done
[18:40:50.665] Created future:
[18:40:50.665] SequentialFuture:
[18:40:50.665] Label: 'future_by-1'
[18:40:50.665] Expression:
[18:40:50.665] {
[18:40:50.665]     do.call(function(...) {
[18:40:50.665]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.665]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.665]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.665]             on.exit(options(oopts), add = TRUE)
[18:40:50.665]         }
[18:40:50.665]         {
[18:40:50.665]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.665]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.665]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.665]             })
[18:40:50.665]         }
[18:40:50.665]     }, args = future.call.arguments)
[18:40:50.665] }
[18:40:50.665] Lazy evaluation: FALSE
[18:40:50.665] Asynchronous evaluation: FALSE
[18:40:50.665] Local evaluation: TRUE
[18:40:50.665] Environment: R_GlobalEnv
[18:40:50.665] Capture standard output: TRUE
[18:40:50.665] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:50.665] Globals: 5 objects totaling 998 bytes (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 152 bytes, list '...future.elements_ii' of 511 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:50.665] Packages: <none>
[18:40:50.665] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:50.665] Resolved: TRUE
[18:40:50.665] Value: 1.27 KiB of class 'list'
[18:40:50.665] Early signaling: FALSE
[18:40:50.665] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:50.665] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.667] Chunk #1 of 1 ... DONE
[18:40:50.667] Launching 1 futures (chunks) ... DONE
[18:40:50.667] Resolving 1 futures (chunks) ...
[18:40:50.667] resolve() on list ...
[18:40:50.668]  recursive: 0
[18:40:50.668]  length: 1
[18:40:50.668] 
[18:40:50.668] resolved() for 'SequentialFuture' ...
[18:40:50.668] - state: 'finished'
[18:40:50.669] - run: TRUE
[18:40:50.669] - result: 'FutureResult'
[18:40:50.669] resolved() for 'SequentialFuture' ... done
[18:40:50.669] Future #1
[18:40:50.670] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:50.670] - nx: 1
[18:40:50.670] - relay: TRUE
[18:40:50.670] - stdout: TRUE
[18:40:50.670] - signal: TRUE
[18:40:50.671] - resignal: FALSE
[18:40:50.671] - force: TRUE
[18:40:50.671] - relayed: [n=1] FALSE
[18:40:50.671] - queued futures: [n=1] FALSE
[18:40:50.671]  - until=1
[18:40:50.671]  - relaying element #1
[18:40:50.672] - relayed: [n=1] TRUE
[18:40:50.672] - queued futures: [n=1] TRUE
[18:40:50.672] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:50.672]  length: 0 (resolved future 1)
[18:40:50.673] Relaying remaining futures
[18:40:50.673] signalConditionsASAP(NULL, pos=0) ...
[18:40:50.673] - nx: 1
[18:40:50.673] - relay: TRUE
[18:40:50.673] - stdout: TRUE
[18:40:50.674] - signal: TRUE
[18:40:50.674] - resignal: FALSE
[18:40:50.674] - force: TRUE
[18:40:50.674] - relayed: [n=1] TRUE
[18:40:50.674] - queued futures: [n=1] TRUE
 - flush all
[18:40:50.675] - relayed: [n=1] TRUE
[18:40:50.675] - queued futures: [n=1] TRUE
[18:40:50.675] signalConditionsASAP(NULL, pos=0) ... done
[18:40:50.675] resolve() on list ... DONE
[18:40:50.675]  - Number of value chunks collected: 1
[18:40:50.676] Resolving 1 futures (chunks) ... DONE
[18:40:50.676] Reducing values from 1 chunks ...
[18:40:50.676]  - Number of values collected after concatenation: 6
[18:40:50.676]  - Number of values expected: 6
[18:40:50.676] Reducing values from 1 chunks ... DONE
[18:40:50.677] future_lapply() ... DONE
[18:40:50.677] future_by_internal() ... DONE
[18:40:50.681] future_by_internal() ...
[18:40:50.682] future_lapply() ...
[18:40:50.683] Number of chunks: 1
[18:40:50.684] getGlobalsAndPackagesXApply() ...
[18:40:50.684]  - future.globals: TRUE
[18:40:50.684] getGlobalsAndPackages() ...
[18:40:50.684] Searching for globals...
[18:40:50.687] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:50.687] Searching for globals ... DONE
[18:40:50.687] Resolving globals: FALSE
[18:40:50.688] The total size of the 1 globals is 762 bytes (762 bytes)
[18:40:50.688] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 762 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (762 bytes of class 'function')
[18:40:50.689] - globals: [1] 'FUN'
[18:40:50.689] - packages: [1] 'stats'
[18:40:50.689] getGlobalsAndPackages() ... DONE
[18:40:50.689]  - globals found/used: [n=1] 'FUN'
[18:40:50.689]  - needed namespaces: [n=1] 'stats'
[18:40:50.689] Finding globals ... DONE
[18:40:50.690]  - use_args: TRUE
[18:40:50.690]  - Getting '...' globals ...
[18:40:50.690] resolve() on list ...
[18:40:50.691]  recursive: 0
[18:40:50.691]  length: 1
[18:40:50.691]  elements: '...'
[18:40:50.691]  length: 0 (resolved future 1)
[18:40:50.691] resolve() on list ... DONE
[18:40:50.691]    - '...' content: [n=1] 'singular.ok'
[18:40:50.692] List of 1
[18:40:50.692]  $ ...:List of 1
[18:40:50.692]   ..$ singular.ok: logi FALSE
[18:40:50.692]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.692]  - attr(*, "where")=List of 1
[18:40:50.692]   ..$ ...:<environment: 0x000001cd50717008> 
[18:40:50.692]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.692]  - attr(*, "resolved")= logi TRUE
[18:40:50.692]  - attr(*, "total_size")= num NA
[18:40:50.696]  - Getting '...' globals ... DONE
[18:40:50.696] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:50.696] List of 2
[18:40:50.696]  $ ...future.FUN:function (x, ...)  
[18:40:50.696]  $ ...          :List of 1
[18:40:50.696]   ..$ singular.ok: logi FALSE
[18:40:50.696]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.696]  - attr(*, "where")=List of 2
[18:40:50.696]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.696]   ..$ ...          :<environment: 0x000001cd50717008> 
[18:40:50.696]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.696]  - attr(*, "resolved")= logi FALSE
[18:40:50.696]  - attr(*, "total_size")= int 19977
[18:40:50.700] Packages to be attached in all futures: [n=1] 'stats'
[18:40:50.701] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.701] Number of futures (= number of chunks): 1
[18:40:50.701] Launching 1 futures (chunks) ...
[18:40:50.701] Chunk #1 of 1 ...
[18:40:50.702]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.702] getGlobalsAndPackages() ...
[18:40:50.702] Searching for globals...
[18:40:50.703] 
[18:40:50.703] Searching for globals ... DONE
[18:40:50.703] - globals: [0] <none>
[18:40:50.703] getGlobalsAndPackages() ... DONE
[18:40:50.703]    + additional globals found: [n=0] 
[18:40:50.704]    + additional namespaces needed: [n=0] 
[18:40:50.704]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.704]  - seeds: <none>
[18:40:50.704]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.704] getGlobalsAndPackages() ...
[18:40:50.704] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.705] Resolving globals: FALSE
[18:40:50.705] Tweak future expression to call with '...' arguments ...
[18:40:50.705] {
[18:40:50.705]     do.call(function(...) {
[18:40:50.705]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.705]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.705]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.705]             on.exit(options(oopts), add = TRUE)
[18:40:50.705]         }
[18:40:50.705]         {
[18:40:50.705]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.705]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.705]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.705]             })
[18:40:50.705]         }
[18:40:50.705]     }, args = future.call.arguments)
[18:40:50.705] }
[18:40:50.706] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.706] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.706] 
[18:40:50.707] getGlobalsAndPackages() ... DONE
[18:40:50.707] run() for 'Future' ...
[18:40:50.707] - state: 'created'
[18:40:50.707] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:50.708] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.708] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.708]   - Field: 'label'
[18:40:50.708]   - Field: 'local'
[18:40:50.709]   - Field: 'owner'
[18:40:50.709]   - Field: 'envir'
[18:40:50.709]   - Field: 'packages'
[18:40:50.709]   - Field: 'gc'
[18:40:50.709]   - Field: 'conditions'
[18:40:50.710]   - Field: 'expr'
[18:40:50.710]   - Field: 'uuid'
[18:40:50.710]   - Field: 'seed'
[18:40:50.710]   - Field: 'version'
[18:40:50.710]   - Field: 'result'
[18:40:50.711]   - Field: 'asynchronous'
[18:40:50.711]   - Field: 'calls'
[18:40:50.711]   - Field: 'globals'
[18:40:50.711]   - Field: 'stdout'
[18:40:50.711]   - Field: 'earlySignal'
[18:40:50.712]   - Field: 'lazy'
[18:40:50.712]   - Field: 'state'
[18:40:50.712] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.712] - Launch lazy future ...
[18:40:50.712] Packages needed by the future expression (n = 1): 'stats'
[18:40:50.713] Packages needed by future strategies (n = 0): <none>
[18:40:50.713] {
[18:40:50.713]     {
[18:40:50.713]         {
[18:40:50.713]             ...future.startTime <- base::Sys.time()
[18:40:50.713]             {
[18:40:50.713]                 {
[18:40:50.713]                   {
[18:40:50.713]                     {
[18:40:50.713]                       base::local({
[18:40:50.713]                         has_future <- base::requireNamespace("future", 
[18:40:50.713]                           quietly = TRUE)
[18:40:50.713]                         if (has_future) {
[18:40:50.713]                           ns <- base::getNamespace("future")
[18:40:50.713]                           version <- ns[[".package"]][["version"]]
[18:40:50.713]                           if (is.null(version)) 
[18:40:50.713]                             version <- utils::packageVersion("future")
[18:40:50.713]                         }
[18:40:50.713]                         else {
[18:40:50.713]                           version <- NULL
[18:40:50.713]                         }
[18:40:50.713]                         if (!has_future || version < "1.8.0") {
[18:40:50.713]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.713]                             "", base::R.version$version.string), 
[18:40:50.713]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:50.713]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.713]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.713]                               "release", "version")], collapse = " "), 
[18:40:50.713]                             hostname = base::Sys.info()[["nodename"]])
[18:40:50.713]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.713]                             info)
[18:40:50.713]                           info <- base::paste(info, collapse = "; ")
[18:40:50.713]                           if (!has_future) {
[18:40:50.713]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.713]                               info)
[18:40:50.713]                           }
[18:40:50.713]                           else {
[18:40:50.713]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.713]                               info, version)
[18:40:50.713]                           }
[18:40:50.713]                           base::stop(msg)
[18:40:50.713]                         }
[18:40:50.713]                       })
[18:40:50.713]                     }
[18:40:50.713]                     base::local({
[18:40:50.713]                       for (pkg in "stats") {
[18:40:50.713]                         base::loadNamespace(pkg)
[18:40:50.713]                         base::library(pkg, character.only = TRUE)
[18:40:50.713]                       }
[18:40:50.713]                     })
[18:40:50.713]                   }
[18:40:50.713]                   ...future.strategy.old <- future::plan("list")
[18:40:50.713]                   options(future.plan = NULL)
[18:40:50.713]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.713]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.713]                 }
[18:40:50.713]                 ...future.workdir <- getwd()
[18:40:50.713]             }
[18:40:50.713]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.713]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.713]         }
[18:40:50.713]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.713]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.713]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.713]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.713]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.713]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.713]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.713]             base::names(...future.oldOptions))
[18:40:50.713]     }
[18:40:50.713]     if (FALSE) {
[18:40:50.713]     }
[18:40:50.713]     else {
[18:40:50.713]         if (TRUE) {
[18:40:50.713]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.713]                 open = "w")
[18:40:50.713]         }
[18:40:50.713]         else {
[18:40:50.713]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.713]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.713]         }
[18:40:50.713]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.713]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.713]             base::sink(type = "output", split = FALSE)
[18:40:50.713]             base::close(...future.stdout)
[18:40:50.713]         }, add = TRUE)
[18:40:50.713]     }
[18:40:50.713]     ...future.frame <- base::sys.nframe()
[18:40:50.713]     ...future.conditions <- base::list()
[18:40:50.713]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.713]     if (FALSE) {
[18:40:50.713]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.713]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.713]     }
[18:40:50.713]     ...future.result <- base::tryCatch({
[18:40:50.713]         base::withCallingHandlers({
[18:40:50.713]             ...future.value <- base::withVisible(base::local({
[18:40:50.713]                 do.call(function(...) {
[18:40:50.713]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.713]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.713]                     ...future.globals.maxSize)) {
[18:40:50.713]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.713]                     on.exit(options(oopts), add = TRUE)
[18:40:50.713]                   }
[18:40:50.713]                   {
[18:40:50.713]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.713]                       FUN = function(jj) {
[18:40:50.713]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.713]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.713]                       })
[18:40:50.713]                   }
[18:40:50.713]                 }, args = future.call.arguments)
[18:40:50.713]             }))
[18:40:50.713]             future::FutureResult(value = ...future.value$value, 
[18:40:50.713]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.713]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.713]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.713]                     ...future.globalenv.names))
[18:40:50.713]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.713]         }, condition = base::local({
[18:40:50.713]             c <- base::c
[18:40:50.713]             inherits <- base::inherits
[18:40:50.713]             invokeRestart <- base::invokeRestart
[18:40:50.713]             length <- base::length
[18:40:50.713]             list <- base::list
[18:40:50.713]             seq.int <- base::seq.int
[18:40:50.713]             signalCondition <- base::signalCondition
[18:40:50.713]             sys.calls <- base::sys.calls
[18:40:50.713]             `[[` <- base::`[[`
[18:40:50.713]             `+` <- base::`+`
[18:40:50.713]             `<<-` <- base::`<<-`
[18:40:50.713]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.713]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.713]                   3L)]
[18:40:50.713]             }
[18:40:50.713]             function(cond) {
[18:40:50.713]                 is_error <- inherits(cond, "error")
[18:40:50.713]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.713]                   NULL)
[18:40:50.713]                 if (is_error) {
[18:40:50.713]                   sessionInformation <- function() {
[18:40:50.713]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.713]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.713]                       search = base::search(), system = base::Sys.info())
[18:40:50.713]                   }
[18:40:50.713]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.713]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.713]                     cond$call), session = sessionInformation(), 
[18:40:50.713]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.713]                   signalCondition(cond)
[18:40:50.713]                 }
[18:40:50.713]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.713]                 "immediateCondition"))) {
[18:40:50.713]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.713]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.713]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.713]                   if (TRUE && !signal) {
[18:40:50.713]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.713]                     {
[18:40:50.713]                       inherits <- base::inherits
[18:40:50.713]                       invokeRestart <- base::invokeRestart
[18:40:50.713]                       is.null <- base::is.null
[18:40:50.713]                       muffled <- FALSE
[18:40:50.713]                       if (inherits(cond, "message")) {
[18:40:50.713]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.713]                         if (muffled) 
[18:40:50.713]                           invokeRestart("muffleMessage")
[18:40:50.713]                       }
[18:40:50.713]                       else if (inherits(cond, "warning")) {
[18:40:50.713]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.713]                         if (muffled) 
[18:40:50.713]                           invokeRestart("muffleWarning")
[18:40:50.713]                       }
[18:40:50.713]                       else if (inherits(cond, "condition")) {
[18:40:50.713]                         if (!is.null(pattern)) {
[18:40:50.713]                           computeRestarts <- base::computeRestarts
[18:40:50.713]                           grepl <- base::grepl
[18:40:50.713]                           restarts <- computeRestarts(cond)
[18:40:50.713]                           for (restart in restarts) {
[18:40:50.713]                             name <- restart$name
[18:40:50.713]                             if (is.null(name)) 
[18:40:50.713]                               next
[18:40:50.713]                             if (!grepl(pattern, name)) 
[18:40:50.713]                               next
[18:40:50.713]                             invokeRestart(restart)
[18:40:50.713]                             muffled <- TRUE
[18:40:50.713]                             break
[18:40:50.713]                           }
[18:40:50.713]                         }
[18:40:50.713]                       }
[18:40:50.713]                       invisible(muffled)
[18:40:50.713]                     }
[18:40:50.713]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.713]                   }
[18:40:50.713]                 }
[18:40:50.713]                 else {
[18:40:50.713]                   if (TRUE) {
[18:40:50.713]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.713]                     {
[18:40:50.713]                       inherits <- base::inherits
[18:40:50.713]                       invokeRestart <- base::invokeRestart
[18:40:50.713]                       is.null <- base::is.null
[18:40:50.713]                       muffled <- FALSE
[18:40:50.713]                       if (inherits(cond, "message")) {
[18:40:50.713]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.713]                         if (muffled) 
[18:40:50.713]                           invokeRestart("muffleMessage")
[18:40:50.713]                       }
[18:40:50.713]                       else if (inherits(cond, "warning")) {
[18:40:50.713]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.713]                         if (muffled) 
[18:40:50.713]                           invokeRestart("muffleWarning")
[18:40:50.713]                       }
[18:40:50.713]                       else if (inherits(cond, "condition")) {
[18:40:50.713]                         if (!is.null(pattern)) {
[18:40:50.713]                           computeRestarts <- base::computeRestarts
[18:40:50.713]                           grepl <- base::grepl
[18:40:50.713]                           restarts <- computeRestarts(cond)
[18:40:50.713]                           for (restart in restarts) {
[18:40:50.713]                             name <- restart$name
[18:40:50.713]                             if (is.null(name)) 
[18:40:50.713]                               next
[18:40:50.713]                             if (!grepl(pattern, name)) 
[18:40:50.713]                               next
[18:40:50.713]                             invokeRestart(restart)
[18:40:50.713]                             muffled <- TRUE
[18:40:50.713]                             break
[18:40:50.713]                           }
[18:40:50.713]                         }
[18:40:50.713]                       }
[18:40:50.713]                       invisible(muffled)
[18:40:50.713]                     }
[18:40:50.713]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.713]                   }
[18:40:50.713]                 }
[18:40:50.713]             }
[18:40:50.713]         }))
[18:40:50.713]     }, error = function(ex) {
[18:40:50.713]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.713]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.713]                 ...future.rng), started = ...future.startTime, 
[18:40:50.713]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.713]             version = "1.8"), class = "FutureResult")
[18:40:50.713]     }, finally = {
[18:40:50.713]         if (!identical(...future.workdir, getwd())) 
[18:40:50.713]             setwd(...future.workdir)
[18:40:50.713]         {
[18:40:50.713]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.713]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.713]             }
[18:40:50.713]             base::options(...future.oldOptions)
[18:40:50.713]             if (.Platform$OS.type == "windows") {
[18:40:50.713]                 old_names <- names(...future.oldEnvVars)
[18:40:50.713]                 envs <- base::Sys.getenv()
[18:40:50.713]                 names <- names(envs)
[18:40:50.713]                 common <- intersect(names, old_names)
[18:40:50.713]                 added <- setdiff(names, old_names)
[18:40:50.713]                 removed <- setdiff(old_names, names)
[18:40:50.713]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.713]                   envs[common]]
[18:40:50.713]                 NAMES <- toupper(changed)
[18:40:50.713]                 args <- list()
[18:40:50.713]                 for (kk in seq_along(NAMES)) {
[18:40:50.713]                   name <- changed[[kk]]
[18:40:50.713]                   NAME <- NAMES[[kk]]
[18:40:50.713]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.713]                     next
[18:40:50.713]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.713]                 }
[18:40:50.713]                 NAMES <- toupper(added)
[18:40:50.713]                 for (kk in seq_along(NAMES)) {
[18:40:50.713]                   name <- added[[kk]]
[18:40:50.713]                   NAME <- NAMES[[kk]]
[18:40:50.713]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.713]                     next
[18:40:50.713]                   args[[name]] <- ""
[18:40:50.713]                 }
[18:40:50.713]                 NAMES <- toupper(removed)
[18:40:50.713]                 for (kk in seq_along(NAMES)) {
[18:40:50.713]                   name <- removed[[kk]]
[18:40:50.713]                   NAME <- NAMES[[kk]]
[18:40:50.713]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.713]                     next
[18:40:50.713]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.713]                 }
[18:40:50.713]                 if (length(args) > 0) 
[18:40:50.713]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.713]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.713]             }
[18:40:50.713]             else {
[18:40:50.713]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.713]             }
[18:40:50.713]             {
[18:40:50.713]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.713]                   0L) {
[18:40:50.713]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.713]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.713]                   base::options(opts)
[18:40:50.713]                 }
[18:40:50.713]                 {
[18:40:50.713]                   {
[18:40:50.713]                     NULL
[18:40:50.713]                     RNGkind("Mersenne-Twister")
[18:40:50.713]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.713]                       inherits = FALSE)
[18:40:50.713]                   }
[18:40:50.713]                   options(future.plan = NULL)
[18:40:50.713]                   if (is.na(NA_character_)) 
[18:40:50.713]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.713]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.713]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.713]                     .init = FALSE)
[18:40:50.713]                 }
[18:40:50.713]             }
[18:40:50.713]         }
[18:40:50.713]     })
[18:40:50.713]     if (TRUE) {
[18:40:50.713]         base::sink(type = "output", split = FALSE)
[18:40:50.713]         if (TRUE) {
[18:40:50.713]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.713]         }
[18:40:50.713]         else {
[18:40:50.713]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.713]         }
[18:40:50.713]         base::close(...future.stdout)
[18:40:50.713]         ...future.stdout <- NULL
[18:40:50.713]     }
[18:40:50.713]     ...future.result$conditions <- ...future.conditions
[18:40:50.713]     ...future.result$finished <- base::Sys.time()
[18:40:50.713]     ...future.result
[18:40:50.713] }
[18:40:50.717] assign_globals() ...
[18:40:50.718] List of 5
[18:40:50.718]  $ ...future.FUN            :function (x, ...)  
[18:40:50.718]  $ future.call.arguments    :List of 1
[18:40:50.718]   ..$ singular.ok: logi FALSE
[18:40:50.718]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.718]  $ ...future.elements_ii    :List of 3
[18:40:50.718]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.718]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:50.718]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.718]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:50.718]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.718]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:50.718]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.718]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:50.718]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.718]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:50.718]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.718]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:50.718]  $ ...future.seeds_ii       : NULL
[18:40:50.718]  $ ...future.globals.maxSize: NULL
[18:40:50.718]  - attr(*, "where")=List of 5
[18:40:50.718]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.718]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.718]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.718]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.718]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.718]  - attr(*, "resolved")= logi FALSE
[18:40:50.718]  - attr(*, "total_size")= num 19977
[18:40:50.718]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.718]  - attr(*, "already-done")= logi TRUE
[18:40:50.731] - reassign environment for '...future.FUN'
[18:40:50.731] - copied '...future.FUN' to environment
[18:40:50.732] - copied 'future.call.arguments' to environment
[18:40:50.732] - copied '...future.elements_ii' to environment
[18:40:50.732] - copied '...future.seeds_ii' to environment
[18:40:50.732] - copied '...future.globals.maxSize' to environment
[18:40:50.732] assign_globals() ... done
[18:40:50.733] plan(): Setting new future strategy stack:
[18:40:50.733] List of future strategies:
[18:40:50.733] 1. sequential:
[18:40:50.733]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.733]    - tweaked: FALSE
[18:40:50.733]    - call: NULL
[18:40:50.734] plan(): nbrOfWorkers() = 1
[18:40:50.739] plan(): Setting new future strategy stack:
[18:40:50.739] List of future strategies:
[18:40:50.739] 1. sequential:
[18:40:50.739]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.739]    - tweaked: FALSE
[18:40:50.739]    - call: plan(strategy)
[18:40:50.740] plan(): nbrOfWorkers() = 1
[18:40:50.740] SequentialFuture started (and completed)
[18:40:50.740] - Launch lazy future ... done
[18:40:50.740] run() for 'SequentialFuture' ... done
[18:40:50.741] Created future:
[18:40:50.741] SequentialFuture:
[18:40:50.741] Label: 'future_by-1'
[18:40:50.741] Expression:
[18:40:50.741] {
[18:40:50.741]     do.call(function(...) {
[18:40:50.741]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.741]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.741]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.741]             on.exit(options(oopts), add = TRUE)
[18:40:50.741]         }
[18:40:50.741]         {
[18:40:50.741]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.741]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.741]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.741]             })
[18:40:50.741]         }
[18:40:50.741]     }, args = future.call.arguments)
[18:40:50.741] }
[18:40:50.741] Lazy evaluation: FALSE
[18:40:50.741] Asynchronous evaluation: FALSE
[18:40:50.741] Local evaluation: TRUE
[18:40:50.741] Environment: R_GlobalEnv
[18:40:50.741] Capture standard output: TRUE
[18:40:50.741] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:50.741] Globals: 5 objects totaling 2.93 KiB (function '...future.FUN' of 762 bytes, DotDotDotList 'future.call.arguments' of 157 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:50.741] Packages: 1 packages ('stats')
[18:40:50.741] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:50.741] Resolved: TRUE
[18:40:50.741] Value: 85.42 KiB of class 'list'
[18:40:50.741] Early signaling: FALSE
[18:40:50.741] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:50.741] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.743] Chunk #1 of 1 ... DONE
[18:40:50.743] Launching 1 futures (chunks) ... DONE
[18:40:50.743] Resolving 1 futures (chunks) ...
[18:40:50.743] resolve() on list ...
[18:40:50.743]  recursive: 0
[18:40:50.744]  length: 1
[18:40:50.744] 
[18:40:50.744] resolved() for 'SequentialFuture' ...
[18:40:50.744] - state: 'finished'
[18:40:50.744] - run: TRUE
[18:40:50.745] - result: 'FutureResult'
[18:40:50.745] resolved() for 'SequentialFuture' ... done
[18:40:50.745] Future #1
[18:40:50.745] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:50.745] - nx: 1
[18:40:50.746] - relay: TRUE
[18:40:50.746] - stdout: TRUE
[18:40:50.746] - signal: TRUE
[18:40:50.746] - resignal: FALSE
[18:40:50.746] - force: TRUE
[18:40:50.746] - relayed: [n=1] FALSE
[18:40:50.747] - queued futures: [n=1] FALSE
[18:40:50.747]  - until=1
[18:40:50.747]  - relaying element #1
[18:40:50.747] - relayed: [n=1] TRUE
[18:40:50.747] - queued futures: [n=1] TRUE
[18:40:50.748] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:50.748]  length: 0 (resolved future 1)
[18:40:50.748] Relaying remaining futures
[18:40:50.748] signalConditionsASAP(NULL, pos=0) ...
[18:40:50.748] - nx: 1
[18:40:50.749] - relay: TRUE
[18:40:50.749] - stdout: TRUE
[18:40:50.749] - signal: TRUE
[18:40:50.749] - resignal: FALSE
[18:40:50.749] - force: TRUE
[18:40:50.750] - relayed: [n=1] TRUE
[18:40:50.750] - queued futures: [n=1] TRUE
 - flush all
[18:40:50.750] - relayed: [n=1] TRUE
[18:40:50.750] - queued futures: [n=1] TRUE
[18:40:50.750] signalConditionsASAP(NULL, pos=0) ... done
[18:40:50.751] resolve() on list ... DONE
[18:40:50.751]  - Number of value chunks collected: 1
[18:40:50.751] Resolving 1 futures (chunks) ... DONE
[18:40:50.751] Reducing values from 1 chunks ...
[18:40:50.751]  - Number of values collected after concatenation: 3
[18:40:50.752]  - Number of values expected: 3
[18:40:50.752] Reducing values from 1 chunks ... DONE
[18:40:50.752] future_lapply() ... DONE
[18:40:50.752] future_by_internal() ... DONE
[18:40:50.758] future_by_internal() ...
[18:40:50.759] future_lapply() ...
[18:40:50.760] Number of chunks: 1
[18:40:50.760] getGlobalsAndPackagesXApply() ...
[18:40:50.760]  - future.globals: TRUE
[18:40:50.761] getGlobalsAndPackages() ...
[18:40:50.761] Searching for globals...
[18:40:50.765] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:50.765] Searching for globals ... DONE
[18:40:50.765] Resolving globals: FALSE
[18:40:50.766] The total size of the 3 globals is 2.07 KiB (2118 bytes)
[18:40:50.766] The total size of the 3 globals exported for future expression ('FUN()') is 2.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.28 KiB of class 'function'), 'breaks' (463 bytes of class 'numeric') and 'wool' (342 bytes of class 'numeric')
[18:40:50.767] - globals: [3] 'FUN', 'breaks', 'wool'
[18:40:50.767] - packages: [1] 'stats'
[18:40:50.767] getGlobalsAndPackages() ... DONE
[18:40:50.767]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[18:40:50.767]  - needed namespaces: [n=1] 'stats'
[18:40:50.767] Finding globals ... DONE
[18:40:50.768]  - use_args: TRUE
[18:40:50.768]  - Getting '...' globals ...
[18:40:50.768] resolve() on list ...
[18:40:50.768]  recursive: 0
[18:40:50.769]  length: 1
[18:40:50.769]  elements: '...'
[18:40:50.769]  length: 0 (resolved future 1)
[18:40:50.769] resolve() on list ... DONE
[18:40:50.769]    - '...' content: [n=0] 
[18:40:50.769] List of 1
[18:40:50.769]  $ ...: list()
[18:40:50.769]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.769]  - attr(*, "where")=List of 1
[18:40:50.769]   ..$ ...:<environment: 0x000001cd524bd530> 
[18:40:50.769]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.769]  - attr(*, "resolved")= logi TRUE
[18:40:50.769]  - attr(*, "total_size")= num NA
[18:40:50.772]  - Getting '...' globals ... DONE
[18:40:50.773] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[18:40:50.773] List of 4
[18:40:50.773]  $ ...future.FUN:function (x)  
[18:40:50.773]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:50.773]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:50.773]  $ ...          : list()
[18:40:50.773]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.773]  - attr(*, "where")=List of 4
[18:40:50.773]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.773]   ..$ breaks       :<environment: R_EmptyEnv> 
[18:40:50.773]   ..$ wool         :<environment: R_EmptyEnv> 
[18:40:50.773]   ..$ ...          :<environment: 0x000001cd524bd530> 
[18:40:50.773]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.773]  - attr(*, "resolved")= logi FALSE
[18:40:50.773]  - attr(*, "total_size")= int 18867
[18:40:50.777] Packages to be attached in all futures: [n=1] 'stats'
[18:40:50.778] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.778] Number of futures (= number of chunks): 1
[18:40:50.778] Launching 1 futures (chunks) ...
[18:40:50.778] Chunk #1 of 1 ...
[18:40:50.778]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.779] getGlobalsAndPackages() ...
[18:40:50.779] Searching for globals...
[18:40:50.779] 
[18:40:50.780] Searching for globals ... DONE
[18:40:50.780] - globals: [0] <none>
[18:40:50.780] getGlobalsAndPackages() ... DONE
[18:40:50.780]    + additional globals found: [n=0] 
[18:40:50.780]    + additional namespaces needed: [n=0] 
[18:40:50.780]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.780]  - seeds: <none>
[18:40:50.781]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.781] getGlobalsAndPackages() ...
[18:40:50.781] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.781] Resolving globals: FALSE
[18:40:50.781] Tweak future expression to call with '...' arguments ...
[18:40:50.782] {
[18:40:50.782]     do.call(function(...) {
[18:40:50.782]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.782]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.782]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.782]             on.exit(options(oopts), add = TRUE)
[18:40:50.782]         }
[18:40:50.782]         {
[18:40:50.782]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.782]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.782]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.782]             })
[18:40:50.782]         }
[18:40:50.782]     }, args = future.call.arguments)
[18:40:50.782] }
[18:40:50.782] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.783] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.783] 
[18:40:50.783] getGlobalsAndPackages() ... DONE
[18:40:50.783] run() for 'Future' ...
[18:40:50.783] - state: 'created'
[18:40:50.784] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:50.784] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.784] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.784]   - Field: 'label'
[18:40:50.785]   - Field: 'local'
[18:40:50.785]   - Field: 'owner'
[18:40:50.785]   - Field: 'envir'
[18:40:50.785]   - Field: 'packages'
[18:40:50.785]   - Field: 'gc'
[18:40:50.785]   - Field: 'conditions'
[18:40:50.786]   - Field: 'expr'
[18:40:50.786]   - Field: 'uuid'
[18:40:50.786]   - Field: 'seed'
[18:40:50.786]   - Field: 'version'
[18:40:50.786]   - Field: 'result'
[18:40:50.786]   - Field: 'asynchronous'
[18:40:50.787]   - Field: 'calls'
[18:40:50.787]   - Field: 'globals'
[18:40:50.787]   - Field: 'stdout'
[18:40:50.787]   - Field: 'earlySignal'
[18:40:50.787]   - Field: 'lazy'
[18:40:50.788]   - Field: 'state'
[18:40:50.788] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.788] - Launch lazy future ...
[18:40:50.788] Packages needed by the future expression (n = 1): 'stats'
[18:40:50.788] Packages needed by future strategies (n = 0): <none>
[18:40:50.789] {
[18:40:50.789]     {
[18:40:50.789]         {
[18:40:50.789]             ...future.startTime <- base::Sys.time()
[18:40:50.789]             {
[18:40:50.789]                 {
[18:40:50.789]                   {
[18:40:50.789]                     {
[18:40:50.789]                       base::local({
[18:40:50.789]                         has_future <- base::requireNamespace("future", 
[18:40:50.789]                           quietly = TRUE)
[18:40:50.789]                         if (has_future) {
[18:40:50.789]                           ns <- base::getNamespace("future")
[18:40:50.789]                           version <- ns[[".package"]][["version"]]
[18:40:50.789]                           if (is.null(version)) 
[18:40:50.789]                             version <- utils::packageVersion("future")
[18:40:50.789]                         }
[18:40:50.789]                         else {
[18:40:50.789]                           version <- NULL
[18:40:50.789]                         }
[18:40:50.789]                         if (!has_future || version < "1.8.0") {
[18:40:50.789]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.789]                             "", base::R.version$version.string), 
[18:40:50.789]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:50.789]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.789]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.789]                               "release", "version")], collapse = " "), 
[18:40:50.789]                             hostname = base::Sys.info()[["nodename"]])
[18:40:50.789]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.789]                             info)
[18:40:50.789]                           info <- base::paste(info, collapse = "; ")
[18:40:50.789]                           if (!has_future) {
[18:40:50.789]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.789]                               info)
[18:40:50.789]                           }
[18:40:50.789]                           else {
[18:40:50.789]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.789]                               info, version)
[18:40:50.789]                           }
[18:40:50.789]                           base::stop(msg)
[18:40:50.789]                         }
[18:40:50.789]                       })
[18:40:50.789]                     }
[18:40:50.789]                     base::local({
[18:40:50.789]                       for (pkg in "stats") {
[18:40:50.789]                         base::loadNamespace(pkg)
[18:40:50.789]                         base::library(pkg, character.only = TRUE)
[18:40:50.789]                       }
[18:40:50.789]                     })
[18:40:50.789]                   }
[18:40:50.789]                   ...future.strategy.old <- future::plan("list")
[18:40:50.789]                   options(future.plan = NULL)
[18:40:50.789]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.789]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.789]                 }
[18:40:50.789]                 ...future.workdir <- getwd()
[18:40:50.789]             }
[18:40:50.789]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.789]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.789]         }
[18:40:50.789]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.789]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.789]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.789]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.789]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.789]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.789]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.789]             base::names(...future.oldOptions))
[18:40:50.789]     }
[18:40:50.789]     if (FALSE) {
[18:40:50.789]     }
[18:40:50.789]     else {
[18:40:50.789]         if (TRUE) {
[18:40:50.789]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.789]                 open = "w")
[18:40:50.789]         }
[18:40:50.789]         else {
[18:40:50.789]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.789]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.789]         }
[18:40:50.789]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.789]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.789]             base::sink(type = "output", split = FALSE)
[18:40:50.789]             base::close(...future.stdout)
[18:40:50.789]         }, add = TRUE)
[18:40:50.789]     }
[18:40:50.789]     ...future.frame <- base::sys.nframe()
[18:40:50.789]     ...future.conditions <- base::list()
[18:40:50.789]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.789]     if (FALSE) {
[18:40:50.789]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.789]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.789]     }
[18:40:50.789]     ...future.result <- base::tryCatch({
[18:40:50.789]         base::withCallingHandlers({
[18:40:50.789]             ...future.value <- base::withVisible(base::local({
[18:40:50.789]                 do.call(function(...) {
[18:40:50.789]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.789]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.789]                     ...future.globals.maxSize)) {
[18:40:50.789]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.789]                     on.exit(options(oopts), add = TRUE)
[18:40:50.789]                   }
[18:40:50.789]                   {
[18:40:50.789]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.789]                       FUN = function(jj) {
[18:40:50.789]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.789]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.789]                       })
[18:40:50.789]                   }
[18:40:50.789]                 }, args = future.call.arguments)
[18:40:50.789]             }))
[18:40:50.789]             future::FutureResult(value = ...future.value$value, 
[18:40:50.789]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.789]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.789]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.789]                     ...future.globalenv.names))
[18:40:50.789]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.789]         }, condition = base::local({
[18:40:50.789]             c <- base::c
[18:40:50.789]             inherits <- base::inherits
[18:40:50.789]             invokeRestart <- base::invokeRestart
[18:40:50.789]             length <- base::length
[18:40:50.789]             list <- base::list
[18:40:50.789]             seq.int <- base::seq.int
[18:40:50.789]             signalCondition <- base::signalCondition
[18:40:50.789]             sys.calls <- base::sys.calls
[18:40:50.789]             `[[` <- base::`[[`
[18:40:50.789]             `+` <- base::`+`
[18:40:50.789]             `<<-` <- base::`<<-`
[18:40:50.789]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.789]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.789]                   3L)]
[18:40:50.789]             }
[18:40:50.789]             function(cond) {
[18:40:50.789]                 is_error <- inherits(cond, "error")
[18:40:50.789]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.789]                   NULL)
[18:40:50.789]                 if (is_error) {
[18:40:50.789]                   sessionInformation <- function() {
[18:40:50.789]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.789]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.789]                       search = base::search(), system = base::Sys.info())
[18:40:50.789]                   }
[18:40:50.789]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.789]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.789]                     cond$call), session = sessionInformation(), 
[18:40:50.789]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.789]                   signalCondition(cond)
[18:40:50.789]                 }
[18:40:50.789]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.789]                 "immediateCondition"))) {
[18:40:50.789]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.789]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.789]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.789]                   if (TRUE && !signal) {
[18:40:50.789]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.789]                     {
[18:40:50.789]                       inherits <- base::inherits
[18:40:50.789]                       invokeRestart <- base::invokeRestart
[18:40:50.789]                       is.null <- base::is.null
[18:40:50.789]                       muffled <- FALSE
[18:40:50.789]                       if (inherits(cond, "message")) {
[18:40:50.789]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.789]                         if (muffled) 
[18:40:50.789]                           invokeRestart("muffleMessage")
[18:40:50.789]                       }
[18:40:50.789]                       else if (inherits(cond, "warning")) {
[18:40:50.789]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.789]                         if (muffled) 
[18:40:50.789]                           invokeRestart("muffleWarning")
[18:40:50.789]                       }
[18:40:50.789]                       else if (inherits(cond, "condition")) {
[18:40:50.789]                         if (!is.null(pattern)) {
[18:40:50.789]                           computeRestarts <- base::computeRestarts
[18:40:50.789]                           grepl <- base::grepl
[18:40:50.789]                           restarts <- computeRestarts(cond)
[18:40:50.789]                           for (restart in restarts) {
[18:40:50.789]                             name <- restart$name
[18:40:50.789]                             if (is.null(name)) 
[18:40:50.789]                               next
[18:40:50.789]                             if (!grepl(pattern, name)) 
[18:40:50.789]                               next
[18:40:50.789]                             invokeRestart(restart)
[18:40:50.789]                             muffled <- TRUE
[18:40:50.789]                             break
[18:40:50.789]                           }
[18:40:50.789]                         }
[18:40:50.789]                       }
[18:40:50.789]                       invisible(muffled)
[18:40:50.789]                     }
[18:40:50.789]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.789]                   }
[18:40:50.789]                 }
[18:40:50.789]                 else {
[18:40:50.789]                   if (TRUE) {
[18:40:50.789]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.789]                     {
[18:40:50.789]                       inherits <- base::inherits
[18:40:50.789]                       invokeRestart <- base::invokeRestart
[18:40:50.789]                       is.null <- base::is.null
[18:40:50.789]                       muffled <- FALSE
[18:40:50.789]                       if (inherits(cond, "message")) {
[18:40:50.789]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.789]                         if (muffled) 
[18:40:50.789]                           invokeRestart("muffleMessage")
[18:40:50.789]                       }
[18:40:50.789]                       else if (inherits(cond, "warning")) {
[18:40:50.789]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.789]                         if (muffled) 
[18:40:50.789]                           invokeRestart("muffleWarning")
[18:40:50.789]                       }
[18:40:50.789]                       else if (inherits(cond, "condition")) {
[18:40:50.789]                         if (!is.null(pattern)) {
[18:40:50.789]                           computeRestarts <- base::computeRestarts
[18:40:50.789]                           grepl <- base::grepl
[18:40:50.789]                           restarts <- computeRestarts(cond)
[18:40:50.789]                           for (restart in restarts) {
[18:40:50.789]                             name <- restart$name
[18:40:50.789]                             if (is.null(name)) 
[18:40:50.789]                               next
[18:40:50.789]                             if (!grepl(pattern, name)) 
[18:40:50.789]                               next
[18:40:50.789]                             invokeRestart(restart)
[18:40:50.789]                             muffled <- TRUE
[18:40:50.789]                             break
[18:40:50.789]                           }
[18:40:50.789]                         }
[18:40:50.789]                       }
[18:40:50.789]                       invisible(muffled)
[18:40:50.789]                     }
[18:40:50.789]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.789]                   }
[18:40:50.789]                 }
[18:40:50.789]             }
[18:40:50.789]         }))
[18:40:50.789]     }, error = function(ex) {
[18:40:50.789]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.789]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.789]                 ...future.rng), started = ...future.startTime, 
[18:40:50.789]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.789]             version = "1.8"), class = "FutureResult")
[18:40:50.789]     }, finally = {
[18:40:50.789]         if (!identical(...future.workdir, getwd())) 
[18:40:50.789]             setwd(...future.workdir)
[18:40:50.789]         {
[18:40:50.789]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.789]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.789]             }
[18:40:50.789]             base::options(...future.oldOptions)
[18:40:50.789]             if (.Platform$OS.type == "windows") {
[18:40:50.789]                 old_names <- names(...future.oldEnvVars)
[18:40:50.789]                 envs <- base::Sys.getenv()
[18:40:50.789]                 names <- names(envs)
[18:40:50.789]                 common <- intersect(names, old_names)
[18:40:50.789]                 added <- setdiff(names, old_names)
[18:40:50.789]                 removed <- setdiff(old_names, names)
[18:40:50.789]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.789]                   envs[common]]
[18:40:50.789]                 NAMES <- toupper(changed)
[18:40:50.789]                 args <- list()
[18:40:50.789]                 for (kk in seq_along(NAMES)) {
[18:40:50.789]                   name <- changed[[kk]]
[18:40:50.789]                   NAME <- NAMES[[kk]]
[18:40:50.789]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.789]                     next
[18:40:50.789]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.789]                 }
[18:40:50.789]                 NAMES <- toupper(added)
[18:40:50.789]                 for (kk in seq_along(NAMES)) {
[18:40:50.789]                   name <- added[[kk]]
[18:40:50.789]                   NAME <- NAMES[[kk]]
[18:40:50.789]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.789]                     next
[18:40:50.789]                   args[[name]] <- ""
[18:40:50.789]                 }
[18:40:50.789]                 NAMES <- toupper(removed)
[18:40:50.789]                 for (kk in seq_along(NAMES)) {
[18:40:50.789]                   name <- removed[[kk]]
[18:40:50.789]                   NAME <- NAMES[[kk]]
[18:40:50.789]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.789]                     next
[18:40:50.789]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.789]                 }
[18:40:50.789]                 if (length(args) > 0) 
[18:40:50.789]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.789]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.789]             }
[18:40:50.789]             else {
[18:40:50.789]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.789]             }
[18:40:50.789]             {
[18:40:50.789]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.789]                   0L) {
[18:40:50.789]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.789]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.789]                   base::options(opts)
[18:40:50.789]                 }
[18:40:50.789]                 {
[18:40:50.789]                   {
[18:40:50.789]                     NULL
[18:40:50.789]                     RNGkind("Mersenne-Twister")
[18:40:50.789]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.789]                       inherits = FALSE)
[18:40:50.789]                   }
[18:40:50.789]                   options(future.plan = NULL)
[18:40:50.789]                   if (is.na(NA_character_)) 
[18:40:50.789]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.789]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.789]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.789]                     .init = FALSE)
[18:40:50.789]                 }
[18:40:50.789]             }
[18:40:50.789]         }
[18:40:50.789]     })
[18:40:50.789]     if (TRUE) {
[18:40:50.789]         base::sink(type = "output", split = FALSE)
[18:40:50.789]         if (TRUE) {
[18:40:50.789]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.789]         }
[18:40:50.789]         else {
[18:40:50.789]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.789]         }
[18:40:50.789]         base::close(...future.stdout)
[18:40:50.789]         ...future.stdout <- NULL
[18:40:50.789]     }
[18:40:50.789]     ...future.result$conditions <- ...future.conditions
[18:40:50.789]     ...future.result$finished <- base::Sys.time()
[18:40:50.789]     ...future.result
[18:40:50.789] }
[18:40:50.793] assign_globals() ...
[18:40:50.793] List of 7
[18:40:50.793]  $ ...future.FUN            :function (x)  
[18:40:50.793]  $ breaks                   : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:50.793]  $ wool                     : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:50.793]  $ future.call.arguments    : list()
[18:40:50.793]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.793]  $ ...future.elements_ii    :List of 3
[18:40:50.793]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.793]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:50.793]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.793]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:50.793]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.793]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:50.793]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.793]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:50.793]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.793]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:50.793]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.793]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:50.793]  $ ...future.seeds_ii       : NULL
[18:40:50.793]  $ ...future.globals.maxSize: NULL
[18:40:50.793]  - attr(*, "where")=List of 7
[18:40:50.793]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.793]   ..$ breaks                   :<environment: R_EmptyEnv> 
[18:40:50.793]   ..$ wool                     :<environment: R_EmptyEnv> 
[18:40:50.793]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.793]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.793]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.793]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.793]  - attr(*, "resolved")= logi FALSE
[18:40:50.793]  - attr(*, "total_size")= num 18867
[18:40:50.793]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.793]  - attr(*, "already-done")= logi TRUE
[18:40:50.805] - reassign environment for '...future.FUN'
[18:40:50.805] - copied '...future.FUN' to environment
[18:40:50.805] - copied 'breaks' to environment
[18:40:50.806] - copied 'wool' to environment
[18:40:50.806] - copied 'future.call.arguments' to environment
[18:40:50.806] - copied '...future.elements_ii' to environment
[18:40:50.806] - copied '...future.seeds_ii' to environment
[18:40:50.806] - copied '...future.globals.maxSize' to environment
[18:40:50.806] assign_globals() ... done
[18:40:50.807] plan(): Setting new future strategy stack:
[18:40:50.807] List of future strategies:
[18:40:50.807] 1. sequential:
[18:40:50.807]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.807]    - tweaked: FALSE
[18:40:50.807]    - call: NULL
[18:40:50.808] plan(): nbrOfWorkers() = 1
[18:40:50.811] plan(): Setting new future strategy stack:
[18:40:50.812] List of future strategies:
[18:40:50.812] 1. sequential:
[18:40:50.812]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.812]    - tweaked: FALSE
[18:40:50.812]    - call: plan(strategy)
[18:40:50.812] plan(): nbrOfWorkers() = 1
[18:40:50.813] SequentialFuture started (and completed)
[18:40:50.813] - Launch lazy future ... done
[18:40:50.813] run() for 'SequentialFuture' ... done
[18:40:50.813] Created future:
[18:40:50.813] SequentialFuture:
[18:40:50.813] Label: 'future_by-1'
[18:40:50.813] Expression:
[18:40:50.813] {
[18:40:50.813]     do.call(function(...) {
[18:40:50.813]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.813]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.813]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.813]             on.exit(options(oopts), add = TRUE)
[18:40:50.813]         }
[18:40:50.813]         {
[18:40:50.813]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.813]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.813]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.813]             })
[18:40:50.813]         }
[18:40:50.813]     }, args = future.call.arguments)
[18:40:50.813] }
[18:40:50.813] Lazy evaluation: FALSE
[18:40:50.813] Asynchronous evaluation: FALSE
[18:40:50.813] Local evaluation: TRUE
[18:40:50.813] Environment: 0x000001cd52498ed8
[18:40:50.813] Capture standard output: TRUE
[18:40:50.813] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:50.813] Globals: 7 objects totaling 4.20 KiB (function '...future.FUN' of 1.28 KiB, numeric 'breaks' of 463 bytes, factor 'wool' of 342 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, ...)
[18:40:50.813] Packages: 1 packages ('stats')
[18:40:50.813] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:50.813] Resolved: TRUE
[18:40:50.813] Value: 86.77 KiB of class 'list'
[18:40:50.813] Early signaling: FALSE
[18:40:50.813] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:50.813] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.815] Chunk #1 of 1 ... DONE
[18:40:50.815] Launching 1 futures (chunks) ... DONE
[18:40:50.815] Resolving 1 futures (chunks) ...
[18:40:50.816] resolve() on list ...
[18:40:50.816]  recursive: 0
[18:40:50.816]  length: 1
[18:40:50.816] 
[18:40:50.816] resolved() for 'SequentialFuture' ...
[18:40:50.816] - state: 'finished'
[18:40:50.817] - run: TRUE
[18:40:50.817] - result: 'FutureResult'
[18:40:50.817] resolved() for 'SequentialFuture' ... done
[18:40:50.817] Future #1
[18:40:50.817] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:50.818] - nx: 1
[18:40:50.818] - relay: TRUE
[18:40:50.818] - stdout: TRUE
[18:40:50.818] - signal: TRUE
[18:40:50.818] - resignal: FALSE
[18:40:50.818] - force: TRUE
[18:40:50.818] - relayed: [n=1] FALSE
[18:40:50.819] - queued futures: [n=1] FALSE
[18:40:50.819]  - until=1
[18:40:50.819]  - relaying element #1
[18:40:50.819] - relayed: [n=1] TRUE
[18:40:50.819] - queued futures: [n=1] TRUE
[18:40:50.820] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:50.820]  length: 0 (resolved future 1)
[18:40:50.820] Relaying remaining futures
[18:40:50.820] signalConditionsASAP(NULL, pos=0) ...
[18:40:50.820] - nx: 1
[18:40:50.820] - relay: TRUE
[18:40:50.820] - stdout: TRUE
[18:40:50.821] - signal: TRUE
[18:40:50.821] - resignal: FALSE
[18:40:50.821] - force: TRUE
[18:40:50.821] - relayed: [n=1] TRUE
[18:40:50.821] - queued futures: [n=1] TRUE
 - flush all
[18:40:50.821] - relayed: [n=1] TRUE
[18:40:50.822] - queued futures: [n=1] TRUE
[18:40:50.822] signalConditionsASAP(NULL, pos=0) ... done
[18:40:50.822] resolve() on list ... DONE
[18:40:50.822]  - Number of value chunks collected: 1
[18:40:50.822] Resolving 1 futures (chunks) ... DONE
[18:40:50.822] Reducing values from 1 chunks ...
[18:40:50.823]  - Number of values collected after concatenation: 3
[18:40:50.823]  - Number of values expected: 3
[18:40:50.823] Reducing values from 1 chunks ... DONE
[18:40:50.823] future_lapply() ... DONE
[18:40:50.823] future_by_internal() ... DONE
[18:40:50.824] future_by_internal() ...
[18:40:50.824] future_lapply() ...
[18:40:50.825] Number of chunks: 1
[18:40:50.825] getGlobalsAndPackagesXApply() ...
[18:40:50.825]  - future.globals: TRUE
[18:40:50.825] getGlobalsAndPackages() ...
[18:40:50.825] Searching for globals...
[18:40:50.827] - globals found: [2] 'FUN', 'UseMethod'
[18:40:50.827] Searching for globals ... DONE
[18:40:50.827] Resolving globals: FALSE
[18:40:50.827] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:50.828] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:50.828] - globals: [1] 'FUN'
[18:40:50.828] 
[18:40:50.828] getGlobalsAndPackages() ... DONE
[18:40:50.829]  - globals found/used: [n=1] 'FUN'
[18:40:50.829]  - needed namespaces: [n=0] 
[18:40:50.829] Finding globals ... DONE
[18:40:50.829]  - use_args: TRUE
[18:40:50.829]  - Getting '...' globals ...
[18:40:50.830] resolve() on list ...
[18:40:50.830]  recursive: 0
[18:40:50.830]  length: 1
[18:40:50.830]  elements: '...'
[18:40:50.830]  length: 0 (resolved future 1)
[18:40:50.831] resolve() on list ... DONE
[18:40:50.831]    - '...' content: [n=0] 
[18:40:50.831] List of 1
[18:40:50.831]  $ ...: list()
[18:40:50.831]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.831]  - attr(*, "where")=List of 1
[18:40:50.831]   ..$ ...:<environment: 0x000001cd50f6acb8> 
[18:40:50.831]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.831]  - attr(*, "resolved")= logi TRUE
[18:40:50.831]  - attr(*, "total_size")= num NA
[18:40:50.834]  - Getting '...' globals ... DONE
[18:40:50.834] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:50.834] List of 2
[18:40:50.834]  $ ...future.FUN:function (object, ...)  
[18:40:50.834]  $ ...          : list()
[18:40:50.834]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.834]  - attr(*, "where")=List of 2
[18:40:50.834]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.834]   ..$ ...          :<environment: 0x000001cd50f6acb8> 
[18:40:50.834]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.834]  - attr(*, "resolved")= logi FALSE
[18:40:50.834]  - attr(*, "total_size")= int 18709
[18:40:50.838] Packages to be attached in all futures: [n=0] 
[18:40:50.838] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.838] Number of futures (= number of chunks): 1
[18:40:50.838] Launching 1 futures (chunks) ...
[18:40:50.838] Chunk #1 of 1 ...
[18:40:50.838]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.839] getGlobalsAndPackages() ...
[18:40:50.839] Searching for globals...
[18:40:50.839] 
[18:40:50.840] Searching for globals ... DONE
[18:40:50.840] - globals: [0] <none>
[18:40:50.840] getGlobalsAndPackages() ... DONE
[18:40:50.840]    + additional globals found: [n=0] 
[18:40:50.840]    + additional namespaces needed: [n=0] 
[18:40:50.840]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.841]  - seeds: <none>
[18:40:50.841]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.841] getGlobalsAndPackages() ...
[18:40:50.841] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.841] Resolving globals: FALSE
[18:40:50.841] Tweak future expression to call with '...' arguments ...
[18:40:50.842] {
[18:40:50.842]     do.call(function(...) {
[18:40:50.842]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.842]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.842]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.842]             on.exit(options(oopts), add = TRUE)
[18:40:50.842]         }
[18:40:50.842]         {
[18:40:50.842]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.842]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.842]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.842]             })
[18:40:50.842]         }
[18:40:50.842]     }, args = future.call.arguments)
[18:40:50.842] }
[18:40:50.842] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.843] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.843] 
[18:40:50.843] getGlobalsAndPackages() ... DONE
[18:40:50.843] run() for 'Future' ...
[18:40:50.844] - state: 'created'
[18:40:50.844] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:50.844] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.844] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.844]   - Field: 'label'
[18:40:50.845]   - Field: 'local'
[18:40:50.845]   - Field: 'owner'
[18:40:50.845]   - Field: 'envir'
[18:40:50.845]   - Field: 'packages'
[18:40:50.845]   - Field: 'gc'
[18:40:50.846]   - Field: 'conditions'
[18:40:50.846]   - Field: 'expr'
[18:40:50.846]   - Field: 'uuid'
[18:40:50.846]   - Field: 'seed'
[18:40:50.846]   - Field: 'version'
[18:40:50.846]   - Field: 'result'
[18:40:50.847]   - Field: 'asynchronous'
[18:40:50.847]   - Field: 'calls'
[18:40:50.847]   - Field: 'globals'
[18:40:50.847]   - Field: 'stdout'
[18:40:50.847]   - Field: 'earlySignal'
[18:40:50.847]   - Field: 'lazy'
[18:40:50.848]   - Field: 'state'
[18:40:50.848] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.848] - Launch lazy future ...
[18:40:50.848] Packages needed by the future expression (n = 0): <none>
[18:40:50.848] Packages needed by future strategies (n = 0): <none>
[18:40:50.849] {
[18:40:50.849]     {
[18:40:50.849]         {
[18:40:50.849]             ...future.startTime <- base::Sys.time()
[18:40:50.849]             {
[18:40:50.849]                 {
[18:40:50.849]                   {
[18:40:50.849]                     base::local({
[18:40:50.849]                       has_future <- base::requireNamespace("future", 
[18:40:50.849]                         quietly = TRUE)
[18:40:50.849]                       if (has_future) {
[18:40:50.849]                         ns <- base::getNamespace("future")
[18:40:50.849]                         version <- ns[[".package"]][["version"]]
[18:40:50.849]                         if (is.null(version)) 
[18:40:50.849]                           version <- utils::packageVersion("future")
[18:40:50.849]                       }
[18:40:50.849]                       else {
[18:40:50.849]                         version <- NULL
[18:40:50.849]                       }
[18:40:50.849]                       if (!has_future || version < "1.8.0") {
[18:40:50.849]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.849]                           "", base::R.version$version.string), 
[18:40:50.849]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:50.849]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.849]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.849]                             "release", "version")], collapse = " "), 
[18:40:50.849]                           hostname = base::Sys.info()[["nodename"]])
[18:40:50.849]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.849]                           info)
[18:40:50.849]                         info <- base::paste(info, collapse = "; ")
[18:40:50.849]                         if (!has_future) {
[18:40:50.849]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.849]                             info)
[18:40:50.849]                         }
[18:40:50.849]                         else {
[18:40:50.849]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.849]                             info, version)
[18:40:50.849]                         }
[18:40:50.849]                         base::stop(msg)
[18:40:50.849]                       }
[18:40:50.849]                     })
[18:40:50.849]                   }
[18:40:50.849]                   ...future.strategy.old <- future::plan("list")
[18:40:50.849]                   options(future.plan = NULL)
[18:40:50.849]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.849]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.849]                 }
[18:40:50.849]                 ...future.workdir <- getwd()
[18:40:50.849]             }
[18:40:50.849]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.849]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.849]         }
[18:40:50.849]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.849]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.849]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.849]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.849]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.849]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.849]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.849]             base::names(...future.oldOptions))
[18:40:50.849]     }
[18:40:50.849]     if (FALSE) {
[18:40:50.849]     }
[18:40:50.849]     else {
[18:40:50.849]         if (TRUE) {
[18:40:50.849]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.849]                 open = "w")
[18:40:50.849]         }
[18:40:50.849]         else {
[18:40:50.849]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.849]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.849]         }
[18:40:50.849]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.849]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.849]             base::sink(type = "output", split = FALSE)
[18:40:50.849]             base::close(...future.stdout)
[18:40:50.849]         }, add = TRUE)
[18:40:50.849]     }
[18:40:50.849]     ...future.frame <- base::sys.nframe()
[18:40:50.849]     ...future.conditions <- base::list()
[18:40:50.849]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.849]     if (FALSE) {
[18:40:50.849]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.849]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.849]     }
[18:40:50.849]     ...future.result <- base::tryCatch({
[18:40:50.849]         base::withCallingHandlers({
[18:40:50.849]             ...future.value <- base::withVisible(base::local({
[18:40:50.849]                 do.call(function(...) {
[18:40:50.849]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.849]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.849]                     ...future.globals.maxSize)) {
[18:40:50.849]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.849]                     on.exit(options(oopts), add = TRUE)
[18:40:50.849]                   }
[18:40:50.849]                   {
[18:40:50.849]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.849]                       FUN = function(jj) {
[18:40:50.849]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.849]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.849]                       })
[18:40:50.849]                   }
[18:40:50.849]                 }, args = future.call.arguments)
[18:40:50.849]             }))
[18:40:50.849]             future::FutureResult(value = ...future.value$value, 
[18:40:50.849]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.849]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.849]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.849]                     ...future.globalenv.names))
[18:40:50.849]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.849]         }, condition = base::local({
[18:40:50.849]             c <- base::c
[18:40:50.849]             inherits <- base::inherits
[18:40:50.849]             invokeRestart <- base::invokeRestart
[18:40:50.849]             length <- base::length
[18:40:50.849]             list <- base::list
[18:40:50.849]             seq.int <- base::seq.int
[18:40:50.849]             signalCondition <- base::signalCondition
[18:40:50.849]             sys.calls <- base::sys.calls
[18:40:50.849]             `[[` <- base::`[[`
[18:40:50.849]             `+` <- base::`+`
[18:40:50.849]             `<<-` <- base::`<<-`
[18:40:50.849]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.849]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.849]                   3L)]
[18:40:50.849]             }
[18:40:50.849]             function(cond) {
[18:40:50.849]                 is_error <- inherits(cond, "error")
[18:40:50.849]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.849]                   NULL)
[18:40:50.849]                 if (is_error) {
[18:40:50.849]                   sessionInformation <- function() {
[18:40:50.849]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.849]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.849]                       search = base::search(), system = base::Sys.info())
[18:40:50.849]                   }
[18:40:50.849]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.849]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.849]                     cond$call), session = sessionInformation(), 
[18:40:50.849]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.849]                   signalCondition(cond)
[18:40:50.849]                 }
[18:40:50.849]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.849]                 "immediateCondition"))) {
[18:40:50.849]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.849]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.849]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.849]                   if (TRUE && !signal) {
[18:40:50.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.849]                     {
[18:40:50.849]                       inherits <- base::inherits
[18:40:50.849]                       invokeRestart <- base::invokeRestart
[18:40:50.849]                       is.null <- base::is.null
[18:40:50.849]                       muffled <- FALSE
[18:40:50.849]                       if (inherits(cond, "message")) {
[18:40:50.849]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.849]                         if (muffled) 
[18:40:50.849]                           invokeRestart("muffleMessage")
[18:40:50.849]                       }
[18:40:50.849]                       else if (inherits(cond, "warning")) {
[18:40:50.849]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.849]                         if (muffled) 
[18:40:50.849]                           invokeRestart("muffleWarning")
[18:40:50.849]                       }
[18:40:50.849]                       else if (inherits(cond, "condition")) {
[18:40:50.849]                         if (!is.null(pattern)) {
[18:40:50.849]                           computeRestarts <- base::computeRestarts
[18:40:50.849]                           grepl <- base::grepl
[18:40:50.849]                           restarts <- computeRestarts(cond)
[18:40:50.849]                           for (restart in restarts) {
[18:40:50.849]                             name <- restart$name
[18:40:50.849]                             if (is.null(name)) 
[18:40:50.849]                               next
[18:40:50.849]                             if (!grepl(pattern, name)) 
[18:40:50.849]                               next
[18:40:50.849]                             invokeRestart(restart)
[18:40:50.849]                             muffled <- TRUE
[18:40:50.849]                             break
[18:40:50.849]                           }
[18:40:50.849]                         }
[18:40:50.849]                       }
[18:40:50.849]                       invisible(muffled)
[18:40:50.849]                     }
[18:40:50.849]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.849]                   }
[18:40:50.849]                 }
[18:40:50.849]                 else {
[18:40:50.849]                   if (TRUE) {
[18:40:50.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.849]                     {
[18:40:50.849]                       inherits <- base::inherits
[18:40:50.849]                       invokeRestart <- base::invokeRestart
[18:40:50.849]                       is.null <- base::is.null
[18:40:50.849]                       muffled <- FALSE
[18:40:50.849]                       if (inherits(cond, "message")) {
[18:40:50.849]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.849]                         if (muffled) 
[18:40:50.849]                           invokeRestart("muffleMessage")
[18:40:50.849]                       }
[18:40:50.849]                       else if (inherits(cond, "warning")) {
[18:40:50.849]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.849]                         if (muffled) 
[18:40:50.849]                           invokeRestart("muffleWarning")
[18:40:50.849]                       }
[18:40:50.849]                       else if (inherits(cond, "condition")) {
[18:40:50.849]                         if (!is.null(pattern)) {
[18:40:50.849]                           computeRestarts <- base::computeRestarts
[18:40:50.849]                           grepl <- base::grepl
[18:40:50.849]                           restarts <- computeRestarts(cond)
[18:40:50.849]                           for (restart in restarts) {
[18:40:50.849]                             name <- restart$name
[18:40:50.849]                             if (is.null(name)) 
[18:40:50.849]                               next
[18:40:50.849]                             if (!grepl(pattern, name)) 
[18:40:50.849]                               next
[18:40:50.849]                             invokeRestart(restart)
[18:40:50.849]                             muffled <- TRUE
[18:40:50.849]                             break
[18:40:50.849]                           }
[18:40:50.849]                         }
[18:40:50.849]                       }
[18:40:50.849]                       invisible(muffled)
[18:40:50.849]                     }
[18:40:50.849]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.849]                   }
[18:40:50.849]                 }
[18:40:50.849]             }
[18:40:50.849]         }))
[18:40:50.849]     }, error = function(ex) {
[18:40:50.849]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.849]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.849]                 ...future.rng), started = ...future.startTime, 
[18:40:50.849]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.849]             version = "1.8"), class = "FutureResult")
[18:40:50.849]     }, finally = {
[18:40:50.849]         if (!identical(...future.workdir, getwd())) 
[18:40:50.849]             setwd(...future.workdir)
[18:40:50.849]         {
[18:40:50.849]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.849]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.849]             }
[18:40:50.849]             base::options(...future.oldOptions)
[18:40:50.849]             if (.Platform$OS.type == "windows") {
[18:40:50.849]                 old_names <- names(...future.oldEnvVars)
[18:40:50.849]                 envs <- base::Sys.getenv()
[18:40:50.849]                 names <- names(envs)
[18:40:50.849]                 common <- intersect(names, old_names)
[18:40:50.849]                 added <- setdiff(names, old_names)
[18:40:50.849]                 removed <- setdiff(old_names, names)
[18:40:50.849]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.849]                   envs[common]]
[18:40:50.849]                 NAMES <- toupper(changed)
[18:40:50.849]                 args <- list()
[18:40:50.849]                 for (kk in seq_along(NAMES)) {
[18:40:50.849]                   name <- changed[[kk]]
[18:40:50.849]                   NAME <- NAMES[[kk]]
[18:40:50.849]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.849]                     next
[18:40:50.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.849]                 }
[18:40:50.849]                 NAMES <- toupper(added)
[18:40:50.849]                 for (kk in seq_along(NAMES)) {
[18:40:50.849]                   name <- added[[kk]]
[18:40:50.849]                   NAME <- NAMES[[kk]]
[18:40:50.849]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.849]                     next
[18:40:50.849]                   args[[name]] <- ""
[18:40:50.849]                 }
[18:40:50.849]                 NAMES <- toupper(removed)
[18:40:50.849]                 for (kk in seq_along(NAMES)) {
[18:40:50.849]                   name <- removed[[kk]]
[18:40:50.849]                   NAME <- NAMES[[kk]]
[18:40:50.849]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.849]                     next
[18:40:50.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.849]                 }
[18:40:50.849]                 if (length(args) > 0) 
[18:40:50.849]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.849]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.849]             }
[18:40:50.849]             else {
[18:40:50.849]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.849]             }
[18:40:50.849]             {
[18:40:50.849]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.849]                   0L) {
[18:40:50.849]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.849]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.849]                   base::options(opts)
[18:40:50.849]                 }
[18:40:50.849]                 {
[18:40:50.849]                   {
[18:40:50.849]                     NULL
[18:40:50.849]                     RNGkind("Mersenne-Twister")
[18:40:50.849]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.849]                       inherits = FALSE)
[18:40:50.849]                   }
[18:40:50.849]                   options(future.plan = NULL)
[18:40:50.849]                   if (is.na(NA_character_)) 
[18:40:50.849]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.849]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.849]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.849]                     .init = FALSE)
[18:40:50.849]                 }
[18:40:50.849]             }
[18:40:50.849]         }
[18:40:50.849]     })
[18:40:50.849]     if (TRUE) {
[18:40:50.849]         base::sink(type = "output", split = FALSE)
[18:40:50.849]         if (TRUE) {
[18:40:50.849]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.849]         }
[18:40:50.849]         else {
[18:40:50.849]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.849]         }
[18:40:50.849]         base::close(...future.stdout)
[18:40:50.849]         ...future.stdout <- NULL
[18:40:50.849]     }
[18:40:50.849]     ...future.result$conditions <- ...future.conditions
[18:40:50.849]     ...future.result$finished <- base::Sys.time()
[18:40:50.849]     ...future.result
[18:40:50.849] }
[18:40:50.853] assign_globals() ...
[18:40:50.853] List of 5
[18:40:50.853]  $ ...future.FUN            :function (object, ...)  
[18:40:50.853]  $ future.call.arguments    : list()
[18:40:50.853]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.853]  $ ...future.elements_ii    :List of 3
[18:40:50.853]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.853]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:50.853]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.853]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:50.853]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.853]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:50.853]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.853]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:50.853]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.853]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:50.853]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.853]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:50.853]  $ ...future.seeds_ii       : NULL
[18:40:50.853]  $ ...future.globals.maxSize: NULL
[18:40:50.853]  - attr(*, "where")=List of 5
[18:40:50.853]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.853]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.853]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.853]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.853]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.853]  - attr(*, "resolved")= logi FALSE
[18:40:50.853]  - attr(*, "total_size")= num 18709
[18:40:50.853]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.853]  - attr(*, "already-done")= logi TRUE
[18:40:50.864] - copied '...future.FUN' to environment
[18:40:50.864] - copied 'future.call.arguments' to environment
[18:40:50.864] - copied '...future.elements_ii' to environment
[18:40:50.865] - copied '...future.seeds_ii' to environment
[18:40:50.865] - copied '...future.globals.maxSize' to environment
[18:40:50.865] assign_globals() ... done
[18:40:50.865] plan(): Setting new future strategy stack:
[18:40:50.865] List of future strategies:
[18:40:50.865] 1. sequential:
[18:40:50.865]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.865]    - tweaked: FALSE
[18:40:50.865]    - call: NULL
[18:40:50.866] plan(): nbrOfWorkers() = 1
[18:40:50.869] plan(): Setting new future strategy stack:
[18:40:50.869] List of future strategies:
[18:40:50.869] 1. sequential:
[18:40:50.869]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.869]    - tweaked: FALSE
[18:40:50.869]    - call: plan(strategy)
[18:40:50.870] plan(): nbrOfWorkers() = 1
[18:40:50.870] SequentialFuture started (and completed)
[18:40:50.870] - Launch lazy future ... done
[18:40:50.871] run() for 'SequentialFuture' ... done
[18:40:50.871] Created future:
[18:40:50.871] SequentialFuture:
[18:40:50.871] Label: 'future_by-1'
[18:40:50.871] Expression:
[18:40:50.871] {
[18:40:50.871]     do.call(function(...) {
[18:40:50.871]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.871]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.871]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.871]             on.exit(options(oopts), add = TRUE)
[18:40:50.871]         }
[18:40:50.871]         {
[18:40:50.871]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.871]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.871]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.871]             })
[18:40:50.871]         }
[18:40:50.871]     }, args = future.call.arguments)
[18:40:50.871] }
[18:40:50.871] Lazy evaluation: FALSE
[18:40:50.871] Asynchronous evaluation: FALSE
[18:40:50.871] Local evaluation: TRUE
[18:40:50.871] Environment: 0x000001cd50f3e710
[18:40:50.871] Capture standard output: TRUE
[18:40:50.871] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:50.871] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:50.871] Packages: <none>
[18:40:50.871] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:50.871] Resolved: TRUE
[18:40:50.871] Value: 1.39 KiB of class 'list'
[18:40:50.871] Early signaling: FALSE
[18:40:50.871] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:50.871] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.872] Chunk #1 of 1 ... DONE
[18:40:50.872] Launching 1 futures (chunks) ... DONE
[18:40:50.873] Resolving 1 futures (chunks) ...
[18:40:50.873] resolve() on list ...
[18:40:50.873]  recursive: 0
[18:40:50.873]  length: 1
[18:40:50.873] 
[18:40:50.873] resolved() for 'SequentialFuture' ...
[18:40:50.874] - state: 'finished'
[18:40:50.874] - run: TRUE
[18:40:50.874] - result: 'FutureResult'
[18:40:50.874] resolved() for 'SequentialFuture' ... done
[18:40:50.874] Future #1
[18:40:50.875] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:50.875] - nx: 1
[18:40:50.875] - relay: TRUE
[18:40:50.875] - stdout: TRUE
[18:40:50.875] - signal: TRUE
[18:40:50.875] - resignal: FALSE
[18:40:50.876] - force: TRUE
[18:40:50.876] - relayed: [n=1] FALSE
[18:40:50.876] - queued futures: [n=1] FALSE
[18:40:50.876]  - until=1
[18:40:50.876]  - relaying element #1
[18:40:50.876] - relayed: [n=1] TRUE
[18:40:50.877] - queued futures: [n=1] TRUE
[18:40:50.877] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:50.877]  length: 0 (resolved future 1)
[18:40:50.877] Relaying remaining futures
[18:40:50.877] signalConditionsASAP(NULL, pos=0) ...
[18:40:50.877] - nx: 1
[18:40:50.878] - relay: TRUE
[18:40:50.878] - stdout: TRUE
[18:40:50.878] - signal: TRUE
[18:40:50.878] - resignal: FALSE
[18:40:50.878] - force: TRUE
[18:40:50.880] - relayed: [n=1] TRUE
[18:40:50.880] - queued futures: [n=1] TRUE
 - flush all
[18:40:50.880] - relayed: [n=1] TRUE
[18:40:50.881] - queued futures: [n=1] TRUE
[18:40:50.881] signalConditionsASAP(NULL, pos=0) ... done
[18:40:50.881] resolve() on list ... DONE
[18:40:50.881]  - Number of value chunks collected: 1
[18:40:50.881] Resolving 1 futures (chunks) ... DONE
[18:40:50.881] Reducing values from 1 chunks ...
[18:40:50.882]  - Number of values collected after concatenation: 3
[18:40:50.882]  - Number of values expected: 3
[18:40:50.882] Reducing values from 1 chunks ... DONE
[18:40:50.882] future_lapply() ... DONE
[18:40:50.882] future_by_internal() ... DONE
[18:40:50.885] future_by_internal() ...
Warning in future_by_match_FUN(FUN) :
  Specifying the function 'FUN' for future_by() as a character string is deprecated in future.apply (>= 1.10.0) [2022-11-04], because base::by() does not support it. Instead, specify it as a function, e.g. FUN = sqrt and FUN = `[[`. It is deprecated.
[18:40:50.885] future_lapply() ...
[18:40:50.886] Number of chunks: 1
[18:40:50.886] getGlobalsAndPackagesXApply() ...
[18:40:50.886]  - future.globals: TRUE
[18:40:50.886] getGlobalsAndPackages() ...
[18:40:50.887] Searching for globals...
[18:40:50.888] - globals found: [2] 'FUN', 'UseMethod'
[18:40:50.888] Searching for globals ... DONE
[18:40:50.888] Resolving globals: FALSE
[18:40:50.889] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:50.889] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:50.889] - globals: [1] 'FUN'
[18:40:50.890] 
[18:40:50.890] getGlobalsAndPackages() ... DONE
[18:40:50.890]  - globals found/used: [n=1] 'FUN'
[18:40:50.890]  - needed namespaces: [n=0] 
[18:40:50.890] Finding globals ... DONE
[18:40:50.890]  - use_args: TRUE
[18:40:50.891]  - Getting '...' globals ...
[18:40:50.891] resolve() on list ...
[18:40:50.891]  recursive: 0
[18:40:50.891]  length: 1
[18:40:50.892]  elements: '...'
[18:40:50.892]  length: 0 (resolved future 1)
[18:40:50.892] resolve() on list ... DONE
[18:40:50.892]    - '...' content: [n=0] 
[18:40:50.892] List of 1
[18:40:50.892]  $ ...: list()
[18:40:50.892]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.892]  - attr(*, "where")=List of 1
[18:40:50.892]   ..$ ...:<environment: 0x000001cd4e7c0c00> 
[18:40:50.892]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.892]  - attr(*, "resolved")= logi TRUE
[18:40:50.892]  - attr(*, "total_size")= num NA
[18:40:50.895]  - Getting '...' globals ... DONE
[18:40:50.895] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:50.895] List of 2
[18:40:50.895]  $ ...future.FUN:function (object, ...)  
[18:40:50.895]  $ ...          : list()
[18:40:50.895]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.895]  - attr(*, "where")=List of 2
[18:40:50.895]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.895]   ..$ ...          :<environment: 0x000001cd4e7c0c00> 
[18:40:50.895]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.895]  - attr(*, "resolved")= logi FALSE
[18:40:50.895]  - attr(*, "total_size")= int 18647
[18:40:50.899] Packages to be attached in all futures: [n=0] 
[18:40:50.899] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.899] Number of futures (= number of chunks): 1
[18:40:50.899] Launching 1 futures (chunks) ...
[18:40:50.899] Chunk #1 of 1 ...
[18:40:50.900]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.900] getGlobalsAndPackages() ...
[18:40:50.900] Searching for globals...
[18:40:50.901] 
[18:40:50.901] Searching for globals ... DONE
[18:40:50.901] - globals: [0] <none>
[18:40:50.901] getGlobalsAndPackages() ... DONE
[18:40:50.901]    + additional globals found: [n=0] 
[18:40:50.901]    + additional namespaces needed: [n=0] 
[18:40:50.902]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.902]  - seeds: <none>
[18:40:50.902]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.902] getGlobalsAndPackages() ...
[18:40:50.902] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.902] Resolving globals: FALSE
[18:40:50.903] Tweak future expression to call with '...' arguments ...
[18:40:50.903] {
[18:40:50.903]     do.call(function(...) {
[18:40:50.903]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.903]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.903]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.903]             on.exit(options(oopts), add = TRUE)
[18:40:50.903]         }
[18:40:50.903]         {
[18:40:50.903]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.903]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.903]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.903]             })
[18:40:50.903]         }
[18:40:50.903]     }, args = future.call.arguments)
[18:40:50.903] }
[18:40:50.903] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.904] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.904] 
[18:40:50.904] getGlobalsAndPackages() ... DONE
[18:40:50.904] run() for 'Future' ...
[18:40:50.905] - state: 'created'
[18:40:50.905] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:50.905] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.905] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.906]   - Field: 'label'
[18:40:50.906]   - Field: 'local'
[18:40:50.906]   - Field: 'owner'
[18:40:50.906]   - Field: 'envir'
[18:40:50.906]   - Field: 'packages'
[18:40:50.906]   - Field: 'gc'
[18:40:50.907]   - Field: 'conditions'
[18:40:50.907]   - Field: 'expr'
[18:40:50.907]   - Field: 'uuid'
[18:40:50.907]   - Field: 'seed'
[18:40:50.907]   - Field: 'version'
[18:40:50.907]   - Field: 'result'
[18:40:50.908]   - Field: 'asynchronous'
[18:40:50.908]   - Field: 'calls'
[18:40:50.908]   - Field: 'globals'
[18:40:50.908]   - Field: 'stdout'
[18:40:50.908]   - Field: 'earlySignal'
[18:40:50.908]   - Field: 'lazy'
[18:40:50.909]   - Field: 'state'
[18:40:50.909] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.909] - Launch lazy future ...
[18:40:50.909] Packages needed by the future expression (n = 0): <none>
[18:40:50.909] Packages needed by future strategies (n = 0): <none>
[18:40:50.910] {
[18:40:50.910]     {
[18:40:50.910]         {
[18:40:50.910]             ...future.startTime <- base::Sys.time()
[18:40:50.910]             {
[18:40:50.910]                 {
[18:40:50.910]                   {
[18:40:50.910]                     base::local({
[18:40:50.910]                       has_future <- base::requireNamespace("future", 
[18:40:50.910]                         quietly = TRUE)
[18:40:50.910]                       if (has_future) {
[18:40:50.910]                         ns <- base::getNamespace("future")
[18:40:50.910]                         version <- ns[[".package"]][["version"]]
[18:40:50.910]                         if (is.null(version)) 
[18:40:50.910]                           version <- utils::packageVersion("future")
[18:40:50.910]                       }
[18:40:50.910]                       else {
[18:40:50.910]                         version <- NULL
[18:40:50.910]                       }
[18:40:50.910]                       if (!has_future || version < "1.8.0") {
[18:40:50.910]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.910]                           "", base::R.version$version.string), 
[18:40:50.910]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:50.910]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.910]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.910]                             "release", "version")], collapse = " "), 
[18:40:50.910]                           hostname = base::Sys.info()[["nodename"]])
[18:40:50.910]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.910]                           info)
[18:40:50.910]                         info <- base::paste(info, collapse = "; ")
[18:40:50.910]                         if (!has_future) {
[18:40:50.910]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.910]                             info)
[18:40:50.910]                         }
[18:40:50.910]                         else {
[18:40:50.910]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.910]                             info, version)
[18:40:50.910]                         }
[18:40:50.910]                         base::stop(msg)
[18:40:50.910]                       }
[18:40:50.910]                     })
[18:40:50.910]                   }
[18:40:50.910]                   ...future.strategy.old <- future::plan("list")
[18:40:50.910]                   options(future.plan = NULL)
[18:40:50.910]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.910]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.910]                 }
[18:40:50.910]                 ...future.workdir <- getwd()
[18:40:50.910]             }
[18:40:50.910]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.910]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.910]         }
[18:40:50.910]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.910]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.910]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.910]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.910]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.910]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.910]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.910]             base::names(...future.oldOptions))
[18:40:50.910]     }
[18:40:50.910]     if (FALSE) {
[18:40:50.910]     }
[18:40:50.910]     else {
[18:40:50.910]         if (TRUE) {
[18:40:50.910]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.910]                 open = "w")
[18:40:50.910]         }
[18:40:50.910]         else {
[18:40:50.910]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.910]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.910]         }
[18:40:50.910]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.910]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.910]             base::sink(type = "output", split = FALSE)
[18:40:50.910]             base::close(...future.stdout)
[18:40:50.910]         }, add = TRUE)
[18:40:50.910]     }
[18:40:50.910]     ...future.frame <- base::sys.nframe()
[18:40:50.910]     ...future.conditions <- base::list()
[18:40:50.910]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.910]     if (FALSE) {
[18:40:50.910]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.910]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.910]     }
[18:40:50.910]     ...future.result <- base::tryCatch({
[18:40:50.910]         base::withCallingHandlers({
[18:40:50.910]             ...future.value <- base::withVisible(base::local({
[18:40:50.910]                 do.call(function(...) {
[18:40:50.910]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.910]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.910]                     ...future.globals.maxSize)) {
[18:40:50.910]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.910]                     on.exit(options(oopts), add = TRUE)
[18:40:50.910]                   }
[18:40:50.910]                   {
[18:40:50.910]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.910]                       FUN = function(jj) {
[18:40:50.910]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.910]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.910]                       })
[18:40:50.910]                   }
[18:40:50.910]                 }, args = future.call.arguments)
[18:40:50.910]             }))
[18:40:50.910]             future::FutureResult(value = ...future.value$value, 
[18:40:50.910]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.910]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.910]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.910]                     ...future.globalenv.names))
[18:40:50.910]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.910]         }, condition = base::local({
[18:40:50.910]             c <- base::c
[18:40:50.910]             inherits <- base::inherits
[18:40:50.910]             invokeRestart <- base::invokeRestart
[18:40:50.910]             length <- base::length
[18:40:50.910]             list <- base::list
[18:40:50.910]             seq.int <- base::seq.int
[18:40:50.910]             signalCondition <- base::signalCondition
[18:40:50.910]             sys.calls <- base::sys.calls
[18:40:50.910]             `[[` <- base::`[[`
[18:40:50.910]             `+` <- base::`+`
[18:40:50.910]             `<<-` <- base::`<<-`
[18:40:50.910]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.910]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.910]                   3L)]
[18:40:50.910]             }
[18:40:50.910]             function(cond) {
[18:40:50.910]                 is_error <- inherits(cond, "error")
[18:40:50.910]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.910]                   NULL)
[18:40:50.910]                 if (is_error) {
[18:40:50.910]                   sessionInformation <- function() {
[18:40:50.910]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.910]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.910]                       search = base::search(), system = base::Sys.info())
[18:40:50.910]                   }
[18:40:50.910]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.910]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.910]                     cond$call), session = sessionInformation(), 
[18:40:50.910]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.910]                   signalCondition(cond)
[18:40:50.910]                 }
[18:40:50.910]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.910]                 "immediateCondition"))) {
[18:40:50.910]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.910]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.910]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.910]                   if (TRUE && !signal) {
[18:40:50.910]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.910]                     {
[18:40:50.910]                       inherits <- base::inherits
[18:40:50.910]                       invokeRestart <- base::invokeRestart
[18:40:50.910]                       is.null <- base::is.null
[18:40:50.910]                       muffled <- FALSE
[18:40:50.910]                       if (inherits(cond, "message")) {
[18:40:50.910]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.910]                         if (muffled) 
[18:40:50.910]                           invokeRestart("muffleMessage")
[18:40:50.910]                       }
[18:40:50.910]                       else if (inherits(cond, "warning")) {
[18:40:50.910]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.910]                         if (muffled) 
[18:40:50.910]                           invokeRestart("muffleWarning")
[18:40:50.910]                       }
[18:40:50.910]                       else if (inherits(cond, "condition")) {
[18:40:50.910]                         if (!is.null(pattern)) {
[18:40:50.910]                           computeRestarts <- base::computeRestarts
[18:40:50.910]                           grepl <- base::grepl
[18:40:50.910]                           restarts <- computeRestarts(cond)
[18:40:50.910]                           for (restart in restarts) {
[18:40:50.910]                             name <- restart$name
[18:40:50.910]                             if (is.null(name)) 
[18:40:50.910]                               next
[18:40:50.910]                             if (!grepl(pattern, name)) 
[18:40:50.910]                               next
[18:40:50.910]                             invokeRestart(restart)
[18:40:50.910]                             muffled <- TRUE
[18:40:50.910]                             break
[18:40:50.910]                           }
[18:40:50.910]                         }
[18:40:50.910]                       }
[18:40:50.910]                       invisible(muffled)
[18:40:50.910]                     }
[18:40:50.910]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.910]                   }
[18:40:50.910]                 }
[18:40:50.910]                 else {
[18:40:50.910]                   if (TRUE) {
[18:40:50.910]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.910]                     {
[18:40:50.910]                       inherits <- base::inherits
[18:40:50.910]                       invokeRestart <- base::invokeRestart
[18:40:50.910]                       is.null <- base::is.null
[18:40:50.910]                       muffled <- FALSE
[18:40:50.910]                       if (inherits(cond, "message")) {
[18:40:50.910]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.910]                         if (muffled) 
[18:40:50.910]                           invokeRestart("muffleMessage")
[18:40:50.910]                       }
[18:40:50.910]                       else if (inherits(cond, "warning")) {
[18:40:50.910]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.910]                         if (muffled) 
[18:40:50.910]                           invokeRestart("muffleWarning")
[18:40:50.910]                       }
[18:40:50.910]                       else if (inherits(cond, "condition")) {
[18:40:50.910]                         if (!is.null(pattern)) {
[18:40:50.910]                           computeRestarts <- base::computeRestarts
[18:40:50.910]                           grepl <- base::grepl
[18:40:50.910]                           restarts <- computeRestarts(cond)
[18:40:50.910]                           for (restart in restarts) {
[18:40:50.910]                             name <- restart$name
[18:40:50.910]                             if (is.null(name)) 
[18:40:50.910]                               next
[18:40:50.910]                             if (!grepl(pattern, name)) 
[18:40:50.910]                               next
[18:40:50.910]                             invokeRestart(restart)
[18:40:50.910]                             muffled <- TRUE
[18:40:50.910]                             break
[18:40:50.910]                           }
[18:40:50.910]                         }
[18:40:50.910]                       }
[18:40:50.910]                       invisible(muffled)
[18:40:50.910]                     }
[18:40:50.910]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.910]                   }
[18:40:50.910]                 }
[18:40:50.910]             }
[18:40:50.910]         }))
[18:40:50.910]     }, error = function(ex) {
[18:40:50.910]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.910]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.910]                 ...future.rng), started = ...future.startTime, 
[18:40:50.910]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.910]             version = "1.8"), class = "FutureResult")
[18:40:50.910]     }, finally = {
[18:40:50.910]         if (!identical(...future.workdir, getwd())) 
[18:40:50.910]             setwd(...future.workdir)
[18:40:50.910]         {
[18:40:50.910]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.910]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.910]             }
[18:40:50.910]             base::options(...future.oldOptions)
[18:40:50.910]             if (.Platform$OS.type == "windows") {
[18:40:50.910]                 old_names <- names(...future.oldEnvVars)
[18:40:50.910]                 envs <- base::Sys.getenv()
[18:40:50.910]                 names <- names(envs)
[18:40:50.910]                 common <- intersect(names, old_names)
[18:40:50.910]                 added <- setdiff(names, old_names)
[18:40:50.910]                 removed <- setdiff(old_names, names)
[18:40:50.910]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.910]                   envs[common]]
[18:40:50.910]                 NAMES <- toupper(changed)
[18:40:50.910]                 args <- list()
[18:40:50.910]                 for (kk in seq_along(NAMES)) {
[18:40:50.910]                   name <- changed[[kk]]
[18:40:50.910]                   NAME <- NAMES[[kk]]
[18:40:50.910]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.910]                     next
[18:40:50.910]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.910]                 }
[18:40:50.910]                 NAMES <- toupper(added)
[18:40:50.910]                 for (kk in seq_along(NAMES)) {
[18:40:50.910]                   name <- added[[kk]]
[18:40:50.910]                   NAME <- NAMES[[kk]]
[18:40:50.910]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.910]                     next
[18:40:50.910]                   args[[name]] <- ""
[18:40:50.910]                 }
[18:40:50.910]                 NAMES <- toupper(removed)
[18:40:50.910]                 for (kk in seq_along(NAMES)) {
[18:40:50.910]                   name <- removed[[kk]]
[18:40:50.910]                   NAME <- NAMES[[kk]]
[18:40:50.910]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.910]                     next
[18:40:50.910]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.910]                 }
[18:40:50.910]                 if (length(args) > 0) 
[18:40:50.910]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.910]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.910]             }
[18:40:50.910]             else {
[18:40:50.910]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.910]             }
[18:40:50.910]             {
[18:40:50.910]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.910]                   0L) {
[18:40:50.910]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.910]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.910]                   base::options(opts)
[18:40:50.910]                 }
[18:40:50.910]                 {
[18:40:50.910]                   {
[18:40:50.910]                     NULL
[18:40:50.910]                     RNGkind("Mersenne-Twister")
[18:40:50.910]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.910]                       inherits = FALSE)
[18:40:50.910]                   }
[18:40:50.910]                   options(future.plan = NULL)
[18:40:50.910]                   if (is.na(NA_character_)) 
[18:40:50.910]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.910]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.910]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.910]                     .init = FALSE)
[18:40:50.910]                 }
[18:40:50.910]             }
[18:40:50.910]         }
[18:40:50.910]     })
[18:40:50.910]     if (TRUE) {
[18:40:50.910]         base::sink(type = "output", split = FALSE)
[18:40:50.910]         if (TRUE) {
[18:40:50.910]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.910]         }
[18:40:50.910]         else {
[18:40:50.910]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.910]         }
[18:40:50.910]         base::close(...future.stdout)
[18:40:50.910]         ...future.stdout <- NULL
[18:40:50.910]     }
[18:40:50.910]     ...future.result$conditions <- ...future.conditions
[18:40:50.910]     ...future.result$finished <- base::Sys.time()
[18:40:50.910]     ...future.result
[18:40:50.910] }
[18:40:50.914] assign_globals() ...
[18:40:50.914] List of 5
[18:40:50.914]  $ ...future.FUN            :function (object, ...)  
[18:40:50.914]  $ future.call.arguments    : list()
[18:40:50.914]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.914]  $ ...future.elements_ii    :List of 3
[18:40:50.914]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.914]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:50.914]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.914]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:50.914]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.914]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:50.914]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.914]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:50.914]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:50.914]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:50.914]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.914]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:50.914]  $ ...future.seeds_ii       : NULL
[18:40:50.914]  $ ...future.globals.maxSize: NULL
[18:40:50.914]  - attr(*, "where")=List of 5
[18:40:50.914]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.914]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.914]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.914]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.914]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.914]  - attr(*, "resolved")= logi FALSE
[18:40:50.914]  - attr(*, "total_size")= num 18647
[18:40:50.914]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.914]  - attr(*, "already-done")= logi TRUE
[18:40:50.924] - copied '...future.FUN' to environment
[18:40:50.924] - copied 'future.call.arguments' to environment
[18:40:50.925] - copied '...future.elements_ii' to environment
[18:40:50.925] - copied '...future.seeds_ii' to environment
[18:40:50.925] - copied '...future.globals.maxSize' to environment
[18:40:50.925] assign_globals() ... done
[18:40:50.925] plan(): Setting new future strategy stack:
[18:40:50.926] List of future strategies:
[18:40:50.926] 1. sequential:
[18:40:50.926]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.926]    - tweaked: FALSE
[18:40:50.926]    - call: NULL
[18:40:50.926] plan(): nbrOfWorkers() = 1
[18:40:50.929] plan(): Setting new future strategy stack:
[18:40:50.929] List of future strategies:
[18:40:50.929] 1. sequential:
[18:40:50.929]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.929]    - tweaked: FALSE
[18:40:50.929]    - call: plan(strategy)
[18:40:50.930] plan(): nbrOfWorkers() = 1
[18:40:50.930] SequentialFuture started (and completed)
[18:40:50.931] - Launch lazy future ... done
[18:40:50.931] run() for 'SequentialFuture' ... done
[18:40:50.931] Created future:
[18:40:50.931] SequentialFuture:
[18:40:50.931] Label: 'future_by-1'
[18:40:50.931] Expression:
[18:40:50.931] {
[18:40:50.931]     do.call(function(...) {
[18:40:50.931]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.931]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.931]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.931]             on.exit(options(oopts), add = TRUE)
[18:40:50.931]         }
[18:40:50.931]         {
[18:40:50.931]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.931]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.931]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.931]             })
[18:40:50.931]         }
[18:40:50.931]     }, args = future.call.arguments)
[18:40:50.931] }
[18:40:50.931] Lazy evaluation: FALSE
[18:40:50.931] Asynchronous evaluation: FALSE
[18:40:50.931] Local evaluation: TRUE
[18:40:50.931] Environment: 0x000001cd4ea36a08
[18:40:50.931] Capture standard output: TRUE
[18:40:50.931] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:50.931] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:50.931] Packages: <none>
[18:40:50.931] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:50.931] Resolved: TRUE
[18:40:50.931] Value: 1.39 KiB of class 'list'
[18:40:50.931] Early signaling: FALSE
[18:40:50.931] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:50.931] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.932] Chunk #1 of 1 ... DONE
[18:40:50.932] Launching 1 futures (chunks) ... DONE
[18:40:50.933] Resolving 1 futures (chunks) ...
[18:40:50.933] resolve() on list ...
[18:40:50.933]  recursive: 0
[18:40:50.933]  length: 1
[18:40:50.933] 
[18:40:50.933] resolved() for 'SequentialFuture' ...
[18:40:50.934] - state: 'finished'
[18:40:50.934] - run: TRUE
[18:40:50.934] - result: 'FutureResult'
[18:40:50.934] resolved() for 'SequentialFuture' ... done
[18:40:50.934] Future #1
[18:40:50.935] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:50.935] - nx: 1
[18:40:50.935] - relay: TRUE
[18:40:50.935] - stdout: TRUE
[18:40:50.935] - signal: TRUE
[18:40:50.935] - resignal: FALSE
[18:40:50.935] - force: TRUE
[18:40:50.936] - relayed: [n=1] FALSE
[18:40:50.936] - queued futures: [n=1] FALSE
[18:40:50.936]  - until=1
[18:40:50.936]  - relaying element #1
[18:40:50.936] - relayed: [n=1] TRUE
[18:40:50.937] - queued futures: [n=1] TRUE
[18:40:50.937] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:50.937]  length: 0 (resolved future 1)
[18:40:50.937] Relaying remaining futures
[18:40:50.937] signalConditionsASAP(NULL, pos=0) ...
[18:40:50.937] - nx: 1
[18:40:50.938] - relay: TRUE
[18:40:50.938] - stdout: TRUE
[18:40:50.938] - signal: TRUE
[18:40:50.938] - resignal: FALSE
[18:40:50.938] - force: TRUE
[18:40:50.938] - relayed: [n=1] TRUE
[18:40:50.938] - queued futures: [n=1] TRUE
 - flush all
[18:40:50.939] - relayed: [n=1] TRUE
[18:40:50.939] - queued futures: [n=1] TRUE
[18:40:50.939] signalConditionsASAP(NULL, pos=0) ... done
[18:40:50.939] resolve() on list ... DONE
[18:40:50.939]  - Number of value chunks collected: 1
[18:40:50.940] Resolving 1 futures (chunks) ... DONE
[18:40:50.940] Reducing values from 1 chunks ...
[18:40:50.940]  - Number of values collected after concatenation: 3
[18:40:50.940]  - Number of values expected: 3
[18:40:50.940] Reducing values from 1 chunks ... DONE
[18:40:50.940] future_lapply() ... DONE
[18:40:50.941] future_by_internal() ... DONE
[18:40:50.942] future_by_internal() ...
- plan('multisession') ...
[18:40:50.942] plan(): Setting new future strategy stack:
[18:40:50.942] List of future strategies:
[18:40:50.942] 1. multisession:
[18:40:50.942]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:50.942]    - tweaked: FALSE
[18:40:50.942]    - call: plan(strategy)
[18:40:50.943] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[18:40:50.943] multisession:
[18:40:50.943] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:50.943] - tweaked: FALSE
[18:40:50.943] - call: plan(strategy)
[18:40:50.946] getGlobalsAndPackages() ...
[18:40:50.946] Not searching for globals
[18:40:50.946] - globals: [0] <none>
[18:40:50.946] getGlobalsAndPackages() ... DONE
[18:40:50.947] Packages needed by the future expression (n = 0): <none>
[18:40:50.947] Packages needed by future strategies (n = 0): <none>
[18:40:50.947] {
[18:40:50.947]     {
[18:40:50.947]         {
[18:40:50.947]             ...future.startTime <- base::Sys.time()
[18:40:50.947]             {
[18:40:50.947]                 {
[18:40:50.947]                   {
[18:40:50.947]                     base::local({
[18:40:50.947]                       has_future <- base::requireNamespace("future", 
[18:40:50.947]                         quietly = TRUE)
[18:40:50.947]                       if (has_future) {
[18:40:50.947]                         ns <- base::getNamespace("future")
[18:40:50.947]                         version <- ns[[".package"]][["version"]]
[18:40:50.947]                         if (is.null(version)) 
[18:40:50.947]                           version <- utils::packageVersion("future")
[18:40:50.947]                       }
[18:40:50.947]                       else {
[18:40:50.947]                         version <- NULL
[18:40:50.947]                       }
[18:40:50.947]                       if (!has_future || version < "1.8.0") {
[18:40:50.947]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.947]                           "", base::R.version$version.string), 
[18:40:50.947]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:50.947]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.947]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.947]                             "release", "version")], collapse = " "), 
[18:40:50.947]                           hostname = base::Sys.info()[["nodename"]])
[18:40:50.947]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.947]                           info)
[18:40:50.947]                         info <- base::paste(info, collapse = "; ")
[18:40:50.947]                         if (!has_future) {
[18:40:50.947]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.947]                             info)
[18:40:50.947]                         }
[18:40:50.947]                         else {
[18:40:50.947]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.947]                             info, version)
[18:40:50.947]                         }
[18:40:50.947]                         base::stop(msg)
[18:40:50.947]                       }
[18:40:50.947]                     })
[18:40:50.947]                   }
[18:40:50.947]                   ...future.strategy.old <- future::plan("list")
[18:40:50.947]                   options(future.plan = NULL)
[18:40:50.947]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.947]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.947]                 }
[18:40:50.947]                 ...future.workdir <- getwd()
[18:40:50.947]             }
[18:40:50.947]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.947]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.947]         }
[18:40:50.947]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.947]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.947]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.947]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.947]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.947]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.947]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.947]             base::names(...future.oldOptions))
[18:40:50.947]     }
[18:40:50.947]     if (FALSE) {
[18:40:50.947]     }
[18:40:50.947]     else {
[18:40:50.947]         if (TRUE) {
[18:40:50.947]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.947]                 open = "w")
[18:40:50.947]         }
[18:40:50.947]         else {
[18:40:50.947]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.947]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.947]         }
[18:40:50.947]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.947]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.947]             base::sink(type = "output", split = FALSE)
[18:40:50.947]             base::close(...future.stdout)
[18:40:50.947]         }, add = TRUE)
[18:40:50.947]     }
[18:40:50.947]     ...future.frame <- base::sys.nframe()
[18:40:50.947]     ...future.conditions <- base::list()
[18:40:50.947]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.947]     if (FALSE) {
[18:40:50.947]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.947]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.947]     }
[18:40:50.947]     ...future.result <- base::tryCatch({
[18:40:50.947]         base::withCallingHandlers({
[18:40:50.947]             ...future.value <- base::withVisible(base::local(NA))
[18:40:50.947]             future::FutureResult(value = ...future.value$value, 
[18:40:50.947]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.947]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.947]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.947]                     ...future.globalenv.names))
[18:40:50.947]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.947]         }, condition = base::local({
[18:40:50.947]             c <- base::c
[18:40:50.947]             inherits <- base::inherits
[18:40:50.947]             invokeRestart <- base::invokeRestart
[18:40:50.947]             length <- base::length
[18:40:50.947]             list <- base::list
[18:40:50.947]             seq.int <- base::seq.int
[18:40:50.947]             signalCondition <- base::signalCondition
[18:40:50.947]             sys.calls <- base::sys.calls
[18:40:50.947]             `[[` <- base::`[[`
[18:40:50.947]             `+` <- base::`+`
[18:40:50.947]             `<<-` <- base::`<<-`
[18:40:50.947]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.947]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.947]                   3L)]
[18:40:50.947]             }
[18:40:50.947]             function(cond) {
[18:40:50.947]                 is_error <- inherits(cond, "error")
[18:40:50.947]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.947]                   NULL)
[18:40:50.947]                 if (is_error) {
[18:40:50.947]                   sessionInformation <- function() {
[18:40:50.947]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.947]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.947]                       search = base::search(), system = base::Sys.info())
[18:40:50.947]                   }
[18:40:50.947]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.947]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.947]                     cond$call), session = sessionInformation(), 
[18:40:50.947]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.947]                   signalCondition(cond)
[18:40:50.947]                 }
[18:40:50.947]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.947]                 "immediateCondition"))) {
[18:40:50.947]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.947]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.947]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.947]                   if (TRUE && !signal) {
[18:40:50.947]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.947]                     {
[18:40:50.947]                       inherits <- base::inherits
[18:40:50.947]                       invokeRestart <- base::invokeRestart
[18:40:50.947]                       is.null <- base::is.null
[18:40:50.947]                       muffled <- FALSE
[18:40:50.947]                       if (inherits(cond, "message")) {
[18:40:50.947]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.947]                         if (muffled) 
[18:40:50.947]                           invokeRestart("muffleMessage")
[18:40:50.947]                       }
[18:40:50.947]                       else if (inherits(cond, "warning")) {
[18:40:50.947]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.947]                         if (muffled) 
[18:40:50.947]                           invokeRestart("muffleWarning")
[18:40:50.947]                       }
[18:40:50.947]                       else if (inherits(cond, "condition")) {
[18:40:50.947]                         if (!is.null(pattern)) {
[18:40:50.947]                           computeRestarts <- base::computeRestarts
[18:40:50.947]                           grepl <- base::grepl
[18:40:50.947]                           restarts <- computeRestarts(cond)
[18:40:50.947]                           for (restart in restarts) {
[18:40:50.947]                             name <- restart$name
[18:40:50.947]                             if (is.null(name)) 
[18:40:50.947]                               next
[18:40:50.947]                             if (!grepl(pattern, name)) 
[18:40:50.947]                               next
[18:40:50.947]                             invokeRestart(restart)
[18:40:50.947]                             muffled <- TRUE
[18:40:50.947]                             break
[18:40:50.947]                           }
[18:40:50.947]                         }
[18:40:50.947]                       }
[18:40:50.947]                       invisible(muffled)
[18:40:50.947]                     }
[18:40:50.947]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.947]                   }
[18:40:50.947]                 }
[18:40:50.947]                 else {
[18:40:50.947]                   if (TRUE) {
[18:40:50.947]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.947]                     {
[18:40:50.947]                       inherits <- base::inherits
[18:40:50.947]                       invokeRestart <- base::invokeRestart
[18:40:50.947]                       is.null <- base::is.null
[18:40:50.947]                       muffled <- FALSE
[18:40:50.947]                       if (inherits(cond, "message")) {
[18:40:50.947]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.947]                         if (muffled) 
[18:40:50.947]                           invokeRestart("muffleMessage")
[18:40:50.947]                       }
[18:40:50.947]                       else if (inherits(cond, "warning")) {
[18:40:50.947]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.947]                         if (muffled) 
[18:40:50.947]                           invokeRestart("muffleWarning")
[18:40:50.947]                       }
[18:40:50.947]                       else if (inherits(cond, "condition")) {
[18:40:50.947]                         if (!is.null(pattern)) {
[18:40:50.947]                           computeRestarts <- base::computeRestarts
[18:40:50.947]                           grepl <- base::grepl
[18:40:50.947]                           restarts <- computeRestarts(cond)
[18:40:50.947]                           for (restart in restarts) {
[18:40:50.947]                             name <- restart$name
[18:40:50.947]                             if (is.null(name)) 
[18:40:50.947]                               next
[18:40:50.947]                             if (!grepl(pattern, name)) 
[18:40:50.947]                               next
[18:40:50.947]                             invokeRestart(restart)
[18:40:50.947]                             muffled <- TRUE
[18:40:50.947]                             break
[18:40:50.947]                           }
[18:40:50.947]                         }
[18:40:50.947]                       }
[18:40:50.947]                       invisible(muffled)
[18:40:50.947]                     }
[18:40:50.947]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.947]                   }
[18:40:50.947]                 }
[18:40:50.947]             }
[18:40:50.947]         }))
[18:40:50.947]     }, error = function(ex) {
[18:40:50.947]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.947]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.947]                 ...future.rng), started = ...future.startTime, 
[18:40:50.947]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.947]             version = "1.8"), class = "FutureResult")
[18:40:50.947]     }, finally = {
[18:40:50.947]         if (!identical(...future.workdir, getwd())) 
[18:40:50.947]             setwd(...future.workdir)
[18:40:50.947]         {
[18:40:50.947]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.947]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.947]             }
[18:40:50.947]             base::options(...future.oldOptions)
[18:40:50.947]             if (.Platform$OS.type == "windows") {
[18:40:50.947]                 old_names <- names(...future.oldEnvVars)
[18:40:50.947]                 envs <- base::Sys.getenv()
[18:40:50.947]                 names <- names(envs)
[18:40:50.947]                 common <- intersect(names, old_names)
[18:40:50.947]                 added <- setdiff(names, old_names)
[18:40:50.947]                 removed <- setdiff(old_names, names)
[18:40:50.947]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.947]                   envs[common]]
[18:40:50.947]                 NAMES <- toupper(changed)
[18:40:50.947]                 args <- list()
[18:40:50.947]                 for (kk in seq_along(NAMES)) {
[18:40:50.947]                   name <- changed[[kk]]
[18:40:50.947]                   NAME <- NAMES[[kk]]
[18:40:50.947]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.947]                     next
[18:40:50.947]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.947]                 }
[18:40:50.947]                 NAMES <- toupper(added)
[18:40:50.947]                 for (kk in seq_along(NAMES)) {
[18:40:50.947]                   name <- added[[kk]]
[18:40:50.947]                   NAME <- NAMES[[kk]]
[18:40:50.947]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.947]                     next
[18:40:50.947]                   args[[name]] <- ""
[18:40:50.947]                 }
[18:40:50.947]                 NAMES <- toupper(removed)
[18:40:50.947]                 for (kk in seq_along(NAMES)) {
[18:40:50.947]                   name <- removed[[kk]]
[18:40:50.947]                   NAME <- NAMES[[kk]]
[18:40:50.947]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.947]                     next
[18:40:50.947]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.947]                 }
[18:40:50.947]                 if (length(args) > 0) 
[18:40:50.947]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.947]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.947]             }
[18:40:50.947]             else {
[18:40:50.947]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.947]             }
[18:40:50.947]             {
[18:40:50.947]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.947]                   0L) {
[18:40:50.947]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.947]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.947]                   base::options(opts)
[18:40:50.947]                 }
[18:40:50.947]                 {
[18:40:50.947]                   {
[18:40:50.947]                     NULL
[18:40:50.947]                     RNGkind("Mersenne-Twister")
[18:40:50.947]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.947]                       inherits = FALSE)
[18:40:50.947]                   }
[18:40:50.947]                   options(future.plan = NULL)
[18:40:50.947]                   if (is.na(NA_character_)) 
[18:40:50.947]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.947]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.947]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.947]                     .init = FALSE)
[18:40:50.947]                 }
[18:40:50.947]             }
[18:40:50.947]         }
[18:40:50.947]     })
[18:40:50.947]     if (TRUE) {
[18:40:50.947]         base::sink(type = "output", split = FALSE)
[18:40:50.947]         if (TRUE) {
[18:40:50.947]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.947]         }
[18:40:50.947]         else {
[18:40:50.947]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.947]         }
[18:40:50.947]         base::close(...future.stdout)
[18:40:50.947]         ...future.stdout <- NULL
[18:40:50.947]     }
[18:40:50.947]     ...future.result$conditions <- ...future.conditions
[18:40:50.947]     ...future.result$finished <- base::Sys.time()
[18:40:50.947]     ...future.result
[18:40:50.947] }
[18:40:50.951] plan(): Setting new future strategy stack:
[18:40:50.951] List of future strategies:
[18:40:50.951] 1. sequential:
[18:40:50.951]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:50.951]    - tweaked: FALSE
[18:40:50.951]    - call: NULL
[18:40:50.952] plan(): nbrOfWorkers() = 1
[18:40:50.953] plan(): Setting new future strategy stack:
[18:40:50.953] List of future strategies:
[18:40:50.953] 1. multisession:
[18:40:50.953]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:50.953]    - tweaked: FALSE
[18:40:50.953]    - call: plan(strategy)
[18:40:50.956] plan(): nbrOfWorkers() = 1
[18:40:50.956] SequentialFuture started (and completed)
[18:40:50.957] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[18:40:50.959] plan(): nbrOfWorkers() = 1
[18:40:50.959] future_by_internal() ...
[18:40:50.959] future_lapply() ...
[18:40:50.962] Number of chunks: 1
[18:40:50.962] getGlobalsAndPackagesXApply() ...
[18:40:50.962]  - future.globals: TRUE
[18:40:50.963] getGlobalsAndPackages() ...
[18:40:50.963] Searching for globals...
[18:40:50.964] - globals found: [2] 'FUN', 'UseMethod'
[18:40:50.964] Searching for globals ... DONE
[18:40:50.964] Resolving globals: FALSE
[18:40:50.965] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:50.965] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:50.966] - globals: [1] 'FUN'
[18:40:50.966] 
[18:40:50.966] getGlobalsAndPackages() ... DONE
[18:40:50.966]  - globals found/used: [n=1] 'FUN'
[18:40:50.966]  - needed namespaces: [n=0] 
[18:40:50.966] Finding globals ... DONE
[18:40:50.967]  - use_args: TRUE
[18:40:50.967]  - Getting '...' globals ...
[18:40:50.967] resolve() on list ...
[18:40:50.967]  recursive: 0
[18:40:50.967]  length: 1
[18:40:50.968]  elements: '...'
[18:40:50.968]  length: 0 (resolved future 1)
[18:40:50.968] resolve() on list ... DONE
[18:40:50.968]    - '...' content: [n=0] 
[18:40:50.968] List of 1
[18:40:50.968]  $ ...: list()
[18:40:50.968]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.968]  - attr(*, "where")=List of 1
[18:40:50.968]   ..$ ...:<environment: 0x000001cd51534928> 
[18:40:50.968]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.968]  - attr(*, "resolved")= logi TRUE
[18:40:50.968]  - attr(*, "total_size")= num NA
[18:40:50.971]  - Getting '...' globals ... DONE
[18:40:50.971] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:50.972] List of 2
[18:40:50.972]  $ ...future.FUN:function (object, ...)  
[18:40:50.972]  $ ...          : list()
[18:40:50.972]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.972]  - attr(*, "where")=List of 2
[18:40:50.972]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:50.972]   ..$ ...          :<environment: 0x000001cd51534928> 
[18:40:50.972]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.972]  - attr(*, "resolved")= logi FALSE
[18:40:50.972]  - attr(*, "total_size")= int 15670
[18:40:50.975] Packages to be attached in all futures: [n=0] 
[18:40:50.975] getGlobalsAndPackagesXApply() ... DONE
[18:40:50.975] Number of futures (= number of chunks): 1
[18:40:50.976] Launching 1 futures (chunks) ...
[18:40:50.976] Chunk #1 of 1 ...
[18:40:50.976]  - Finding globals in 'X' for chunk #1 ...
[18:40:50.976] getGlobalsAndPackages() ...
[18:40:50.976] Searching for globals...
[18:40:50.977] 
[18:40:50.977] Searching for globals ... DONE
[18:40:50.977] - globals: [0] <none>
[18:40:50.977] getGlobalsAndPackages() ... DONE
[18:40:50.977]    + additional globals found: [n=0] 
[18:40:50.978]    + additional namespaces needed: [n=0] 
[18:40:50.978]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:50.978]  - seeds: <none>
[18:40:50.978]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.978] getGlobalsAndPackages() ...
[18:40:50.978] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.979] Resolving globals: FALSE
[18:40:50.979] Tweak future expression to call with '...' arguments ...
[18:40:50.979] {
[18:40:50.979]     do.call(function(...) {
[18:40:50.979]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.979]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:50.979]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.979]             on.exit(options(oopts), add = TRUE)
[18:40:50.979]         }
[18:40:50.979]         {
[18:40:50.979]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:50.979]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.979]                 ...future.FUN(...future.X_jj, ...)
[18:40:50.979]             })
[18:40:50.979]         }
[18:40:50.979]     }, args = future.call.arguments)
[18:40:50.979] }
[18:40:50.979] Tweak future expression to call with '...' arguments ... DONE
[18:40:50.980] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:50.980] 
[18:40:50.980] getGlobalsAndPackages() ... DONE
[18:40:50.980] run() for 'Future' ...
[18:40:50.981] - state: 'created'
[18:40:50.981] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:50.983] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:50.983] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:50.984]   - Field: 'label'
[18:40:50.984]   - Field: 'local'
[18:40:50.984]   - Field: 'owner'
[18:40:50.984]   - Field: 'envir'
[18:40:50.984]   - Field: 'packages'
[18:40:50.985]   - Field: 'gc'
[18:40:50.985]   - Field: 'conditions'
[18:40:50.985]   - Field: 'expr'
[18:40:50.985]   - Field: 'uuid'
[18:40:50.985]   - Field: 'seed'
[18:40:50.985]   - Field: 'version'
[18:40:50.986]   - Field: 'result'
[18:40:50.986]   - Field: 'asynchronous'
[18:40:50.986]   - Field: 'calls'
[18:40:50.986]   - Field: 'globals'
[18:40:50.986]   - Field: 'stdout'
[18:40:50.986]   - Field: 'earlySignal'
[18:40:50.987]   - Field: 'lazy'
[18:40:50.987]   - Field: 'state'
[18:40:50.987] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:50.987] - Launch lazy future ...
[18:40:50.987] Packages needed by the future expression (n = 0): <none>
[18:40:50.988] Packages needed by future strategies (n = 0): <none>
[18:40:50.988] {
[18:40:50.988]     {
[18:40:50.988]         {
[18:40:50.988]             ...future.startTime <- base::Sys.time()
[18:40:50.988]             {
[18:40:50.988]                 {
[18:40:50.988]                   {
[18:40:50.988]                     base::local({
[18:40:50.988]                       has_future <- base::requireNamespace("future", 
[18:40:50.988]                         quietly = TRUE)
[18:40:50.988]                       if (has_future) {
[18:40:50.988]                         ns <- base::getNamespace("future")
[18:40:50.988]                         version <- ns[[".package"]][["version"]]
[18:40:50.988]                         if (is.null(version)) 
[18:40:50.988]                           version <- utils::packageVersion("future")
[18:40:50.988]                       }
[18:40:50.988]                       else {
[18:40:50.988]                         version <- NULL
[18:40:50.988]                       }
[18:40:50.988]                       if (!has_future || version < "1.8.0") {
[18:40:50.988]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:50.988]                           "", base::R.version$version.string), 
[18:40:50.988]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:50.988]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:50.988]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:50.988]                             "release", "version")], collapse = " "), 
[18:40:50.988]                           hostname = base::Sys.info()[["nodename"]])
[18:40:50.988]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:50.988]                           info)
[18:40:50.988]                         info <- base::paste(info, collapse = "; ")
[18:40:50.988]                         if (!has_future) {
[18:40:50.988]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:50.988]                             info)
[18:40:50.988]                         }
[18:40:50.988]                         else {
[18:40:50.988]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:50.988]                             info, version)
[18:40:50.988]                         }
[18:40:50.988]                         base::stop(msg)
[18:40:50.988]                       }
[18:40:50.988]                     })
[18:40:50.988]                   }
[18:40:50.988]                   ...future.strategy.old <- future::plan("list")
[18:40:50.988]                   options(future.plan = NULL)
[18:40:50.988]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.988]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:50.988]                 }
[18:40:50.988]                 ...future.workdir <- getwd()
[18:40:50.988]             }
[18:40:50.988]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:50.988]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:50.988]         }
[18:40:50.988]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:50.988]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:50.988]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:50.988]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:50.988]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:50.988]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:50.988]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:50.988]             base::names(...future.oldOptions))
[18:40:50.988]     }
[18:40:50.988]     if (FALSE) {
[18:40:50.988]     }
[18:40:50.988]     else {
[18:40:50.988]         if (TRUE) {
[18:40:50.988]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:50.988]                 open = "w")
[18:40:50.988]         }
[18:40:50.988]         else {
[18:40:50.988]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:50.988]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:50.988]         }
[18:40:50.988]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:50.988]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:50.988]             base::sink(type = "output", split = FALSE)
[18:40:50.988]             base::close(...future.stdout)
[18:40:50.988]         }, add = TRUE)
[18:40:50.988]     }
[18:40:50.988]     ...future.frame <- base::sys.nframe()
[18:40:50.988]     ...future.conditions <- base::list()
[18:40:50.988]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:50.988]     if (FALSE) {
[18:40:50.988]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:50.988]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:50.988]     }
[18:40:50.988]     ...future.result <- base::tryCatch({
[18:40:50.988]         base::withCallingHandlers({
[18:40:50.988]             ...future.value <- base::withVisible(base::local({
[18:40:50.988]                 do.call(function(...) {
[18:40:50.988]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:50.988]                   if (!identical(...future.globals.maxSize.org, 
[18:40:50.988]                     ...future.globals.maxSize)) {
[18:40:50.988]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:50.988]                     on.exit(options(oopts), add = TRUE)
[18:40:50.988]                   }
[18:40:50.988]                   {
[18:40:50.988]                     lapply(seq_along(...future.elements_ii), 
[18:40:50.988]                       FUN = function(jj) {
[18:40:50.988]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:50.988]                         ...future.FUN(...future.X_jj, ...)
[18:40:50.988]                       })
[18:40:50.988]                   }
[18:40:50.988]                 }, args = future.call.arguments)
[18:40:50.988]             }))
[18:40:50.988]             future::FutureResult(value = ...future.value$value, 
[18:40:50.988]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.988]                   ...future.rng), globalenv = if (FALSE) 
[18:40:50.988]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:50.988]                     ...future.globalenv.names))
[18:40:50.988]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:50.988]         }, condition = base::local({
[18:40:50.988]             c <- base::c
[18:40:50.988]             inherits <- base::inherits
[18:40:50.988]             invokeRestart <- base::invokeRestart
[18:40:50.988]             length <- base::length
[18:40:50.988]             list <- base::list
[18:40:50.988]             seq.int <- base::seq.int
[18:40:50.988]             signalCondition <- base::signalCondition
[18:40:50.988]             sys.calls <- base::sys.calls
[18:40:50.988]             `[[` <- base::`[[`
[18:40:50.988]             `+` <- base::`+`
[18:40:50.988]             `<<-` <- base::`<<-`
[18:40:50.988]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:50.988]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:50.988]                   3L)]
[18:40:50.988]             }
[18:40:50.988]             function(cond) {
[18:40:50.988]                 is_error <- inherits(cond, "error")
[18:40:50.988]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:50.988]                   NULL)
[18:40:50.988]                 if (is_error) {
[18:40:50.988]                   sessionInformation <- function() {
[18:40:50.988]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:50.988]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:50.988]                       search = base::search(), system = base::Sys.info())
[18:40:50.988]                   }
[18:40:50.988]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.988]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:50.988]                     cond$call), session = sessionInformation(), 
[18:40:50.988]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:50.988]                   signalCondition(cond)
[18:40:50.988]                 }
[18:40:50.988]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:50.988]                 "immediateCondition"))) {
[18:40:50.988]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:50.988]                   ...future.conditions[[length(...future.conditions) + 
[18:40:50.988]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:50.988]                   if (TRUE && !signal) {
[18:40:50.988]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.988]                     {
[18:40:50.988]                       inherits <- base::inherits
[18:40:50.988]                       invokeRestart <- base::invokeRestart
[18:40:50.988]                       is.null <- base::is.null
[18:40:50.988]                       muffled <- FALSE
[18:40:50.988]                       if (inherits(cond, "message")) {
[18:40:50.988]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.988]                         if (muffled) 
[18:40:50.988]                           invokeRestart("muffleMessage")
[18:40:50.988]                       }
[18:40:50.988]                       else if (inherits(cond, "warning")) {
[18:40:50.988]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.988]                         if (muffled) 
[18:40:50.988]                           invokeRestart("muffleWarning")
[18:40:50.988]                       }
[18:40:50.988]                       else if (inherits(cond, "condition")) {
[18:40:50.988]                         if (!is.null(pattern)) {
[18:40:50.988]                           computeRestarts <- base::computeRestarts
[18:40:50.988]                           grepl <- base::grepl
[18:40:50.988]                           restarts <- computeRestarts(cond)
[18:40:50.988]                           for (restart in restarts) {
[18:40:50.988]                             name <- restart$name
[18:40:50.988]                             if (is.null(name)) 
[18:40:50.988]                               next
[18:40:50.988]                             if (!grepl(pattern, name)) 
[18:40:50.988]                               next
[18:40:50.988]                             invokeRestart(restart)
[18:40:50.988]                             muffled <- TRUE
[18:40:50.988]                             break
[18:40:50.988]                           }
[18:40:50.988]                         }
[18:40:50.988]                       }
[18:40:50.988]                       invisible(muffled)
[18:40:50.988]                     }
[18:40:50.988]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.988]                   }
[18:40:50.988]                 }
[18:40:50.988]                 else {
[18:40:50.988]                   if (TRUE) {
[18:40:50.988]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:50.988]                     {
[18:40:50.988]                       inherits <- base::inherits
[18:40:50.988]                       invokeRestart <- base::invokeRestart
[18:40:50.988]                       is.null <- base::is.null
[18:40:50.988]                       muffled <- FALSE
[18:40:50.988]                       if (inherits(cond, "message")) {
[18:40:50.988]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:50.988]                         if (muffled) 
[18:40:50.988]                           invokeRestart("muffleMessage")
[18:40:50.988]                       }
[18:40:50.988]                       else if (inherits(cond, "warning")) {
[18:40:50.988]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:50.988]                         if (muffled) 
[18:40:50.988]                           invokeRestart("muffleWarning")
[18:40:50.988]                       }
[18:40:50.988]                       else if (inherits(cond, "condition")) {
[18:40:50.988]                         if (!is.null(pattern)) {
[18:40:50.988]                           computeRestarts <- base::computeRestarts
[18:40:50.988]                           grepl <- base::grepl
[18:40:50.988]                           restarts <- computeRestarts(cond)
[18:40:50.988]                           for (restart in restarts) {
[18:40:50.988]                             name <- restart$name
[18:40:50.988]                             if (is.null(name)) 
[18:40:50.988]                               next
[18:40:50.988]                             if (!grepl(pattern, name)) 
[18:40:50.988]                               next
[18:40:50.988]                             invokeRestart(restart)
[18:40:50.988]                             muffled <- TRUE
[18:40:50.988]                             break
[18:40:50.988]                           }
[18:40:50.988]                         }
[18:40:50.988]                       }
[18:40:50.988]                       invisible(muffled)
[18:40:50.988]                     }
[18:40:50.988]                     muffleCondition(cond, pattern = "^muffle")
[18:40:50.988]                   }
[18:40:50.988]                 }
[18:40:50.988]             }
[18:40:50.988]         }))
[18:40:50.988]     }, error = function(ex) {
[18:40:50.988]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:50.988]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:50.988]                 ...future.rng), started = ...future.startTime, 
[18:40:50.988]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:50.988]             version = "1.8"), class = "FutureResult")
[18:40:50.988]     }, finally = {
[18:40:50.988]         if (!identical(...future.workdir, getwd())) 
[18:40:50.988]             setwd(...future.workdir)
[18:40:50.988]         {
[18:40:50.988]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:50.988]                 ...future.oldOptions$nwarnings <- NULL
[18:40:50.988]             }
[18:40:50.988]             base::options(...future.oldOptions)
[18:40:50.988]             if (.Platform$OS.type == "windows") {
[18:40:50.988]                 old_names <- names(...future.oldEnvVars)
[18:40:50.988]                 envs <- base::Sys.getenv()
[18:40:50.988]                 names <- names(envs)
[18:40:50.988]                 common <- intersect(names, old_names)
[18:40:50.988]                 added <- setdiff(names, old_names)
[18:40:50.988]                 removed <- setdiff(old_names, names)
[18:40:50.988]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:50.988]                   envs[common]]
[18:40:50.988]                 NAMES <- toupper(changed)
[18:40:50.988]                 args <- list()
[18:40:50.988]                 for (kk in seq_along(NAMES)) {
[18:40:50.988]                   name <- changed[[kk]]
[18:40:50.988]                   NAME <- NAMES[[kk]]
[18:40:50.988]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.988]                     next
[18:40:50.988]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.988]                 }
[18:40:50.988]                 NAMES <- toupper(added)
[18:40:50.988]                 for (kk in seq_along(NAMES)) {
[18:40:50.988]                   name <- added[[kk]]
[18:40:50.988]                   NAME <- NAMES[[kk]]
[18:40:50.988]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.988]                     next
[18:40:50.988]                   args[[name]] <- ""
[18:40:50.988]                 }
[18:40:50.988]                 NAMES <- toupper(removed)
[18:40:50.988]                 for (kk in seq_along(NAMES)) {
[18:40:50.988]                   name <- removed[[kk]]
[18:40:50.988]                   NAME <- NAMES[[kk]]
[18:40:50.988]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:50.988]                     next
[18:40:50.988]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:50.988]                 }
[18:40:50.988]                 if (length(args) > 0) 
[18:40:50.988]                   base::do.call(base::Sys.setenv, args = args)
[18:40:50.988]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:50.988]             }
[18:40:50.988]             else {
[18:40:50.988]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:50.988]             }
[18:40:50.988]             {
[18:40:50.988]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:50.988]                   0L) {
[18:40:50.988]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:50.988]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:50.988]                   base::options(opts)
[18:40:50.988]                 }
[18:40:50.988]                 {
[18:40:50.988]                   {
[18:40:50.988]                     NULL
[18:40:50.988]                     RNGkind("Mersenne-Twister")
[18:40:50.988]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:50.988]                       inherits = FALSE)
[18:40:50.988]                   }
[18:40:50.988]                   options(future.plan = NULL)
[18:40:50.988]                   if (is.na(NA_character_)) 
[18:40:50.988]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:50.988]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:50.988]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:50.988]                     .init = FALSE)
[18:40:50.988]                 }
[18:40:50.988]             }
[18:40:50.988]         }
[18:40:50.988]     })
[18:40:50.988]     if (TRUE) {
[18:40:50.988]         base::sink(type = "output", split = FALSE)
[18:40:50.988]         if (TRUE) {
[18:40:50.988]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:50.988]         }
[18:40:50.988]         else {
[18:40:50.988]             ...future.result["stdout"] <- base::list(NULL)
[18:40:50.988]         }
[18:40:50.988]         base::close(...future.stdout)
[18:40:50.988]         ...future.stdout <- NULL
[18:40:50.988]     }
[18:40:50.988]     ...future.result$conditions <- ...future.conditions
[18:40:50.988]     ...future.result$finished <- base::Sys.time()
[18:40:50.988]     ...future.result
[18:40:50.988] }
[18:40:50.992] assign_globals() ...
[18:40:50.992] List of 5
[18:40:50.992]  $ ...future.FUN            :function (object, ...)  
[18:40:50.992]  $ future.call.arguments    : list()
[18:40:50.992]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:50.992]  $ ...future.elements_ii    :List of 3
[18:40:50.992]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:50.992]   .. ..$ breaks: num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:50.992]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.992]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:50.992]   .. ..$ breaks: num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:50.992]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.992]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:50.992]   .. ..$ breaks: num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:50.992]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:50.992]  $ ...future.seeds_ii       : NULL
[18:40:50.992]  $ ...future.globals.maxSize: NULL
[18:40:50.992]  - attr(*, "where")=List of 5
[18:40:50.992]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:50.992]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:50.992]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:50.992]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:50.992]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:50.992]  - attr(*, "resolved")= logi FALSE
[18:40:50.992]  - attr(*, "total_size")= num 15670
[18:40:50.992]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:50.992]  - attr(*, "already-done")= logi TRUE
[18:40:51.003] - copied '...future.FUN' to environment
[18:40:51.003] - copied 'future.call.arguments' to environment
[18:40:51.004] - copied '...future.elements_ii' to environment
[18:40:51.004] - copied '...future.seeds_ii' to environment
[18:40:51.004] - copied '...future.globals.maxSize' to environment
[18:40:51.004] assign_globals() ... done
[18:40:51.004] plan(): Setting new future strategy stack:
[18:40:51.005] List of future strategies:
[18:40:51.005] 1. sequential:
[18:40:51.005]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.005]    - tweaked: FALSE
[18:40:51.005]    - call: NULL
[18:40:51.005] plan(): nbrOfWorkers() = 1
[18:40:51.008] plan(): Setting new future strategy stack:
[18:40:51.008] List of future strategies:
[18:40:51.008] 1. multisession:
[18:40:51.008]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.008]    - tweaked: FALSE
[18:40:51.008]    - call: plan(strategy)
[18:40:51.010] plan(): nbrOfWorkers() = 1
[18:40:51.011] SequentialFuture started (and completed)
[18:40:51.011] - Launch lazy future ... done
[18:40:51.011] run() for 'SequentialFuture' ... done
[18:40:51.011] Created future:
[18:40:51.011] SequentialFuture:
[18:40:51.011] Label: 'future_by-1'
[18:40:51.011] Expression:
[18:40:51.011] {
[18:40:51.011]     do.call(function(...) {
[18:40:51.011]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.011]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.011]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.011]             on.exit(options(oopts), add = TRUE)
[18:40:51.011]         }
[18:40:51.011]         {
[18:40:51.011]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.011]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.011]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.011]             })
[18:40:51.011]         }
[18:40:51.011]     }, args = future.call.arguments)
[18:40:51.011] }
[18:40:51.011] Lazy evaluation: FALSE
[18:40:51.011] Asynchronous evaluation: FALSE
[18:40:51.011] Local evaluation: TRUE
[18:40:51.011] Environment: R_GlobalEnv
[18:40:51.011] Capture standard output: TRUE
[18:40:51.011] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.011] Globals: 5 objects totaling 1.90 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.48 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.011] Packages: <none>
[18:40:51.011] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.011] Resolved: TRUE
[18:40:51.011] Value: 1.16 KiB of class 'list'
[18:40:51.011] Early signaling: FALSE
[18:40:51.011] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.011] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.013] Chunk #1 of 1 ... DONE
[18:40:51.013] Launching 1 futures (chunks) ... DONE
[18:40:51.013] Resolving 1 futures (chunks) ...
[18:40:51.013] resolve() on list ...
[18:40:51.013]  recursive: 0
[18:40:51.013]  length: 1
[18:40:51.013] 
[18:40:51.014] resolved() for 'SequentialFuture' ...
[18:40:51.014] - state: 'finished'
[18:40:51.014] - run: TRUE
[18:40:51.014] - result: 'FutureResult'
[18:40:51.014] resolved() for 'SequentialFuture' ... done
[18:40:51.015] Future #1
[18:40:51.015] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.015] - nx: 1
[18:40:51.015] - relay: TRUE
[18:40:51.015] - stdout: TRUE
[18:40:51.015] - signal: TRUE
[18:40:51.016] - resignal: FALSE
[18:40:51.016] - force: TRUE
[18:40:51.016] - relayed: [n=1] FALSE
[18:40:51.016] - queued futures: [n=1] FALSE
[18:40:51.016]  - until=1
[18:40:51.016]  - relaying element #1
[18:40:51.017] - relayed: [n=1] TRUE
[18:40:51.017] - queued futures: [n=1] TRUE
[18:40:51.017] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.017]  length: 0 (resolved future 1)
[18:40:51.017] Relaying remaining futures
[18:40:51.017] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.018] - nx: 1
[18:40:51.018] - relay: TRUE
[18:40:51.018] - stdout: TRUE
[18:40:51.018] - signal: TRUE
[18:40:51.018] - resignal: FALSE
[18:40:51.018] - force: TRUE
[18:40:51.018] - relayed: [n=1] TRUE
[18:40:51.019] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.019] - relayed: [n=1] TRUE
[18:40:51.019] - queued futures: [n=1] TRUE
[18:40:51.019] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.019] resolve() on list ... DONE
[18:40:51.020]  - Number of value chunks collected: 1
[18:40:51.020] Resolving 1 futures (chunks) ... DONE
[18:40:51.020] Reducing values from 1 chunks ...
[18:40:51.020]  - Number of values collected after concatenation: 3
[18:40:51.020]  - Number of values expected: 3
[18:40:51.020] Reducing values from 1 chunks ... DONE
[18:40:51.020] future_lapply() ... DONE
[18:40:51.021] future_by_internal() ... DONE
[18:40:51.021] future_by_internal() ...
[18:40:51.021] future_lapply() ...
[18:40:51.024] Number of chunks: 1
[18:40:51.024] getGlobalsAndPackagesXApply() ...
[18:40:51.024]  - future.globals: TRUE
[18:40:51.024] getGlobalsAndPackages() ...
[18:40:51.025] Searching for globals...
[18:40:51.026] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.026] Searching for globals ... DONE
[18:40:51.026] Resolving globals: FALSE
[18:40:51.027] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.027] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.027] - globals: [1] 'FUN'
[18:40:51.027] 
[18:40:51.028] getGlobalsAndPackages() ... DONE
[18:40:51.028]  - globals found/used: [n=1] 'FUN'
[18:40:51.028]  - needed namespaces: [n=0] 
[18:40:51.028] Finding globals ... DONE
[18:40:51.028]  - use_args: TRUE
[18:40:51.028]  - Getting '...' globals ...
[18:40:51.029] resolve() on list ...
[18:40:51.029]  recursive: 0
[18:40:51.029]  length: 1
[18:40:51.029]  elements: '...'
[18:40:51.030]  length: 0 (resolved future 1)
[18:40:51.030] resolve() on list ... DONE
[18:40:51.030]    - '...' content: [n=1] 'digits'
[18:40:51.030] List of 1
[18:40:51.030]  $ ...:List of 1
[18:40:51.030]   ..$ digits: int 2
[18:40:51.030]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.030]  - attr(*, "where")=List of 1
[18:40:51.030]   ..$ ...:<environment: 0x000001cd4d7a8b20> 
[18:40:51.030]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.030]  - attr(*, "resolved")= logi TRUE
[18:40:51.030]  - attr(*, "total_size")= num NA
[18:40:51.033]  - Getting '...' globals ... DONE
[18:40:51.034] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.034] List of 2
[18:40:51.034]  $ ...future.FUN:function (object, ...)  
[18:40:51.034]  $ ...          :List of 1
[18:40:51.034]   ..$ digits: int 2
[18:40:51.034]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.034]  - attr(*, "where")=List of 2
[18:40:51.034]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.034]   ..$ ...          :<environment: 0x000001cd4d7a8b20> 
[18:40:51.034]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.034]  - attr(*, "resolved")= logi FALSE
[18:40:51.034]  - attr(*, "total_size")= int 13284
[18:40:51.038] Packages to be attached in all futures: [n=0] 
[18:40:51.038] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.038] Number of futures (= number of chunks): 1
[18:40:51.038] Launching 1 futures (chunks) ...
[18:40:51.038] Chunk #1 of 1 ...
[18:40:51.039]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.039] getGlobalsAndPackages() ...
[18:40:51.039] Searching for globals...
[18:40:51.039] 
[18:40:51.039] Searching for globals ... DONE
[18:40:51.040] - globals: [0] <none>
[18:40:51.040] getGlobalsAndPackages() ... DONE
[18:40:51.040]    + additional globals found: [n=0] 
[18:40:51.040]    + additional namespaces needed: [n=0] 
[18:40:51.040]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.040]  - seeds: <none>
[18:40:51.040]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.041] getGlobalsAndPackages() ...
[18:40:51.041] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.041] Resolving globals: FALSE
[18:40:51.041] Tweak future expression to call with '...' arguments ...
[18:40:51.041] {
[18:40:51.041]     do.call(function(...) {
[18:40:51.041]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.041]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.041]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.041]             on.exit(options(oopts), add = TRUE)
[18:40:51.041]         }
[18:40:51.041]         {
[18:40:51.041]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.041]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.041]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.041]             })
[18:40:51.041]         }
[18:40:51.041]     }, args = future.call.arguments)
[18:40:51.041] }
[18:40:51.042] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.042] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.043] 
[18:40:51.043] getGlobalsAndPackages() ... DONE
[18:40:51.043] run() for 'Future' ...
[18:40:51.043] - state: 'created'
[18:40:51.044] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:51.046] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.046] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.046]   - Field: 'label'
[18:40:51.047]   - Field: 'local'
[18:40:51.047]   - Field: 'owner'
[18:40:51.047]   - Field: 'envir'
[18:40:51.047]   - Field: 'packages'
[18:40:51.047]   - Field: 'gc'
[18:40:51.047]   - Field: 'conditions'
[18:40:51.048]   - Field: 'expr'
[18:40:51.048]   - Field: 'uuid'
[18:40:51.048]   - Field: 'seed'
[18:40:51.048]   - Field: 'version'
[18:40:51.048]   - Field: 'result'
[18:40:51.048]   - Field: 'asynchronous'
[18:40:51.049]   - Field: 'calls'
[18:40:51.049]   - Field: 'globals'
[18:40:51.049]   - Field: 'stdout'
[18:40:51.049]   - Field: 'earlySignal'
[18:40:51.049]   - Field: 'lazy'
[18:40:51.049]   - Field: 'state'
[18:40:51.050] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.050] - Launch lazy future ...
[18:40:51.050] Packages needed by the future expression (n = 0): <none>
[18:40:51.050] Packages needed by future strategies (n = 0): <none>
[18:40:51.051] {
[18:40:51.051]     {
[18:40:51.051]         {
[18:40:51.051]             ...future.startTime <- base::Sys.time()
[18:40:51.051]             {
[18:40:51.051]                 {
[18:40:51.051]                   {
[18:40:51.051]                     base::local({
[18:40:51.051]                       has_future <- base::requireNamespace("future", 
[18:40:51.051]                         quietly = TRUE)
[18:40:51.051]                       if (has_future) {
[18:40:51.051]                         ns <- base::getNamespace("future")
[18:40:51.051]                         version <- ns[[".package"]][["version"]]
[18:40:51.051]                         if (is.null(version)) 
[18:40:51.051]                           version <- utils::packageVersion("future")
[18:40:51.051]                       }
[18:40:51.051]                       else {
[18:40:51.051]                         version <- NULL
[18:40:51.051]                       }
[18:40:51.051]                       if (!has_future || version < "1.8.0") {
[18:40:51.051]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.051]                           "", base::R.version$version.string), 
[18:40:51.051]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.051]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.051]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.051]                             "release", "version")], collapse = " "), 
[18:40:51.051]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.051]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.051]                           info)
[18:40:51.051]                         info <- base::paste(info, collapse = "; ")
[18:40:51.051]                         if (!has_future) {
[18:40:51.051]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.051]                             info)
[18:40:51.051]                         }
[18:40:51.051]                         else {
[18:40:51.051]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.051]                             info, version)
[18:40:51.051]                         }
[18:40:51.051]                         base::stop(msg)
[18:40:51.051]                       }
[18:40:51.051]                     })
[18:40:51.051]                   }
[18:40:51.051]                   ...future.strategy.old <- future::plan("list")
[18:40:51.051]                   options(future.plan = NULL)
[18:40:51.051]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.051]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.051]                 }
[18:40:51.051]                 ...future.workdir <- getwd()
[18:40:51.051]             }
[18:40:51.051]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.051]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.051]         }
[18:40:51.051]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.051]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.051]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.051]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.051]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.051]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.051]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.051]             base::names(...future.oldOptions))
[18:40:51.051]     }
[18:40:51.051]     if (FALSE) {
[18:40:51.051]     }
[18:40:51.051]     else {
[18:40:51.051]         if (TRUE) {
[18:40:51.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.051]                 open = "w")
[18:40:51.051]         }
[18:40:51.051]         else {
[18:40:51.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.051]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.051]         }
[18:40:51.051]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.051]             base::sink(type = "output", split = FALSE)
[18:40:51.051]             base::close(...future.stdout)
[18:40:51.051]         }, add = TRUE)
[18:40:51.051]     }
[18:40:51.051]     ...future.frame <- base::sys.nframe()
[18:40:51.051]     ...future.conditions <- base::list()
[18:40:51.051]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.051]     if (FALSE) {
[18:40:51.051]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.051]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.051]     }
[18:40:51.051]     ...future.result <- base::tryCatch({
[18:40:51.051]         base::withCallingHandlers({
[18:40:51.051]             ...future.value <- base::withVisible(base::local({
[18:40:51.051]                 do.call(function(...) {
[18:40:51.051]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.051]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.051]                     ...future.globals.maxSize)) {
[18:40:51.051]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.051]                     on.exit(options(oopts), add = TRUE)
[18:40:51.051]                   }
[18:40:51.051]                   {
[18:40:51.051]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.051]                       FUN = function(jj) {
[18:40:51.051]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.051]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.051]                       })
[18:40:51.051]                   }
[18:40:51.051]                 }, args = future.call.arguments)
[18:40:51.051]             }))
[18:40:51.051]             future::FutureResult(value = ...future.value$value, 
[18:40:51.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.051]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.051]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.051]                     ...future.globalenv.names))
[18:40:51.051]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.051]         }, condition = base::local({
[18:40:51.051]             c <- base::c
[18:40:51.051]             inherits <- base::inherits
[18:40:51.051]             invokeRestart <- base::invokeRestart
[18:40:51.051]             length <- base::length
[18:40:51.051]             list <- base::list
[18:40:51.051]             seq.int <- base::seq.int
[18:40:51.051]             signalCondition <- base::signalCondition
[18:40:51.051]             sys.calls <- base::sys.calls
[18:40:51.051]             `[[` <- base::`[[`
[18:40:51.051]             `+` <- base::`+`
[18:40:51.051]             `<<-` <- base::`<<-`
[18:40:51.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.051]                   3L)]
[18:40:51.051]             }
[18:40:51.051]             function(cond) {
[18:40:51.051]                 is_error <- inherits(cond, "error")
[18:40:51.051]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.051]                   NULL)
[18:40:51.051]                 if (is_error) {
[18:40:51.051]                   sessionInformation <- function() {
[18:40:51.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.051]                       search = base::search(), system = base::Sys.info())
[18:40:51.051]                   }
[18:40:51.051]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.051]                     cond$call), session = sessionInformation(), 
[18:40:51.051]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.051]                   signalCondition(cond)
[18:40:51.051]                 }
[18:40:51.051]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.051]                 "immediateCondition"))) {
[18:40:51.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.051]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.051]                   if (TRUE && !signal) {
[18:40:51.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.051]                     {
[18:40:51.051]                       inherits <- base::inherits
[18:40:51.051]                       invokeRestart <- base::invokeRestart
[18:40:51.051]                       is.null <- base::is.null
[18:40:51.051]                       muffled <- FALSE
[18:40:51.051]                       if (inherits(cond, "message")) {
[18:40:51.051]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.051]                         if (muffled) 
[18:40:51.051]                           invokeRestart("muffleMessage")
[18:40:51.051]                       }
[18:40:51.051]                       else if (inherits(cond, "warning")) {
[18:40:51.051]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.051]                         if (muffled) 
[18:40:51.051]                           invokeRestart("muffleWarning")
[18:40:51.051]                       }
[18:40:51.051]                       else if (inherits(cond, "condition")) {
[18:40:51.051]                         if (!is.null(pattern)) {
[18:40:51.051]                           computeRestarts <- base::computeRestarts
[18:40:51.051]                           grepl <- base::grepl
[18:40:51.051]                           restarts <- computeRestarts(cond)
[18:40:51.051]                           for (restart in restarts) {
[18:40:51.051]                             name <- restart$name
[18:40:51.051]                             if (is.null(name)) 
[18:40:51.051]                               next
[18:40:51.051]                             if (!grepl(pattern, name)) 
[18:40:51.051]                               next
[18:40:51.051]                             invokeRestart(restart)
[18:40:51.051]                             muffled <- TRUE
[18:40:51.051]                             break
[18:40:51.051]                           }
[18:40:51.051]                         }
[18:40:51.051]                       }
[18:40:51.051]                       invisible(muffled)
[18:40:51.051]                     }
[18:40:51.051]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.051]                   }
[18:40:51.051]                 }
[18:40:51.051]                 else {
[18:40:51.051]                   if (TRUE) {
[18:40:51.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.051]                     {
[18:40:51.051]                       inherits <- base::inherits
[18:40:51.051]                       invokeRestart <- base::invokeRestart
[18:40:51.051]                       is.null <- base::is.null
[18:40:51.051]                       muffled <- FALSE
[18:40:51.051]                       if (inherits(cond, "message")) {
[18:40:51.051]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.051]                         if (muffled) 
[18:40:51.051]                           invokeRestart("muffleMessage")
[18:40:51.051]                       }
[18:40:51.051]                       else if (inherits(cond, "warning")) {
[18:40:51.051]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.051]                         if (muffled) 
[18:40:51.051]                           invokeRestart("muffleWarning")
[18:40:51.051]                       }
[18:40:51.051]                       else if (inherits(cond, "condition")) {
[18:40:51.051]                         if (!is.null(pattern)) {
[18:40:51.051]                           computeRestarts <- base::computeRestarts
[18:40:51.051]                           grepl <- base::grepl
[18:40:51.051]                           restarts <- computeRestarts(cond)
[18:40:51.051]                           for (restart in restarts) {
[18:40:51.051]                             name <- restart$name
[18:40:51.051]                             if (is.null(name)) 
[18:40:51.051]                               next
[18:40:51.051]                             if (!grepl(pattern, name)) 
[18:40:51.051]                               next
[18:40:51.051]                             invokeRestart(restart)
[18:40:51.051]                             muffled <- TRUE
[18:40:51.051]                             break
[18:40:51.051]                           }
[18:40:51.051]                         }
[18:40:51.051]                       }
[18:40:51.051]                       invisible(muffled)
[18:40:51.051]                     }
[18:40:51.051]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.051]                   }
[18:40:51.051]                 }
[18:40:51.051]             }
[18:40:51.051]         }))
[18:40:51.051]     }, error = function(ex) {
[18:40:51.051]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.051]                 ...future.rng), started = ...future.startTime, 
[18:40:51.051]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.051]             version = "1.8"), class = "FutureResult")
[18:40:51.051]     }, finally = {
[18:40:51.051]         if (!identical(...future.workdir, getwd())) 
[18:40:51.051]             setwd(...future.workdir)
[18:40:51.051]         {
[18:40:51.051]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.051]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.051]             }
[18:40:51.051]             base::options(...future.oldOptions)
[18:40:51.051]             if (.Platform$OS.type == "windows") {
[18:40:51.051]                 old_names <- names(...future.oldEnvVars)
[18:40:51.051]                 envs <- base::Sys.getenv()
[18:40:51.051]                 names <- names(envs)
[18:40:51.051]                 common <- intersect(names, old_names)
[18:40:51.051]                 added <- setdiff(names, old_names)
[18:40:51.051]                 removed <- setdiff(old_names, names)
[18:40:51.051]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.051]                   envs[common]]
[18:40:51.051]                 NAMES <- toupper(changed)
[18:40:51.051]                 args <- list()
[18:40:51.051]                 for (kk in seq_along(NAMES)) {
[18:40:51.051]                   name <- changed[[kk]]
[18:40:51.051]                   NAME <- NAMES[[kk]]
[18:40:51.051]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.051]                     next
[18:40:51.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.051]                 }
[18:40:51.051]                 NAMES <- toupper(added)
[18:40:51.051]                 for (kk in seq_along(NAMES)) {
[18:40:51.051]                   name <- added[[kk]]
[18:40:51.051]                   NAME <- NAMES[[kk]]
[18:40:51.051]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.051]                     next
[18:40:51.051]                   args[[name]] <- ""
[18:40:51.051]                 }
[18:40:51.051]                 NAMES <- toupper(removed)
[18:40:51.051]                 for (kk in seq_along(NAMES)) {
[18:40:51.051]                   name <- removed[[kk]]
[18:40:51.051]                   NAME <- NAMES[[kk]]
[18:40:51.051]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.051]                     next
[18:40:51.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.051]                 }
[18:40:51.051]                 if (length(args) > 0) 
[18:40:51.051]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.051]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.051]             }
[18:40:51.051]             else {
[18:40:51.051]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.051]             }
[18:40:51.051]             {
[18:40:51.051]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.051]                   0L) {
[18:40:51.051]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.051]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.051]                   base::options(opts)
[18:40:51.051]                 }
[18:40:51.051]                 {
[18:40:51.051]                   {
[18:40:51.051]                     NULL
[18:40:51.051]                     RNGkind("Mersenne-Twister")
[18:40:51.051]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.051]                       inherits = FALSE)
[18:40:51.051]                   }
[18:40:51.051]                   options(future.plan = NULL)
[18:40:51.051]                   if (is.na(NA_character_)) 
[18:40:51.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.051]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.051]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.051]                     .init = FALSE)
[18:40:51.051]                 }
[18:40:51.051]             }
[18:40:51.051]         }
[18:40:51.051]     })
[18:40:51.051]     if (TRUE) {
[18:40:51.051]         base::sink(type = "output", split = FALSE)
[18:40:51.051]         if (TRUE) {
[18:40:51.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.051]         }
[18:40:51.051]         else {
[18:40:51.051]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.051]         }
[18:40:51.051]         base::close(...future.stdout)
[18:40:51.051]         ...future.stdout <- NULL
[18:40:51.051]     }
[18:40:51.051]     ...future.result$conditions <- ...future.conditions
[18:40:51.051]     ...future.result$finished <- base::Sys.time()
[18:40:51.051]     ...future.result
[18:40:51.051] }
[18:40:51.055] assign_globals() ...
[18:40:51.055] List of 5
[18:40:51.055]  $ ...future.FUN            :function (object, ...)  
[18:40:51.055]  $ future.call.arguments    :List of 1
[18:40:51.055]   ..$ digits: int 2
[18:40:51.055]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.055]  $ ...future.elements_ii    :List of 6
[18:40:51.055]   ..$ : num [1:9] 26 30 54 25 70 52 51 26 67
[18:40:51.055]   ..$ : num [1:9] 27 14 29 19 29 31 41 20 44
[18:40:51.055]   ..$ : num [1:9] 18 21 29 17 12 18 35 30 36
[18:40:51.055]   ..$ : num [1:9] 42 26 19 16 39 28 21 39 29
[18:40:51.055]   ..$ : num [1:9] 36 21 24 18 10 43 28 15 26
[18:40:51.055]   ..$ : num [1:9] 20 21 24 17 13 15 15 16 28
[18:40:51.055]  $ ...future.seeds_ii       : NULL
[18:40:51.055]  $ ...future.globals.maxSize: NULL
[18:40:51.055]  - attr(*, "where")=List of 5
[18:40:51.055]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.055]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.055]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.055]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.055]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.055]  - attr(*, "resolved")= logi FALSE
[18:40:51.055]  - attr(*, "total_size")= num 13284
[18:40:51.055]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.055]  - attr(*, "already-done")= logi TRUE
[18:40:51.063] - copied '...future.FUN' to environment
[18:40:51.063] - copied 'future.call.arguments' to environment
[18:40:51.064] - copied '...future.elements_ii' to environment
[18:40:51.064] - copied '...future.seeds_ii' to environment
[18:40:51.064] - copied '...future.globals.maxSize' to environment
[18:40:51.064] assign_globals() ... done
[18:40:51.064] plan(): Setting new future strategy stack:
[18:40:51.065] List of future strategies:
[18:40:51.065] 1. sequential:
[18:40:51.065]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.065]    - tweaked: FALSE
[18:40:51.065]    - call: NULL
[18:40:51.065] plan(): nbrOfWorkers() = 1
[18:40:51.067] plan(): Setting new future strategy stack:
[18:40:51.067] List of future strategies:
[18:40:51.067] 1. multisession:
[18:40:51.067]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.067]    - tweaked: FALSE
[18:40:51.067]    - call: plan(strategy)
[18:40:51.070] plan(): nbrOfWorkers() = 1
[18:40:51.070] SequentialFuture started (and completed)
[18:40:51.070] - Launch lazy future ... done
[18:40:51.070] run() for 'SequentialFuture' ... done
[18:40:51.071] Created future:
[18:40:51.071] SequentialFuture:
[18:40:51.071] Label: 'future_by-1'
[18:40:51.071] Expression:
[18:40:51.071] {
[18:40:51.071]     do.call(function(...) {
[18:40:51.071]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.071]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.071]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.071]             on.exit(options(oopts), add = TRUE)
[18:40:51.071]         }
[18:40:51.071]         {
[18:40:51.071]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.071]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.071]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.071]             })
[18:40:51.071]         }
[18:40:51.071]     }, args = future.call.arguments)
[18:40:51.071] }
[18:40:51.071] Lazy evaluation: FALSE
[18:40:51.071] Asynchronous evaluation: FALSE
[18:40:51.071] Local evaluation: TRUE
[18:40:51.071] Environment: R_GlobalEnv
[18:40:51.071] Capture standard output: TRUE
[18:40:51.071] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.071] Globals: 5 objects totaling 998 bytes (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 152 bytes, list '...future.elements_ii' of 511 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.071] Packages: <none>
[18:40:51.071] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.071] Resolved: TRUE
[18:40:51.071] Value: 1.27 KiB of class 'list'
[18:40:51.071] Early signaling: FALSE
[18:40:51.071] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.071] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.072] Chunk #1 of 1 ... DONE
[18:40:51.072] Launching 1 futures (chunks) ... DONE
[18:40:51.072] Resolving 1 futures (chunks) ...
[18:40:51.072] resolve() on list ...
[18:40:51.072]  recursive: 0
[18:40:51.073]  length: 1
[18:40:51.073] 
[18:40:51.073] resolved() for 'SequentialFuture' ...
[18:40:51.073] - state: 'finished'
[18:40:51.073] - run: TRUE
[18:40:51.073] - result: 'FutureResult'
[18:40:51.074] resolved() for 'SequentialFuture' ... done
[18:40:51.074] Future #1
[18:40:51.074] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.074] - nx: 1
[18:40:51.074] - relay: TRUE
[18:40:51.075] - stdout: TRUE
[18:40:51.075] - signal: TRUE
[18:40:51.075] - resignal: FALSE
[18:40:51.075] - force: TRUE
[18:40:51.075] - relayed: [n=1] FALSE
[18:40:51.075] - queued futures: [n=1] FALSE
[18:40:51.075]  - until=1
[18:40:51.076]  - relaying element #1
[18:40:51.076] - relayed: [n=1] TRUE
[18:40:51.076] - queued futures: [n=1] TRUE
[18:40:51.076] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.076]  length: 0 (resolved future 1)
[18:40:51.077] Relaying remaining futures
[18:40:51.077] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.077] - nx: 1
[18:40:51.077] - relay: TRUE
[18:40:51.077] - stdout: TRUE
[18:40:51.077] - signal: TRUE
[18:40:51.077] - resignal: FALSE
[18:40:51.078] - force: TRUE
[18:40:51.078] - relayed: [n=1] TRUE
[18:40:51.078] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.078] - relayed: [n=1] TRUE
[18:40:51.078] - queued futures: [n=1] TRUE
[18:40:51.078] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.079] resolve() on list ... DONE
[18:40:51.079]  - Number of value chunks collected: 1
[18:40:51.079] Resolving 1 futures (chunks) ... DONE
[18:40:51.079] Reducing values from 1 chunks ...
[18:40:51.079]  - Number of values collected after concatenation: 6
[18:40:51.079]  - Number of values expected: 6
[18:40:51.080] Reducing values from 1 chunks ... DONE
[18:40:51.080] future_lapply() ... DONE
[18:40:51.080] future_by_internal() ... DONE
[18:40:51.081] future_by_internal() ...
[18:40:51.082] future_lapply() ...
[18:40:51.085] Number of chunks: 1
[18:40:51.085] getGlobalsAndPackagesXApply() ...
[18:40:51.085]  - future.globals: TRUE
[18:40:51.085] getGlobalsAndPackages() ...
[18:40:51.085] Searching for globals...
[18:40:51.087] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:51.087] Searching for globals ... DONE
[18:40:51.087] Resolving globals: FALSE
[18:40:51.088] The total size of the 1 globals is 762 bytes (762 bytes)
[18:40:51.088] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 762 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (762 bytes of class 'function')
[18:40:51.089] - globals: [1] 'FUN'
[18:40:51.089] - packages: [1] 'stats'
[18:40:51.089] getGlobalsAndPackages() ... DONE
[18:40:51.089]  - globals found/used: [n=1] 'FUN'
[18:40:51.089]  - needed namespaces: [n=1] 'stats'
[18:40:51.090] Finding globals ... DONE
[18:40:51.090]  - use_args: TRUE
[18:40:51.090]  - Getting '...' globals ...
[18:40:51.090] resolve() on list ...
[18:40:51.090]  recursive: 0
[18:40:51.091]  length: 1
[18:40:51.091]  elements: '...'
[18:40:51.091]  length: 0 (resolved future 1)
[18:40:51.091] resolve() on list ... DONE
[18:40:51.091]    - '...' content: [n=1] 'singular.ok'
[18:40:51.092] List of 1
[18:40:51.092]  $ ...:List of 1
[18:40:51.092]   ..$ singular.ok: logi FALSE
[18:40:51.092]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.092]  - attr(*, "where")=List of 1
[18:40:51.092]   ..$ ...:<environment: 0x000001cd5162b680> 
[18:40:51.092]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.092]  - attr(*, "resolved")= logi TRUE
[18:40:51.092]  - attr(*, "total_size")= num NA
[18:40:51.095]  - Getting '...' globals ... DONE
[18:40:51.095] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.095] List of 2
[18:40:51.095]  $ ...future.FUN:function (x, ...)  
[18:40:51.095]  $ ...          :List of 1
[18:40:51.095]   ..$ singular.ok: logi FALSE
[18:40:51.095]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.095]  - attr(*, "where")=List of 2
[18:40:51.095]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.095]   ..$ ...          :<environment: 0x000001cd5162b680> 
[18:40:51.095]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.095]  - attr(*, "resolved")= logi FALSE
[18:40:51.095]  - attr(*, "total_size")= int 19977
[18:40:51.099] Packages to be attached in all futures: [n=1] 'stats'
[18:40:51.099] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.100] Number of futures (= number of chunks): 1
[18:40:51.100] Launching 1 futures (chunks) ...
[18:40:51.100] Chunk #1 of 1 ...
[18:40:51.100]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.100] getGlobalsAndPackages() ...
[18:40:51.100] Searching for globals...
[18:40:51.101] 
[18:40:51.101] Searching for globals ... DONE
[18:40:51.101] - globals: [0] <none>
[18:40:51.102] getGlobalsAndPackages() ... DONE
[18:40:51.102]    + additional globals found: [n=0] 
[18:40:51.102]    + additional namespaces needed: [n=0] 
[18:40:51.102]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.102]  - seeds: <none>
[18:40:51.102]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.103] getGlobalsAndPackages() ...
[18:40:51.103] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.103] Resolving globals: FALSE
[18:40:51.103] Tweak future expression to call with '...' arguments ...
[18:40:51.103] {
[18:40:51.103]     do.call(function(...) {
[18:40:51.103]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.103]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.103]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.103]             on.exit(options(oopts), add = TRUE)
[18:40:51.103]         }
[18:40:51.103]         {
[18:40:51.103]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.103]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.103]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.103]             })
[18:40:51.103]         }
[18:40:51.103]     }, args = future.call.arguments)
[18:40:51.103] }
[18:40:51.104] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.104] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.105] 
[18:40:51.105] getGlobalsAndPackages() ... DONE
[18:40:51.105] run() for 'Future' ...
[18:40:51.106] - state: 'created'
[18:40:51.106] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:51.109] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.110] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.110]   - Field: 'label'
[18:40:51.110]   - Field: 'local'
[18:40:51.110]   - Field: 'owner'
[18:40:51.111]   - Field: 'envir'
[18:40:51.111]   - Field: 'packages'
[18:40:51.111]   - Field: 'gc'
[18:40:51.111]   - Field: 'conditions'
[18:40:51.111]   - Field: 'expr'
[18:40:51.111]   - Field: 'uuid'
[18:40:51.112]   - Field: 'seed'
[18:40:51.112]   - Field: 'version'
[18:40:51.112]   - Field: 'result'
[18:40:51.112]   - Field: 'asynchronous'
[18:40:51.112]   - Field: 'calls'
[18:40:51.112]   - Field: 'globals'
[18:40:51.113]   - Field: 'stdout'
[18:40:51.113]   - Field: 'earlySignal'
[18:40:51.113]   - Field: 'lazy'
[18:40:51.113]   - Field: 'state'
[18:40:51.113] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.114] - Launch lazy future ...
[18:40:51.114] Packages needed by the future expression (n = 1): 'stats'
[18:40:51.114] Packages needed by future strategies (n = 0): <none>
[18:40:51.115] {
[18:40:51.115]     {
[18:40:51.115]         {
[18:40:51.115]             ...future.startTime <- base::Sys.time()
[18:40:51.115]             {
[18:40:51.115]                 {
[18:40:51.115]                   {
[18:40:51.115]                     {
[18:40:51.115]                       base::local({
[18:40:51.115]                         has_future <- base::requireNamespace("future", 
[18:40:51.115]                           quietly = TRUE)
[18:40:51.115]                         if (has_future) {
[18:40:51.115]                           ns <- base::getNamespace("future")
[18:40:51.115]                           version <- ns[[".package"]][["version"]]
[18:40:51.115]                           if (is.null(version)) 
[18:40:51.115]                             version <- utils::packageVersion("future")
[18:40:51.115]                         }
[18:40:51.115]                         else {
[18:40:51.115]                           version <- NULL
[18:40:51.115]                         }
[18:40:51.115]                         if (!has_future || version < "1.8.0") {
[18:40:51.115]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.115]                             "", base::R.version$version.string), 
[18:40:51.115]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:51.115]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.115]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.115]                               "release", "version")], collapse = " "), 
[18:40:51.115]                             hostname = base::Sys.info()[["nodename"]])
[18:40:51.115]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.115]                             info)
[18:40:51.115]                           info <- base::paste(info, collapse = "; ")
[18:40:51.115]                           if (!has_future) {
[18:40:51.115]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.115]                               info)
[18:40:51.115]                           }
[18:40:51.115]                           else {
[18:40:51.115]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.115]                               info, version)
[18:40:51.115]                           }
[18:40:51.115]                           base::stop(msg)
[18:40:51.115]                         }
[18:40:51.115]                       })
[18:40:51.115]                     }
[18:40:51.115]                     base::local({
[18:40:51.115]                       for (pkg in "stats") {
[18:40:51.115]                         base::loadNamespace(pkg)
[18:40:51.115]                         base::library(pkg, character.only = TRUE)
[18:40:51.115]                       }
[18:40:51.115]                     })
[18:40:51.115]                   }
[18:40:51.115]                   ...future.strategy.old <- future::plan("list")
[18:40:51.115]                   options(future.plan = NULL)
[18:40:51.115]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.115]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.115]                 }
[18:40:51.115]                 ...future.workdir <- getwd()
[18:40:51.115]             }
[18:40:51.115]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.115]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.115]         }
[18:40:51.115]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.115]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.115]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.115]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.115]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.115]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.115]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.115]             base::names(...future.oldOptions))
[18:40:51.115]     }
[18:40:51.115]     if (FALSE) {
[18:40:51.115]     }
[18:40:51.115]     else {
[18:40:51.115]         if (TRUE) {
[18:40:51.115]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.115]                 open = "w")
[18:40:51.115]         }
[18:40:51.115]         else {
[18:40:51.115]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.115]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.115]         }
[18:40:51.115]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.115]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.115]             base::sink(type = "output", split = FALSE)
[18:40:51.115]             base::close(...future.stdout)
[18:40:51.115]         }, add = TRUE)
[18:40:51.115]     }
[18:40:51.115]     ...future.frame <- base::sys.nframe()
[18:40:51.115]     ...future.conditions <- base::list()
[18:40:51.115]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.115]     if (FALSE) {
[18:40:51.115]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.115]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.115]     }
[18:40:51.115]     ...future.result <- base::tryCatch({
[18:40:51.115]         base::withCallingHandlers({
[18:40:51.115]             ...future.value <- base::withVisible(base::local({
[18:40:51.115]                 do.call(function(...) {
[18:40:51.115]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.115]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.115]                     ...future.globals.maxSize)) {
[18:40:51.115]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.115]                     on.exit(options(oopts), add = TRUE)
[18:40:51.115]                   }
[18:40:51.115]                   {
[18:40:51.115]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.115]                       FUN = function(jj) {
[18:40:51.115]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.115]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.115]                       })
[18:40:51.115]                   }
[18:40:51.115]                 }, args = future.call.arguments)
[18:40:51.115]             }))
[18:40:51.115]             future::FutureResult(value = ...future.value$value, 
[18:40:51.115]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.115]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.115]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.115]                     ...future.globalenv.names))
[18:40:51.115]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.115]         }, condition = base::local({
[18:40:51.115]             c <- base::c
[18:40:51.115]             inherits <- base::inherits
[18:40:51.115]             invokeRestart <- base::invokeRestart
[18:40:51.115]             length <- base::length
[18:40:51.115]             list <- base::list
[18:40:51.115]             seq.int <- base::seq.int
[18:40:51.115]             signalCondition <- base::signalCondition
[18:40:51.115]             sys.calls <- base::sys.calls
[18:40:51.115]             `[[` <- base::`[[`
[18:40:51.115]             `+` <- base::`+`
[18:40:51.115]             `<<-` <- base::`<<-`
[18:40:51.115]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.115]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.115]                   3L)]
[18:40:51.115]             }
[18:40:51.115]             function(cond) {
[18:40:51.115]                 is_error <- inherits(cond, "error")
[18:40:51.115]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.115]                   NULL)
[18:40:51.115]                 if (is_error) {
[18:40:51.115]                   sessionInformation <- function() {
[18:40:51.115]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.115]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.115]                       search = base::search(), system = base::Sys.info())
[18:40:51.115]                   }
[18:40:51.115]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.115]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.115]                     cond$call), session = sessionInformation(), 
[18:40:51.115]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.115]                   signalCondition(cond)
[18:40:51.115]                 }
[18:40:51.115]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.115]                 "immediateCondition"))) {
[18:40:51.115]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.115]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.115]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.115]                   if (TRUE && !signal) {
[18:40:51.115]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.115]                     {
[18:40:51.115]                       inherits <- base::inherits
[18:40:51.115]                       invokeRestart <- base::invokeRestart
[18:40:51.115]                       is.null <- base::is.null
[18:40:51.115]                       muffled <- FALSE
[18:40:51.115]                       if (inherits(cond, "message")) {
[18:40:51.115]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.115]                         if (muffled) 
[18:40:51.115]                           invokeRestart("muffleMessage")
[18:40:51.115]                       }
[18:40:51.115]                       else if (inherits(cond, "warning")) {
[18:40:51.115]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.115]                         if (muffled) 
[18:40:51.115]                           invokeRestart("muffleWarning")
[18:40:51.115]                       }
[18:40:51.115]                       else if (inherits(cond, "condition")) {
[18:40:51.115]                         if (!is.null(pattern)) {
[18:40:51.115]                           computeRestarts <- base::computeRestarts
[18:40:51.115]                           grepl <- base::grepl
[18:40:51.115]                           restarts <- computeRestarts(cond)
[18:40:51.115]                           for (restart in restarts) {
[18:40:51.115]                             name <- restart$name
[18:40:51.115]                             if (is.null(name)) 
[18:40:51.115]                               next
[18:40:51.115]                             if (!grepl(pattern, name)) 
[18:40:51.115]                               next
[18:40:51.115]                             invokeRestart(restart)
[18:40:51.115]                             muffled <- TRUE
[18:40:51.115]                             break
[18:40:51.115]                           }
[18:40:51.115]                         }
[18:40:51.115]                       }
[18:40:51.115]                       invisible(muffled)
[18:40:51.115]                     }
[18:40:51.115]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.115]                   }
[18:40:51.115]                 }
[18:40:51.115]                 else {
[18:40:51.115]                   if (TRUE) {
[18:40:51.115]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.115]                     {
[18:40:51.115]                       inherits <- base::inherits
[18:40:51.115]                       invokeRestart <- base::invokeRestart
[18:40:51.115]                       is.null <- base::is.null
[18:40:51.115]                       muffled <- FALSE
[18:40:51.115]                       if (inherits(cond, "message")) {
[18:40:51.115]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.115]                         if (muffled) 
[18:40:51.115]                           invokeRestart("muffleMessage")
[18:40:51.115]                       }
[18:40:51.115]                       else if (inherits(cond, "warning")) {
[18:40:51.115]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.115]                         if (muffled) 
[18:40:51.115]                           invokeRestart("muffleWarning")
[18:40:51.115]                       }
[18:40:51.115]                       else if (inherits(cond, "condition")) {
[18:40:51.115]                         if (!is.null(pattern)) {
[18:40:51.115]                           computeRestarts <- base::computeRestarts
[18:40:51.115]                           grepl <- base::grepl
[18:40:51.115]                           restarts <- computeRestarts(cond)
[18:40:51.115]                           for (restart in restarts) {
[18:40:51.115]                             name <- restart$name
[18:40:51.115]                             if (is.null(name)) 
[18:40:51.115]                               next
[18:40:51.115]                             if (!grepl(pattern, name)) 
[18:40:51.115]                               next
[18:40:51.115]                             invokeRestart(restart)
[18:40:51.115]                             muffled <- TRUE
[18:40:51.115]                             break
[18:40:51.115]                           }
[18:40:51.115]                         }
[18:40:51.115]                       }
[18:40:51.115]                       invisible(muffled)
[18:40:51.115]                     }
[18:40:51.115]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.115]                   }
[18:40:51.115]                 }
[18:40:51.115]             }
[18:40:51.115]         }))
[18:40:51.115]     }, error = function(ex) {
[18:40:51.115]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.115]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.115]                 ...future.rng), started = ...future.startTime, 
[18:40:51.115]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.115]             version = "1.8"), class = "FutureResult")
[18:40:51.115]     }, finally = {
[18:40:51.115]         if (!identical(...future.workdir, getwd())) 
[18:40:51.115]             setwd(...future.workdir)
[18:40:51.115]         {
[18:40:51.115]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.115]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.115]             }
[18:40:51.115]             base::options(...future.oldOptions)
[18:40:51.115]             if (.Platform$OS.type == "windows") {
[18:40:51.115]                 old_names <- names(...future.oldEnvVars)
[18:40:51.115]                 envs <- base::Sys.getenv()
[18:40:51.115]                 names <- names(envs)
[18:40:51.115]                 common <- intersect(names, old_names)
[18:40:51.115]                 added <- setdiff(names, old_names)
[18:40:51.115]                 removed <- setdiff(old_names, names)
[18:40:51.115]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.115]                   envs[common]]
[18:40:51.115]                 NAMES <- toupper(changed)
[18:40:51.115]                 args <- list()
[18:40:51.115]                 for (kk in seq_along(NAMES)) {
[18:40:51.115]                   name <- changed[[kk]]
[18:40:51.115]                   NAME <- NAMES[[kk]]
[18:40:51.115]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.115]                     next
[18:40:51.115]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.115]                 }
[18:40:51.115]                 NAMES <- toupper(added)
[18:40:51.115]                 for (kk in seq_along(NAMES)) {
[18:40:51.115]                   name <- added[[kk]]
[18:40:51.115]                   NAME <- NAMES[[kk]]
[18:40:51.115]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.115]                     next
[18:40:51.115]                   args[[name]] <- ""
[18:40:51.115]                 }
[18:40:51.115]                 NAMES <- toupper(removed)
[18:40:51.115]                 for (kk in seq_along(NAMES)) {
[18:40:51.115]                   name <- removed[[kk]]
[18:40:51.115]                   NAME <- NAMES[[kk]]
[18:40:51.115]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.115]                     next
[18:40:51.115]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.115]                 }
[18:40:51.115]                 if (length(args) > 0) 
[18:40:51.115]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.115]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.115]             }
[18:40:51.115]             else {
[18:40:51.115]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.115]             }
[18:40:51.115]             {
[18:40:51.115]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.115]                   0L) {
[18:40:51.115]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.115]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.115]                   base::options(opts)
[18:40:51.115]                 }
[18:40:51.115]                 {
[18:40:51.115]                   {
[18:40:51.115]                     NULL
[18:40:51.115]                     RNGkind("Mersenne-Twister")
[18:40:51.115]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.115]                       inherits = FALSE)
[18:40:51.115]                   }
[18:40:51.115]                   options(future.plan = NULL)
[18:40:51.115]                   if (is.na(NA_character_)) 
[18:40:51.115]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.115]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.115]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.115]                     .init = FALSE)
[18:40:51.115]                 }
[18:40:51.115]             }
[18:40:51.115]         }
[18:40:51.115]     })
[18:40:51.115]     if (TRUE) {
[18:40:51.115]         base::sink(type = "output", split = FALSE)
[18:40:51.115]         if (TRUE) {
[18:40:51.115]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.115]         }
[18:40:51.115]         else {
[18:40:51.115]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.115]         }
[18:40:51.115]         base::close(...future.stdout)
[18:40:51.115]         ...future.stdout <- NULL
[18:40:51.115]     }
[18:40:51.115]     ...future.result$conditions <- ...future.conditions
[18:40:51.115]     ...future.result$finished <- base::Sys.time()
[18:40:51.115]     ...future.result
[18:40:51.115] }
[18:40:51.119] assign_globals() ...
[18:40:51.119] List of 5
[18:40:51.119]  $ ...future.FUN            :function (x, ...)  
[18:40:51.119]  $ future.call.arguments    :List of 1
[18:40:51.119]   ..$ singular.ok: logi FALSE
[18:40:51.119]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.119]  $ ...future.elements_ii    :List of 3
[18:40:51.119]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.119]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.119]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.119]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.119]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.119]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.119]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.119]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.119]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.119]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.119]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.119]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.119]  $ ...future.seeds_ii       : NULL
[18:40:51.119]  $ ...future.globals.maxSize: NULL
[18:40:51.119]  - attr(*, "where")=List of 5
[18:40:51.119]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.119]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.119]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.119]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.119]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.119]  - attr(*, "resolved")= logi FALSE
[18:40:51.119]  - attr(*, "total_size")= num 19977
[18:40:51.119]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.119]  - attr(*, "already-done")= logi TRUE
[18:40:51.132] - reassign environment for '...future.FUN'
[18:40:51.132] - copied '...future.FUN' to environment
[18:40:51.132] - copied 'future.call.arguments' to environment
[18:40:51.132] - copied '...future.elements_ii' to environment
[18:40:51.133] - copied '...future.seeds_ii' to environment
[18:40:51.133] - copied '...future.globals.maxSize' to environment
[18:40:51.133] assign_globals() ... done
[18:40:51.134] plan(): Setting new future strategy stack:
[18:40:51.134] List of future strategies:
[18:40:51.134] 1. sequential:
[18:40:51.134]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.134]    - tweaked: FALSE
[18:40:51.134]    - call: NULL
[18:40:51.134] plan(): nbrOfWorkers() = 1
[18:40:51.138] plan(): Setting new future strategy stack:
[18:40:51.138] List of future strategies:
[18:40:51.138] 1. multisession:
[18:40:51.138]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.138]    - tweaked: FALSE
[18:40:51.138]    - call: plan(strategy)
[18:40:51.141] plan(): nbrOfWorkers() = 1
[18:40:51.141] SequentialFuture started (and completed)
[18:40:51.141] - Launch lazy future ... done
[18:40:51.142] run() for 'SequentialFuture' ... done
[18:40:51.142] Created future:
[18:40:51.142] SequentialFuture:
[18:40:51.142] Label: 'future_by-1'
[18:40:51.142] Expression:
[18:40:51.142] {
[18:40:51.142]     do.call(function(...) {
[18:40:51.142]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.142]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.142]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.142]             on.exit(options(oopts), add = TRUE)
[18:40:51.142]         }
[18:40:51.142]         {
[18:40:51.142]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.142]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.142]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.142]             })
[18:40:51.142]         }
[18:40:51.142]     }, args = future.call.arguments)
[18:40:51.142] }
[18:40:51.142] Lazy evaluation: FALSE
[18:40:51.142] Asynchronous evaluation: FALSE
[18:40:51.142] Local evaluation: TRUE
[18:40:51.142] Environment: R_GlobalEnv
[18:40:51.142] Capture standard output: TRUE
[18:40:51.142] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.142] Globals: 5 objects totaling 2.93 KiB (function '...future.FUN' of 762 bytes, DotDotDotList 'future.call.arguments' of 157 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.142] Packages: 1 packages ('stats')
[18:40:51.142] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.142] Resolved: TRUE
[18:40:51.142] Value: 89.51 KiB of class 'list'
[18:40:51.142] Early signaling: FALSE
[18:40:51.142] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.142] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.144] Chunk #1 of 1 ... DONE
[18:40:51.144] Launching 1 futures (chunks) ... DONE
[18:40:51.144] Resolving 1 futures (chunks) ...
[18:40:51.144] resolve() on list ...
[18:40:51.144]  recursive: 0
[18:40:51.144]  length: 1
[18:40:51.145] 
[18:40:51.145] resolved() for 'SequentialFuture' ...
[18:40:51.145] - state: 'finished'
[18:40:51.145] - run: TRUE
[18:40:51.145] - result: 'FutureResult'
[18:40:51.146] resolved() for 'SequentialFuture' ... done
[18:40:51.146] Future #1
[18:40:51.146] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.146] - nx: 1
[18:40:51.146] - relay: TRUE
[18:40:51.146] - stdout: TRUE
[18:40:51.147] - signal: TRUE
[18:40:51.147] - resignal: FALSE
[18:40:51.147] - force: TRUE
[18:40:51.147] - relayed: [n=1] FALSE
[18:40:51.147] - queued futures: [n=1] FALSE
[18:40:51.147]  - until=1
[18:40:51.147]  - relaying element #1
[18:40:51.148] - relayed: [n=1] TRUE
[18:40:51.148] - queued futures: [n=1] TRUE
[18:40:51.148] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.148]  length: 0 (resolved future 1)
[18:40:51.148] Relaying remaining futures
[18:40:51.149] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.149] - nx: 1
[18:40:51.149] - relay: TRUE
[18:40:51.149] - stdout: TRUE
[18:40:51.149] - signal: TRUE
[18:40:51.149] - resignal: FALSE
[18:40:51.150] - force: TRUE
[18:40:51.150] - relayed: [n=1] TRUE
[18:40:51.150] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.150] - relayed: [n=1] TRUE
[18:40:51.150] - queued futures: [n=1] TRUE
[18:40:51.150] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.151] resolve() on list ... DONE
[18:40:51.151]  - Number of value chunks collected: 1
[18:40:51.151] Resolving 1 futures (chunks) ... DONE
[18:40:51.151] Reducing values from 1 chunks ...
[18:40:51.151]  - Number of values collected after concatenation: 3
[18:40:51.151]  - Number of values expected: 3
[18:40:51.152] Reducing values from 1 chunks ... DONE
[18:40:51.152] future_lapply() ... DONE
[18:40:51.152] future_by_internal() ... DONE
[18:40:51.157] future_by_internal() ...
[18:40:51.157] future_lapply() ...
[18:40:51.160] Number of chunks: 1
[18:40:51.160] getGlobalsAndPackagesXApply() ...
[18:40:51.161]  - future.globals: TRUE
[18:40:51.161] getGlobalsAndPackages() ...
[18:40:51.161] Searching for globals...
[18:40:51.163] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:51.163] Searching for globals ... DONE
[18:40:51.163] Resolving globals: FALSE
[18:40:51.164] The total size of the 3 globals is 2.07 KiB (2118 bytes)
[18:40:51.164] The total size of the 3 globals exported for future expression ('FUN()') is 2.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.28 KiB of class 'function'), 'breaks' (463 bytes of class 'numeric') and 'wool' (342 bytes of class 'numeric')
[18:40:51.165] - globals: [3] 'FUN', 'breaks', 'wool'
[18:40:51.165] - packages: [1] 'stats'
[18:40:51.165] getGlobalsAndPackages() ... DONE
[18:40:51.165]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[18:40:51.165]  - needed namespaces: [n=1] 'stats'
[18:40:51.166] Finding globals ... DONE
[18:40:51.166]  - use_args: TRUE
[18:40:51.166]  - Getting '...' globals ...
[18:40:51.166] resolve() on list ...
[18:40:51.166]  recursive: 0
[18:40:51.167]  length: 1
[18:40:51.167]  elements: '...'
[18:40:51.167]  length: 0 (resolved future 1)
[18:40:51.167] resolve() on list ... DONE
[18:40:51.167]    - '...' content: [n=0] 
[18:40:51.168] List of 1
[18:40:51.168]  $ ...: list()
[18:40:51.168]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.168]  - attr(*, "where")=List of 1
[18:40:51.168]   ..$ ...:<environment: 0x000001cd50569e48> 
[18:40:51.168]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.168]  - attr(*, "resolved")= logi TRUE
[18:40:51.168]  - attr(*, "total_size")= num NA
[18:40:51.170]  - Getting '...' globals ... DONE
[18:40:51.171] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[18:40:51.171] List of 4
[18:40:51.171]  $ ...future.FUN:function (x)  
[18:40:51.171]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:51.171]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.171]  $ ...          : list()
[18:40:51.171]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.171]  - attr(*, "where")=List of 4
[18:40:51.171]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.171]   ..$ breaks       :<environment: R_EmptyEnv> 
[18:40:51.171]   ..$ wool         :<environment: R_EmptyEnv> 
[18:40:51.171]   ..$ ...          :<environment: 0x000001cd50569e48> 
[18:40:51.171]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.171]  - attr(*, "resolved")= logi FALSE
[18:40:51.171]  - attr(*, "total_size")= int 18867
[18:40:51.176] Packages to be attached in all futures: [n=1] 'stats'
[18:40:51.176] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.176] Number of futures (= number of chunks): 1
[18:40:51.176] Launching 1 futures (chunks) ...
[18:40:51.176] Chunk #1 of 1 ...
[18:40:51.177]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.177] getGlobalsAndPackages() ...
[18:40:51.177] Searching for globals...
[18:40:51.178] 
[18:40:51.178] Searching for globals ... DONE
[18:40:51.178] - globals: [0] <none>
[18:40:51.178] getGlobalsAndPackages() ... DONE
[18:40:51.178]    + additional globals found: [n=0] 
[18:40:51.178]    + additional namespaces needed: [n=0] 
[18:40:51.179]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.179]  - seeds: <none>
[18:40:51.179]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.179] getGlobalsAndPackages() ...
[18:40:51.179] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.179] Resolving globals: FALSE
[18:40:51.180] Tweak future expression to call with '...' arguments ...
[18:40:51.180] {
[18:40:51.180]     do.call(function(...) {
[18:40:51.180]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.180]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.180]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.180]             on.exit(options(oopts), add = TRUE)
[18:40:51.180]         }
[18:40:51.180]         {
[18:40:51.180]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.180]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.180]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.180]             })
[18:40:51.180]         }
[18:40:51.180]     }, args = future.call.arguments)
[18:40:51.180] }
[18:40:51.180] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.181] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.181] 
[18:40:51.181] getGlobalsAndPackages() ... DONE
[18:40:51.181] run() for 'Future' ...
[18:40:51.182] - state: 'created'
[18:40:51.182] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:51.184] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.184] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.185]   - Field: 'label'
[18:40:51.185]   - Field: 'local'
[18:40:51.185]   - Field: 'owner'
[18:40:51.185]   - Field: 'envir'
[18:40:51.185]   - Field: 'packages'
[18:40:51.185]   - Field: 'gc'
[18:40:51.186]   - Field: 'conditions'
[18:40:51.186]   - Field: 'expr'
[18:40:51.186]   - Field: 'uuid'
[18:40:51.186]   - Field: 'seed'
[18:40:51.186]   - Field: 'version'
[18:40:51.187]   - Field: 'result'
[18:40:51.187]   - Field: 'asynchronous'
[18:40:51.187]   - Field: 'calls'
[18:40:51.187]   - Field: 'globals'
[18:40:51.187]   - Field: 'stdout'
[18:40:51.187]   - Field: 'earlySignal'
[18:40:51.188]   - Field: 'lazy'
[18:40:51.188]   - Field: 'state'
[18:40:51.188] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.188] - Launch lazy future ...
[18:40:51.188] Packages needed by the future expression (n = 1): 'stats'
[18:40:51.189] Packages needed by future strategies (n = 0): <none>
[18:40:51.189] {
[18:40:51.189]     {
[18:40:51.189]         {
[18:40:51.189]             ...future.startTime <- base::Sys.time()
[18:40:51.189]             {
[18:40:51.189]                 {
[18:40:51.189]                   {
[18:40:51.189]                     {
[18:40:51.189]                       base::local({
[18:40:51.189]                         has_future <- base::requireNamespace("future", 
[18:40:51.189]                           quietly = TRUE)
[18:40:51.189]                         if (has_future) {
[18:40:51.189]                           ns <- base::getNamespace("future")
[18:40:51.189]                           version <- ns[[".package"]][["version"]]
[18:40:51.189]                           if (is.null(version)) 
[18:40:51.189]                             version <- utils::packageVersion("future")
[18:40:51.189]                         }
[18:40:51.189]                         else {
[18:40:51.189]                           version <- NULL
[18:40:51.189]                         }
[18:40:51.189]                         if (!has_future || version < "1.8.0") {
[18:40:51.189]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.189]                             "", base::R.version$version.string), 
[18:40:51.189]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:51.189]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.189]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.189]                               "release", "version")], collapse = " "), 
[18:40:51.189]                             hostname = base::Sys.info()[["nodename"]])
[18:40:51.189]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.189]                             info)
[18:40:51.189]                           info <- base::paste(info, collapse = "; ")
[18:40:51.189]                           if (!has_future) {
[18:40:51.189]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.189]                               info)
[18:40:51.189]                           }
[18:40:51.189]                           else {
[18:40:51.189]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.189]                               info, version)
[18:40:51.189]                           }
[18:40:51.189]                           base::stop(msg)
[18:40:51.189]                         }
[18:40:51.189]                       })
[18:40:51.189]                     }
[18:40:51.189]                     base::local({
[18:40:51.189]                       for (pkg in "stats") {
[18:40:51.189]                         base::loadNamespace(pkg)
[18:40:51.189]                         base::library(pkg, character.only = TRUE)
[18:40:51.189]                       }
[18:40:51.189]                     })
[18:40:51.189]                   }
[18:40:51.189]                   ...future.strategy.old <- future::plan("list")
[18:40:51.189]                   options(future.plan = NULL)
[18:40:51.189]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.189]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.189]                 }
[18:40:51.189]                 ...future.workdir <- getwd()
[18:40:51.189]             }
[18:40:51.189]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.189]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.189]         }
[18:40:51.189]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.189]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.189]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.189]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.189]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.189]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.189]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.189]             base::names(...future.oldOptions))
[18:40:51.189]     }
[18:40:51.189]     if (FALSE) {
[18:40:51.189]     }
[18:40:51.189]     else {
[18:40:51.189]         if (TRUE) {
[18:40:51.189]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.189]                 open = "w")
[18:40:51.189]         }
[18:40:51.189]         else {
[18:40:51.189]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.189]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.189]         }
[18:40:51.189]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.189]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.189]             base::sink(type = "output", split = FALSE)
[18:40:51.189]             base::close(...future.stdout)
[18:40:51.189]         }, add = TRUE)
[18:40:51.189]     }
[18:40:51.189]     ...future.frame <- base::sys.nframe()
[18:40:51.189]     ...future.conditions <- base::list()
[18:40:51.189]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.189]     if (FALSE) {
[18:40:51.189]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.189]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.189]     }
[18:40:51.189]     ...future.result <- base::tryCatch({
[18:40:51.189]         base::withCallingHandlers({
[18:40:51.189]             ...future.value <- base::withVisible(base::local({
[18:40:51.189]                 do.call(function(...) {
[18:40:51.189]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.189]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.189]                     ...future.globals.maxSize)) {
[18:40:51.189]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.189]                     on.exit(options(oopts), add = TRUE)
[18:40:51.189]                   }
[18:40:51.189]                   {
[18:40:51.189]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.189]                       FUN = function(jj) {
[18:40:51.189]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.189]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.189]                       })
[18:40:51.189]                   }
[18:40:51.189]                 }, args = future.call.arguments)
[18:40:51.189]             }))
[18:40:51.189]             future::FutureResult(value = ...future.value$value, 
[18:40:51.189]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.189]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.189]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.189]                     ...future.globalenv.names))
[18:40:51.189]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.189]         }, condition = base::local({
[18:40:51.189]             c <- base::c
[18:40:51.189]             inherits <- base::inherits
[18:40:51.189]             invokeRestart <- base::invokeRestart
[18:40:51.189]             length <- base::length
[18:40:51.189]             list <- base::list
[18:40:51.189]             seq.int <- base::seq.int
[18:40:51.189]             signalCondition <- base::signalCondition
[18:40:51.189]             sys.calls <- base::sys.calls
[18:40:51.189]             `[[` <- base::`[[`
[18:40:51.189]             `+` <- base::`+`
[18:40:51.189]             `<<-` <- base::`<<-`
[18:40:51.189]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.189]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.189]                   3L)]
[18:40:51.189]             }
[18:40:51.189]             function(cond) {
[18:40:51.189]                 is_error <- inherits(cond, "error")
[18:40:51.189]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.189]                   NULL)
[18:40:51.189]                 if (is_error) {
[18:40:51.189]                   sessionInformation <- function() {
[18:40:51.189]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.189]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.189]                       search = base::search(), system = base::Sys.info())
[18:40:51.189]                   }
[18:40:51.189]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.189]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.189]                     cond$call), session = sessionInformation(), 
[18:40:51.189]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.189]                   signalCondition(cond)
[18:40:51.189]                 }
[18:40:51.189]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.189]                 "immediateCondition"))) {
[18:40:51.189]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.189]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.189]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.189]                   if (TRUE && !signal) {
[18:40:51.189]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.189]                     {
[18:40:51.189]                       inherits <- base::inherits
[18:40:51.189]                       invokeRestart <- base::invokeRestart
[18:40:51.189]                       is.null <- base::is.null
[18:40:51.189]                       muffled <- FALSE
[18:40:51.189]                       if (inherits(cond, "message")) {
[18:40:51.189]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.189]                         if (muffled) 
[18:40:51.189]                           invokeRestart("muffleMessage")
[18:40:51.189]                       }
[18:40:51.189]                       else if (inherits(cond, "warning")) {
[18:40:51.189]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.189]                         if (muffled) 
[18:40:51.189]                           invokeRestart("muffleWarning")
[18:40:51.189]                       }
[18:40:51.189]                       else if (inherits(cond, "condition")) {
[18:40:51.189]                         if (!is.null(pattern)) {
[18:40:51.189]                           computeRestarts <- base::computeRestarts
[18:40:51.189]                           grepl <- base::grepl
[18:40:51.189]                           restarts <- computeRestarts(cond)
[18:40:51.189]                           for (restart in restarts) {
[18:40:51.189]                             name <- restart$name
[18:40:51.189]                             if (is.null(name)) 
[18:40:51.189]                               next
[18:40:51.189]                             if (!grepl(pattern, name)) 
[18:40:51.189]                               next
[18:40:51.189]                             invokeRestart(restart)
[18:40:51.189]                             muffled <- TRUE
[18:40:51.189]                             break
[18:40:51.189]                           }
[18:40:51.189]                         }
[18:40:51.189]                       }
[18:40:51.189]                       invisible(muffled)
[18:40:51.189]                     }
[18:40:51.189]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.189]                   }
[18:40:51.189]                 }
[18:40:51.189]                 else {
[18:40:51.189]                   if (TRUE) {
[18:40:51.189]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.189]                     {
[18:40:51.189]                       inherits <- base::inherits
[18:40:51.189]                       invokeRestart <- base::invokeRestart
[18:40:51.189]                       is.null <- base::is.null
[18:40:51.189]                       muffled <- FALSE
[18:40:51.189]                       if (inherits(cond, "message")) {
[18:40:51.189]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.189]                         if (muffled) 
[18:40:51.189]                           invokeRestart("muffleMessage")
[18:40:51.189]                       }
[18:40:51.189]                       else if (inherits(cond, "warning")) {
[18:40:51.189]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.189]                         if (muffled) 
[18:40:51.189]                           invokeRestart("muffleWarning")
[18:40:51.189]                       }
[18:40:51.189]                       else if (inherits(cond, "condition")) {
[18:40:51.189]                         if (!is.null(pattern)) {
[18:40:51.189]                           computeRestarts <- base::computeRestarts
[18:40:51.189]                           grepl <- base::grepl
[18:40:51.189]                           restarts <- computeRestarts(cond)
[18:40:51.189]                           for (restart in restarts) {
[18:40:51.189]                             name <- restart$name
[18:40:51.189]                             if (is.null(name)) 
[18:40:51.189]                               next
[18:40:51.189]                             if (!grepl(pattern, name)) 
[18:40:51.189]                               next
[18:40:51.189]                             invokeRestart(restart)
[18:40:51.189]                             muffled <- TRUE
[18:40:51.189]                             break
[18:40:51.189]                           }
[18:40:51.189]                         }
[18:40:51.189]                       }
[18:40:51.189]                       invisible(muffled)
[18:40:51.189]                     }
[18:40:51.189]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.189]                   }
[18:40:51.189]                 }
[18:40:51.189]             }
[18:40:51.189]         }))
[18:40:51.189]     }, error = function(ex) {
[18:40:51.189]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.189]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.189]                 ...future.rng), started = ...future.startTime, 
[18:40:51.189]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.189]             version = "1.8"), class = "FutureResult")
[18:40:51.189]     }, finally = {
[18:40:51.189]         if (!identical(...future.workdir, getwd())) 
[18:40:51.189]             setwd(...future.workdir)
[18:40:51.189]         {
[18:40:51.189]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.189]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.189]             }
[18:40:51.189]             base::options(...future.oldOptions)
[18:40:51.189]             if (.Platform$OS.type == "windows") {
[18:40:51.189]                 old_names <- names(...future.oldEnvVars)
[18:40:51.189]                 envs <- base::Sys.getenv()
[18:40:51.189]                 names <- names(envs)
[18:40:51.189]                 common <- intersect(names, old_names)
[18:40:51.189]                 added <- setdiff(names, old_names)
[18:40:51.189]                 removed <- setdiff(old_names, names)
[18:40:51.189]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.189]                   envs[common]]
[18:40:51.189]                 NAMES <- toupper(changed)
[18:40:51.189]                 args <- list()
[18:40:51.189]                 for (kk in seq_along(NAMES)) {
[18:40:51.189]                   name <- changed[[kk]]
[18:40:51.189]                   NAME <- NAMES[[kk]]
[18:40:51.189]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.189]                     next
[18:40:51.189]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.189]                 }
[18:40:51.189]                 NAMES <- toupper(added)
[18:40:51.189]                 for (kk in seq_along(NAMES)) {
[18:40:51.189]                   name <- added[[kk]]
[18:40:51.189]                   NAME <- NAMES[[kk]]
[18:40:51.189]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.189]                     next
[18:40:51.189]                   args[[name]] <- ""
[18:40:51.189]                 }
[18:40:51.189]                 NAMES <- toupper(removed)
[18:40:51.189]                 for (kk in seq_along(NAMES)) {
[18:40:51.189]                   name <- removed[[kk]]
[18:40:51.189]                   NAME <- NAMES[[kk]]
[18:40:51.189]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.189]                     next
[18:40:51.189]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.189]                 }
[18:40:51.189]                 if (length(args) > 0) 
[18:40:51.189]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.189]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.189]             }
[18:40:51.189]             else {
[18:40:51.189]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.189]             }
[18:40:51.189]             {
[18:40:51.189]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.189]                   0L) {
[18:40:51.189]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.189]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.189]                   base::options(opts)
[18:40:51.189]                 }
[18:40:51.189]                 {
[18:40:51.189]                   {
[18:40:51.189]                     NULL
[18:40:51.189]                     RNGkind("Mersenne-Twister")
[18:40:51.189]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.189]                       inherits = FALSE)
[18:40:51.189]                   }
[18:40:51.189]                   options(future.plan = NULL)
[18:40:51.189]                   if (is.na(NA_character_)) 
[18:40:51.189]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.189]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.189]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.189]                     .init = FALSE)
[18:40:51.189]                 }
[18:40:51.189]             }
[18:40:51.189]         }
[18:40:51.189]     })
[18:40:51.189]     if (TRUE) {
[18:40:51.189]         base::sink(type = "output", split = FALSE)
[18:40:51.189]         if (TRUE) {
[18:40:51.189]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.189]         }
[18:40:51.189]         else {
[18:40:51.189]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.189]         }
[18:40:51.189]         base::close(...future.stdout)
[18:40:51.189]         ...future.stdout <- NULL
[18:40:51.189]     }
[18:40:51.189]     ...future.result$conditions <- ...future.conditions
[18:40:51.189]     ...future.result$finished <- base::Sys.time()
[18:40:51.189]     ...future.result
[18:40:51.189] }
[18:40:51.193] assign_globals() ...
[18:40:51.193] List of 7
[18:40:51.193]  $ ...future.FUN            :function (x)  
[18:40:51.193]  $ breaks                   : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:51.193]  $ wool                     : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.193]  $ future.call.arguments    : list()
[18:40:51.193]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.193]  $ ...future.elements_ii    :List of 3
[18:40:51.193]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.193]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.193]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.193]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.193]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.193]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.193]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.193]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.193]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.193]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.193]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.193]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.193]  $ ...future.seeds_ii       : NULL
[18:40:51.193]  $ ...future.globals.maxSize: NULL
[18:40:51.193]  - attr(*, "where")=List of 7
[18:40:51.193]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.193]   ..$ breaks                   :<environment: R_EmptyEnv> 
[18:40:51.193]   ..$ wool                     :<environment: R_EmptyEnv> 
[18:40:51.193]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.193]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.193]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.193]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.193]  - attr(*, "resolved")= logi FALSE
[18:40:51.193]  - attr(*, "total_size")= num 18867
[18:40:51.193]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.193]  - attr(*, "already-done")= logi TRUE
[18:40:51.205] - reassign environment for '...future.FUN'
[18:40:51.205] - copied '...future.FUN' to environment
[18:40:51.205] - copied 'breaks' to environment
[18:40:51.206] - copied 'wool' to environment
[18:40:51.206] - copied 'future.call.arguments' to environment
[18:40:51.206] - copied '...future.elements_ii' to environment
[18:40:51.206] - copied '...future.seeds_ii' to environment
[18:40:51.206] - copied '...future.globals.maxSize' to environment
[18:40:51.206] assign_globals() ... done
[18:40:51.207] plan(): Setting new future strategy stack:
[18:40:51.207] List of future strategies:
[18:40:51.207] 1. sequential:
[18:40:51.207]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.207]    - tweaked: FALSE
[18:40:51.207]    - call: NULL
[18:40:51.208] plan(): nbrOfWorkers() = 1
[18:40:51.212] plan(): Setting new future strategy stack:
[18:40:51.212] List of future strategies:
[18:40:51.212] 1. multisession:
[18:40:51.212]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.212]    - tweaked: FALSE
[18:40:51.212]    - call: plan(strategy)
[18:40:51.214] plan(): nbrOfWorkers() = 1
[18:40:51.214] SequentialFuture started (and completed)
[18:40:51.215] - Launch lazy future ... done
[18:40:51.215] run() for 'SequentialFuture' ... done
[18:40:51.215] Created future:
[18:40:51.215] SequentialFuture:
[18:40:51.215] Label: 'future_by-1'
[18:40:51.215] Expression:
[18:40:51.215] {
[18:40:51.215]     do.call(function(...) {
[18:40:51.215]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.215]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.215]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.215]             on.exit(options(oopts), add = TRUE)
[18:40:51.215]         }
[18:40:51.215]         {
[18:40:51.215]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.215]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.215]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.215]             })
[18:40:51.215]         }
[18:40:51.215]     }, args = future.call.arguments)
[18:40:51.215] }
[18:40:51.215] Lazy evaluation: FALSE
[18:40:51.215] Asynchronous evaluation: FALSE
[18:40:51.215] Local evaluation: TRUE
[18:40:51.215] Environment: 0x000001cd505368d0
[18:40:51.215] Capture standard output: TRUE
[18:40:51.215] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.215] Globals: 7 objects totaling 4.20 KiB (function '...future.FUN' of 1.28 KiB, numeric 'breaks' of 463 bytes, factor 'wool' of 342 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, ...)
[18:40:51.215] Packages: 1 packages ('stats')
[18:40:51.215] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.215] Resolved: TRUE
[18:40:51.215] Value: 90.86 KiB of class 'list'
[18:40:51.215] Early signaling: FALSE
[18:40:51.215] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.215] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.217] Chunk #1 of 1 ... DONE
[18:40:51.217] Launching 1 futures (chunks) ... DONE
[18:40:51.217] Resolving 1 futures (chunks) ...
[18:40:51.218] resolve() on list ...
[18:40:51.218]  recursive: 0
[18:40:51.218]  length: 1
[18:40:51.218] 
[18:40:51.218] resolved() for 'SequentialFuture' ...
[18:40:51.218] - state: 'finished'
[18:40:51.219] - run: TRUE
[18:40:51.219] - result: 'FutureResult'
[18:40:51.219] resolved() for 'SequentialFuture' ... done
[18:40:51.219] Future #1
[18:40:51.219] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.219] - nx: 1
[18:40:51.220] - relay: TRUE
[18:40:51.220] - stdout: TRUE
[18:40:51.220] - signal: TRUE
[18:40:51.220] - resignal: FALSE
[18:40:51.220] - force: TRUE
[18:40:51.220] - relayed: [n=1] FALSE
[18:40:51.221] - queued futures: [n=1] FALSE
[18:40:51.221]  - until=1
[18:40:51.221]  - relaying element #1
[18:40:51.221] - relayed: [n=1] TRUE
[18:40:51.221] - queued futures: [n=1] TRUE
[18:40:51.221] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.222]  length: 0 (resolved future 1)
[18:40:51.222] Relaying remaining futures
[18:40:51.222] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.222] - nx: 1
[18:40:51.222] - relay: TRUE
[18:40:51.222] - stdout: TRUE
[18:40:51.223] - signal: TRUE
[18:40:51.223] - resignal: FALSE
[18:40:51.223] - force: TRUE
[18:40:51.223] - relayed: [n=1] TRUE
[18:40:51.223] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.223] - relayed: [n=1] TRUE
[18:40:51.224] - queued futures: [n=1] TRUE
[18:40:51.224] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.224] resolve() on list ... DONE
[18:40:51.224]  - Number of value chunks collected: 1
[18:40:51.224] Resolving 1 futures (chunks) ... DONE
[18:40:51.224] Reducing values from 1 chunks ...
[18:40:51.225]  - Number of values collected after concatenation: 3
[18:40:51.225]  - Number of values expected: 3
[18:40:51.225] Reducing values from 1 chunks ... DONE
[18:40:51.225] future_lapply() ... DONE
[18:40:51.225] future_by_internal() ... DONE
[18:40:51.226] future_by_internal() ...
[18:40:51.226] future_lapply() ...
[18:40:51.229] Number of chunks: 1
[18:40:51.229] getGlobalsAndPackagesXApply() ...
[18:40:51.229]  - future.globals: TRUE
[18:40:51.229] getGlobalsAndPackages() ...
[18:40:51.229] Searching for globals...
[18:40:51.231] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.231] Searching for globals ... DONE
[18:40:51.231] Resolving globals: FALSE
[18:40:51.231] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.232] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.232] - globals: [1] 'FUN'
[18:40:51.232] 
[18:40:51.232] getGlobalsAndPackages() ... DONE
[18:40:51.233]  - globals found/used: [n=1] 'FUN'
[18:40:51.234]  - needed namespaces: [n=0] 
[18:40:51.235] Finding globals ... DONE
[18:40:51.235]  - use_args: TRUE
[18:40:51.235]  - Getting '...' globals ...
[18:40:51.235] resolve() on list ...
[18:40:51.235]  recursive: 0
[18:40:51.236]  length: 1
[18:40:51.236]  elements: '...'
[18:40:51.236]  length: 0 (resolved future 1)
[18:40:51.236] resolve() on list ... DONE
[18:40:51.236]    - '...' content: [n=0] 
[18:40:51.236] List of 1
[18:40:51.236]  $ ...: list()
[18:40:51.236]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.236]  - attr(*, "where")=List of 1
[18:40:51.236]   ..$ ...:<environment: 0x000001cd52327e08> 
[18:40:51.236]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.236]  - attr(*, "resolved")= logi TRUE
[18:40:51.236]  - attr(*, "total_size")= num NA
[18:40:51.239]  - Getting '...' globals ... DONE
[18:40:51.240] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.240] List of 2
[18:40:51.240]  $ ...future.FUN:function (object, ...)  
[18:40:51.240]  $ ...          : list()
[18:40:51.240]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.240]  - attr(*, "where")=List of 2
[18:40:51.240]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.240]   ..$ ...          :<environment: 0x000001cd52327e08> 
[18:40:51.240]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.240]  - attr(*, "resolved")= logi FALSE
[18:40:51.240]  - attr(*, "total_size")= int 19278
[18:40:51.243] Packages to be attached in all futures: [n=0] 
[18:40:51.243] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.243] Number of futures (= number of chunks): 1
[18:40:51.244] Launching 1 futures (chunks) ...
[18:40:51.244] Chunk #1 of 1 ...
[18:40:51.244]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.244] getGlobalsAndPackages() ...
[18:40:51.244] Searching for globals...
[18:40:51.245] 
[18:40:51.245] Searching for globals ... DONE
[18:40:51.245] - globals: [0] <none>
[18:40:51.245] getGlobalsAndPackages() ... DONE
[18:40:51.246]    + additional globals found: [n=0] 
[18:40:51.246]    + additional namespaces needed: [n=0] 
[18:40:51.246]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.246]  - seeds: <none>
[18:40:51.246]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.246] getGlobalsAndPackages() ...
[18:40:51.246] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.247] Resolving globals: FALSE
[18:40:51.247] Tweak future expression to call with '...' arguments ...
[18:40:51.247] {
[18:40:51.247]     do.call(function(...) {
[18:40:51.247]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.247]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.247]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.247]             on.exit(options(oopts), add = TRUE)
[18:40:51.247]         }
[18:40:51.247]         {
[18:40:51.247]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.247]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.247]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.247]             })
[18:40:51.247]         }
[18:40:51.247]     }, args = future.call.arguments)
[18:40:51.247] }
[18:40:51.247] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.248] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.248] 
[18:40:51.248] getGlobalsAndPackages() ... DONE
[18:40:51.249] run() for 'Future' ...
[18:40:51.249] - state: 'created'
[18:40:51.249] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:51.251] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.252] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.252]   - Field: 'label'
[18:40:51.252]   - Field: 'local'
[18:40:51.252]   - Field: 'owner'
[18:40:51.252]   - Field: 'envir'
[18:40:51.253]   - Field: 'packages'
[18:40:51.253]   - Field: 'gc'
[18:40:51.253]   - Field: 'conditions'
[18:40:51.253]   - Field: 'expr'
[18:40:51.253]   - Field: 'uuid'
[18:40:51.253]   - Field: 'seed'
[18:40:51.254]   - Field: 'version'
[18:40:51.254]   - Field: 'result'
[18:40:51.254]   - Field: 'asynchronous'
[18:40:51.254]   - Field: 'calls'
[18:40:51.254]   - Field: 'globals'
[18:40:51.254]   - Field: 'stdout'
[18:40:51.255]   - Field: 'earlySignal'
[18:40:51.255]   - Field: 'lazy'
[18:40:51.255]   - Field: 'state'
[18:40:51.255] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.255] - Launch lazy future ...
[18:40:51.256] Packages needed by the future expression (n = 0): <none>
[18:40:51.256] Packages needed by future strategies (n = 0): <none>
[18:40:51.256] {
[18:40:51.256]     {
[18:40:51.256]         {
[18:40:51.256]             ...future.startTime <- base::Sys.time()
[18:40:51.256]             {
[18:40:51.256]                 {
[18:40:51.256]                   {
[18:40:51.256]                     base::local({
[18:40:51.256]                       has_future <- base::requireNamespace("future", 
[18:40:51.256]                         quietly = TRUE)
[18:40:51.256]                       if (has_future) {
[18:40:51.256]                         ns <- base::getNamespace("future")
[18:40:51.256]                         version <- ns[[".package"]][["version"]]
[18:40:51.256]                         if (is.null(version)) 
[18:40:51.256]                           version <- utils::packageVersion("future")
[18:40:51.256]                       }
[18:40:51.256]                       else {
[18:40:51.256]                         version <- NULL
[18:40:51.256]                       }
[18:40:51.256]                       if (!has_future || version < "1.8.0") {
[18:40:51.256]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.256]                           "", base::R.version$version.string), 
[18:40:51.256]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.256]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.256]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.256]                             "release", "version")], collapse = " "), 
[18:40:51.256]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.256]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.256]                           info)
[18:40:51.256]                         info <- base::paste(info, collapse = "; ")
[18:40:51.256]                         if (!has_future) {
[18:40:51.256]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.256]                             info)
[18:40:51.256]                         }
[18:40:51.256]                         else {
[18:40:51.256]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.256]                             info, version)
[18:40:51.256]                         }
[18:40:51.256]                         base::stop(msg)
[18:40:51.256]                       }
[18:40:51.256]                     })
[18:40:51.256]                   }
[18:40:51.256]                   ...future.strategy.old <- future::plan("list")
[18:40:51.256]                   options(future.plan = NULL)
[18:40:51.256]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.256]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.256]                 }
[18:40:51.256]                 ...future.workdir <- getwd()
[18:40:51.256]             }
[18:40:51.256]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.256]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.256]         }
[18:40:51.256]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.256]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.256]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.256]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.256]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.256]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.256]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.256]             base::names(...future.oldOptions))
[18:40:51.256]     }
[18:40:51.256]     if (FALSE) {
[18:40:51.256]     }
[18:40:51.256]     else {
[18:40:51.256]         if (TRUE) {
[18:40:51.256]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.256]                 open = "w")
[18:40:51.256]         }
[18:40:51.256]         else {
[18:40:51.256]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.256]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.256]         }
[18:40:51.256]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.256]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.256]             base::sink(type = "output", split = FALSE)
[18:40:51.256]             base::close(...future.stdout)
[18:40:51.256]         }, add = TRUE)
[18:40:51.256]     }
[18:40:51.256]     ...future.frame <- base::sys.nframe()
[18:40:51.256]     ...future.conditions <- base::list()
[18:40:51.256]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.256]     if (FALSE) {
[18:40:51.256]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.256]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.256]     }
[18:40:51.256]     ...future.result <- base::tryCatch({
[18:40:51.256]         base::withCallingHandlers({
[18:40:51.256]             ...future.value <- base::withVisible(base::local({
[18:40:51.256]                 do.call(function(...) {
[18:40:51.256]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.256]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.256]                     ...future.globals.maxSize)) {
[18:40:51.256]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.256]                     on.exit(options(oopts), add = TRUE)
[18:40:51.256]                   }
[18:40:51.256]                   {
[18:40:51.256]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.256]                       FUN = function(jj) {
[18:40:51.256]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.256]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.256]                       })
[18:40:51.256]                   }
[18:40:51.256]                 }, args = future.call.arguments)
[18:40:51.256]             }))
[18:40:51.256]             future::FutureResult(value = ...future.value$value, 
[18:40:51.256]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.256]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.256]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.256]                     ...future.globalenv.names))
[18:40:51.256]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.256]         }, condition = base::local({
[18:40:51.256]             c <- base::c
[18:40:51.256]             inherits <- base::inherits
[18:40:51.256]             invokeRestart <- base::invokeRestart
[18:40:51.256]             length <- base::length
[18:40:51.256]             list <- base::list
[18:40:51.256]             seq.int <- base::seq.int
[18:40:51.256]             signalCondition <- base::signalCondition
[18:40:51.256]             sys.calls <- base::sys.calls
[18:40:51.256]             `[[` <- base::`[[`
[18:40:51.256]             `+` <- base::`+`
[18:40:51.256]             `<<-` <- base::`<<-`
[18:40:51.256]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.256]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.256]                   3L)]
[18:40:51.256]             }
[18:40:51.256]             function(cond) {
[18:40:51.256]                 is_error <- inherits(cond, "error")
[18:40:51.256]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.256]                   NULL)
[18:40:51.256]                 if (is_error) {
[18:40:51.256]                   sessionInformation <- function() {
[18:40:51.256]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.256]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.256]                       search = base::search(), system = base::Sys.info())
[18:40:51.256]                   }
[18:40:51.256]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.256]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.256]                     cond$call), session = sessionInformation(), 
[18:40:51.256]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.256]                   signalCondition(cond)
[18:40:51.256]                 }
[18:40:51.256]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.256]                 "immediateCondition"))) {
[18:40:51.256]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.256]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.256]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.256]                   if (TRUE && !signal) {
[18:40:51.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.256]                     {
[18:40:51.256]                       inherits <- base::inherits
[18:40:51.256]                       invokeRestart <- base::invokeRestart
[18:40:51.256]                       is.null <- base::is.null
[18:40:51.256]                       muffled <- FALSE
[18:40:51.256]                       if (inherits(cond, "message")) {
[18:40:51.256]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.256]                         if (muffled) 
[18:40:51.256]                           invokeRestart("muffleMessage")
[18:40:51.256]                       }
[18:40:51.256]                       else if (inherits(cond, "warning")) {
[18:40:51.256]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.256]                         if (muffled) 
[18:40:51.256]                           invokeRestart("muffleWarning")
[18:40:51.256]                       }
[18:40:51.256]                       else if (inherits(cond, "condition")) {
[18:40:51.256]                         if (!is.null(pattern)) {
[18:40:51.256]                           computeRestarts <- base::computeRestarts
[18:40:51.256]                           grepl <- base::grepl
[18:40:51.256]                           restarts <- computeRestarts(cond)
[18:40:51.256]                           for (restart in restarts) {
[18:40:51.256]                             name <- restart$name
[18:40:51.256]                             if (is.null(name)) 
[18:40:51.256]                               next
[18:40:51.256]                             if (!grepl(pattern, name)) 
[18:40:51.256]                               next
[18:40:51.256]                             invokeRestart(restart)
[18:40:51.256]                             muffled <- TRUE
[18:40:51.256]                             break
[18:40:51.256]                           }
[18:40:51.256]                         }
[18:40:51.256]                       }
[18:40:51.256]                       invisible(muffled)
[18:40:51.256]                     }
[18:40:51.256]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.256]                   }
[18:40:51.256]                 }
[18:40:51.256]                 else {
[18:40:51.256]                   if (TRUE) {
[18:40:51.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.256]                     {
[18:40:51.256]                       inherits <- base::inherits
[18:40:51.256]                       invokeRestart <- base::invokeRestart
[18:40:51.256]                       is.null <- base::is.null
[18:40:51.256]                       muffled <- FALSE
[18:40:51.256]                       if (inherits(cond, "message")) {
[18:40:51.256]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.256]                         if (muffled) 
[18:40:51.256]                           invokeRestart("muffleMessage")
[18:40:51.256]                       }
[18:40:51.256]                       else if (inherits(cond, "warning")) {
[18:40:51.256]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.256]                         if (muffled) 
[18:40:51.256]                           invokeRestart("muffleWarning")
[18:40:51.256]                       }
[18:40:51.256]                       else if (inherits(cond, "condition")) {
[18:40:51.256]                         if (!is.null(pattern)) {
[18:40:51.256]                           computeRestarts <- base::computeRestarts
[18:40:51.256]                           grepl <- base::grepl
[18:40:51.256]                           restarts <- computeRestarts(cond)
[18:40:51.256]                           for (restart in restarts) {
[18:40:51.256]                             name <- restart$name
[18:40:51.256]                             if (is.null(name)) 
[18:40:51.256]                               next
[18:40:51.256]                             if (!grepl(pattern, name)) 
[18:40:51.256]                               next
[18:40:51.256]                             invokeRestart(restart)
[18:40:51.256]                             muffled <- TRUE
[18:40:51.256]                             break
[18:40:51.256]                           }
[18:40:51.256]                         }
[18:40:51.256]                       }
[18:40:51.256]                       invisible(muffled)
[18:40:51.256]                     }
[18:40:51.256]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.256]                   }
[18:40:51.256]                 }
[18:40:51.256]             }
[18:40:51.256]         }))
[18:40:51.256]     }, error = function(ex) {
[18:40:51.256]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.256]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.256]                 ...future.rng), started = ...future.startTime, 
[18:40:51.256]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.256]             version = "1.8"), class = "FutureResult")
[18:40:51.256]     }, finally = {
[18:40:51.256]         if (!identical(...future.workdir, getwd())) 
[18:40:51.256]             setwd(...future.workdir)
[18:40:51.256]         {
[18:40:51.256]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.256]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.256]             }
[18:40:51.256]             base::options(...future.oldOptions)
[18:40:51.256]             if (.Platform$OS.type == "windows") {
[18:40:51.256]                 old_names <- names(...future.oldEnvVars)
[18:40:51.256]                 envs <- base::Sys.getenv()
[18:40:51.256]                 names <- names(envs)
[18:40:51.256]                 common <- intersect(names, old_names)
[18:40:51.256]                 added <- setdiff(names, old_names)
[18:40:51.256]                 removed <- setdiff(old_names, names)
[18:40:51.256]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.256]                   envs[common]]
[18:40:51.256]                 NAMES <- toupper(changed)
[18:40:51.256]                 args <- list()
[18:40:51.256]                 for (kk in seq_along(NAMES)) {
[18:40:51.256]                   name <- changed[[kk]]
[18:40:51.256]                   NAME <- NAMES[[kk]]
[18:40:51.256]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.256]                     next
[18:40:51.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.256]                 }
[18:40:51.256]                 NAMES <- toupper(added)
[18:40:51.256]                 for (kk in seq_along(NAMES)) {
[18:40:51.256]                   name <- added[[kk]]
[18:40:51.256]                   NAME <- NAMES[[kk]]
[18:40:51.256]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.256]                     next
[18:40:51.256]                   args[[name]] <- ""
[18:40:51.256]                 }
[18:40:51.256]                 NAMES <- toupper(removed)
[18:40:51.256]                 for (kk in seq_along(NAMES)) {
[18:40:51.256]                   name <- removed[[kk]]
[18:40:51.256]                   NAME <- NAMES[[kk]]
[18:40:51.256]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.256]                     next
[18:40:51.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.256]                 }
[18:40:51.256]                 if (length(args) > 0) 
[18:40:51.256]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.256]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.256]             }
[18:40:51.256]             else {
[18:40:51.256]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.256]             }
[18:40:51.256]             {
[18:40:51.256]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.256]                   0L) {
[18:40:51.256]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.256]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.256]                   base::options(opts)
[18:40:51.256]                 }
[18:40:51.256]                 {
[18:40:51.256]                   {
[18:40:51.256]                     NULL
[18:40:51.256]                     RNGkind("Mersenne-Twister")
[18:40:51.256]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.256]                       inherits = FALSE)
[18:40:51.256]                   }
[18:40:51.256]                   options(future.plan = NULL)
[18:40:51.256]                   if (is.na(NA_character_)) 
[18:40:51.256]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.256]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.256]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.256]                     .init = FALSE)
[18:40:51.256]                 }
[18:40:51.256]             }
[18:40:51.256]         }
[18:40:51.256]     })
[18:40:51.256]     if (TRUE) {
[18:40:51.256]         base::sink(type = "output", split = FALSE)
[18:40:51.256]         if (TRUE) {
[18:40:51.256]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.256]         }
[18:40:51.256]         else {
[18:40:51.256]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.256]         }
[18:40:51.256]         base::close(...future.stdout)
[18:40:51.256]         ...future.stdout <- NULL
[18:40:51.256]     }
[18:40:51.256]     ...future.result$conditions <- ...future.conditions
[18:40:51.256]     ...future.result$finished <- base::Sys.time()
[18:40:51.256]     ...future.result
[18:40:51.256] }
[18:40:51.260] assign_globals() ...
[18:40:51.260] List of 5
[18:40:51.260]  $ ...future.FUN            :function (object, ...)  
[18:40:51.260]  $ future.call.arguments    : list()
[18:40:51.260]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.260]  $ ...future.elements_ii    :List of 3
[18:40:51.260]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.260]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.260]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.260]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.260]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.260]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.260]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.260]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.260]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.260]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.260]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.260]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.260]  $ ...future.seeds_ii       : NULL
[18:40:51.260]  $ ...future.globals.maxSize: NULL
[18:40:51.260]  - attr(*, "where")=List of 5
[18:40:51.260]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.260]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.260]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.260]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.260]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.260]  - attr(*, "resolved")= logi FALSE
[18:40:51.260]  - attr(*, "total_size")= num 19278
[18:40:51.260]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.260]  - attr(*, "already-done")= logi TRUE
[18:40:51.271] - copied '...future.FUN' to environment
[18:40:51.271] - copied 'future.call.arguments' to environment
[18:40:51.271] - copied '...future.elements_ii' to environment
[18:40:51.271] - copied '...future.seeds_ii' to environment
[18:40:51.271] - copied '...future.globals.maxSize' to environment
[18:40:51.271] assign_globals() ... done
[18:40:51.272] plan(): Setting new future strategy stack:
[18:40:51.272] List of future strategies:
[18:40:51.272] 1. sequential:
[18:40:51.272]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.272]    - tweaked: FALSE
[18:40:51.272]    - call: NULL
[18:40:51.273] plan(): nbrOfWorkers() = 1
[18:40:51.276] plan(): Setting new future strategy stack:
[18:40:51.276] List of future strategies:
[18:40:51.276] 1. multisession:
[18:40:51.276]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.276]    - tweaked: FALSE
[18:40:51.276]    - call: plan(strategy)
[18:40:51.278] plan(): nbrOfWorkers() = 1
[18:40:51.279] SequentialFuture started (and completed)
[18:40:51.279] - Launch lazy future ... done
[18:40:51.279] run() for 'SequentialFuture' ... done
[18:40:51.279] Created future:
[18:40:51.279] SequentialFuture:
[18:40:51.279] Label: 'future_by-1'
[18:40:51.279] Expression:
[18:40:51.279] {
[18:40:51.279]     do.call(function(...) {
[18:40:51.279]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.279]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.279]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.279]             on.exit(options(oopts), add = TRUE)
[18:40:51.279]         }
[18:40:51.279]         {
[18:40:51.279]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.279]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.279]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.279]             })
[18:40:51.279]         }
[18:40:51.279]     }, args = future.call.arguments)
[18:40:51.279] }
[18:40:51.279] Lazy evaluation: FALSE
[18:40:51.279] Asynchronous evaluation: FALSE
[18:40:51.279] Local evaluation: TRUE
[18:40:51.279] Environment: 0x000001cd522b09e8
[18:40:51.279] Capture standard output: TRUE
[18:40:51.279] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.279] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.279] Packages: <none>
[18:40:51.279] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.279] Resolved: TRUE
[18:40:51.279] Value: 1.39 KiB of class 'list'
[18:40:51.279] Early signaling: FALSE
[18:40:51.279] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.279] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.281] Chunk #1 of 1 ... DONE
[18:40:51.281] Launching 1 futures (chunks) ... DONE
[18:40:51.281] Resolving 1 futures (chunks) ...
[18:40:51.281] resolve() on list ...
[18:40:51.281]  recursive: 0
[18:40:51.281]  length: 1
[18:40:51.281] 
[18:40:51.282] resolved() for 'SequentialFuture' ...
[18:40:51.282] - state: 'finished'
[18:40:51.282] - run: TRUE
[18:40:51.282] - result: 'FutureResult'
[18:40:51.282] resolved() for 'SequentialFuture' ... done
[18:40:51.283] Future #1
[18:40:51.283] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.283] - nx: 1
[18:40:51.283] - relay: TRUE
[18:40:51.283] - stdout: TRUE
[18:40:51.283] - signal: TRUE
[18:40:51.284] - resignal: FALSE
[18:40:51.284] - force: TRUE
[18:40:51.284] - relayed: [n=1] FALSE
[18:40:51.284] - queued futures: [n=1] FALSE
[18:40:51.284]  - until=1
[18:40:51.284]  - relaying element #1
[18:40:51.285] - relayed: [n=1] TRUE
[18:40:51.285] - queued futures: [n=1] TRUE
[18:40:51.285] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.285]  length: 0 (resolved future 1)
[18:40:51.285] Relaying remaining futures
[18:40:51.285] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.286] - nx: 1
[18:40:51.286] - relay: TRUE
[18:40:51.286] - stdout: TRUE
[18:40:51.286] - signal: TRUE
[18:40:51.286] - resignal: FALSE
[18:40:51.286] - force: TRUE
[18:40:51.286] - relayed: [n=1] TRUE
[18:40:51.287] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.287] - relayed: [n=1] TRUE
[18:40:51.287] - queued futures: [n=1] TRUE
[18:40:51.287] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.287] resolve() on list ... DONE
[18:40:51.288]  - Number of value chunks collected: 1
[18:40:51.288] Resolving 1 futures (chunks) ... DONE
[18:40:51.288] Reducing values from 1 chunks ...
[18:40:51.288]  - Number of values collected after concatenation: 3
[18:40:51.288]  - Number of values expected: 3
[18:40:51.288] Reducing values from 1 chunks ... DONE
[18:40:51.288] future_lapply() ... DONE
[18:40:51.289] future_by_internal() ... DONE
[18:40:51.290] future_by_internal() ...
Warning in future_by_match_FUN(FUN) :
  Specifying the function 'FUN' for future_by() as a character string is deprecated in future.apply (>= 1.10.0) [2022-11-04], because base::by() does not support it. Instead, specify it as a function, e.g. FUN = sqrt and FUN = `[[`. It is deprecated.
[18:40:51.290] future_lapply() ...
[18:40:51.293] Number of chunks: 1
[18:40:51.293] getGlobalsAndPackagesXApply() ...
[18:40:51.293]  - future.globals: TRUE
[18:40:51.293] getGlobalsAndPackages() ...
[18:40:51.293] Searching for globals...
[18:40:51.295] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.295] Searching for globals ... DONE
[18:40:51.295] Resolving globals: FALSE
[18:40:51.295] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.296] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.296] - globals: [1] 'FUN'
[18:40:51.296] 
[18:40:51.296] getGlobalsAndPackages() ... DONE
[18:40:51.297]  - globals found/used: [n=1] 'FUN'
[18:40:51.297]  - needed namespaces: [n=0] 
[18:40:51.297] Finding globals ... DONE
[18:40:51.297]  - use_args: TRUE
[18:40:51.297]  - Getting '...' globals ...
[18:40:51.298] resolve() on list ...
[18:40:51.298]  recursive: 0
[18:40:51.298]  length: 1
[18:40:51.298]  elements: '...'
[18:40:51.298]  length: 0 (resolved future 1)
[18:40:51.299] resolve() on list ... DONE
[18:40:51.299]    - '...' content: [n=0] 
[18:40:51.299] List of 1
[18:40:51.299]  $ ...: list()
[18:40:51.299]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.299]  - attr(*, "where")=List of 1
[18:40:51.299]   ..$ ...:<environment: 0x000001cd50d098c8> 
[18:40:51.299]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.299]  - attr(*, "resolved")= logi TRUE
[18:40:51.299]  - attr(*, "total_size")= num NA
[18:40:51.302]  - Getting '...' globals ... DONE
[18:40:51.302] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.302] List of 2
[18:40:51.302]  $ ...future.FUN:function (object, ...)  
[18:40:51.302]  $ ...          : list()
[18:40:51.302]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.302]  - attr(*, "where")=List of 2
[18:40:51.302]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.302]   ..$ ...          :<environment: 0x000001cd50d098c8> 
[18:40:51.302]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.302]  - attr(*, "resolved")= logi FALSE
[18:40:51.302]  - attr(*, "total_size")= int 18647
[18:40:51.306] Packages to be attached in all futures: [n=0] 
[18:40:51.306] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.306] Number of futures (= number of chunks): 1
[18:40:51.306] Launching 1 futures (chunks) ...
[18:40:51.306] Chunk #1 of 1 ...
[18:40:51.306]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.307] getGlobalsAndPackages() ...
[18:40:51.307] Searching for globals...
[18:40:51.307] 
[18:40:51.308] Searching for globals ... DONE
[18:40:51.308] - globals: [0] <none>
[18:40:51.308] getGlobalsAndPackages() ... DONE
[18:40:51.308]    + additional globals found: [n=0] 
[18:40:51.308]    + additional namespaces needed: [n=0] 
[18:40:51.308]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.308]  - seeds: <none>
[18:40:51.309]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.309] getGlobalsAndPackages() ...
[18:40:51.309] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.309] Resolving globals: FALSE
[18:40:51.309] Tweak future expression to call with '...' arguments ...
[18:40:51.310] {
[18:40:51.310]     do.call(function(...) {
[18:40:51.310]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.310]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.310]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.310]             on.exit(options(oopts), add = TRUE)
[18:40:51.310]         }
[18:40:51.310]         {
[18:40:51.310]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.310]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.310]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.310]             })
[18:40:51.310]         }
[18:40:51.310]     }, args = future.call.arguments)
[18:40:51.310] }
[18:40:51.310] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.310] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.311] 
[18:40:51.311] getGlobalsAndPackages() ... DONE
[18:40:51.311] run() for 'Future' ...
[18:40:51.311] - state: 'created'
[18:40:51.312] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:51.314] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.314] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.314]   - Field: 'label'
[18:40:51.314]   - Field: 'local'
[18:40:51.315]   - Field: 'owner'
[18:40:51.315]   - Field: 'envir'
[18:40:51.315]   - Field: 'packages'
[18:40:51.315]   - Field: 'gc'
[18:40:51.315]   - Field: 'conditions'
[18:40:51.315]   - Field: 'expr'
[18:40:51.316]   - Field: 'uuid'
[18:40:51.316]   - Field: 'seed'
[18:40:51.316]   - Field: 'version'
[18:40:51.316]   - Field: 'result'
[18:40:51.316]   - Field: 'asynchronous'
[18:40:51.316]   - Field: 'calls'
[18:40:51.317]   - Field: 'globals'
[18:40:51.317]   - Field: 'stdout'
[18:40:51.317]   - Field: 'earlySignal'
[18:40:51.317]   - Field: 'lazy'
[18:40:51.317]   - Field: 'state'
[18:40:51.317] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.318] - Launch lazy future ...
[18:40:51.318] Packages needed by the future expression (n = 0): <none>
[18:40:51.318] Packages needed by future strategies (n = 0): <none>
[18:40:51.319] {
[18:40:51.319]     {
[18:40:51.319]         {
[18:40:51.319]             ...future.startTime <- base::Sys.time()
[18:40:51.319]             {
[18:40:51.319]                 {
[18:40:51.319]                   {
[18:40:51.319]                     base::local({
[18:40:51.319]                       has_future <- base::requireNamespace("future", 
[18:40:51.319]                         quietly = TRUE)
[18:40:51.319]                       if (has_future) {
[18:40:51.319]                         ns <- base::getNamespace("future")
[18:40:51.319]                         version <- ns[[".package"]][["version"]]
[18:40:51.319]                         if (is.null(version)) 
[18:40:51.319]                           version <- utils::packageVersion("future")
[18:40:51.319]                       }
[18:40:51.319]                       else {
[18:40:51.319]                         version <- NULL
[18:40:51.319]                       }
[18:40:51.319]                       if (!has_future || version < "1.8.0") {
[18:40:51.319]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.319]                           "", base::R.version$version.string), 
[18:40:51.319]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.319]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.319]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.319]                             "release", "version")], collapse = " "), 
[18:40:51.319]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.319]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.319]                           info)
[18:40:51.319]                         info <- base::paste(info, collapse = "; ")
[18:40:51.319]                         if (!has_future) {
[18:40:51.319]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.319]                             info)
[18:40:51.319]                         }
[18:40:51.319]                         else {
[18:40:51.319]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.319]                             info, version)
[18:40:51.319]                         }
[18:40:51.319]                         base::stop(msg)
[18:40:51.319]                       }
[18:40:51.319]                     })
[18:40:51.319]                   }
[18:40:51.319]                   ...future.strategy.old <- future::plan("list")
[18:40:51.319]                   options(future.plan = NULL)
[18:40:51.319]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.319]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.319]                 }
[18:40:51.319]                 ...future.workdir <- getwd()
[18:40:51.319]             }
[18:40:51.319]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.319]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.319]         }
[18:40:51.319]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.319]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.319]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.319]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.319]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.319]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.319]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.319]             base::names(...future.oldOptions))
[18:40:51.319]     }
[18:40:51.319]     if (FALSE) {
[18:40:51.319]     }
[18:40:51.319]     else {
[18:40:51.319]         if (TRUE) {
[18:40:51.319]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.319]                 open = "w")
[18:40:51.319]         }
[18:40:51.319]         else {
[18:40:51.319]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.319]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.319]         }
[18:40:51.319]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.319]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.319]             base::sink(type = "output", split = FALSE)
[18:40:51.319]             base::close(...future.stdout)
[18:40:51.319]         }, add = TRUE)
[18:40:51.319]     }
[18:40:51.319]     ...future.frame <- base::sys.nframe()
[18:40:51.319]     ...future.conditions <- base::list()
[18:40:51.319]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.319]     if (FALSE) {
[18:40:51.319]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.319]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.319]     }
[18:40:51.319]     ...future.result <- base::tryCatch({
[18:40:51.319]         base::withCallingHandlers({
[18:40:51.319]             ...future.value <- base::withVisible(base::local({
[18:40:51.319]                 do.call(function(...) {
[18:40:51.319]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.319]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.319]                     ...future.globals.maxSize)) {
[18:40:51.319]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.319]                     on.exit(options(oopts), add = TRUE)
[18:40:51.319]                   }
[18:40:51.319]                   {
[18:40:51.319]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.319]                       FUN = function(jj) {
[18:40:51.319]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.319]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.319]                       })
[18:40:51.319]                   }
[18:40:51.319]                 }, args = future.call.arguments)
[18:40:51.319]             }))
[18:40:51.319]             future::FutureResult(value = ...future.value$value, 
[18:40:51.319]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.319]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.319]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.319]                     ...future.globalenv.names))
[18:40:51.319]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.319]         }, condition = base::local({
[18:40:51.319]             c <- base::c
[18:40:51.319]             inherits <- base::inherits
[18:40:51.319]             invokeRestart <- base::invokeRestart
[18:40:51.319]             length <- base::length
[18:40:51.319]             list <- base::list
[18:40:51.319]             seq.int <- base::seq.int
[18:40:51.319]             signalCondition <- base::signalCondition
[18:40:51.319]             sys.calls <- base::sys.calls
[18:40:51.319]             `[[` <- base::`[[`
[18:40:51.319]             `+` <- base::`+`
[18:40:51.319]             `<<-` <- base::`<<-`
[18:40:51.319]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.319]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.319]                   3L)]
[18:40:51.319]             }
[18:40:51.319]             function(cond) {
[18:40:51.319]                 is_error <- inherits(cond, "error")
[18:40:51.319]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.319]                   NULL)
[18:40:51.319]                 if (is_error) {
[18:40:51.319]                   sessionInformation <- function() {
[18:40:51.319]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.319]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.319]                       search = base::search(), system = base::Sys.info())
[18:40:51.319]                   }
[18:40:51.319]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.319]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.319]                     cond$call), session = sessionInformation(), 
[18:40:51.319]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.319]                   signalCondition(cond)
[18:40:51.319]                 }
[18:40:51.319]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.319]                 "immediateCondition"))) {
[18:40:51.319]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.319]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.319]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.319]                   if (TRUE && !signal) {
[18:40:51.319]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.319]                     {
[18:40:51.319]                       inherits <- base::inherits
[18:40:51.319]                       invokeRestart <- base::invokeRestart
[18:40:51.319]                       is.null <- base::is.null
[18:40:51.319]                       muffled <- FALSE
[18:40:51.319]                       if (inherits(cond, "message")) {
[18:40:51.319]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.319]                         if (muffled) 
[18:40:51.319]                           invokeRestart("muffleMessage")
[18:40:51.319]                       }
[18:40:51.319]                       else if (inherits(cond, "warning")) {
[18:40:51.319]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.319]                         if (muffled) 
[18:40:51.319]                           invokeRestart("muffleWarning")
[18:40:51.319]                       }
[18:40:51.319]                       else if (inherits(cond, "condition")) {
[18:40:51.319]                         if (!is.null(pattern)) {
[18:40:51.319]                           computeRestarts <- base::computeRestarts
[18:40:51.319]                           grepl <- base::grepl
[18:40:51.319]                           restarts <- computeRestarts(cond)
[18:40:51.319]                           for (restart in restarts) {
[18:40:51.319]                             name <- restart$name
[18:40:51.319]                             if (is.null(name)) 
[18:40:51.319]                               next
[18:40:51.319]                             if (!grepl(pattern, name)) 
[18:40:51.319]                               next
[18:40:51.319]                             invokeRestart(restart)
[18:40:51.319]                             muffled <- TRUE
[18:40:51.319]                             break
[18:40:51.319]                           }
[18:40:51.319]                         }
[18:40:51.319]                       }
[18:40:51.319]                       invisible(muffled)
[18:40:51.319]                     }
[18:40:51.319]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.319]                   }
[18:40:51.319]                 }
[18:40:51.319]                 else {
[18:40:51.319]                   if (TRUE) {
[18:40:51.319]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.319]                     {
[18:40:51.319]                       inherits <- base::inherits
[18:40:51.319]                       invokeRestart <- base::invokeRestart
[18:40:51.319]                       is.null <- base::is.null
[18:40:51.319]                       muffled <- FALSE
[18:40:51.319]                       if (inherits(cond, "message")) {
[18:40:51.319]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.319]                         if (muffled) 
[18:40:51.319]                           invokeRestart("muffleMessage")
[18:40:51.319]                       }
[18:40:51.319]                       else if (inherits(cond, "warning")) {
[18:40:51.319]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.319]                         if (muffled) 
[18:40:51.319]                           invokeRestart("muffleWarning")
[18:40:51.319]                       }
[18:40:51.319]                       else if (inherits(cond, "condition")) {
[18:40:51.319]                         if (!is.null(pattern)) {
[18:40:51.319]                           computeRestarts <- base::computeRestarts
[18:40:51.319]                           grepl <- base::grepl
[18:40:51.319]                           restarts <- computeRestarts(cond)
[18:40:51.319]                           for (restart in restarts) {
[18:40:51.319]                             name <- restart$name
[18:40:51.319]                             if (is.null(name)) 
[18:40:51.319]                               next
[18:40:51.319]                             if (!grepl(pattern, name)) 
[18:40:51.319]                               next
[18:40:51.319]                             invokeRestart(restart)
[18:40:51.319]                             muffled <- TRUE
[18:40:51.319]                             break
[18:40:51.319]                           }
[18:40:51.319]                         }
[18:40:51.319]                       }
[18:40:51.319]                       invisible(muffled)
[18:40:51.319]                     }
[18:40:51.319]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.319]                   }
[18:40:51.319]                 }
[18:40:51.319]             }
[18:40:51.319]         }))
[18:40:51.319]     }, error = function(ex) {
[18:40:51.319]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.319]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.319]                 ...future.rng), started = ...future.startTime, 
[18:40:51.319]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.319]             version = "1.8"), class = "FutureResult")
[18:40:51.319]     }, finally = {
[18:40:51.319]         if (!identical(...future.workdir, getwd())) 
[18:40:51.319]             setwd(...future.workdir)
[18:40:51.319]         {
[18:40:51.319]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.319]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.319]             }
[18:40:51.319]             base::options(...future.oldOptions)
[18:40:51.319]             if (.Platform$OS.type == "windows") {
[18:40:51.319]                 old_names <- names(...future.oldEnvVars)
[18:40:51.319]                 envs <- base::Sys.getenv()
[18:40:51.319]                 names <- names(envs)
[18:40:51.319]                 common <- intersect(names, old_names)
[18:40:51.319]                 added <- setdiff(names, old_names)
[18:40:51.319]                 removed <- setdiff(old_names, names)
[18:40:51.319]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.319]                   envs[common]]
[18:40:51.319]                 NAMES <- toupper(changed)
[18:40:51.319]                 args <- list()
[18:40:51.319]                 for (kk in seq_along(NAMES)) {
[18:40:51.319]                   name <- changed[[kk]]
[18:40:51.319]                   NAME <- NAMES[[kk]]
[18:40:51.319]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.319]                     next
[18:40:51.319]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.319]                 }
[18:40:51.319]                 NAMES <- toupper(added)
[18:40:51.319]                 for (kk in seq_along(NAMES)) {
[18:40:51.319]                   name <- added[[kk]]
[18:40:51.319]                   NAME <- NAMES[[kk]]
[18:40:51.319]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.319]                     next
[18:40:51.319]                   args[[name]] <- ""
[18:40:51.319]                 }
[18:40:51.319]                 NAMES <- toupper(removed)
[18:40:51.319]                 for (kk in seq_along(NAMES)) {
[18:40:51.319]                   name <- removed[[kk]]
[18:40:51.319]                   NAME <- NAMES[[kk]]
[18:40:51.319]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.319]                     next
[18:40:51.319]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.319]                 }
[18:40:51.319]                 if (length(args) > 0) 
[18:40:51.319]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.319]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.319]             }
[18:40:51.319]             else {
[18:40:51.319]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.319]             }
[18:40:51.319]             {
[18:40:51.319]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.319]                   0L) {
[18:40:51.319]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.319]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.319]                   base::options(opts)
[18:40:51.319]                 }
[18:40:51.319]                 {
[18:40:51.319]                   {
[18:40:51.319]                     NULL
[18:40:51.319]                     RNGkind("Mersenne-Twister")
[18:40:51.319]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.319]                       inherits = FALSE)
[18:40:51.319]                   }
[18:40:51.319]                   options(future.plan = NULL)
[18:40:51.319]                   if (is.na(NA_character_)) 
[18:40:51.319]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.319]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.319]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.319]                     .init = FALSE)
[18:40:51.319]                 }
[18:40:51.319]             }
[18:40:51.319]         }
[18:40:51.319]     })
[18:40:51.319]     if (TRUE) {
[18:40:51.319]         base::sink(type = "output", split = FALSE)
[18:40:51.319]         if (TRUE) {
[18:40:51.319]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.319]         }
[18:40:51.319]         else {
[18:40:51.319]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.319]         }
[18:40:51.319]         base::close(...future.stdout)
[18:40:51.319]         ...future.stdout <- NULL
[18:40:51.319]     }
[18:40:51.319]     ...future.result$conditions <- ...future.conditions
[18:40:51.319]     ...future.result$finished <- base::Sys.time()
[18:40:51.319]     ...future.result
[18:40:51.319] }
[18:40:51.322] assign_globals() ...
[18:40:51.323] List of 5
[18:40:51.323]  $ ...future.FUN            :function (object, ...)  
[18:40:51.323]  $ future.call.arguments    : list()
[18:40:51.323]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.323]  $ ...future.elements_ii    :List of 3
[18:40:51.323]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.323]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.323]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.323]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.323]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.323]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.323]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.323]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.323]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.323]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.323]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.323]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.323]  $ ...future.seeds_ii       : NULL
[18:40:51.323]  $ ...future.globals.maxSize: NULL
[18:40:51.323]  - attr(*, "where")=List of 5
[18:40:51.323]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.323]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.323]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.323]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.323]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.323]  - attr(*, "resolved")= logi FALSE
[18:40:51.323]  - attr(*, "total_size")= num 18647
[18:40:51.323]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.323]  - attr(*, "already-done")= logi TRUE
[18:40:51.333] - copied '...future.FUN' to environment
[18:40:51.333] - copied 'future.call.arguments' to environment
[18:40:51.333] - copied '...future.elements_ii' to environment
[18:40:51.334] - copied '...future.seeds_ii' to environment
[18:40:51.334] - copied '...future.globals.maxSize' to environment
[18:40:51.334] assign_globals() ... done
[18:40:51.334] plan(): Setting new future strategy stack:
[18:40:51.334] List of future strategies:
[18:40:51.334] 1. sequential:
[18:40:51.334]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.334]    - tweaked: FALSE
[18:40:51.334]    - call: NULL
[18:40:51.335] plan(): nbrOfWorkers() = 1
[18:40:51.338] plan(): Setting new future strategy stack:
[18:40:51.338] List of future strategies:
[18:40:51.338] 1. multisession:
[18:40:51.338]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.338]    - tweaked: FALSE
[18:40:51.338]    - call: plan(strategy)
[18:40:51.341] plan(): nbrOfWorkers() = 1
[18:40:51.341] SequentialFuture started (and completed)
[18:40:51.341] - Launch lazy future ... done
[18:40:51.341] run() for 'SequentialFuture' ... done
[18:40:51.342] Created future:
[18:40:51.342] SequentialFuture:
[18:40:51.342] Label: 'future_by-1'
[18:40:51.342] Expression:
[18:40:51.342] {
[18:40:51.342]     do.call(function(...) {
[18:40:51.342]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.342]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.342]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.342]             on.exit(options(oopts), add = TRUE)
[18:40:51.342]         }
[18:40:51.342]         {
[18:40:51.342]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.342]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.342]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.342]             })
[18:40:51.342]         }
[18:40:51.342]     }, args = future.call.arguments)
[18:40:51.342] }
[18:40:51.342] Lazy evaluation: FALSE
[18:40:51.342] Asynchronous evaluation: FALSE
[18:40:51.342] Local evaluation: TRUE
[18:40:51.342] Environment: 0x000001cd50c8da88
[18:40:51.342] Capture standard output: TRUE
[18:40:51.342] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.342] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.342] Packages: <none>
[18:40:51.342] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.342] Resolved: TRUE
[18:40:51.342] Value: 1.39 KiB of class 'list'
[18:40:51.342] Early signaling: FALSE
[18:40:51.342] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.342] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.343] Chunk #1 of 1 ... DONE
[18:40:51.343] Launching 1 futures (chunks) ... DONE
[18:40:51.343] Resolving 1 futures (chunks) ...
[18:40:51.344] resolve() on list ...
[18:40:51.344]  recursive: 0
[18:40:51.344]  length: 1
[18:40:51.344] 
[18:40:51.344] resolved() for 'SequentialFuture' ...
[18:40:51.344] - state: 'finished'
[18:40:51.345] - run: TRUE
[18:40:51.345] - result: 'FutureResult'
[18:40:51.345] resolved() for 'SequentialFuture' ... done
[18:40:51.345] Future #1
[18:40:51.345] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.346] - nx: 1
[18:40:51.346] - relay: TRUE
[18:40:51.346] - stdout: TRUE
[18:40:51.346] - signal: TRUE
[18:40:51.346] - resignal: FALSE
[18:40:51.346] - force: TRUE
[18:40:51.346] - relayed: [n=1] FALSE
[18:40:51.347] - queued futures: [n=1] FALSE
[18:40:51.347]  - until=1
[18:40:51.347]  - relaying element #1
[18:40:51.347] - relayed: [n=1] TRUE
[18:40:51.347] - queued futures: [n=1] TRUE
[18:40:51.348] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.348]  length: 0 (resolved future 1)
[18:40:51.348] Relaying remaining futures
[18:40:51.348] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.348] - nx: 1
[18:40:51.348] - relay: TRUE
[18:40:51.349] - stdout: TRUE
[18:40:51.349] - signal: TRUE
[18:40:51.349] - resignal: FALSE
[18:40:51.351] - force: TRUE
[18:40:51.351] - relayed: [n=1] TRUE
[18:40:51.351] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.351] - relayed: [n=1] TRUE
[18:40:51.351] - queued futures: [n=1] TRUE
[18:40:51.351] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.352] resolve() on list ... DONE
[18:40:51.352]  - Number of value chunks collected: 1
[18:40:51.352] Resolving 1 futures (chunks) ... DONE
[18:40:51.352] Reducing values from 1 chunks ...
[18:40:51.352]  - Number of values collected after concatenation: 3
[18:40:51.352]  - Number of values expected: 3
[18:40:51.353] Reducing values from 1 chunks ... DONE
[18:40:51.353] future_lapply() ... DONE
[18:40:51.353] future_by_internal() ... DONE
[18:40:51.354] future_by_internal() ...
Testing with 1 cores ... DONE
Testing with 2 cores ...
- plan('sequential') ...
[18:40:51.355] plan(): Setting new future strategy stack:
[18:40:51.355] List of future strategies:
[18:40:51.355] 1. sequential:
[18:40:51.355]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.355]    - tweaked: FALSE
[18:40:51.355]    - call: plan(strategy)
[18:40:51.356] plan(): nbrOfWorkers() = 1
[18:40:51.356] future_by_internal() ...
[18:40:51.356] future_lapply() ...
[18:40:51.357] Number of chunks: 1
[18:40:51.357] getGlobalsAndPackagesXApply() ...
[18:40:51.357]  - future.globals: TRUE
[18:40:51.358] getGlobalsAndPackages() ...
[18:40:51.358] Searching for globals...
[18:40:51.359] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.359] Searching for globals ... DONE
[18:40:51.359] Resolving globals: FALSE
[18:40:51.360] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.360] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.360] - globals: [1] 'FUN'
[18:40:51.361] 
[18:40:51.361] getGlobalsAndPackages() ... DONE
[18:40:51.361]  - globals found/used: [n=1] 'FUN'
[18:40:51.361]  - needed namespaces: [n=0] 
[18:40:51.361] Finding globals ... DONE
[18:40:51.361]  - use_args: TRUE
[18:40:51.362]  - Getting '...' globals ...
[18:40:51.362] resolve() on list ...
[18:40:51.362]  recursive: 0
[18:40:51.362]  length: 1
[18:40:51.362]  elements: '...'
[18:40:51.363]  length: 0 (resolved future 1)
[18:40:51.363] resolve() on list ... DONE
[18:40:51.363]    - '...' content: [n=0] 
[18:40:51.363] List of 1
[18:40:51.363]  $ ...: list()
[18:40:51.363]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.363]  - attr(*, "where")=List of 1
[18:40:51.363]   ..$ ...:<environment: 0x000001cd4e7b76b8> 
[18:40:51.363]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.363]  - attr(*, "resolved")= logi TRUE
[18:40:51.363]  - attr(*, "total_size")= num NA
[18:40:51.366]  - Getting '...' globals ... DONE
[18:40:51.366] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.366] List of 2
[18:40:51.366]  $ ...future.FUN:function (object, ...)  
[18:40:51.366]  $ ...          : list()
[18:40:51.366]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.366]  - attr(*, "where")=List of 2
[18:40:51.366]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.366]   ..$ ...          :<environment: 0x000001cd4e7b76b8> 
[18:40:51.366]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.366]  - attr(*, "resolved")= logi FALSE
[18:40:51.366]  - attr(*, "total_size")= int 15670
[18:40:51.370] Packages to be attached in all futures: [n=0] 
[18:40:51.370] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.370] Number of futures (= number of chunks): 1
[18:40:51.370] Launching 1 futures (chunks) ...
[18:40:51.370] Chunk #1 of 1 ...
[18:40:51.371]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.371] getGlobalsAndPackages() ...
[18:40:51.371] Searching for globals...
[18:40:51.372] 
[18:40:51.372] Searching for globals ... DONE
[18:40:51.372] - globals: [0] <none>
[18:40:51.372] getGlobalsAndPackages() ... DONE
[18:40:51.372]    + additional globals found: [n=0] 
[18:40:51.372]    + additional namespaces needed: [n=0] 
[18:40:51.372]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.373]  - seeds: <none>
[18:40:51.373]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.373] getGlobalsAndPackages() ...
[18:40:51.373] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.373] Resolving globals: FALSE
[18:40:51.373] Tweak future expression to call with '...' arguments ...
[18:40:51.374] {
[18:40:51.374]     do.call(function(...) {
[18:40:51.374]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.374]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.374]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.374]             on.exit(options(oopts), add = TRUE)
[18:40:51.374]         }
[18:40:51.374]         {
[18:40:51.374]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.374]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.374]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.374]             })
[18:40:51.374]         }
[18:40:51.374]     }, args = future.call.arguments)
[18:40:51.374] }
[18:40:51.374] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.375] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.375] 
[18:40:51.375] getGlobalsAndPackages() ... DONE
[18:40:51.375] run() for 'Future' ...
[18:40:51.375] - state: 'created'
[18:40:51.376] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:51.376] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.376] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.376]   - Field: 'label'
[18:40:51.377]   - Field: 'local'
[18:40:51.377]   - Field: 'owner'
[18:40:51.377]   - Field: 'envir'
[18:40:51.377]   - Field: 'packages'
[18:40:51.377]   - Field: 'gc'
[18:40:51.377]   - Field: 'conditions'
[18:40:51.378]   - Field: 'expr'
[18:40:51.378]   - Field: 'uuid'
[18:40:51.378]   - Field: 'seed'
[18:40:51.378]   - Field: 'version'
[18:40:51.378]   - Field: 'result'
[18:40:51.378]   - Field: 'asynchronous'
[18:40:51.379]   - Field: 'calls'
[18:40:51.379]   - Field: 'globals'
[18:40:51.379]   - Field: 'stdout'
[18:40:51.379]   - Field: 'earlySignal'
[18:40:51.379]   - Field: 'lazy'
[18:40:51.380]   - Field: 'state'
[18:40:51.380] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.380] - Launch lazy future ...
[18:40:51.380] Packages needed by the future expression (n = 0): <none>
[18:40:51.380] Packages needed by future strategies (n = 0): <none>
[18:40:51.381] {
[18:40:51.381]     {
[18:40:51.381]         {
[18:40:51.381]             ...future.startTime <- base::Sys.time()
[18:40:51.381]             {
[18:40:51.381]                 {
[18:40:51.381]                   {
[18:40:51.381]                     base::local({
[18:40:51.381]                       has_future <- base::requireNamespace("future", 
[18:40:51.381]                         quietly = TRUE)
[18:40:51.381]                       if (has_future) {
[18:40:51.381]                         ns <- base::getNamespace("future")
[18:40:51.381]                         version <- ns[[".package"]][["version"]]
[18:40:51.381]                         if (is.null(version)) 
[18:40:51.381]                           version <- utils::packageVersion("future")
[18:40:51.381]                       }
[18:40:51.381]                       else {
[18:40:51.381]                         version <- NULL
[18:40:51.381]                       }
[18:40:51.381]                       if (!has_future || version < "1.8.0") {
[18:40:51.381]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.381]                           "", base::R.version$version.string), 
[18:40:51.381]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.381]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.381]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.381]                             "release", "version")], collapse = " "), 
[18:40:51.381]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.381]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.381]                           info)
[18:40:51.381]                         info <- base::paste(info, collapse = "; ")
[18:40:51.381]                         if (!has_future) {
[18:40:51.381]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.381]                             info)
[18:40:51.381]                         }
[18:40:51.381]                         else {
[18:40:51.381]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.381]                             info, version)
[18:40:51.381]                         }
[18:40:51.381]                         base::stop(msg)
[18:40:51.381]                       }
[18:40:51.381]                     })
[18:40:51.381]                   }
[18:40:51.381]                   ...future.strategy.old <- future::plan("list")
[18:40:51.381]                   options(future.plan = NULL)
[18:40:51.381]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.381]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.381]                 }
[18:40:51.381]                 ...future.workdir <- getwd()
[18:40:51.381]             }
[18:40:51.381]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.381]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.381]         }
[18:40:51.381]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.381]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.381]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.381]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.381]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.381]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.381]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.381]             base::names(...future.oldOptions))
[18:40:51.381]     }
[18:40:51.381]     if (FALSE) {
[18:40:51.381]     }
[18:40:51.381]     else {
[18:40:51.381]         if (TRUE) {
[18:40:51.381]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.381]                 open = "w")
[18:40:51.381]         }
[18:40:51.381]         else {
[18:40:51.381]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.381]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.381]         }
[18:40:51.381]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.381]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.381]             base::sink(type = "output", split = FALSE)
[18:40:51.381]             base::close(...future.stdout)
[18:40:51.381]         }, add = TRUE)
[18:40:51.381]     }
[18:40:51.381]     ...future.frame <- base::sys.nframe()
[18:40:51.381]     ...future.conditions <- base::list()
[18:40:51.381]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.381]     if (FALSE) {
[18:40:51.381]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.381]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.381]     }
[18:40:51.381]     ...future.result <- base::tryCatch({
[18:40:51.381]         base::withCallingHandlers({
[18:40:51.381]             ...future.value <- base::withVisible(base::local({
[18:40:51.381]                 do.call(function(...) {
[18:40:51.381]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.381]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.381]                     ...future.globals.maxSize)) {
[18:40:51.381]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.381]                     on.exit(options(oopts), add = TRUE)
[18:40:51.381]                   }
[18:40:51.381]                   {
[18:40:51.381]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.381]                       FUN = function(jj) {
[18:40:51.381]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.381]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.381]                       })
[18:40:51.381]                   }
[18:40:51.381]                 }, args = future.call.arguments)
[18:40:51.381]             }))
[18:40:51.381]             future::FutureResult(value = ...future.value$value, 
[18:40:51.381]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.381]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.381]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.381]                     ...future.globalenv.names))
[18:40:51.381]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.381]         }, condition = base::local({
[18:40:51.381]             c <- base::c
[18:40:51.381]             inherits <- base::inherits
[18:40:51.381]             invokeRestart <- base::invokeRestart
[18:40:51.381]             length <- base::length
[18:40:51.381]             list <- base::list
[18:40:51.381]             seq.int <- base::seq.int
[18:40:51.381]             signalCondition <- base::signalCondition
[18:40:51.381]             sys.calls <- base::sys.calls
[18:40:51.381]             `[[` <- base::`[[`
[18:40:51.381]             `+` <- base::`+`
[18:40:51.381]             `<<-` <- base::`<<-`
[18:40:51.381]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.381]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.381]                   3L)]
[18:40:51.381]             }
[18:40:51.381]             function(cond) {
[18:40:51.381]                 is_error <- inherits(cond, "error")
[18:40:51.381]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.381]                   NULL)
[18:40:51.381]                 if (is_error) {
[18:40:51.381]                   sessionInformation <- function() {
[18:40:51.381]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.381]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.381]                       search = base::search(), system = base::Sys.info())
[18:40:51.381]                   }
[18:40:51.381]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.381]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.381]                     cond$call), session = sessionInformation(), 
[18:40:51.381]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.381]                   signalCondition(cond)
[18:40:51.381]                 }
[18:40:51.381]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.381]                 "immediateCondition"))) {
[18:40:51.381]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.381]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.381]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.381]                   if (TRUE && !signal) {
[18:40:51.381]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.381]                     {
[18:40:51.381]                       inherits <- base::inherits
[18:40:51.381]                       invokeRestart <- base::invokeRestart
[18:40:51.381]                       is.null <- base::is.null
[18:40:51.381]                       muffled <- FALSE
[18:40:51.381]                       if (inherits(cond, "message")) {
[18:40:51.381]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.381]                         if (muffled) 
[18:40:51.381]                           invokeRestart("muffleMessage")
[18:40:51.381]                       }
[18:40:51.381]                       else if (inherits(cond, "warning")) {
[18:40:51.381]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.381]                         if (muffled) 
[18:40:51.381]                           invokeRestart("muffleWarning")
[18:40:51.381]                       }
[18:40:51.381]                       else if (inherits(cond, "condition")) {
[18:40:51.381]                         if (!is.null(pattern)) {
[18:40:51.381]                           computeRestarts <- base::computeRestarts
[18:40:51.381]                           grepl <- base::grepl
[18:40:51.381]                           restarts <- computeRestarts(cond)
[18:40:51.381]                           for (restart in restarts) {
[18:40:51.381]                             name <- restart$name
[18:40:51.381]                             if (is.null(name)) 
[18:40:51.381]                               next
[18:40:51.381]                             if (!grepl(pattern, name)) 
[18:40:51.381]                               next
[18:40:51.381]                             invokeRestart(restart)
[18:40:51.381]                             muffled <- TRUE
[18:40:51.381]                             break
[18:40:51.381]                           }
[18:40:51.381]                         }
[18:40:51.381]                       }
[18:40:51.381]                       invisible(muffled)
[18:40:51.381]                     }
[18:40:51.381]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.381]                   }
[18:40:51.381]                 }
[18:40:51.381]                 else {
[18:40:51.381]                   if (TRUE) {
[18:40:51.381]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.381]                     {
[18:40:51.381]                       inherits <- base::inherits
[18:40:51.381]                       invokeRestart <- base::invokeRestart
[18:40:51.381]                       is.null <- base::is.null
[18:40:51.381]                       muffled <- FALSE
[18:40:51.381]                       if (inherits(cond, "message")) {
[18:40:51.381]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.381]                         if (muffled) 
[18:40:51.381]                           invokeRestart("muffleMessage")
[18:40:51.381]                       }
[18:40:51.381]                       else if (inherits(cond, "warning")) {
[18:40:51.381]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.381]                         if (muffled) 
[18:40:51.381]                           invokeRestart("muffleWarning")
[18:40:51.381]                       }
[18:40:51.381]                       else if (inherits(cond, "condition")) {
[18:40:51.381]                         if (!is.null(pattern)) {
[18:40:51.381]                           computeRestarts <- base::computeRestarts
[18:40:51.381]                           grepl <- base::grepl
[18:40:51.381]                           restarts <- computeRestarts(cond)
[18:40:51.381]                           for (restart in restarts) {
[18:40:51.381]                             name <- restart$name
[18:40:51.381]                             if (is.null(name)) 
[18:40:51.381]                               next
[18:40:51.381]                             if (!grepl(pattern, name)) 
[18:40:51.381]                               next
[18:40:51.381]                             invokeRestart(restart)
[18:40:51.381]                             muffled <- TRUE
[18:40:51.381]                             break
[18:40:51.381]                           }
[18:40:51.381]                         }
[18:40:51.381]                       }
[18:40:51.381]                       invisible(muffled)
[18:40:51.381]                     }
[18:40:51.381]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.381]                   }
[18:40:51.381]                 }
[18:40:51.381]             }
[18:40:51.381]         }))
[18:40:51.381]     }, error = function(ex) {
[18:40:51.381]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.381]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.381]                 ...future.rng), started = ...future.startTime, 
[18:40:51.381]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.381]             version = "1.8"), class = "FutureResult")
[18:40:51.381]     }, finally = {
[18:40:51.381]         if (!identical(...future.workdir, getwd())) 
[18:40:51.381]             setwd(...future.workdir)
[18:40:51.381]         {
[18:40:51.381]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.381]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.381]             }
[18:40:51.381]             base::options(...future.oldOptions)
[18:40:51.381]             if (.Platform$OS.type == "windows") {
[18:40:51.381]                 old_names <- names(...future.oldEnvVars)
[18:40:51.381]                 envs <- base::Sys.getenv()
[18:40:51.381]                 names <- names(envs)
[18:40:51.381]                 common <- intersect(names, old_names)
[18:40:51.381]                 added <- setdiff(names, old_names)
[18:40:51.381]                 removed <- setdiff(old_names, names)
[18:40:51.381]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.381]                   envs[common]]
[18:40:51.381]                 NAMES <- toupper(changed)
[18:40:51.381]                 args <- list()
[18:40:51.381]                 for (kk in seq_along(NAMES)) {
[18:40:51.381]                   name <- changed[[kk]]
[18:40:51.381]                   NAME <- NAMES[[kk]]
[18:40:51.381]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.381]                     next
[18:40:51.381]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.381]                 }
[18:40:51.381]                 NAMES <- toupper(added)
[18:40:51.381]                 for (kk in seq_along(NAMES)) {
[18:40:51.381]                   name <- added[[kk]]
[18:40:51.381]                   NAME <- NAMES[[kk]]
[18:40:51.381]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.381]                     next
[18:40:51.381]                   args[[name]] <- ""
[18:40:51.381]                 }
[18:40:51.381]                 NAMES <- toupper(removed)
[18:40:51.381]                 for (kk in seq_along(NAMES)) {
[18:40:51.381]                   name <- removed[[kk]]
[18:40:51.381]                   NAME <- NAMES[[kk]]
[18:40:51.381]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.381]                     next
[18:40:51.381]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.381]                 }
[18:40:51.381]                 if (length(args) > 0) 
[18:40:51.381]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.381]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.381]             }
[18:40:51.381]             else {
[18:40:51.381]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.381]             }
[18:40:51.381]             {
[18:40:51.381]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.381]                   0L) {
[18:40:51.381]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.381]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.381]                   base::options(opts)
[18:40:51.381]                 }
[18:40:51.381]                 {
[18:40:51.381]                   {
[18:40:51.381]                     NULL
[18:40:51.381]                     RNGkind("Mersenne-Twister")
[18:40:51.381]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.381]                       inherits = FALSE)
[18:40:51.381]                   }
[18:40:51.381]                   options(future.plan = NULL)
[18:40:51.381]                   if (is.na(NA_character_)) 
[18:40:51.381]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.381]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.381]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.381]                     .init = FALSE)
[18:40:51.381]                 }
[18:40:51.381]             }
[18:40:51.381]         }
[18:40:51.381]     })
[18:40:51.381]     if (TRUE) {
[18:40:51.381]         base::sink(type = "output", split = FALSE)
[18:40:51.381]         if (TRUE) {
[18:40:51.381]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.381]         }
[18:40:51.381]         else {
[18:40:51.381]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.381]         }
[18:40:51.381]         base::close(...future.stdout)
[18:40:51.381]         ...future.stdout <- NULL
[18:40:51.381]     }
[18:40:51.381]     ...future.result$conditions <- ...future.conditions
[18:40:51.381]     ...future.result$finished <- base::Sys.time()
[18:40:51.381]     ...future.result
[18:40:51.381] }
[18:40:51.385] assign_globals() ...
[18:40:51.385] List of 5
[18:40:51.385]  $ ...future.FUN            :function (object, ...)  
[18:40:51.385]  $ future.call.arguments    : list()
[18:40:51.385]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.385]  $ ...future.elements_ii    :List of 3
[18:40:51.385]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:51.385]   .. ..$ breaks: num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.385]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.385]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:51.385]   .. ..$ breaks: num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.385]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.385]   ..$ :'data.frame':	18 obs. of  2 variables:
[18:40:51.385]   .. ..$ breaks: num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.385]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.385]  $ ...future.seeds_ii       : NULL
[18:40:51.385]  $ ...future.globals.maxSize: NULL
[18:40:51.385]  - attr(*, "where")=List of 5
[18:40:51.385]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.385]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.385]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.385]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.385]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.385]  - attr(*, "resolved")= logi FALSE
[18:40:51.385]  - attr(*, "total_size")= num 15670
[18:40:51.385]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.385]  - attr(*, "already-done")= logi TRUE
[18:40:51.394] - copied '...future.FUN' to environment
[18:40:51.394] - copied 'future.call.arguments' to environment
[18:40:51.394] - copied '...future.elements_ii' to environment
[18:40:51.394] - copied '...future.seeds_ii' to environment
[18:40:51.395] - copied '...future.globals.maxSize' to environment
[18:40:51.395] assign_globals() ... done
[18:40:51.395] plan(): Setting new future strategy stack:
[18:40:51.395] List of future strategies:
[18:40:51.395] 1. sequential:
[18:40:51.395]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.395]    - tweaked: FALSE
[18:40:51.395]    - call: NULL
[18:40:51.396] plan(): nbrOfWorkers() = 1
[18:40:51.399] plan(): Setting new future strategy stack:
[18:40:51.399] List of future strategies:
[18:40:51.399] 1. sequential:
[18:40:51.399]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.399]    - tweaked: FALSE
[18:40:51.399]    - call: plan(strategy)
[18:40:51.399] plan(): nbrOfWorkers() = 1
[18:40:51.400] SequentialFuture started (and completed)
[18:40:51.400] - Launch lazy future ... done
[18:40:51.400] run() for 'SequentialFuture' ... done
[18:40:51.400] Created future:
[18:40:51.400] SequentialFuture:
[18:40:51.400] Label: 'future_by-1'
[18:40:51.400] Expression:
[18:40:51.400] {
[18:40:51.400]     do.call(function(...) {
[18:40:51.400]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.400]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.400]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.400]             on.exit(options(oopts), add = TRUE)
[18:40:51.400]         }
[18:40:51.400]         {
[18:40:51.400]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.400]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.400]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.400]             })
[18:40:51.400]         }
[18:40:51.400]     }, args = future.call.arguments)
[18:40:51.400] }
[18:40:51.400] Lazy evaluation: FALSE
[18:40:51.400] Asynchronous evaluation: FALSE
[18:40:51.400] Local evaluation: TRUE
[18:40:51.400] Environment: R_GlobalEnv
[18:40:51.400] Capture standard output: TRUE
[18:40:51.400] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.400] Globals: 5 objects totaling 1.90 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.48 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.400] Packages: <none>
[18:40:51.400] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.400] Resolved: TRUE
[18:40:51.400] Value: 1.16 KiB of class 'list'
[18:40:51.400] Early signaling: FALSE
[18:40:51.400] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.400] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.401] Chunk #1 of 1 ... DONE
[18:40:51.402] Launching 1 futures (chunks) ... DONE
[18:40:51.402] Resolving 1 futures (chunks) ...
[18:40:51.402] resolve() on list ...
[18:40:51.402]  recursive: 0
[18:40:51.402]  length: 1
[18:40:51.402] 
[18:40:51.403] resolved() for 'SequentialFuture' ...
[18:40:51.403] - state: 'finished'
[18:40:51.403] - run: TRUE
[18:40:51.403] - result: 'FutureResult'
[18:40:51.403] resolved() for 'SequentialFuture' ... done
[18:40:51.403] Future #1
[18:40:51.404] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.404] - nx: 1
[18:40:51.404] - relay: TRUE
[18:40:51.404] - stdout: TRUE
[18:40:51.404] - signal: TRUE
[18:40:51.404] - resignal: FALSE
[18:40:51.405] - force: TRUE
[18:40:51.405] - relayed: [n=1] FALSE
[18:40:51.405] - queued futures: [n=1] FALSE
[18:40:51.405]  - until=1
[18:40:51.405]  - relaying element #1
[18:40:51.406] - relayed: [n=1] TRUE
[18:40:51.406] - queued futures: [n=1] TRUE
[18:40:51.406] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.406]  length: 0 (resolved future 1)
[18:40:51.406] Relaying remaining futures
[18:40:51.406] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.407] - nx: 1
[18:40:51.407] - relay: TRUE
[18:40:51.407] - stdout: TRUE
[18:40:51.407] - signal: TRUE
[18:40:51.407] - resignal: FALSE
[18:40:51.407] - force: TRUE
[18:40:51.407] - relayed: [n=1] TRUE
[18:40:51.408] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.408] - relayed: [n=1] TRUE
[18:40:51.408] - queued futures: [n=1] TRUE
[18:40:51.408] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.408] resolve() on list ... DONE
[18:40:51.408]  - Number of value chunks collected: 1
[18:40:51.409] Resolving 1 futures (chunks) ... DONE
[18:40:51.409] Reducing values from 1 chunks ...
[18:40:51.409]  - Number of values collected after concatenation: 3
[18:40:51.409]  - Number of values expected: 3
[18:40:51.409] Reducing values from 1 chunks ... DONE
[18:40:51.409] future_lapply() ... DONE
[18:40:51.410] future_by_internal() ... DONE
[18:40:51.410] future_by_internal() ...
[18:40:51.410] future_lapply() ...
[18:40:51.411] Number of chunks: 1
[18:40:51.411] getGlobalsAndPackagesXApply() ...
[18:40:51.411]  - future.globals: TRUE
[18:40:51.411] getGlobalsAndPackages() ...
[18:40:51.412] Searching for globals...
[18:40:51.413] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.413] Searching for globals ... DONE
[18:40:51.413] Resolving globals: FALSE
[18:40:51.414] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.414] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.414] - globals: [1] 'FUN'
[18:40:51.415] 
[18:40:51.415] getGlobalsAndPackages() ... DONE
[18:40:51.415]  - globals found/used: [n=1] 'FUN'
[18:40:51.415]  - needed namespaces: [n=0] 
[18:40:51.415] Finding globals ... DONE
[18:40:51.415]  - use_args: TRUE
[18:40:51.415]  - Getting '...' globals ...
[18:40:51.416] resolve() on list ...
[18:40:51.416]  recursive: 0
[18:40:51.416]  length: 1
[18:40:51.416]  elements: '...'
[18:40:51.417]  length: 0 (resolved future 1)
[18:40:51.417] resolve() on list ... DONE
[18:40:51.417]    - '...' content: [n=1] 'digits'
[18:40:51.417] List of 1
[18:40:51.417]  $ ...:List of 1
[18:40:51.417]   ..$ digits: int 2
[18:40:51.417]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.417]  - attr(*, "where")=List of 1
[18:40:51.417]   ..$ ...:<environment: 0x000001cd50ebe2b0> 
[18:40:51.417]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.417]  - attr(*, "resolved")= logi TRUE
[18:40:51.417]  - attr(*, "total_size")= num NA
[18:40:51.420]  - Getting '...' globals ... DONE
[18:40:51.421] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.421] List of 2
[18:40:51.421]  $ ...future.FUN:function (object, ...)  
[18:40:51.421]  $ ...          :List of 1
[18:40:51.421]   ..$ digits: int 2
[18:40:51.421]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.421]  - attr(*, "where")=List of 2
[18:40:51.421]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.421]   ..$ ...          :<environment: 0x000001cd50ebe2b0> 
[18:40:51.421]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.421]  - attr(*, "resolved")= logi FALSE
[18:40:51.421]  - attr(*, "total_size")= int 13284
[18:40:51.425] Packages to be attached in all futures: [n=0] 
[18:40:51.425] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.425] Number of futures (= number of chunks): 1
[18:40:51.425] Launching 1 futures (chunks) ...
[18:40:51.425] Chunk #1 of 1 ...
[18:40:51.426]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.426] getGlobalsAndPackages() ...
[18:40:51.426] Searching for globals...
[18:40:51.426] 
[18:40:51.426] Searching for globals ... DONE
[18:40:51.427] - globals: [0] <none>
[18:40:51.427] getGlobalsAndPackages() ... DONE
[18:40:51.427]    + additional globals found: [n=0] 
[18:40:51.427]    + additional namespaces needed: [n=0] 
[18:40:51.427]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.427]  - seeds: <none>
[18:40:51.427]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.428] getGlobalsAndPackages() ...
[18:40:51.428] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.428] Resolving globals: FALSE
[18:40:51.428] Tweak future expression to call with '...' arguments ...
[18:40:51.428] {
[18:40:51.428]     do.call(function(...) {
[18:40:51.428]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.428]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.428]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.428]             on.exit(options(oopts), add = TRUE)
[18:40:51.428]         }
[18:40:51.428]         {
[18:40:51.428]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.428]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.428]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.428]             })
[18:40:51.428]         }
[18:40:51.428]     }, args = future.call.arguments)
[18:40:51.428] }
[18:40:51.429] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.429] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.429] 
[18:40:51.430] getGlobalsAndPackages() ... DONE
[18:40:51.430] run() for 'Future' ...
[18:40:51.430] - state: 'created'
[18:40:51.430] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:51.431] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.431] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.431]   - Field: 'label'
[18:40:51.431]   - Field: 'local'
[18:40:51.431]   - Field: 'owner'
[18:40:51.432]   - Field: 'envir'
[18:40:51.432]   - Field: 'packages'
[18:40:51.432]   - Field: 'gc'
[18:40:51.432]   - Field: 'conditions'
[18:40:51.432]   - Field: 'expr'
[18:40:51.432]   - Field: 'uuid'
[18:40:51.433]   - Field: 'seed'
[18:40:51.433]   - Field: 'version'
[18:40:51.433]   - Field: 'result'
[18:40:51.433]   - Field: 'asynchronous'
[18:40:51.433]   - Field: 'calls'
[18:40:51.434]   - Field: 'globals'
[18:40:51.434]   - Field: 'stdout'
[18:40:51.434]   - Field: 'earlySignal'
[18:40:51.434]   - Field: 'lazy'
[18:40:51.434]   - Field: 'state'
[18:40:51.434] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.435] - Launch lazy future ...
[18:40:51.435] Packages needed by the future expression (n = 0): <none>
[18:40:51.435] Packages needed by future strategies (n = 0): <none>
[18:40:51.435] {
[18:40:51.435]     {
[18:40:51.435]         {
[18:40:51.435]             ...future.startTime <- base::Sys.time()
[18:40:51.435]             {
[18:40:51.435]                 {
[18:40:51.435]                   {
[18:40:51.435]                     base::local({
[18:40:51.435]                       has_future <- base::requireNamespace("future", 
[18:40:51.435]                         quietly = TRUE)
[18:40:51.435]                       if (has_future) {
[18:40:51.435]                         ns <- base::getNamespace("future")
[18:40:51.435]                         version <- ns[[".package"]][["version"]]
[18:40:51.435]                         if (is.null(version)) 
[18:40:51.435]                           version <- utils::packageVersion("future")
[18:40:51.435]                       }
[18:40:51.435]                       else {
[18:40:51.435]                         version <- NULL
[18:40:51.435]                       }
[18:40:51.435]                       if (!has_future || version < "1.8.0") {
[18:40:51.435]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.435]                           "", base::R.version$version.string), 
[18:40:51.435]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.435]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.435]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.435]                             "release", "version")], collapse = " "), 
[18:40:51.435]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.435]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.435]                           info)
[18:40:51.435]                         info <- base::paste(info, collapse = "; ")
[18:40:51.435]                         if (!has_future) {
[18:40:51.435]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.435]                             info)
[18:40:51.435]                         }
[18:40:51.435]                         else {
[18:40:51.435]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.435]                             info, version)
[18:40:51.435]                         }
[18:40:51.435]                         base::stop(msg)
[18:40:51.435]                       }
[18:40:51.435]                     })
[18:40:51.435]                   }
[18:40:51.435]                   ...future.strategy.old <- future::plan("list")
[18:40:51.435]                   options(future.plan = NULL)
[18:40:51.435]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.435]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.435]                 }
[18:40:51.435]                 ...future.workdir <- getwd()
[18:40:51.435]             }
[18:40:51.435]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.435]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.435]         }
[18:40:51.435]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.435]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.435]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.435]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.435]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.435]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.435]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.435]             base::names(...future.oldOptions))
[18:40:51.435]     }
[18:40:51.435]     if (FALSE) {
[18:40:51.435]     }
[18:40:51.435]     else {
[18:40:51.435]         if (TRUE) {
[18:40:51.435]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.435]                 open = "w")
[18:40:51.435]         }
[18:40:51.435]         else {
[18:40:51.435]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.435]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.435]         }
[18:40:51.435]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.435]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.435]             base::sink(type = "output", split = FALSE)
[18:40:51.435]             base::close(...future.stdout)
[18:40:51.435]         }, add = TRUE)
[18:40:51.435]     }
[18:40:51.435]     ...future.frame <- base::sys.nframe()
[18:40:51.435]     ...future.conditions <- base::list()
[18:40:51.435]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.435]     if (FALSE) {
[18:40:51.435]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.435]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.435]     }
[18:40:51.435]     ...future.result <- base::tryCatch({
[18:40:51.435]         base::withCallingHandlers({
[18:40:51.435]             ...future.value <- base::withVisible(base::local({
[18:40:51.435]                 do.call(function(...) {
[18:40:51.435]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.435]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.435]                     ...future.globals.maxSize)) {
[18:40:51.435]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.435]                     on.exit(options(oopts), add = TRUE)
[18:40:51.435]                   }
[18:40:51.435]                   {
[18:40:51.435]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.435]                       FUN = function(jj) {
[18:40:51.435]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.435]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.435]                       })
[18:40:51.435]                   }
[18:40:51.435]                 }, args = future.call.arguments)
[18:40:51.435]             }))
[18:40:51.435]             future::FutureResult(value = ...future.value$value, 
[18:40:51.435]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.435]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.435]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.435]                     ...future.globalenv.names))
[18:40:51.435]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.435]         }, condition = base::local({
[18:40:51.435]             c <- base::c
[18:40:51.435]             inherits <- base::inherits
[18:40:51.435]             invokeRestart <- base::invokeRestart
[18:40:51.435]             length <- base::length
[18:40:51.435]             list <- base::list
[18:40:51.435]             seq.int <- base::seq.int
[18:40:51.435]             signalCondition <- base::signalCondition
[18:40:51.435]             sys.calls <- base::sys.calls
[18:40:51.435]             `[[` <- base::`[[`
[18:40:51.435]             `+` <- base::`+`
[18:40:51.435]             `<<-` <- base::`<<-`
[18:40:51.435]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.435]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.435]                   3L)]
[18:40:51.435]             }
[18:40:51.435]             function(cond) {
[18:40:51.435]                 is_error <- inherits(cond, "error")
[18:40:51.435]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.435]                   NULL)
[18:40:51.435]                 if (is_error) {
[18:40:51.435]                   sessionInformation <- function() {
[18:40:51.435]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.435]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.435]                       search = base::search(), system = base::Sys.info())
[18:40:51.435]                   }
[18:40:51.435]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.435]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.435]                     cond$call), session = sessionInformation(), 
[18:40:51.435]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.435]                   signalCondition(cond)
[18:40:51.435]                 }
[18:40:51.435]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.435]                 "immediateCondition"))) {
[18:40:51.435]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.435]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.435]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.435]                   if (TRUE && !signal) {
[18:40:51.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.435]                     {
[18:40:51.435]                       inherits <- base::inherits
[18:40:51.435]                       invokeRestart <- base::invokeRestart
[18:40:51.435]                       is.null <- base::is.null
[18:40:51.435]                       muffled <- FALSE
[18:40:51.435]                       if (inherits(cond, "message")) {
[18:40:51.435]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.435]                         if (muffled) 
[18:40:51.435]                           invokeRestart("muffleMessage")
[18:40:51.435]                       }
[18:40:51.435]                       else if (inherits(cond, "warning")) {
[18:40:51.435]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.435]                         if (muffled) 
[18:40:51.435]                           invokeRestart("muffleWarning")
[18:40:51.435]                       }
[18:40:51.435]                       else if (inherits(cond, "condition")) {
[18:40:51.435]                         if (!is.null(pattern)) {
[18:40:51.435]                           computeRestarts <- base::computeRestarts
[18:40:51.435]                           grepl <- base::grepl
[18:40:51.435]                           restarts <- computeRestarts(cond)
[18:40:51.435]                           for (restart in restarts) {
[18:40:51.435]                             name <- restart$name
[18:40:51.435]                             if (is.null(name)) 
[18:40:51.435]                               next
[18:40:51.435]                             if (!grepl(pattern, name)) 
[18:40:51.435]                               next
[18:40:51.435]                             invokeRestart(restart)
[18:40:51.435]                             muffled <- TRUE
[18:40:51.435]                             break
[18:40:51.435]                           }
[18:40:51.435]                         }
[18:40:51.435]                       }
[18:40:51.435]                       invisible(muffled)
[18:40:51.435]                     }
[18:40:51.435]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.435]                   }
[18:40:51.435]                 }
[18:40:51.435]                 else {
[18:40:51.435]                   if (TRUE) {
[18:40:51.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.435]                     {
[18:40:51.435]                       inherits <- base::inherits
[18:40:51.435]                       invokeRestart <- base::invokeRestart
[18:40:51.435]                       is.null <- base::is.null
[18:40:51.435]                       muffled <- FALSE
[18:40:51.435]                       if (inherits(cond, "message")) {
[18:40:51.435]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.435]                         if (muffled) 
[18:40:51.435]                           invokeRestart("muffleMessage")
[18:40:51.435]                       }
[18:40:51.435]                       else if (inherits(cond, "warning")) {
[18:40:51.435]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.435]                         if (muffled) 
[18:40:51.435]                           invokeRestart("muffleWarning")
[18:40:51.435]                       }
[18:40:51.435]                       else if (inherits(cond, "condition")) {
[18:40:51.435]                         if (!is.null(pattern)) {
[18:40:51.435]                           computeRestarts <- base::computeRestarts
[18:40:51.435]                           grepl <- base::grepl
[18:40:51.435]                           restarts <- computeRestarts(cond)
[18:40:51.435]                           for (restart in restarts) {
[18:40:51.435]                             name <- restart$name
[18:40:51.435]                             if (is.null(name)) 
[18:40:51.435]                               next
[18:40:51.435]                             if (!grepl(pattern, name)) 
[18:40:51.435]                               next
[18:40:51.435]                             invokeRestart(restart)
[18:40:51.435]                             muffled <- TRUE
[18:40:51.435]                             break
[18:40:51.435]                           }
[18:40:51.435]                         }
[18:40:51.435]                       }
[18:40:51.435]                       invisible(muffled)
[18:40:51.435]                     }
[18:40:51.435]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.435]                   }
[18:40:51.435]                 }
[18:40:51.435]             }
[18:40:51.435]         }))
[18:40:51.435]     }, error = function(ex) {
[18:40:51.435]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.435]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.435]                 ...future.rng), started = ...future.startTime, 
[18:40:51.435]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.435]             version = "1.8"), class = "FutureResult")
[18:40:51.435]     }, finally = {
[18:40:51.435]         if (!identical(...future.workdir, getwd())) 
[18:40:51.435]             setwd(...future.workdir)
[18:40:51.435]         {
[18:40:51.435]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.435]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.435]             }
[18:40:51.435]             base::options(...future.oldOptions)
[18:40:51.435]             if (.Platform$OS.type == "windows") {
[18:40:51.435]                 old_names <- names(...future.oldEnvVars)
[18:40:51.435]                 envs <- base::Sys.getenv()
[18:40:51.435]                 names <- names(envs)
[18:40:51.435]                 common <- intersect(names, old_names)
[18:40:51.435]                 added <- setdiff(names, old_names)
[18:40:51.435]                 removed <- setdiff(old_names, names)
[18:40:51.435]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.435]                   envs[common]]
[18:40:51.435]                 NAMES <- toupper(changed)
[18:40:51.435]                 args <- list()
[18:40:51.435]                 for (kk in seq_along(NAMES)) {
[18:40:51.435]                   name <- changed[[kk]]
[18:40:51.435]                   NAME <- NAMES[[kk]]
[18:40:51.435]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.435]                     next
[18:40:51.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.435]                 }
[18:40:51.435]                 NAMES <- toupper(added)
[18:40:51.435]                 for (kk in seq_along(NAMES)) {
[18:40:51.435]                   name <- added[[kk]]
[18:40:51.435]                   NAME <- NAMES[[kk]]
[18:40:51.435]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.435]                     next
[18:40:51.435]                   args[[name]] <- ""
[18:40:51.435]                 }
[18:40:51.435]                 NAMES <- toupper(removed)
[18:40:51.435]                 for (kk in seq_along(NAMES)) {
[18:40:51.435]                   name <- removed[[kk]]
[18:40:51.435]                   NAME <- NAMES[[kk]]
[18:40:51.435]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.435]                     next
[18:40:51.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.435]                 }
[18:40:51.435]                 if (length(args) > 0) 
[18:40:51.435]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.435]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.435]             }
[18:40:51.435]             else {
[18:40:51.435]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.435]             }
[18:40:51.435]             {
[18:40:51.435]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.435]                   0L) {
[18:40:51.435]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.435]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.435]                   base::options(opts)
[18:40:51.435]                 }
[18:40:51.435]                 {
[18:40:51.435]                   {
[18:40:51.435]                     NULL
[18:40:51.435]                     RNGkind("Mersenne-Twister")
[18:40:51.435]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.435]                       inherits = FALSE)
[18:40:51.435]                   }
[18:40:51.435]                   options(future.plan = NULL)
[18:40:51.435]                   if (is.na(NA_character_)) 
[18:40:51.435]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.435]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.435]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.435]                     .init = FALSE)
[18:40:51.435]                 }
[18:40:51.435]             }
[18:40:51.435]         }
[18:40:51.435]     })
[18:40:51.435]     if (TRUE) {
[18:40:51.435]         base::sink(type = "output", split = FALSE)
[18:40:51.435]         if (TRUE) {
[18:40:51.435]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.435]         }
[18:40:51.435]         else {
[18:40:51.435]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.435]         }
[18:40:51.435]         base::close(...future.stdout)
[18:40:51.435]         ...future.stdout <- NULL
[18:40:51.435]     }
[18:40:51.435]     ...future.result$conditions <- ...future.conditions
[18:40:51.435]     ...future.result$finished <- base::Sys.time()
[18:40:51.435]     ...future.result
[18:40:51.435] }
[18:40:51.440] assign_globals() ...
[18:40:51.440] List of 5
[18:40:51.440]  $ ...future.FUN            :function (object, ...)  
[18:40:51.440]  $ future.call.arguments    :List of 1
[18:40:51.440]   ..$ digits: int 2
[18:40:51.440]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.440]  $ ...future.elements_ii    :List of 6
[18:40:51.440]   ..$ : num [1:9] 26 30 54 25 70 52 51 26 67
[18:40:51.440]   ..$ : num [1:9] 27 14 29 19 29 31 41 20 44
[18:40:51.440]   ..$ : num [1:9] 18 21 29 17 12 18 35 30 36
[18:40:51.440]   ..$ : num [1:9] 42 26 19 16 39 28 21 39 29
[18:40:51.440]   ..$ : num [1:9] 36 21 24 18 10 43 28 15 26
[18:40:51.440]   ..$ : num [1:9] 20 21 24 17 13 15 15 16 28
[18:40:51.440]  $ ...future.seeds_ii       : NULL
[18:40:51.440]  $ ...future.globals.maxSize: NULL
[18:40:51.440]  - attr(*, "where")=List of 5
[18:40:51.440]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.440]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.440]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.440]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.440]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.440]  - attr(*, "resolved")= logi FALSE
[18:40:51.440]  - attr(*, "total_size")= num 13284
[18:40:51.440]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.440]  - attr(*, "already-done")= logi TRUE
[18:40:51.448] - copied '...future.FUN' to environment
[18:40:51.448] - copied 'future.call.arguments' to environment
[18:40:51.448] - copied '...future.elements_ii' to environment
[18:40:51.448] - copied '...future.seeds_ii' to environment
[18:40:51.449] - copied '...future.globals.maxSize' to environment
[18:40:51.449] assign_globals() ... done
[18:40:51.449] plan(): Setting new future strategy stack:
[18:40:51.449] List of future strategies:
[18:40:51.449] 1. sequential:
[18:40:51.449]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.449]    - tweaked: FALSE
[18:40:51.449]    - call: NULL
[18:40:51.450] plan(): nbrOfWorkers() = 1
[18:40:51.452] plan(): Setting new future strategy stack:
[18:40:51.452] List of future strategies:
[18:40:51.452] 1. sequential:
[18:40:51.452]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.452]    - tweaked: FALSE
[18:40:51.452]    - call: plan(strategy)
[18:40:51.453] plan(): nbrOfWorkers() = 1
[18:40:51.453] SequentialFuture started (and completed)
[18:40:51.453] - Launch lazy future ... done
[18:40:51.453] run() for 'SequentialFuture' ... done
[18:40:51.454] Created future:
[18:40:51.454] SequentialFuture:
[18:40:51.454] Label: 'future_by-1'
[18:40:51.454] Expression:
[18:40:51.454] {
[18:40:51.454]     do.call(function(...) {
[18:40:51.454]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.454]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.454]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.454]             on.exit(options(oopts), add = TRUE)
[18:40:51.454]         }
[18:40:51.454]         {
[18:40:51.454]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.454]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.454]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.454]             })
[18:40:51.454]         }
[18:40:51.454]     }, args = future.call.arguments)
[18:40:51.454] }
[18:40:51.454] Lazy evaluation: FALSE
[18:40:51.454] Asynchronous evaluation: FALSE
[18:40:51.454] Local evaluation: TRUE
[18:40:51.454] Environment: R_GlobalEnv
[18:40:51.454] Capture standard output: TRUE
[18:40:51.454] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.454] Globals: 5 objects totaling 998 bytes (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 152 bytes, list '...future.elements_ii' of 511 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.454] Packages: <none>
[18:40:51.454] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.454] Resolved: TRUE
[18:40:51.454] Value: 1.27 KiB of class 'list'
[18:40:51.454] Early signaling: FALSE
[18:40:51.454] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.454] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.455] Chunk #1 of 1 ... DONE
[18:40:51.455] Launching 1 futures (chunks) ... DONE
[18:40:51.455] Resolving 1 futures (chunks) ...
[18:40:51.455] resolve() on list ...
[18:40:51.455]  recursive: 0
[18:40:51.456]  length: 1
[18:40:51.456] 
[18:40:51.456] resolved() for 'SequentialFuture' ...
[18:40:51.456] - state: 'finished'
[18:40:51.456] - run: TRUE
[18:40:51.456] - result: 'FutureResult'
[18:40:51.457] resolved() for 'SequentialFuture' ... done
[18:40:51.457] Future #1
[18:40:51.457] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.457] - nx: 1
[18:40:51.457] - relay: TRUE
[18:40:51.457] - stdout: TRUE
[18:40:51.458] - signal: TRUE
[18:40:51.458] - resignal: FALSE
[18:40:51.458] - force: TRUE
[18:40:51.458] - relayed: [n=1] FALSE
[18:40:51.458] - queued futures: [n=1] FALSE
[18:40:51.458]  - until=1
[18:40:51.459]  - relaying element #1
[18:40:51.459] - relayed: [n=1] TRUE
[18:40:51.459] - queued futures: [n=1] TRUE
[18:40:51.459] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.459]  length: 0 (resolved future 1)
[18:40:51.460] Relaying remaining futures
[18:40:51.460] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.460] - nx: 1
[18:40:51.460] - relay: TRUE
[18:40:51.460] - stdout: TRUE
[18:40:51.460] - signal: TRUE
[18:40:51.460] - resignal: FALSE
[18:40:51.461] - force: TRUE
[18:40:51.461] - relayed: [n=1] TRUE
[18:40:51.461] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.461] - relayed: [n=1] TRUE
[18:40:51.461] - queued futures: [n=1] TRUE
[18:40:51.461] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.462] resolve() on list ... DONE
[18:40:51.462]  - Number of value chunks collected: 1
[18:40:51.462] Resolving 1 futures (chunks) ... DONE
[18:40:51.462] Reducing values from 1 chunks ...
[18:40:51.462]  - Number of values collected after concatenation: 6
[18:40:51.462]  - Number of values expected: 6
[18:40:51.463] Reducing values from 1 chunks ... DONE
[18:40:51.464] future_lapply() ... DONE
[18:40:51.465] future_by_internal() ... DONE
[18:40:51.466] future_by_internal() ...
[18:40:51.466] future_lapply() ...
[18:40:51.467] Number of chunks: 1
[18:40:51.468] getGlobalsAndPackagesXApply() ...
[18:40:51.468]  - future.globals: TRUE
[18:40:51.468] getGlobalsAndPackages() ...
[18:40:51.468] Searching for globals...
[18:40:51.470] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:51.470] Searching for globals ... DONE
[18:40:51.470] Resolving globals: FALSE
[18:40:51.471] The total size of the 1 globals is 762 bytes (762 bytes)
[18:40:51.471] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 762 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (762 bytes of class 'function')
[18:40:51.471] - globals: [1] 'FUN'
[18:40:51.472] - packages: [1] 'stats'
[18:40:51.472] getGlobalsAndPackages() ... DONE
[18:40:51.472]  - globals found/used: [n=1] 'FUN'
[18:40:51.472]  - needed namespaces: [n=1] 'stats'
[18:40:51.472] Finding globals ... DONE
[18:40:51.473]  - use_args: TRUE
[18:40:51.473]  - Getting '...' globals ...
[18:40:51.473] resolve() on list ...
[18:40:51.473]  recursive: 0
[18:40:51.473]  length: 1
[18:40:51.474]  elements: '...'
[18:40:51.474]  length: 0 (resolved future 1)
[18:40:51.474] resolve() on list ... DONE
[18:40:51.474]    - '...' content: [n=1] 'singular.ok'
[18:40:51.474] List of 1
[18:40:51.474]  $ ...:List of 1
[18:40:51.474]   ..$ singular.ok: logi FALSE
[18:40:51.474]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.474]  - attr(*, "where")=List of 1
[18:40:51.474]   ..$ ...:<environment: 0x000001cd4ea6bff0> 
[18:40:51.474]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.474]  - attr(*, "resolved")= logi TRUE
[18:40:51.474]  - attr(*, "total_size")= num NA
[18:40:51.478]  - Getting '...' globals ... DONE
[18:40:51.478] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.478] List of 2
[18:40:51.478]  $ ...future.FUN:function (x, ...)  
[18:40:51.478]  $ ...          :List of 1
[18:40:51.478]   ..$ singular.ok: logi FALSE
[18:40:51.478]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.478]  - attr(*, "where")=List of 2
[18:40:51.478]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.478]   ..$ ...          :<environment: 0x000001cd4ea6bff0> 
[18:40:51.478]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.478]  - attr(*, "resolved")= logi FALSE
[18:40:51.478]  - attr(*, "total_size")= int 19977
[18:40:51.482] Packages to be attached in all futures: [n=1] 'stats'
[18:40:51.482] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.482] Number of futures (= number of chunks): 1
[18:40:51.482] Launching 1 futures (chunks) ...
[18:40:51.483] Chunk #1 of 1 ...
[18:40:51.483]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.483] getGlobalsAndPackages() ...
[18:40:51.483] Searching for globals...
[18:40:51.484] 
[18:40:51.484] Searching for globals ... DONE
[18:40:51.484] - globals: [0] <none>
[18:40:51.484] getGlobalsAndPackages() ... DONE
[18:40:51.484]    + additional globals found: [n=0] 
[18:40:51.484]    + additional namespaces needed: [n=0] 
[18:40:51.485]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.485]  - seeds: <none>
[18:40:51.485]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.485] getGlobalsAndPackages() ...
[18:40:51.485] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.485] Resolving globals: FALSE
[18:40:51.486] Tweak future expression to call with '...' arguments ...
[18:40:51.486] {
[18:40:51.486]     do.call(function(...) {
[18:40:51.486]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.486]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.486]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.486]             on.exit(options(oopts), add = TRUE)
[18:40:51.486]         }
[18:40:51.486]         {
[18:40:51.486]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.486]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.486]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.486]             })
[18:40:51.486]         }
[18:40:51.486]     }, args = future.call.arguments)
[18:40:51.486] }
[18:40:51.486] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.487] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.487] 
[18:40:51.487] getGlobalsAndPackages() ... DONE
[18:40:51.487] run() for 'Future' ...
[18:40:51.488] - state: 'created'
[18:40:51.488] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:51.488] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.488] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.489]   - Field: 'label'
[18:40:51.489]   - Field: 'local'
[18:40:51.489]   - Field: 'owner'
[18:40:51.489]   - Field: 'envir'
[18:40:51.489]   - Field: 'packages'
[18:40:51.489]   - Field: 'gc'
[18:40:51.490]   - Field: 'conditions'
[18:40:51.490]   - Field: 'expr'
[18:40:51.490]   - Field: 'uuid'
[18:40:51.490]   - Field: 'seed'
[18:40:51.490]   - Field: 'version'
[18:40:51.490]   - Field: 'result'
[18:40:51.491]   - Field: 'asynchronous'
[18:40:51.491]   - Field: 'calls'
[18:40:51.491]   - Field: 'globals'
[18:40:51.491]   - Field: 'stdout'
[18:40:51.491]   - Field: 'earlySignal'
[18:40:51.491]   - Field: 'lazy'
[18:40:51.492]   - Field: 'state'
[18:40:51.492] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.492] - Launch lazy future ...
[18:40:51.492] Packages needed by the future expression (n = 1): 'stats'
[18:40:51.492] Packages needed by future strategies (n = 0): <none>
[18:40:51.493] {
[18:40:51.493]     {
[18:40:51.493]         {
[18:40:51.493]             ...future.startTime <- base::Sys.time()
[18:40:51.493]             {
[18:40:51.493]                 {
[18:40:51.493]                   {
[18:40:51.493]                     {
[18:40:51.493]                       base::local({
[18:40:51.493]                         has_future <- base::requireNamespace("future", 
[18:40:51.493]                           quietly = TRUE)
[18:40:51.493]                         if (has_future) {
[18:40:51.493]                           ns <- base::getNamespace("future")
[18:40:51.493]                           version <- ns[[".package"]][["version"]]
[18:40:51.493]                           if (is.null(version)) 
[18:40:51.493]                             version <- utils::packageVersion("future")
[18:40:51.493]                         }
[18:40:51.493]                         else {
[18:40:51.493]                           version <- NULL
[18:40:51.493]                         }
[18:40:51.493]                         if (!has_future || version < "1.8.0") {
[18:40:51.493]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.493]                             "", base::R.version$version.string), 
[18:40:51.493]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:51.493]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.493]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.493]                               "release", "version")], collapse = " "), 
[18:40:51.493]                             hostname = base::Sys.info()[["nodename"]])
[18:40:51.493]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.493]                             info)
[18:40:51.493]                           info <- base::paste(info, collapse = "; ")
[18:40:51.493]                           if (!has_future) {
[18:40:51.493]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.493]                               info)
[18:40:51.493]                           }
[18:40:51.493]                           else {
[18:40:51.493]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.493]                               info, version)
[18:40:51.493]                           }
[18:40:51.493]                           base::stop(msg)
[18:40:51.493]                         }
[18:40:51.493]                       })
[18:40:51.493]                     }
[18:40:51.493]                     base::local({
[18:40:51.493]                       for (pkg in "stats") {
[18:40:51.493]                         base::loadNamespace(pkg)
[18:40:51.493]                         base::library(pkg, character.only = TRUE)
[18:40:51.493]                       }
[18:40:51.493]                     })
[18:40:51.493]                   }
[18:40:51.493]                   ...future.strategy.old <- future::plan("list")
[18:40:51.493]                   options(future.plan = NULL)
[18:40:51.493]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.493]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.493]                 }
[18:40:51.493]                 ...future.workdir <- getwd()
[18:40:51.493]             }
[18:40:51.493]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.493]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.493]         }
[18:40:51.493]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.493]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.493]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.493]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.493]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.493]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.493]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.493]             base::names(...future.oldOptions))
[18:40:51.493]     }
[18:40:51.493]     if (FALSE) {
[18:40:51.493]     }
[18:40:51.493]     else {
[18:40:51.493]         if (TRUE) {
[18:40:51.493]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.493]                 open = "w")
[18:40:51.493]         }
[18:40:51.493]         else {
[18:40:51.493]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.493]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.493]         }
[18:40:51.493]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.493]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.493]             base::sink(type = "output", split = FALSE)
[18:40:51.493]             base::close(...future.stdout)
[18:40:51.493]         }, add = TRUE)
[18:40:51.493]     }
[18:40:51.493]     ...future.frame <- base::sys.nframe()
[18:40:51.493]     ...future.conditions <- base::list()
[18:40:51.493]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.493]     if (FALSE) {
[18:40:51.493]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.493]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.493]     }
[18:40:51.493]     ...future.result <- base::tryCatch({
[18:40:51.493]         base::withCallingHandlers({
[18:40:51.493]             ...future.value <- base::withVisible(base::local({
[18:40:51.493]                 do.call(function(...) {
[18:40:51.493]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.493]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.493]                     ...future.globals.maxSize)) {
[18:40:51.493]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.493]                     on.exit(options(oopts), add = TRUE)
[18:40:51.493]                   }
[18:40:51.493]                   {
[18:40:51.493]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.493]                       FUN = function(jj) {
[18:40:51.493]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.493]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.493]                       })
[18:40:51.493]                   }
[18:40:51.493]                 }, args = future.call.arguments)
[18:40:51.493]             }))
[18:40:51.493]             future::FutureResult(value = ...future.value$value, 
[18:40:51.493]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.493]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.493]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.493]                     ...future.globalenv.names))
[18:40:51.493]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.493]         }, condition = base::local({
[18:40:51.493]             c <- base::c
[18:40:51.493]             inherits <- base::inherits
[18:40:51.493]             invokeRestart <- base::invokeRestart
[18:40:51.493]             length <- base::length
[18:40:51.493]             list <- base::list
[18:40:51.493]             seq.int <- base::seq.int
[18:40:51.493]             signalCondition <- base::signalCondition
[18:40:51.493]             sys.calls <- base::sys.calls
[18:40:51.493]             `[[` <- base::`[[`
[18:40:51.493]             `+` <- base::`+`
[18:40:51.493]             `<<-` <- base::`<<-`
[18:40:51.493]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.493]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.493]                   3L)]
[18:40:51.493]             }
[18:40:51.493]             function(cond) {
[18:40:51.493]                 is_error <- inherits(cond, "error")
[18:40:51.493]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.493]                   NULL)
[18:40:51.493]                 if (is_error) {
[18:40:51.493]                   sessionInformation <- function() {
[18:40:51.493]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.493]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.493]                       search = base::search(), system = base::Sys.info())
[18:40:51.493]                   }
[18:40:51.493]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.493]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.493]                     cond$call), session = sessionInformation(), 
[18:40:51.493]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.493]                   signalCondition(cond)
[18:40:51.493]                 }
[18:40:51.493]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.493]                 "immediateCondition"))) {
[18:40:51.493]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.493]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.493]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.493]                   if (TRUE && !signal) {
[18:40:51.493]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.493]                     {
[18:40:51.493]                       inherits <- base::inherits
[18:40:51.493]                       invokeRestart <- base::invokeRestart
[18:40:51.493]                       is.null <- base::is.null
[18:40:51.493]                       muffled <- FALSE
[18:40:51.493]                       if (inherits(cond, "message")) {
[18:40:51.493]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.493]                         if (muffled) 
[18:40:51.493]                           invokeRestart("muffleMessage")
[18:40:51.493]                       }
[18:40:51.493]                       else if (inherits(cond, "warning")) {
[18:40:51.493]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.493]                         if (muffled) 
[18:40:51.493]                           invokeRestart("muffleWarning")
[18:40:51.493]                       }
[18:40:51.493]                       else if (inherits(cond, "condition")) {
[18:40:51.493]                         if (!is.null(pattern)) {
[18:40:51.493]                           computeRestarts <- base::computeRestarts
[18:40:51.493]                           grepl <- base::grepl
[18:40:51.493]                           restarts <- computeRestarts(cond)
[18:40:51.493]                           for (restart in restarts) {
[18:40:51.493]                             name <- restart$name
[18:40:51.493]                             if (is.null(name)) 
[18:40:51.493]                               next
[18:40:51.493]                             if (!grepl(pattern, name)) 
[18:40:51.493]                               next
[18:40:51.493]                             invokeRestart(restart)
[18:40:51.493]                             muffled <- TRUE
[18:40:51.493]                             break
[18:40:51.493]                           }
[18:40:51.493]                         }
[18:40:51.493]                       }
[18:40:51.493]                       invisible(muffled)
[18:40:51.493]                     }
[18:40:51.493]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.493]                   }
[18:40:51.493]                 }
[18:40:51.493]                 else {
[18:40:51.493]                   if (TRUE) {
[18:40:51.493]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.493]                     {
[18:40:51.493]                       inherits <- base::inherits
[18:40:51.493]                       invokeRestart <- base::invokeRestart
[18:40:51.493]                       is.null <- base::is.null
[18:40:51.493]                       muffled <- FALSE
[18:40:51.493]                       if (inherits(cond, "message")) {
[18:40:51.493]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.493]                         if (muffled) 
[18:40:51.493]                           invokeRestart("muffleMessage")
[18:40:51.493]                       }
[18:40:51.493]                       else if (inherits(cond, "warning")) {
[18:40:51.493]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.493]                         if (muffled) 
[18:40:51.493]                           invokeRestart("muffleWarning")
[18:40:51.493]                       }
[18:40:51.493]                       else if (inherits(cond, "condition")) {
[18:40:51.493]                         if (!is.null(pattern)) {
[18:40:51.493]                           computeRestarts <- base::computeRestarts
[18:40:51.493]                           grepl <- base::grepl
[18:40:51.493]                           restarts <- computeRestarts(cond)
[18:40:51.493]                           for (restart in restarts) {
[18:40:51.493]                             name <- restart$name
[18:40:51.493]                             if (is.null(name)) 
[18:40:51.493]                               next
[18:40:51.493]                             if (!grepl(pattern, name)) 
[18:40:51.493]                               next
[18:40:51.493]                             invokeRestart(restart)
[18:40:51.493]                             muffled <- TRUE
[18:40:51.493]                             break
[18:40:51.493]                           }
[18:40:51.493]                         }
[18:40:51.493]                       }
[18:40:51.493]                       invisible(muffled)
[18:40:51.493]                     }
[18:40:51.493]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.493]                   }
[18:40:51.493]                 }
[18:40:51.493]             }
[18:40:51.493]         }))
[18:40:51.493]     }, error = function(ex) {
[18:40:51.493]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.493]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.493]                 ...future.rng), started = ...future.startTime, 
[18:40:51.493]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.493]             version = "1.8"), class = "FutureResult")
[18:40:51.493]     }, finally = {
[18:40:51.493]         if (!identical(...future.workdir, getwd())) 
[18:40:51.493]             setwd(...future.workdir)
[18:40:51.493]         {
[18:40:51.493]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.493]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.493]             }
[18:40:51.493]             base::options(...future.oldOptions)
[18:40:51.493]             if (.Platform$OS.type == "windows") {
[18:40:51.493]                 old_names <- names(...future.oldEnvVars)
[18:40:51.493]                 envs <- base::Sys.getenv()
[18:40:51.493]                 names <- names(envs)
[18:40:51.493]                 common <- intersect(names, old_names)
[18:40:51.493]                 added <- setdiff(names, old_names)
[18:40:51.493]                 removed <- setdiff(old_names, names)
[18:40:51.493]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.493]                   envs[common]]
[18:40:51.493]                 NAMES <- toupper(changed)
[18:40:51.493]                 args <- list()
[18:40:51.493]                 for (kk in seq_along(NAMES)) {
[18:40:51.493]                   name <- changed[[kk]]
[18:40:51.493]                   NAME <- NAMES[[kk]]
[18:40:51.493]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.493]                     next
[18:40:51.493]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.493]                 }
[18:40:51.493]                 NAMES <- toupper(added)
[18:40:51.493]                 for (kk in seq_along(NAMES)) {
[18:40:51.493]                   name <- added[[kk]]
[18:40:51.493]                   NAME <- NAMES[[kk]]
[18:40:51.493]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.493]                     next
[18:40:51.493]                   args[[name]] <- ""
[18:40:51.493]                 }
[18:40:51.493]                 NAMES <- toupper(removed)
[18:40:51.493]                 for (kk in seq_along(NAMES)) {
[18:40:51.493]                   name <- removed[[kk]]
[18:40:51.493]                   NAME <- NAMES[[kk]]
[18:40:51.493]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.493]                     next
[18:40:51.493]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.493]                 }
[18:40:51.493]                 if (length(args) > 0) 
[18:40:51.493]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.493]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.493]             }
[18:40:51.493]             else {
[18:40:51.493]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.493]             }
[18:40:51.493]             {
[18:40:51.493]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.493]                   0L) {
[18:40:51.493]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.493]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.493]                   base::options(opts)
[18:40:51.493]                 }
[18:40:51.493]                 {
[18:40:51.493]                   {
[18:40:51.493]                     NULL
[18:40:51.493]                     RNGkind("Mersenne-Twister")
[18:40:51.493]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.493]                       inherits = FALSE)
[18:40:51.493]                   }
[18:40:51.493]                   options(future.plan = NULL)
[18:40:51.493]                   if (is.na(NA_character_)) 
[18:40:51.493]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.493]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.493]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.493]                     .init = FALSE)
[18:40:51.493]                 }
[18:40:51.493]             }
[18:40:51.493]         }
[18:40:51.493]     })
[18:40:51.493]     if (TRUE) {
[18:40:51.493]         base::sink(type = "output", split = FALSE)
[18:40:51.493]         if (TRUE) {
[18:40:51.493]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.493]         }
[18:40:51.493]         else {
[18:40:51.493]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.493]         }
[18:40:51.493]         base::close(...future.stdout)
[18:40:51.493]         ...future.stdout <- NULL
[18:40:51.493]     }
[18:40:51.493]     ...future.result$conditions <- ...future.conditions
[18:40:51.493]     ...future.result$finished <- base::Sys.time()
[18:40:51.493]     ...future.result
[18:40:51.493] }
[18:40:51.497] assign_globals() ...
[18:40:51.497] List of 5
[18:40:51.497]  $ ...future.FUN            :function (x, ...)  
[18:40:51.497]  $ future.call.arguments    :List of 1
[18:40:51.497]   ..$ singular.ok: logi FALSE
[18:40:51.497]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.497]  $ ...future.elements_ii    :List of 3
[18:40:51.497]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.497]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.497]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.497]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.497]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.497]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.497]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.497]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.497]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.497]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.497]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.497]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.497]  $ ...future.seeds_ii       : NULL
[18:40:51.497]  $ ...future.globals.maxSize: NULL
[18:40:51.497]  - attr(*, "where")=List of 5
[18:40:51.497]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.497]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.497]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.497]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.497]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.497]  - attr(*, "resolved")= logi FALSE
[18:40:51.497]  - attr(*, "total_size")= num 19977
[18:40:51.497]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.497]  - attr(*, "already-done")= logi TRUE
[18:40:51.508] - reassign environment for '...future.FUN'
[18:40:51.508] - copied '...future.FUN' to environment
[18:40:51.508] - copied 'future.call.arguments' to environment
[18:40:51.509] - copied '...future.elements_ii' to environment
[18:40:51.509] - copied '...future.seeds_ii' to environment
[18:40:51.509] - copied '...future.globals.maxSize' to environment
[18:40:51.509] assign_globals() ... done
[18:40:51.510] plan(): Setting new future strategy stack:
[18:40:51.510] List of future strategies:
[18:40:51.510] 1. sequential:
[18:40:51.510]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.510]    - tweaked: FALSE
[18:40:51.510]    - call: NULL
[18:40:51.511] plan(): nbrOfWorkers() = 1
[18:40:51.514] plan(): Setting new future strategy stack:
[18:40:51.514] List of future strategies:
[18:40:51.514] 1. sequential:
[18:40:51.514]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.514]    - tweaked: FALSE
[18:40:51.514]    - call: plan(strategy)
[18:40:51.515] plan(): nbrOfWorkers() = 1
[18:40:51.515] SequentialFuture started (and completed)
[18:40:51.516] - Launch lazy future ... done
[18:40:51.516] run() for 'SequentialFuture' ... done
[18:40:51.516] Created future:
[18:40:51.516] SequentialFuture:
[18:40:51.516] Label: 'future_by-1'
[18:40:51.516] Expression:
[18:40:51.516] {
[18:40:51.516]     do.call(function(...) {
[18:40:51.516]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.516]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.516]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.516]             on.exit(options(oopts), add = TRUE)
[18:40:51.516]         }
[18:40:51.516]         {
[18:40:51.516]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.516]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.516]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.516]             })
[18:40:51.516]         }
[18:40:51.516]     }, args = future.call.arguments)
[18:40:51.516] }
[18:40:51.516] Lazy evaluation: FALSE
[18:40:51.516] Asynchronous evaluation: FALSE
[18:40:51.516] Local evaluation: TRUE
[18:40:51.516] Environment: R_GlobalEnv
[18:40:51.516] Capture standard output: TRUE
[18:40:51.516] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.516] Globals: 5 objects totaling 2.93 KiB (function '...future.FUN' of 762 bytes, DotDotDotList 'future.call.arguments' of 157 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.516] Packages: 1 packages ('stats')
[18:40:51.516] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.516] Resolved: TRUE
[18:40:51.516] Value: 85.42 KiB of class 'list'
[18:40:51.516] Early signaling: FALSE
[18:40:51.516] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.516] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.518] Chunk #1 of 1 ... DONE
[18:40:51.518] Launching 1 futures (chunks) ... DONE
[18:40:51.518] Resolving 1 futures (chunks) ...
[18:40:51.518] resolve() on list ...
[18:40:51.518]  recursive: 0
[18:40:51.518]  length: 1
[18:40:51.519] 
[18:40:51.519] resolved() for 'SequentialFuture' ...
[18:40:51.519] - state: 'finished'
[18:40:51.519] - run: TRUE
[18:40:51.519] - result: 'FutureResult'
[18:40:51.520] resolved() for 'SequentialFuture' ... done
[18:40:51.520] Future #1
[18:40:51.520] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.520] - nx: 1
[18:40:51.520] - relay: TRUE
[18:40:51.520] - stdout: TRUE
[18:40:51.521] - signal: TRUE
[18:40:51.521] - resignal: FALSE
[18:40:51.521] - force: TRUE
[18:40:51.521] - relayed: [n=1] FALSE
[18:40:51.521] - queued futures: [n=1] FALSE
[18:40:51.521]  - until=1
[18:40:51.521]  - relaying element #1
[18:40:51.522] - relayed: [n=1] TRUE
[18:40:51.522] - queued futures: [n=1] TRUE
[18:40:51.522] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.522]  length: 0 (resolved future 1)
[18:40:51.522] Relaying remaining futures
[18:40:51.523] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.523] - nx: 1
[18:40:51.523] - relay: TRUE
[18:40:51.523] - stdout: TRUE
[18:40:51.523] - signal: TRUE
[18:40:51.523] - resignal: FALSE
[18:40:51.523] - force: TRUE
[18:40:51.524] - relayed: [n=1] TRUE
[18:40:51.524] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.524] - relayed: [n=1] TRUE
[18:40:51.524] - queued futures: [n=1] TRUE
[18:40:51.524] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.524] resolve() on list ... DONE
[18:40:51.525]  - Number of value chunks collected: 1
[18:40:51.525] Resolving 1 futures (chunks) ... DONE
[18:40:51.525] Reducing values from 1 chunks ...
[18:40:51.525]  - Number of values collected after concatenation: 3
[18:40:51.525]  - Number of values expected: 3
[18:40:51.526] Reducing values from 1 chunks ... DONE
[18:40:51.526] future_lapply() ... DONE
[18:40:51.526] future_by_internal() ... DONE
[18:40:51.531] future_by_internal() ...
[18:40:51.531] future_lapply() ...
[18:40:51.532] Number of chunks: 1
[18:40:51.532] getGlobalsAndPackagesXApply() ...
[18:40:51.533]  - future.globals: TRUE
[18:40:51.533] getGlobalsAndPackages() ...
[18:40:51.533] Searching for globals...
[18:40:51.535] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:51.535] Searching for globals ... DONE
[18:40:51.535] Resolving globals: FALSE
[18:40:51.536] The total size of the 3 globals is 2.07 KiB (2118 bytes)
[18:40:51.536] The total size of the 3 globals exported for future expression ('FUN()') is 2.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.28 KiB of class 'function'), 'breaks' (463 bytes of class 'numeric') and 'wool' (342 bytes of class 'numeric')
[18:40:51.537] - globals: [3] 'FUN', 'breaks', 'wool'
[18:40:51.537] - packages: [1] 'stats'
[18:40:51.537] getGlobalsAndPackages() ... DONE
[18:40:51.537]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[18:40:51.537]  - needed namespaces: [n=1] 'stats'
[18:40:51.538] Finding globals ... DONE
[18:40:51.538]  - use_args: TRUE
[18:40:51.538]  - Getting '...' globals ...
[18:40:51.538] resolve() on list ...
[18:40:51.538]  recursive: 0
[18:40:51.539]  length: 1
[18:40:51.539]  elements: '...'
[18:40:51.539]  length: 0 (resolved future 1)
[18:40:51.539] resolve() on list ... DONE
[18:40:51.539]    - '...' content: [n=0] 
[18:40:51.539] List of 1
[18:40:51.539]  $ ...: list()
[18:40:51.539]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.539]  - attr(*, "where")=List of 1
[18:40:51.539]   ..$ ...:<environment: 0x000001cd514a27d8> 
[18:40:51.539]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.539]  - attr(*, "resolved")= logi TRUE
[18:40:51.539]  - attr(*, "total_size")= num NA
[18:40:51.542]  - Getting '...' globals ... DONE
[18:40:51.543] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[18:40:51.543] List of 4
[18:40:51.543]  $ ...future.FUN:function (x)  
[18:40:51.543]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:51.543]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.543]  $ ...          : list()
[18:40:51.543]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.543]  - attr(*, "where")=List of 4
[18:40:51.543]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.543]   ..$ breaks       :<environment: R_EmptyEnv> 
[18:40:51.543]   ..$ wool         :<environment: R_EmptyEnv> 
[18:40:51.543]   ..$ ...          :<environment: 0x000001cd514a27d8> 
[18:40:51.543]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.543]  - attr(*, "resolved")= logi FALSE
[18:40:51.543]  - attr(*, "total_size")= int 18867
[18:40:51.548] Packages to be attached in all futures: [n=1] 'stats'
[18:40:51.548] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.548] Number of futures (= number of chunks): 1
[18:40:51.548] Launching 1 futures (chunks) ...
[18:40:51.548] Chunk #1 of 1 ...
[18:40:51.549]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.549] getGlobalsAndPackages() ...
[18:40:51.549] Searching for globals...
[18:40:51.549] 
[18:40:51.550] Searching for globals ... DONE
[18:40:51.550] - globals: [0] <none>
[18:40:51.550] getGlobalsAndPackages() ... DONE
[18:40:51.550]    + additional globals found: [n=0] 
[18:40:51.550]    + additional namespaces needed: [n=0] 
[18:40:51.550]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.551]  - seeds: <none>
[18:40:51.551]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.551] getGlobalsAndPackages() ...
[18:40:51.551] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.551] Resolving globals: FALSE
[18:40:51.551] Tweak future expression to call with '...' arguments ...
[18:40:51.552] {
[18:40:51.552]     do.call(function(...) {
[18:40:51.552]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.552]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.552]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.552]             on.exit(options(oopts), add = TRUE)
[18:40:51.552]         }
[18:40:51.552]         {
[18:40:51.552]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.552]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.552]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.552]             })
[18:40:51.552]         }
[18:40:51.552]     }, args = future.call.arguments)
[18:40:51.552] }
[18:40:51.552] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.553] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.553] 
[18:40:51.553] getGlobalsAndPackages() ... DONE
[18:40:51.553] run() for 'Future' ...
[18:40:51.554] - state: 'created'
[18:40:51.554] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:51.554] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.554] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.554]   - Field: 'label'
[18:40:51.555]   - Field: 'local'
[18:40:51.555]   - Field: 'owner'
[18:40:51.555]   - Field: 'envir'
[18:40:51.555]   - Field: 'packages'
[18:40:51.555]   - Field: 'gc'
[18:40:51.556]   - Field: 'conditions'
[18:40:51.556]   - Field: 'expr'
[18:40:51.556]   - Field: 'uuid'
[18:40:51.556]   - Field: 'seed'
[18:40:51.556]   - Field: 'version'
[18:40:51.556]   - Field: 'result'
[18:40:51.557]   - Field: 'asynchronous'
[18:40:51.557]   - Field: 'calls'
[18:40:51.557]   - Field: 'globals'
[18:40:51.557]   - Field: 'stdout'
[18:40:51.557]   - Field: 'earlySignal'
[18:40:51.557]   - Field: 'lazy'
[18:40:51.558]   - Field: 'state'
[18:40:51.558] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.558] - Launch lazy future ...
[18:40:51.558] Packages needed by the future expression (n = 1): 'stats'
[18:40:51.558] Packages needed by future strategies (n = 0): <none>
[18:40:51.559] {
[18:40:51.559]     {
[18:40:51.559]         {
[18:40:51.559]             ...future.startTime <- base::Sys.time()
[18:40:51.559]             {
[18:40:51.559]                 {
[18:40:51.559]                   {
[18:40:51.559]                     {
[18:40:51.559]                       base::local({
[18:40:51.559]                         has_future <- base::requireNamespace("future", 
[18:40:51.559]                           quietly = TRUE)
[18:40:51.559]                         if (has_future) {
[18:40:51.559]                           ns <- base::getNamespace("future")
[18:40:51.559]                           version <- ns[[".package"]][["version"]]
[18:40:51.559]                           if (is.null(version)) 
[18:40:51.559]                             version <- utils::packageVersion("future")
[18:40:51.559]                         }
[18:40:51.559]                         else {
[18:40:51.559]                           version <- NULL
[18:40:51.559]                         }
[18:40:51.559]                         if (!has_future || version < "1.8.0") {
[18:40:51.559]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.559]                             "", base::R.version$version.string), 
[18:40:51.559]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:51.559]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.559]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.559]                               "release", "version")], collapse = " "), 
[18:40:51.559]                             hostname = base::Sys.info()[["nodename"]])
[18:40:51.559]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.559]                             info)
[18:40:51.559]                           info <- base::paste(info, collapse = "; ")
[18:40:51.559]                           if (!has_future) {
[18:40:51.559]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.559]                               info)
[18:40:51.559]                           }
[18:40:51.559]                           else {
[18:40:51.559]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.559]                               info, version)
[18:40:51.559]                           }
[18:40:51.559]                           base::stop(msg)
[18:40:51.559]                         }
[18:40:51.559]                       })
[18:40:51.559]                     }
[18:40:51.559]                     base::local({
[18:40:51.559]                       for (pkg in "stats") {
[18:40:51.559]                         base::loadNamespace(pkg)
[18:40:51.559]                         base::library(pkg, character.only = TRUE)
[18:40:51.559]                       }
[18:40:51.559]                     })
[18:40:51.559]                   }
[18:40:51.559]                   ...future.strategy.old <- future::plan("list")
[18:40:51.559]                   options(future.plan = NULL)
[18:40:51.559]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.559]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.559]                 }
[18:40:51.559]                 ...future.workdir <- getwd()
[18:40:51.559]             }
[18:40:51.559]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.559]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.559]         }
[18:40:51.559]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.559]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.559]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.559]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.559]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.559]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.559]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.559]             base::names(...future.oldOptions))
[18:40:51.559]     }
[18:40:51.559]     if (FALSE) {
[18:40:51.559]     }
[18:40:51.559]     else {
[18:40:51.559]         if (TRUE) {
[18:40:51.559]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.559]                 open = "w")
[18:40:51.559]         }
[18:40:51.559]         else {
[18:40:51.559]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.559]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.559]         }
[18:40:51.559]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.559]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.559]             base::sink(type = "output", split = FALSE)
[18:40:51.559]             base::close(...future.stdout)
[18:40:51.559]         }, add = TRUE)
[18:40:51.559]     }
[18:40:51.559]     ...future.frame <- base::sys.nframe()
[18:40:51.559]     ...future.conditions <- base::list()
[18:40:51.559]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.559]     if (FALSE) {
[18:40:51.559]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.559]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.559]     }
[18:40:51.559]     ...future.result <- base::tryCatch({
[18:40:51.559]         base::withCallingHandlers({
[18:40:51.559]             ...future.value <- base::withVisible(base::local({
[18:40:51.559]                 do.call(function(...) {
[18:40:51.559]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.559]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.559]                     ...future.globals.maxSize)) {
[18:40:51.559]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.559]                     on.exit(options(oopts), add = TRUE)
[18:40:51.559]                   }
[18:40:51.559]                   {
[18:40:51.559]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.559]                       FUN = function(jj) {
[18:40:51.559]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.559]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.559]                       })
[18:40:51.559]                   }
[18:40:51.559]                 }, args = future.call.arguments)
[18:40:51.559]             }))
[18:40:51.559]             future::FutureResult(value = ...future.value$value, 
[18:40:51.559]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.559]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.559]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.559]                     ...future.globalenv.names))
[18:40:51.559]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.559]         }, condition = base::local({
[18:40:51.559]             c <- base::c
[18:40:51.559]             inherits <- base::inherits
[18:40:51.559]             invokeRestart <- base::invokeRestart
[18:40:51.559]             length <- base::length
[18:40:51.559]             list <- base::list
[18:40:51.559]             seq.int <- base::seq.int
[18:40:51.559]             signalCondition <- base::signalCondition
[18:40:51.559]             sys.calls <- base::sys.calls
[18:40:51.559]             `[[` <- base::`[[`
[18:40:51.559]             `+` <- base::`+`
[18:40:51.559]             `<<-` <- base::`<<-`
[18:40:51.559]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.559]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.559]                   3L)]
[18:40:51.559]             }
[18:40:51.559]             function(cond) {
[18:40:51.559]                 is_error <- inherits(cond, "error")
[18:40:51.559]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.559]                   NULL)
[18:40:51.559]                 if (is_error) {
[18:40:51.559]                   sessionInformation <- function() {
[18:40:51.559]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.559]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.559]                       search = base::search(), system = base::Sys.info())
[18:40:51.559]                   }
[18:40:51.559]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.559]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.559]                     cond$call), session = sessionInformation(), 
[18:40:51.559]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.559]                   signalCondition(cond)
[18:40:51.559]                 }
[18:40:51.559]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.559]                 "immediateCondition"))) {
[18:40:51.559]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.559]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.559]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.559]                   if (TRUE && !signal) {
[18:40:51.559]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.559]                     {
[18:40:51.559]                       inherits <- base::inherits
[18:40:51.559]                       invokeRestart <- base::invokeRestart
[18:40:51.559]                       is.null <- base::is.null
[18:40:51.559]                       muffled <- FALSE
[18:40:51.559]                       if (inherits(cond, "message")) {
[18:40:51.559]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.559]                         if (muffled) 
[18:40:51.559]                           invokeRestart("muffleMessage")
[18:40:51.559]                       }
[18:40:51.559]                       else if (inherits(cond, "warning")) {
[18:40:51.559]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.559]                         if (muffled) 
[18:40:51.559]                           invokeRestart("muffleWarning")
[18:40:51.559]                       }
[18:40:51.559]                       else if (inherits(cond, "condition")) {
[18:40:51.559]                         if (!is.null(pattern)) {
[18:40:51.559]                           computeRestarts <- base::computeRestarts
[18:40:51.559]                           grepl <- base::grepl
[18:40:51.559]                           restarts <- computeRestarts(cond)
[18:40:51.559]                           for (restart in restarts) {
[18:40:51.559]                             name <- restart$name
[18:40:51.559]                             if (is.null(name)) 
[18:40:51.559]                               next
[18:40:51.559]                             if (!grepl(pattern, name)) 
[18:40:51.559]                               next
[18:40:51.559]                             invokeRestart(restart)
[18:40:51.559]                             muffled <- TRUE
[18:40:51.559]                             break
[18:40:51.559]                           }
[18:40:51.559]                         }
[18:40:51.559]                       }
[18:40:51.559]                       invisible(muffled)
[18:40:51.559]                     }
[18:40:51.559]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.559]                   }
[18:40:51.559]                 }
[18:40:51.559]                 else {
[18:40:51.559]                   if (TRUE) {
[18:40:51.559]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.559]                     {
[18:40:51.559]                       inherits <- base::inherits
[18:40:51.559]                       invokeRestart <- base::invokeRestart
[18:40:51.559]                       is.null <- base::is.null
[18:40:51.559]                       muffled <- FALSE
[18:40:51.559]                       if (inherits(cond, "message")) {
[18:40:51.559]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.559]                         if (muffled) 
[18:40:51.559]                           invokeRestart("muffleMessage")
[18:40:51.559]                       }
[18:40:51.559]                       else if (inherits(cond, "warning")) {
[18:40:51.559]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.559]                         if (muffled) 
[18:40:51.559]                           invokeRestart("muffleWarning")
[18:40:51.559]                       }
[18:40:51.559]                       else if (inherits(cond, "condition")) {
[18:40:51.559]                         if (!is.null(pattern)) {
[18:40:51.559]                           computeRestarts <- base::computeRestarts
[18:40:51.559]                           grepl <- base::grepl
[18:40:51.559]                           restarts <- computeRestarts(cond)
[18:40:51.559]                           for (restart in restarts) {
[18:40:51.559]                             name <- restart$name
[18:40:51.559]                             if (is.null(name)) 
[18:40:51.559]                               next
[18:40:51.559]                             if (!grepl(pattern, name)) 
[18:40:51.559]                               next
[18:40:51.559]                             invokeRestart(restart)
[18:40:51.559]                             muffled <- TRUE
[18:40:51.559]                             break
[18:40:51.559]                           }
[18:40:51.559]                         }
[18:40:51.559]                       }
[18:40:51.559]                       invisible(muffled)
[18:40:51.559]                     }
[18:40:51.559]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.559]                   }
[18:40:51.559]                 }
[18:40:51.559]             }
[18:40:51.559]         }))
[18:40:51.559]     }, error = function(ex) {
[18:40:51.559]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.559]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.559]                 ...future.rng), started = ...future.startTime, 
[18:40:51.559]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.559]             version = "1.8"), class = "FutureResult")
[18:40:51.559]     }, finally = {
[18:40:51.559]         if (!identical(...future.workdir, getwd())) 
[18:40:51.559]             setwd(...future.workdir)
[18:40:51.559]         {
[18:40:51.559]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.559]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.559]             }
[18:40:51.559]             base::options(...future.oldOptions)
[18:40:51.559]             if (.Platform$OS.type == "windows") {
[18:40:51.559]                 old_names <- names(...future.oldEnvVars)
[18:40:51.559]                 envs <- base::Sys.getenv()
[18:40:51.559]                 names <- names(envs)
[18:40:51.559]                 common <- intersect(names, old_names)
[18:40:51.559]                 added <- setdiff(names, old_names)
[18:40:51.559]                 removed <- setdiff(old_names, names)
[18:40:51.559]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.559]                   envs[common]]
[18:40:51.559]                 NAMES <- toupper(changed)
[18:40:51.559]                 args <- list()
[18:40:51.559]                 for (kk in seq_along(NAMES)) {
[18:40:51.559]                   name <- changed[[kk]]
[18:40:51.559]                   NAME <- NAMES[[kk]]
[18:40:51.559]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.559]                     next
[18:40:51.559]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.559]                 }
[18:40:51.559]                 NAMES <- toupper(added)
[18:40:51.559]                 for (kk in seq_along(NAMES)) {
[18:40:51.559]                   name <- added[[kk]]
[18:40:51.559]                   NAME <- NAMES[[kk]]
[18:40:51.559]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.559]                     next
[18:40:51.559]                   args[[name]] <- ""
[18:40:51.559]                 }
[18:40:51.559]                 NAMES <- toupper(removed)
[18:40:51.559]                 for (kk in seq_along(NAMES)) {
[18:40:51.559]                   name <- removed[[kk]]
[18:40:51.559]                   NAME <- NAMES[[kk]]
[18:40:51.559]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.559]                     next
[18:40:51.559]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.559]                 }
[18:40:51.559]                 if (length(args) > 0) 
[18:40:51.559]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.559]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.559]             }
[18:40:51.559]             else {
[18:40:51.559]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.559]             }
[18:40:51.559]             {
[18:40:51.559]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.559]                   0L) {
[18:40:51.559]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.559]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.559]                   base::options(opts)
[18:40:51.559]                 }
[18:40:51.559]                 {
[18:40:51.559]                   {
[18:40:51.559]                     NULL
[18:40:51.559]                     RNGkind("Mersenne-Twister")
[18:40:51.559]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.559]                       inherits = FALSE)
[18:40:51.559]                   }
[18:40:51.559]                   options(future.plan = NULL)
[18:40:51.559]                   if (is.na(NA_character_)) 
[18:40:51.559]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.559]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.559]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.559]                     .init = FALSE)
[18:40:51.559]                 }
[18:40:51.559]             }
[18:40:51.559]         }
[18:40:51.559]     })
[18:40:51.559]     if (TRUE) {
[18:40:51.559]         base::sink(type = "output", split = FALSE)
[18:40:51.559]         if (TRUE) {
[18:40:51.559]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.559]         }
[18:40:51.559]         else {
[18:40:51.559]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.559]         }
[18:40:51.559]         base::close(...future.stdout)
[18:40:51.559]         ...future.stdout <- NULL
[18:40:51.559]     }
[18:40:51.559]     ...future.result$conditions <- ...future.conditions
[18:40:51.559]     ...future.result$finished <- base::Sys.time()
[18:40:51.559]     ...future.result
[18:40:51.559] }
[18:40:51.563] assign_globals() ...
[18:40:51.563] List of 7
[18:40:51.563]  $ ...future.FUN            :function (x)  
[18:40:51.563]  $ breaks                   : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:51.563]  $ wool                     : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.563]  $ future.call.arguments    : list()
[18:40:51.563]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.563]  $ ...future.elements_ii    :List of 3
[18:40:51.563]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.563]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.563]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.563]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.563]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.563]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.563]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.563]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.563]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.563]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.563]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.563]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.563]  $ ...future.seeds_ii       : NULL
[18:40:51.563]  $ ...future.globals.maxSize: NULL
[18:40:51.563]  - attr(*, "where")=List of 7
[18:40:51.563]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.563]   ..$ breaks                   :<environment: R_EmptyEnv> 
[18:40:51.563]   ..$ wool                     :<environment: R_EmptyEnv> 
[18:40:51.563]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.563]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.563]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.563]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.563]  - attr(*, "resolved")= logi FALSE
[18:40:51.563]  - attr(*, "total_size")= num 18867
[18:40:51.563]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.563]  - attr(*, "already-done")= logi TRUE
[18:40:51.577] - reassign environment for '...future.FUN'
[18:40:51.577] - copied '...future.FUN' to environment
[18:40:51.577] - copied 'breaks' to environment
[18:40:51.577] - copied 'wool' to environment
[18:40:51.577] - copied 'future.call.arguments' to environment
[18:40:51.578] - copied '...future.elements_ii' to environment
[18:40:51.578] - copied '...future.seeds_ii' to environment
[18:40:51.578] - copied '...future.globals.maxSize' to environment
[18:40:51.578] assign_globals() ... done
[18:40:51.579] plan(): Setting new future strategy stack:
[18:40:51.579] List of future strategies:
[18:40:51.579] 1. sequential:
[18:40:51.579]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.579]    - tweaked: FALSE
[18:40:51.579]    - call: NULL
[18:40:51.580] plan(): nbrOfWorkers() = 1
[18:40:51.583] plan(): Setting new future strategy stack:
[18:40:51.583] List of future strategies:
[18:40:51.583] 1. sequential:
[18:40:51.583]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.583]    - tweaked: FALSE
[18:40:51.583]    - call: plan(strategy)
[18:40:51.584] plan(): nbrOfWorkers() = 1
[18:40:51.584] SequentialFuture started (and completed)
[18:40:51.584] - Launch lazy future ... done
[18:40:51.585] run() for 'SequentialFuture' ... done
[18:40:51.585] Created future:
[18:40:51.585] SequentialFuture:
[18:40:51.585] Label: 'future_by-1'
[18:40:51.585] Expression:
[18:40:51.585] {
[18:40:51.585]     do.call(function(...) {
[18:40:51.585]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.585]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.585]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.585]             on.exit(options(oopts), add = TRUE)
[18:40:51.585]         }
[18:40:51.585]         {
[18:40:51.585]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.585]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.585]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.585]             })
[18:40:51.585]         }
[18:40:51.585]     }, args = future.call.arguments)
[18:40:51.585] }
[18:40:51.585] Lazy evaluation: FALSE
[18:40:51.585] Asynchronous evaluation: FALSE
[18:40:51.585] Local evaluation: TRUE
[18:40:51.585] Environment: 0x000001cd51473298
[18:40:51.585] Capture standard output: TRUE
[18:40:51.585] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.585] Globals: 7 objects totaling 4.20 KiB (function '...future.FUN' of 1.28 KiB, numeric 'breaks' of 463 bytes, factor 'wool' of 342 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, ...)
[18:40:51.585] Packages: 1 packages ('stats')
[18:40:51.585] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.585] Resolved: TRUE
[18:40:51.585] Value: 86.77 KiB of class 'list'
[18:40:51.585] Early signaling: FALSE
[18:40:51.585] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.585] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.587] Chunk #1 of 1 ... DONE
[18:40:51.587] Launching 1 futures (chunks) ... DONE
[18:40:51.587] Resolving 1 futures (chunks) ...
[18:40:51.587] resolve() on list ...
[18:40:51.587]  recursive: 0
[18:40:51.587]  length: 1
[18:40:51.588] 
[18:40:51.588] resolved() for 'SequentialFuture' ...
[18:40:51.588] - state: 'finished'
[18:40:51.588] - run: TRUE
[18:40:51.588] - result: 'FutureResult'
[18:40:51.588] resolved() for 'SequentialFuture' ... done
[18:40:51.589] Future #1
[18:40:51.589] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.589] - nx: 1
[18:40:51.589] - relay: TRUE
[18:40:51.589] - stdout: TRUE
[18:40:51.590] - signal: TRUE
[18:40:51.590] - resignal: FALSE
[18:40:51.590] - force: TRUE
[18:40:51.590] - relayed: [n=1] FALSE
[18:40:51.590] - queued futures: [n=1] FALSE
[18:40:51.590]  - until=1
[18:40:51.590]  - relaying element #1
[18:40:51.591] - relayed: [n=1] TRUE
[18:40:51.591] - queued futures: [n=1] TRUE
[18:40:51.591] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.591]  length: 0 (resolved future 1)
[18:40:51.591] Relaying remaining futures
[18:40:51.592] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.592] - nx: 1
[18:40:51.592] - relay: TRUE
[18:40:51.592] - stdout: TRUE
[18:40:51.592] - signal: TRUE
[18:40:51.592] - resignal: FALSE
[18:40:51.593] - force: TRUE
[18:40:51.593] - relayed: [n=1] TRUE
[18:40:51.593] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.593] - relayed: [n=1] TRUE
[18:40:51.593] - queued futures: [n=1] TRUE
[18:40:51.593] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.594] resolve() on list ... DONE
[18:40:51.594]  - Number of value chunks collected: 1
[18:40:51.594] Resolving 1 futures (chunks) ... DONE
[18:40:51.594] Reducing values from 1 chunks ...
[18:40:51.594]  - Number of values collected after concatenation: 3
[18:40:51.594]  - Number of values expected: 3
[18:40:51.595] Reducing values from 1 chunks ... DONE
[18:40:51.595] future_lapply() ... DONE
[18:40:51.595] future_by_internal() ... DONE
[18:40:51.595] future_by_internal() ...
[18:40:51.596] future_lapply() ...
[18:40:51.596] Number of chunks: 1
[18:40:51.597] getGlobalsAndPackagesXApply() ...
[18:40:51.597]  - future.globals: TRUE
[18:40:51.597] getGlobalsAndPackages() ...
[18:40:51.597] Searching for globals...
[18:40:51.598] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.599] Searching for globals ... DONE
[18:40:51.599] Resolving globals: FALSE
[18:40:51.599] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.600] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.600] - globals: [1] 'FUN'
[18:40:51.600] 
[18:40:51.600] getGlobalsAndPackages() ... DONE
[18:40:51.600]  - globals found/used: [n=1] 'FUN'
[18:40:51.600]  - needed namespaces: [n=0] 
[18:40:51.601] Finding globals ... DONE
[18:40:51.601]  - use_args: TRUE
[18:40:51.601]  - Getting '...' globals ...
[18:40:51.601] resolve() on list ...
[18:40:51.601]  recursive: 0
[18:40:51.602]  length: 1
[18:40:51.602]  elements: '...'
[18:40:51.602]  length: 0 (resolved future 1)
[18:40:51.602] resolve() on list ... DONE
[18:40:51.602]    - '...' content: [n=0] 
[18:40:51.603] List of 1
[18:40:51.603]  $ ...: list()
[18:40:51.603]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.603]  - attr(*, "where")=List of 1
[18:40:51.603]   ..$ ...:<environment: 0x000001cd4aa4bb58> 
[18:40:51.603]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.603]  - attr(*, "resolved")= logi TRUE
[18:40:51.603]  - attr(*, "total_size")= num NA
[18:40:51.605]  - Getting '...' globals ... DONE
[18:40:51.606] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.606] List of 2
[18:40:51.606]  $ ...future.FUN:function (object, ...)  
[18:40:51.606]  $ ...          : list()
[18:40:51.606]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.606]  - attr(*, "where")=List of 2
[18:40:51.606]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.606]   ..$ ...          :<environment: 0x000001cd4aa4bb58> 
[18:40:51.606]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.606]  - attr(*, "resolved")= logi FALSE
[18:40:51.606]  - attr(*, "total_size")= int 19278
[18:40:51.609] Packages to be attached in all futures: [n=0] 
[18:40:51.609] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.610] Number of futures (= number of chunks): 1
[18:40:51.610] Launching 1 futures (chunks) ...
[18:40:51.610] Chunk #1 of 1 ...
[18:40:51.610]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.610] getGlobalsAndPackages() ...
[18:40:51.610] Searching for globals...
[18:40:51.611] 
[18:40:51.611] Searching for globals ... DONE
[18:40:51.611] - globals: [0] <none>
[18:40:51.611] getGlobalsAndPackages() ... DONE
[18:40:51.612]    + additional globals found: [n=0] 
[18:40:51.612]    + additional namespaces needed: [n=0] 
[18:40:51.612]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.612]  - seeds: <none>
[18:40:51.612]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.612] getGlobalsAndPackages() ...
[18:40:51.613] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.613] Resolving globals: FALSE
[18:40:51.613] Tweak future expression to call with '...' arguments ...
[18:40:51.613] {
[18:40:51.613]     do.call(function(...) {
[18:40:51.613]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.613]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.613]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.613]             on.exit(options(oopts), add = TRUE)
[18:40:51.613]         }
[18:40:51.613]         {
[18:40:51.613]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.613]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.613]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.613]             })
[18:40:51.613]         }
[18:40:51.613]     }, args = future.call.arguments)
[18:40:51.613] }
[18:40:51.614] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.614] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.614] 
[18:40:51.614] getGlobalsAndPackages() ... DONE
[18:40:51.615] run() for 'Future' ...
[18:40:51.615] - state: 'created'
[18:40:51.615] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:51.615] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.616] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.616]   - Field: 'label'
[18:40:51.616]   - Field: 'local'
[18:40:51.616]   - Field: 'owner'
[18:40:51.616]   - Field: 'envir'
[18:40:51.617]   - Field: 'packages'
[18:40:51.617]   - Field: 'gc'
[18:40:51.617]   - Field: 'conditions'
[18:40:51.617]   - Field: 'expr'
[18:40:51.617]   - Field: 'uuid'
[18:40:51.617]   - Field: 'seed'
[18:40:51.618]   - Field: 'version'
[18:40:51.618]   - Field: 'result'
[18:40:51.618]   - Field: 'asynchronous'
[18:40:51.618]   - Field: 'calls'
[18:40:51.618]   - Field: 'globals'
[18:40:51.618]   - Field: 'stdout'
[18:40:51.619]   - Field: 'earlySignal'
[18:40:51.619]   - Field: 'lazy'
[18:40:51.619]   - Field: 'state'
[18:40:51.619] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.619] - Launch lazy future ...
[18:40:51.620] Packages needed by the future expression (n = 0): <none>
[18:40:51.620] Packages needed by future strategies (n = 0): <none>
[18:40:51.620] {
[18:40:51.620]     {
[18:40:51.620]         {
[18:40:51.620]             ...future.startTime <- base::Sys.time()
[18:40:51.620]             {
[18:40:51.620]                 {
[18:40:51.620]                   {
[18:40:51.620]                     base::local({
[18:40:51.620]                       has_future <- base::requireNamespace("future", 
[18:40:51.620]                         quietly = TRUE)
[18:40:51.620]                       if (has_future) {
[18:40:51.620]                         ns <- base::getNamespace("future")
[18:40:51.620]                         version <- ns[[".package"]][["version"]]
[18:40:51.620]                         if (is.null(version)) 
[18:40:51.620]                           version <- utils::packageVersion("future")
[18:40:51.620]                       }
[18:40:51.620]                       else {
[18:40:51.620]                         version <- NULL
[18:40:51.620]                       }
[18:40:51.620]                       if (!has_future || version < "1.8.0") {
[18:40:51.620]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.620]                           "", base::R.version$version.string), 
[18:40:51.620]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.620]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.620]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.620]                             "release", "version")], collapse = " "), 
[18:40:51.620]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.620]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.620]                           info)
[18:40:51.620]                         info <- base::paste(info, collapse = "; ")
[18:40:51.620]                         if (!has_future) {
[18:40:51.620]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.620]                             info)
[18:40:51.620]                         }
[18:40:51.620]                         else {
[18:40:51.620]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.620]                             info, version)
[18:40:51.620]                         }
[18:40:51.620]                         base::stop(msg)
[18:40:51.620]                       }
[18:40:51.620]                     })
[18:40:51.620]                   }
[18:40:51.620]                   ...future.strategy.old <- future::plan("list")
[18:40:51.620]                   options(future.plan = NULL)
[18:40:51.620]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.620]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.620]                 }
[18:40:51.620]                 ...future.workdir <- getwd()
[18:40:51.620]             }
[18:40:51.620]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.620]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.620]         }
[18:40:51.620]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.620]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.620]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.620]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.620]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.620]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.620]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.620]             base::names(...future.oldOptions))
[18:40:51.620]     }
[18:40:51.620]     if (FALSE) {
[18:40:51.620]     }
[18:40:51.620]     else {
[18:40:51.620]         if (TRUE) {
[18:40:51.620]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.620]                 open = "w")
[18:40:51.620]         }
[18:40:51.620]         else {
[18:40:51.620]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.620]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.620]         }
[18:40:51.620]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.620]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.620]             base::sink(type = "output", split = FALSE)
[18:40:51.620]             base::close(...future.stdout)
[18:40:51.620]         }, add = TRUE)
[18:40:51.620]     }
[18:40:51.620]     ...future.frame <- base::sys.nframe()
[18:40:51.620]     ...future.conditions <- base::list()
[18:40:51.620]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.620]     if (FALSE) {
[18:40:51.620]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.620]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.620]     }
[18:40:51.620]     ...future.result <- base::tryCatch({
[18:40:51.620]         base::withCallingHandlers({
[18:40:51.620]             ...future.value <- base::withVisible(base::local({
[18:40:51.620]                 do.call(function(...) {
[18:40:51.620]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.620]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.620]                     ...future.globals.maxSize)) {
[18:40:51.620]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.620]                     on.exit(options(oopts), add = TRUE)
[18:40:51.620]                   }
[18:40:51.620]                   {
[18:40:51.620]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.620]                       FUN = function(jj) {
[18:40:51.620]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.620]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.620]                       })
[18:40:51.620]                   }
[18:40:51.620]                 }, args = future.call.arguments)
[18:40:51.620]             }))
[18:40:51.620]             future::FutureResult(value = ...future.value$value, 
[18:40:51.620]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.620]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.620]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.620]                     ...future.globalenv.names))
[18:40:51.620]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.620]         }, condition = base::local({
[18:40:51.620]             c <- base::c
[18:40:51.620]             inherits <- base::inherits
[18:40:51.620]             invokeRestart <- base::invokeRestart
[18:40:51.620]             length <- base::length
[18:40:51.620]             list <- base::list
[18:40:51.620]             seq.int <- base::seq.int
[18:40:51.620]             signalCondition <- base::signalCondition
[18:40:51.620]             sys.calls <- base::sys.calls
[18:40:51.620]             `[[` <- base::`[[`
[18:40:51.620]             `+` <- base::`+`
[18:40:51.620]             `<<-` <- base::`<<-`
[18:40:51.620]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.620]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.620]                   3L)]
[18:40:51.620]             }
[18:40:51.620]             function(cond) {
[18:40:51.620]                 is_error <- inherits(cond, "error")
[18:40:51.620]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.620]                   NULL)
[18:40:51.620]                 if (is_error) {
[18:40:51.620]                   sessionInformation <- function() {
[18:40:51.620]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.620]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.620]                       search = base::search(), system = base::Sys.info())
[18:40:51.620]                   }
[18:40:51.620]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.620]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.620]                     cond$call), session = sessionInformation(), 
[18:40:51.620]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.620]                   signalCondition(cond)
[18:40:51.620]                 }
[18:40:51.620]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.620]                 "immediateCondition"))) {
[18:40:51.620]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.620]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.620]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.620]                   if (TRUE && !signal) {
[18:40:51.620]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.620]                     {
[18:40:51.620]                       inherits <- base::inherits
[18:40:51.620]                       invokeRestart <- base::invokeRestart
[18:40:51.620]                       is.null <- base::is.null
[18:40:51.620]                       muffled <- FALSE
[18:40:51.620]                       if (inherits(cond, "message")) {
[18:40:51.620]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.620]                         if (muffled) 
[18:40:51.620]                           invokeRestart("muffleMessage")
[18:40:51.620]                       }
[18:40:51.620]                       else if (inherits(cond, "warning")) {
[18:40:51.620]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.620]                         if (muffled) 
[18:40:51.620]                           invokeRestart("muffleWarning")
[18:40:51.620]                       }
[18:40:51.620]                       else if (inherits(cond, "condition")) {
[18:40:51.620]                         if (!is.null(pattern)) {
[18:40:51.620]                           computeRestarts <- base::computeRestarts
[18:40:51.620]                           grepl <- base::grepl
[18:40:51.620]                           restarts <- computeRestarts(cond)
[18:40:51.620]                           for (restart in restarts) {
[18:40:51.620]                             name <- restart$name
[18:40:51.620]                             if (is.null(name)) 
[18:40:51.620]                               next
[18:40:51.620]                             if (!grepl(pattern, name)) 
[18:40:51.620]                               next
[18:40:51.620]                             invokeRestart(restart)
[18:40:51.620]                             muffled <- TRUE
[18:40:51.620]                             break
[18:40:51.620]                           }
[18:40:51.620]                         }
[18:40:51.620]                       }
[18:40:51.620]                       invisible(muffled)
[18:40:51.620]                     }
[18:40:51.620]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.620]                   }
[18:40:51.620]                 }
[18:40:51.620]                 else {
[18:40:51.620]                   if (TRUE) {
[18:40:51.620]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.620]                     {
[18:40:51.620]                       inherits <- base::inherits
[18:40:51.620]                       invokeRestart <- base::invokeRestart
[18:40:51.620]                       is.null <- base::is.null
[18:40:51.620]                       muffled <- FALSE
[18:40:51.620]                       if (inherits(cond, "message")) {
[18:40:51.620]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.620]                         if (muffled) 
[18:40:51.620]                           invokeRestart("muffleMessage")
[18:40:51.620]                       }
[18:40:51.620]                       else if (inherits(cond, "warning")) {
[18:40:51.620]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.620]                         if (muffled) 
[18:40:51.620]                           invokeRestart("muffleWarning")
[18:40:51.620]                       }
[18:40:51.620]                       else if (inherits(cond, "condition")) {
[18:40:51.620]                         if (!is.null(pattern)) {
[18:40:51.620]                           computeRestarts <- base::computeRestarts
[18:40:51.620]                           grepl <- base::grepl
[18:40:51.620]                           restarts <- computeRestarts(cond)
[18:40:51.620]                           for (restart in restarts) {
[18:40:51.620]                             name <- restart$name
[18:40:51.620]                             if (is.null(name)) 
[18:40:51.620]                               next
[18:40:51.620]                             if (!grepl(pattern, name)) 
[18:40:51.620]                               next
[18:40:51.620]                             invokeRestart(restart)
[18:40:51.620]                             muffled <- TRUE
[18:40:51.620]                             break
[18:40:51.620]                           }
[18:40:51.620]                         }
[18:40:51.620]                       }
[18:40:51.620]                       invisible(muffled)
[18:40:51.620]                     }
[18:40:51.620]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.620]                   }
[18:40:51.620]                 }
[18:40:51.620]             }
[18:40:51.620]         }))
[18:40:51.620]     }, error = function(ex) {
[18:40:51.620]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.620]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.620]                 ...future.rng), started = ...future.startTime, 
[18:40:51.620]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.620]             version = "1.8"), class = "FutureResult")
[18:40:51.620]     }, finally = {
[18:40:51.620]         if (!identical(...future.workdir, getwd())) 
[18:40:51.620]             setwd(...future.workdir)
[18:40:51.620]         {
[18:40:51.620]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.620]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.620]             }
[18:40:51.620]             base::options(...future.oldOptions)
[18:40:51.620]             if (.Platform$OS.type == "windows") {
[18:40:51.620]                 old_names <- names(...future.oldEnvVars)
[18:40:51.620]                 envs <- base::Sys.getenv()
[18:40:51.620]                 names <- names(envs)
[18:40:51.620]                 common <- intersect(names, old_names)
[18:40:51.620]                 added <- setdiff(names, old_names)
[18:40:51.620]                 removed <- setdiff(old_names, names)
[18:40:51.620]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.620]                   envs[common]]
[18:40:51.620]                 NAMES <- toupper(changed)
[18:40:51.620]                 args <- list()
[18:40:51.620]                 for (kk in seq_along(NAMES)) {
[18:40:51.620]                   name <- changed[[kk]]
[18:40:51.620]                   NAME <- NAMES[[kk]]
[18:40:51.620]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.620]                     next
[18:40:51.620]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.620]                 }
[18:40:51.620]                 NAMES <- toupper(added)
[18:40:51.620]                 for (kk in seq_along(NAMES)) {
[18:40:51.620]                   name <- added[[kk]]
[18:40:51.620]                   NAME <- NAMES[[kk]]
[18:40:51.620]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.620]                     next
[18:40:51.620]                   args[[name]] <- ""
[18:40:51.620]                 }
[18:40:51.620]                 NAMES <- toupper(removed)
[18:40:51.620]                 for (kk in seq_along(NAMES)) {
[18:40:51.620]                   name <- removed[[kk]]
[18:40:51.620]                   NAME <- NAMES[[kk]]
[18:40:51.620]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.620]                     next
[18:40:51.620]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.620]                 }
[18:40:51.620]                 if (length(args) > 0) 
[18:40:51.620]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.620]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.620]             }
[18:40:51.620]             else {
[18:40:51.620]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.620]             }
[18:40:51.620]             {
[18:40:51.620]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.620]                   0L) {
[18:40:51.620]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.620]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.620]                   base::options(opts)
[18:40:51.620]                 }
[18:40:51.620]                 {
[18:40:51.620]                   {
[18:40:51.620]                     NULL
[18:40:51.620]                     RNGkind("Mersenne-Twister")
[18:40:51.620]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.620]                       inherits = FALSE)
[18:40:51.620]                   }
[18:40:51.620]                   options(future.plan = NULL)
[18:40:51.620]                   if (is.na(NA_character_)) 
[18:40:51.620]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.620]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.620]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.620]                     .init = FALSE)
[18:40:51.620]                 }
[18:40:51.620]             }
[18:40:51.620]         }
[18:40:51.620]     })
[18:40:51.620]     if (TRUE) {
[18:40:51.620]         base::sink(type = "output", split = FALSE)
[18:40:51.620]         if (TRUE) {
[18:40:51.620]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.620]         }
[18:40:51.620]         else {
[18:40:51.620]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.620]         }
[18:40:51.620]         base::close(...future.stdout)
[18:40:51.620]         ...future.stdout <- NULL
[18:40:51.620]     }
[18:40:51.620]     ...future.result$conditions <- ...future.conditions
[18:40:51.620]     ...future.result$finished <- base::Sys.time()
[18:40:51.620]     ...future.result
[18:40:51.620] }
[18:40:51.624] assign_globals() ...
[18:40:51.624] List of 5
[18:40:51.624]  $ ...future.FUN            :function (object, ...)  
[18:40:51.624]  $ future.call.arguments    : list()
[18:40:51.624]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.624]  $ ...future.elements_ii    :List of 3
[18:40:51.624]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.624]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.624]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.624]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.624]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.624]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.624]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.624]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.624]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.624]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.624]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.624]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.624]  $ ...future.seeds_ii       : NULL
[18:40:51.624]  $ ...future.globals.maxSize: NULL
[18:40:51.624]  - attr(*, "where")=List of 5
[18:40:51.624]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.624]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.624]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.624]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.624]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.624]  - attr(*, "resolved")= logi FALSE
[18:40:51.624]  - attr(*, "total_size")= num 19278
[18:40:51.624]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.624]  - attr(*, "already-done")= logi TRUE
[18:40:51.634] - copied '...future.FUN' to environment
[18:40:51.635] - copied 'future.call.arguments' to environment
[18:40:51.635] - copied '...future.elements_ii' to environment
[18:40:51.635] - copied '...future.seeds_ii' to environment
[18:40:51.635] - copied '...future.globals.maxSize' to environment
[18:40:51.635] assign_globals() ... done
[18:40:51.636] plan(): Setting new future strategy stack:
[18:40:51.636] List of future strategies:
[18:40:51.636] 1. sequential:
[18:40:51.636]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.636]    - tweaked: FALSE
[18:40:51.636]    - call: NULL
[18:40:51.636] plan(): nbrOfWorkers() = 1
[18:40:51.640] plan(): Setting new future strategy stack:
[18:40:51.640] List of future strategies:
[18:40:51.640] 1. sequential:
[18:40:51.640]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.640]    - tweaked: FALSE
[18:40:51.640]    - call: plan(strategy)
[18:40:51.640] plan(): nbrOfWorkers() = 1
[18:40:51.641] SequentialFuture started (and completed)
[18:40:51.641] - Launch lazy future ... done
[18:40:51.641] run() for 'SequentialFuture' ... done
[18:40:51.641] Created future:
[18:40:51.641] SequentialFuture:
[18:40:51.641] Label: 'future_by-1'
[18:40:51.641] Expression:
[18:40:51.641] {
[18:40:51.641]     do.call(function(...) {
[18:40:51.641]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.641]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.641]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.641]             on.exit(options(oopts), add = TRUE)
[18:40:51.641]         }
[18:40:51.641]         {
[18:40:51.641]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.641]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.641]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.641]             })
[18:40:51.641]         }
[18:40:51.641]     }, args = future.call.arguments)
[18:40:51.641] }
[18:40:51.641] Lazy evaluation: FALSE
[18:40:51.641] Asynchronous evaluation: FALSE
[18:40:51.641] Local evaluation: TRUE
[18:40:51.641] Environment: 0x000001cd4ab15ca0
[18:40:51.641] Capture standard output: TRUE
[18:40:51.641] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.641] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.641] Packages: <none>
[18:40:51.641] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.641] Resolved: TRUE
[18:40:51.641] Value: 1.39 KiB of class 'list'
[18:40:51.641] Early signaling: FALSE
[18:40:51.641] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.641] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.643] Chunk #1 of 1 ... DONE
[18:40:51.643] Launching 1 futures (chunks) ... DONE
[18:40:51.643] Resolving 1 futures (chunks) ...
[18:40:51.643] resolve() on list ...
[18:40:51.643]  recursive: 0
[18:40:51.643]  length: 1
[18:40:51.644] 
[18:40:51.644] resolved() for 'SequentialFuture' ...
[18:40:51.644] - state: 'finished'
[18:40:51.644] - run: TRUE
[18:40:51.644] - result: 'FutureResult'
[18:40:51.644] resolved() for 'SequentialFuture' ... done
[18:40:51.645] Future #1
[18:40:51.645] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.645] - nx: 1
[18:40:51.645] - relay: TRUE
[18:40:51.645] - stdout: TRUE
[18:40:51.645] - signal: TRUE
[18:40:51.646] - resignal: FALSE
[18:40:51.646] - force: TRUE
[18:40:51.646] - relayed: [n=1] FALSE
[18:40:51.646] - queued futures: [n=1] FALSE
[18:40:51.646]  - until=1
[18:40:51.646]  - relaying element #1
[18:40:51.647] - relayed: [n=1] TRUE
[18:40:51.647] - queued futures: [n=1] TRUE
[18:40:51.647] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.647]  length: 0 (resolved future 1)
[18:40:51.647] Relaying remaining futures
[18:40:51.647] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.648] - nx: 1
[18:40:51.648] - relay: TRUE
[18:40:51.648] - stdout: TRUE
[18:40:51.648] - signal: TRUE
[18:40:51.648] - resignal: FALSE
[18:40:51.648] - force: TRUE
[18:40:51.649] - relayed: [n=1] TRUE
[18:40:51.649] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.649] - relayed: [n=1] TRUE
[18:40:51.649] - queued futures: [n=1] TRUE
[18:40:51.649] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.649] resolve() on list ... DONE
[18:40:51.650]  - Number of value chunks collected: 1
[18:40:51.650] Resolving 1 futures (chunks) ... DONE
[18:40:51.650] Reducing values from 1 chunks ...
[18:40:51.650]  - Number of values collected after concatenation: 3
[18:40:51.650]  - Number of values expected: 3
[18:40:51.650] Reducing values from 1 chunks ... DONE
[18:40:51.651] future_lapply() ... DONE
[18:40:51.651] future_by_internal() ... DONE
[18:40:51.652] future_by_internal() ...
Warning in future_by_match_FUN(FUN) :
  Specifying the function 'FUN' for future_by() as a character string is deprecated in future.apply (>= 1.10.0) [2022-11-04], because base::by() does not support it. Instead, specify it as a function, e.g. FUN = sqrt and FUN = `[[`. It is deprecated.
[18:40:51.652] future_lapply() ...
[18:40:51.653] Number of chunks: 1
[18:40:51.653] getGlobalsAndPackagesXApply() ...
[18:40:51.653]  - future.globals: TRUE
[18:40:51.653] getGlobalsAndPackages() ...
[18:40:51.654] Searching for globals...
[18:40:51.655] - globals found: [2] 'FUN', 'UseMethod'
[18:40:51.655] Searching for globals ... DONE
[18:40:51.655] Resolving globals: FALSE
[18:40:51.656] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:51.656] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:51.656] - globals: [1] 'FUN'
[18:40:51.657] 
[18:40:51.657] getGlobalsAndPackages() ... DONE
[18:40:51.657]  - globals found/used: [n=1] 'FUN'
[18:40:51.657]  - needed namespaces: [n=0] 
[18:40:51.657] Finding globals ... DONE
[18:40:51.658]  - use_args: TRUE
[18:40:51.658]  - Getting '...' globals ...
[18:40:51.658] resolve() on list ...
[18:40:51.658]  recursive: 0
[18:40:51.658]  length: 1
[18:40:51.659]  elements: '...'
[18:40:51.659]  length: 0 (resolved future 1)
[18:40:51.659] resolve() on list ... DONE
[18:40:51.659]    - '...' content: [n=0] 
[18:40:51.659] List of 1
[18:40:51.659]  $ ...: list()
[18:40:51.659]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.659]  - attr(*, "where")=List of 1
[18:40:51.659]   ..$ ...:<environment: 0x000001cd519710b8> 
[18:40:51.659]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.659]  - attr(*, "resolved")= logi TRUE
[18:40:51.659]  - attr(*, "total_size")= num NA
[18:40:51.663]  - Getting '...' globals ... DONE
[18:40:51.663] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:51.663] List of 2
[18:40:51.663]  $ ...future.FUN:function (object, ...)  
[18:40:51.663]  $ ...          : list()
[18:40:51.663]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.663]  - attr(*, "where")=List of 2
[18:40:51.663]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:51.663]   ..$ ...          :<environment: 0x000001cd519710b8> 
[18:40:51.663]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.663]  - attr(*, "resolved")= logi FALSE
[18:40:51.663]  - attr(*, "total_size")= int 18647
[18:40:51.667] Packages to be attached in all futures: [n=0] 
[18:40:51.667] getGlobalsAndPackagesXApply() ... DONE
[18:40:51.667] Number of futures (= number of chunks): 1
[18:40:51.667] Launching 1 futures (chunks) ...
[18:40:51.667] Chunk #1 of 1 ...
[18:40:51.668]  - Finding globals in 'X' for chunk #1 ...
[18:40:51.668] getGlobalsAndPackages() ...
[18:40:51.668] Searching for globals...
[18:40:51.669] 
[18:40:51.669] Searching for globals ... DONE
[18:40:51.669] - globals: [0] <none>
[18:40:51.669] getGlobalsAndPackages() ... DONE
[18:40:51.669]    + additional globals found: [n=0] 
[18:40:51.669]    + additional namespaces needed: [n=0] 
[18:40:51.670]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:51.670]  - seeds: <none>
[18:40:51.670]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.670] getGlobalsAndPackages() ...
[18:40:51.670] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.670] Resolving globals: FALSE
[18:40:51.671] Tweak future expression to call with '...' arguments ...
[18:40:51.671] {
[18:40:51.671]     do.call(function(...) {
[18:40:51.671]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.671]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.671]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.671]             on.exit(options(oopts), add = TRUE)
[18:40:51.671]         }
[18:40:51.671]         {
[18:40:51.671]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.671]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.671]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.671]             })
[18:40:51.671]         }
[18:40:51.671]     }, args = future.call.arguments)
[18:40:51.671] }
[18:40:51.671] Tweak future expression to call with '...' arguments ... DONE
[18:40:51.672] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:51.672] 
[18:40:51.672] getGlobalsAndPackages() ... DONE
[18:40:51.673] run() for 'Future' ...
[18:40:51.673] - state: 'created'
[18:40:51.673] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[18:40:51.673] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.674] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[18:40:51.674]   - Field: 'label'
[18:40:51.674]   - Field: 'local'
[18:40:51.674]   - Field: 'owner'
[18:40:51.674]   - Field: 'envir'
[18:40:51.675]   - Field: 'packages'
[18:40:51.675]   - Field: 'gc'
[18:40:51.675]   - Field: 'conditions'
[18:40:51.675]   - Field: 'expr'
[18:40:51.675]   - Field: 'uuid'
[18:40:51.676]   - Field: 'seed'
[18:40:51.676]   - Field: 'version'
[18:40:51.676]   - Field: 'result'
[18:40:51.676]   - Field: 'asynchronous'
[18:40:51.676]   - Field: 'calls'
[18:40:51.676]   - Field: 'globals'
[18:40:51.677]   - Field: 'stdout'
[18:40:51.677]   - Field: 'earlySignal'
[18:40:51.677]   - Field: 'lazy'
[18:40:51.677]   - Field: 'state'
[18:40:51.677] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[18:40:51.678] - Launch lazy future ...
[18:40:51.678] Packages needed by the future expression (n = 0): <none>
[18:40:51.678] Packages needed by future strategies (n = 0): <none>
[18:40:51.679] {
[18:40:51.679]     {
[18:40:51.679]         {
[18:40:51.679]             ...future.startTime <- base::Sys.time()
[18:40:51.679]             {
[18:40:51.679]                 {
[18:40:51.679]                   {
[18:40:51.679]                     base::local({
[18:40:51.679]                       has_future <- base::requireNamespace("future", 
[18:40:51.679]                         quietly = TRUE)
[18:40:51.679]                       if (has_future) {
[18:40:51.679]                         ns <- base::getNamespace("future")
[18:40:51.679]                         version <- ns[[".package"]][["version"]]
[18:40:51.679]                         if (is.null(version)) 
[18:40:51.679]                           version <- utils::packageVersion("future")
[18:40:51.679]                       }
[18:40:51.679]                       else {
[18:40:51.679]                         version <- NULL
[18:40:51.679]                       }
[18:40:51.679]                       if (!has_future || version < "1.8.0") {
[18:40:51.679]                         info <- base::c(r_version = base::gsub("R version ", 
[18:40:51.679]                           "", base::R.version$version.string), 
[18:40:51.679]                           platform = base::sprintf("%s (%s-bit)", 
[18:40:51.679]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:51.679]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:51.679]                             "release", "version")], collapse = " "), 
[18:40:51.679]                           hostname = base::Sys.info()[["nodename"]])
[18:40:51.679]                         info <- base::sprintf("%s: %s", base::names(info), 
[18:40:51.679]                           info)
[18:40:51.679]                         info <- base::paste(info, collapse = "; ")
[18:40:51.679]                         if (!has_future) {
[18:40:51.679]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:51.679]                             info)
[18:40:51.679]                         }
[18:40:51.679]                         else {
[18:40:51.679]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:51.679]                             info, version)
[18:40:51.679]                         }
[18:40:51.679]                         base::stop(msg)
[18:40:51.679]                       }
[18:40:51.679]                     })
[18:40:51.679]                   }
[18:40:51.679]                   ...future.strategy.old <- future::plan("list")
[18:40:51.679]                   options(future.plan = NULL)
[18:40:51.679]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.679]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:51.679]                 }
[18:40:51.679]                 ...future.workdir <- getwd()
[18:40:51.679]             }
[18:40:51.679]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:51.679]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:51.679]         }
[18:40:51.679]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:51.679]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:51.679]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:51.679]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:51.679]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:51.679]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:51.679]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:51.679]             base::names(...future.oldOptions))
[18:40:51.679]     }
[18:40:51.679]     if (FALSE) {
[18:40:51.679]     }
[18:40:51.679]     else {
[18:40:51.679]         if (TRUE) {
[18:40:51.679]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:51.679]                 open = "w")
[18:40:51.679]         }
[18:40:51.679]         else {
[18:40:51.679]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:51.679]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:51.679]         }
[18:40:51.679]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:51.679]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:51.679]             base::sink(type = "output", split = FALSE)
[18:40:51.679]             base::close(...future.stdout)
[18:40:51.679]         }, add = TRUE)
[18:40:51.679]     }
[18:40:51.679]     ...future.frame <- base::sys.nframe()
[18:40:51.679]     ...future.conditions <- base::list()
[18:40:51.679]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:51.679]     if (FALSE) {
[18:40:51.679]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:51.679]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:51.679]     }
[18:40:51.679]     ...future.result <- base::tryCatch({
[18:40:51.679]         base::withCallingHandlers({
[18:40:51.679]             ...future.value <- base::withVisible(base::local({
[18:40:51.679]                 do.call(function(...) {
[18:40:51.679]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.679]                   if (!identical(...future.globals.maxSize.org, 
[18:40:51.679]                     ...future.globals.maxSize)) {
[18:40:51.679]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.679]                     on.exit(options(oopts), add = TRUE)
[18:40:51.679]                   }
[18:40:51.679]                   {
[18:40:51.679]                     lapply(seq_along(...future.elements_ii), 
[18:40:51.679]                       FUN = function(jj) {
[18:40:51.679]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.679]                         ...future.FUN(...future.X_jj, ...)
[18:40:51.679]                       })
[18:40:51.679]                   }
[18:40:51.679]                 }, args = future.call.arguments)
[18:40:51.679]             }))
[18:40:51.679]             future::FutureResult(value = ...future.value$value, 
[18:40:51.679]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.679]                   ...future.rng), globalenv = if (FALSE) 
[18:40:51.679]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:51.679]                     ...future.globalenv.names))
[18:40:51.679]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:51.679]         }, condition = base::local({
[18:40:51.679]             c <- base::c
[18:40:51.679]             inherits <- base::inherits
[18:40:51.679]             invokeRestart <- base::invokeRestart
[18:40:51.679]             length <- base::length
[18:40:51.679]             list <- base::list
[18:40:51.679]             seq.int <- base::seq.int
[18:40:51.679]             signalCondition <- base::signalCondition
[18:40:51.679]             sys.calls <- base::sys.calls
[18:40:51.679]             `[[` <- base::`[[`
[18:40:51.679]             `+` <- base::`+`
[18:40:51.679]             `<<-` <- base::`<<-`
[18:40:51.679]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:51.679]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:51.679]                   3L)]
[18:40:51.679]             }
[18:40:51.679]             function(cond) {
[18:40:51.679]                 is_error <- inherits(cond, "error")
[18:40:51.679]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:51.679]                   NULL)
[18:40:51.679]                 if (is_error) {
[18:40:51.679]                   sessionInformation <- function() {
[18:40:51.679]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:51.679]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:51.679]                       search = base::search(), system = base::Sys.info())
[18:40:51.679]                   }
[18:40:51.679]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.679]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:51.679]                     cond$call), session = sessionInformation(), 
[18:40:51.679]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:51.679]                   signalCondition(cond)
[18:40:51.679]                 }
[18:40:51.679]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:51.679]                 "immediateCondition"))) {
[18:40:51.679]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:51.679]                   ...future.conditions[[length(...future.conditions) + 
[18:40:51.679]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:51.679]                   if (TRUE && !signal) {
[18:40:51.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.679]                     {
[18:40:51.679]                       inherits <- base::inherits
[18:40:51.679]                       invokeRestart <- base::invokeRestart
[18:40:51.679]                       is.null <- base::is.null
[18:40:51.679]                       muffled <- FALSE
[18:40:51.679]                       if (inherits(cond, "message")) {
[18:40:51.679]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.679]                         if (muffled) 
[18:40:51.679]                           invokeRestart("muffleMessage")
[18:40:51.679]                       }
[18:40:51.679]                       else if (inherits(cond, "warning")) {
[18:40:51.679]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.679]                         if (muffled) 
[18:40:51.679]                           invokeRestart("muffleWarning")
[18:40:51.679]                       }
[18:40:51.679]                       else if (inherits(cond, "condition")) {
[18:40:51.679]                         if (!is.null(pattern)) {
[18:40:51.679]                           computeRestarts <- base::computeRestarts
[18:40:51.679]                           grepl <- base::grepl
[18:40:51.679]                           restarts <- computeRestarts(cond)
[18:40:51.679]                           for (restart in restarts) {
[18:40:51.679]                             name <- restart$name
[18:40:51.679]                             if (is.null(name)) 
[18:40:51.679]                               next
[18:40:51.679]                             if (!grepl(pattern, name)) 
[18:40:51.679]                               next
[18:40:51.679]                             invokeRestart(restart)
[18:40:51.679]                             muffled <- TRUE
[18:40:51.679]                             break
[18:40:51.679]                           }
[18:40:51.679]                         }
[18:40:51.679]                       }
[18:40:51.679]                       invisible(muffled)
[18:40:51.679]                     }
[18:40:51.679]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.679]                   }
[18:40:51.679]                 }
[18:40:51.679]                 else {
[18:40:51.679]                   if (TRUE) {
[18:40:51.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:51.679]                     {
[18:40:51.679]                       inherits <- base::inherits
[18:40:51.679]                       invokeRestart <- base::invokeRestart
[18:40:51.679]                       is.null <- base::is.null
[18:40:51.679]                       muffled <- FALSE
[18:40:51.679]                       if (inherits(cond, "message")) {
[18:40:51.679]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:51.679]                         if (muffled) 
[18:40:51.679]                           invokeRestart("muffleMessage")
[18:40:51.679]                       }
[18:40:51.679]                       else if (inherits(cond, "warning")) {
[18:40:51.679]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:51.679]                         if (muffled) 
[18:40:51.679]                           invokeRestart("muffleWarning")
[18:40:51.679]                       }
[18:40:51.679]                       else if (inherits(cond, "condition")) {
[18:40:51.679]                         if (!is.null(pattern)) {
[18:40:51.679]                           computeRestarts <- base::computeRestarts
[18:40:51.679]                           grepl <- base::grepl
[18:40:51.679]                           restarts <- computeRestarts(cond)
[18:40:51.679]                           for (restart in restarts) {
[18:40:51.679]                             name <- restart$name
[18:40:51.679]                             if (is.null(name)) 
[18:40:51.679]                               next
[18:40:51.679]                             if (!grepl(pattern, name)) 
[18:40:51.679]                               next
[18:40:51.679]                             invokeRestart(restart)
[18:40:51.679]                             muffled <- TRUE
[18:40:51.679]                             break
[18:40:51.679]                           }
[18:40:51.679]                         }
[18:40:51.679]                       }
[18:40:51.679]                       invisible(muffled)
[18:40:51.679]                     }
[18:40:51.679]                     muffleCondition(cond, pattern = "^muffle")
[18:40:51.679]                   }
[18:40:51.679]                 }
[18:40:51.679]             }
[18:40:51.679]         }))
[18:40:51.679]     }, error = function(ex) {
[18:40:51.679]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:51.679]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:51.679]                 ...future.rng), started = ...future.startTime, 
[18:40:51.679]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:51.679]             version = "1.8"), class = "FutureResult")
[18:40:51.679]     }, finally = {
[18:40:51.679]         if (!identical(...future.workdir, getwd())) 
[18:40:51.679]             setwd(...future.workdir)
[18:40:51.679]         {
[18:40:51.679]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:51.679]                 ...future.oldOptions$nwarnings <- NULL
[18:40:51.679]             }
[18:40:51.679]             base::options(...future.oldOptions)
[18:40:51.679]             if (.Platform$OS.type == "windows") {
[18:40:51.679]                 old_names <- names(...future.oldEnvVars)
[18:40:51.679]                 envs <- base::Sys.getenv()
[18:40:51.679]                 names <- names(envs)
[18:40:51.679]                 common <- intersect(names, old_names)
[18:40:51.679]                 added <- setdiff(names, old_names)
[18:40:51.679]                 removed <- setdiff(old_names, names)
[18:40:51.679]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:51.679]                   envs[common]]
[18:40:51.679]                 NAMES <- toupper(changed)
[18:40:51.679]                 args <- list()
[18:40:51.679]                 for (kk in seq_along(NAMES)) {
[18:40:51.679]                   name <- changed[[kk]]
[18:40:51.679]                   NAME <- NAMES[[kk]]
[18:40:51.679]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.679]                     next
[18:40:51.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.679]                 }
[18:40:51.679]                 NAMES <- toupper(added)
[18:40:51.679]                 for (kk in seq_along(NAMES)) {
[18:40:51.679]                   name <- added[[kk]]
[18:40:51.679]                   NAME <- NAMES[[kk]]
[18:40:51.679]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.679]                     next
[18:40:51.679]                   args[[name]] <- ""
[18:40:51.679]                 }
[18:40:51.679]                 NAMES <- toupper(removed)
[18:40:51.679]                 for (kk in seq_along(NAMES)) {
[18:40:51.679]                   name <- removed[[kk]]
[18:40:51.679]                   NAME <- NAMES[[kk]]
[18:40:51.679]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:51.679]                     next
[18:40:51.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:51.679]                 }
[18:40:51.679]                 if (length(args) > 0) 
[18:40:51.679]                   base::do.call(base::Sys.setenv, args = args)
[18:40:51.679]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:51.679]             }
[18:40:51.679]             else {
[18:40:51.679]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:51.679]             }
[18:40:51.679]             {
[18:40:51.679]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:51.679]                   0L) {
[18:40:51.679]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:51.679]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:51.679]                   base::options(opts)
[18:40:51.679]                 }
[18:40:51.679]                 {
[18:40:51.679]                   {
[18:40:51.679]                     NULL
[18:40:51.679]                     RNGkind("Mersenne-Twister")
[18:40:51.679]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[18:40:51.679]                       inherits = FALSE)
[18:40:51.679]                   }
[18:40:51.679]                   options(future.plan = NULL)
[18:40:51.679]                   if (is.na(NA_character_)) 
[18:40:51.679]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:51.679]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:51.679]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:51.679]                     .init = FALSE)
[18:40:51.679]                 }
[18:40:51.679]             }
[18:40:51.679]         }
[18:40:51.679]     })
[18:40:51.679]     if (TRUE) {
[18:40:51.679]         base::sink(type = "output", split = FALSE)
[18:40:51.679]         if (TRUE) {
[18:40:51.679]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:51.679]         }
[18:40:51.679]         else {
[18:40:51.679]             ...future.result["stdout"] <- base::list(NULL)
[18:40:51.679]         }
[18:40:51.679]         base::close(...future.stdout)
[18:40:51.679]         ...future.stdout <- NULL
[18:40:51.679]     }
[18:40:51.679]     ...future.result$conditions <- ...future.conditions
[18:40:51.679]     ...future.result$finished <- base::Sys.time()
[18:40:51.679]     ...future.result
[18:40:51.679] }
[18:40:51.683] assign_globals() ...
[18:40:51.683] List of 5
[18:40:51.683]  $ ...future.FUN            :function (object, ...)  
[18:40:51.683]  $ future.call.arguments    : list()
[18:40:51.683]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:51.683]  $ ...future.elements_ii    :List of 3
[18:40:51.683]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.683]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[18:40:51.683]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.683]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:51.683]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.683]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[18:40:51.683]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.683]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[18:40:51.683]   ..$ :'data.frame':	18 obs. of  3 variables:
[18:40:51.683]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[18:40:51.683]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[18:40:51.683]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[18:40:51.683]  $ ...future.seeds_ii       : NULL
[18:40:51.683]  $ ...future.globals.maxSize: NULL
[18:40:51.683]  - attr(*, "where")=List of 5
[18:40:51.683]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[18:40:51.683]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[18:40:51.683]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[18:40:51.683]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[18:40:51.683]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[18:40:51.683]  - attr(*, "resolved")= logi FALSE
[18:40:51.683]  - attr(*, "total_size")= num 18647
[18:40:51.683]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:51.683]  - attr(*, "already-done")= logi TRUE
[18:40:51.695] - copied '...future.FUN' to environment
[18:40:51.696] - copied 'future.call.arguments' to environment
[18:40:51.696] - copied '...future.elements_ii' to environment
[18:40:51.696] - copied '...future.seeds_ii' to environment
[18:40:51.696] - copied '...future.globals.maxSize' to environment
[18:40:51.696] assign_globals() ... done
[18:40:51.697] plan(): Setting new future strategy stack:
[18:40:51.697] List of future strategies:
[18:40:51.697] 1. sequential:
[18:40:51.697]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.697]    - tweaked: FALSE
[18:40:51.697]    - call: NULL
[18:40:51.697] plan(): nbrOfWorkers() = 1
[18:40:51.700] plan(): Setting new future strategy stack:
[18:40:51.701] List of future strategies:
[18:40:51.701] 1. sequential:
[18:40:51.701]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:51.701]    - tweaked: FALSE
[18:40:51.701]    - call: plan(strategy)
[18:40:51.701] plan(): nbrOfWorkers() = 1
[18:40:51.702] SequentialFuture started (and completed)
[18:40:51.702] - Launch lazy future ... done
[18:40:51.702] run() for 'SequentialFuture' ... done
[18:40:51.702] Created future:
[18:40:51.702] SequentialFuture:
[18:40:51.702] Label: 'future_by-1'
[18:40:51.702] Expression:
[18:40:51.702] {
[18:40:51.702]     do.call(function(...) {
[18:40:51.702]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:51.702]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:51.702]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:51.702]             on.exit(options(oopts), add = TRUE)
[18:40:51.702]         }
[18:40:51.702]         {
[18:40:51.702]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:51.702]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:51.702]                 ...future.FUN(...future.X_jj, ...)
[18:40:51.702]             })
[18:40:51.702]         }
[18:40:51.702]     }, args = future.call.arguments)
[18:40:51.702] }
[18:40:51.702] Lazy evaluation: FALSE
[18:40:51.702] Asynchronous evaluation: FALSE
[18:40:51.702] Local evaluation: TRUE
[18:40:51.702] Environment: 0x000001cd5193a278
[18:40:51.702] Capture standard output: TRUE
[18:40:51.702] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:51.702] Globals: 5 objects totaling 2.41 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.98 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:51.702] Packages: <none>
[18:40:51.702] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:51.702] Resolved: TRUE
[18:40:51.702] Value: 1.39 KiB of class 'list'
[18:40:51.702] Early signaling: FALSE
[18:40:51.702] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:51.702] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[18:40:51.703] Chunk #1 of 1 ... DONE
[18:40:51.704] Launching 1 futures (chunks) ... DONE
[18:40:51.704] Resolving 1 futures (chunks) ...
[18:40:51.704] resolve() on list ...
[18:40:51.704]  recursive: 0
[18:40:51.704]  length: 1
[18:40:51.704] 
[18:40:51.705] resolved() for 'SequentialFuture' ...
[18:40:51.705] - state: 'finished'
[18:40:51.705] - run: TRUE
[18:40:51.705] - result: 'FutureResult'
[18:40:51.705] resolved() for 'SequentialFuture' ... done
[18:40:51.706] Future #1
[18:40:51.706] signalConditionsASAP(SequentialFuture, pos=1) ...
[18:40:51.706] - nx: 1
[18:40:51.706] - relay: TRUE
[18:40:51.706] - stdout: TRUE
[18:40:51.706] - signal: TRUE
[18:40:51.707] - resignal: FALSE
[18:40:51.707] - force: TRUE
[18:40:51.707] - relayed: [n=1] FALSE
[18:40:51.707] - queued futures: [n=1] FALSE
[18:40:51.707]  - until=1
[18:40:51.707]  - relaying element #1
[18:40:51.708] - relayed: [n=1] TRUE
[18:40:51.708] - queued futures: [n=1] TRUE
[18:40:51.708] signalConditionsASAP(SequentialFuture, pos=1) ... done
[18:40:51.708]  length: 0 (resolved future 1)
[18:40:51.708] Relaying remaining futures
[18:40:51.708] signalConditionsASAP(NULL, pos=0) ...
[18:40:51.709] - nx: 1
[18:40:51.709] - relay: TRUE
[18:40:51.709] - stdout: TRUE
[18:40:51.709] - signal: TRUE
[18:40:51.709] - resignal: FALSE
[18:40:51.709] - force: TRUE
[18:40:51.709] - relayed: [n=1] TRUE
[18:40:51.710] - queued futures: [n=1] TRUE
 - flush all
[18:40:51.710] - relayed: [n=1] TRUE
[18:40:51.710] - queued futures: [n=1] TRUE
[18:40:51.710] signalConditionsASAP(NULL, pos=0) ... done
[18:40:51.710] resolve() on list ... DONE
[18:40:51.711]  - Number of value chunks collected: 1
[18:40:51.711] Resolving 1 futures (chunks) ... DONE
[18:40:51.711] Reducing values from 1 chunks ...
[18:40:51.711]  - Number of values collected after concatenation: 3
[18:40:51.711]  - Number of values expected: 3
[18:40:51.711] Reducing values from 1 chunks ... DONE
[18:40:51.711] future_lapply() ... DONE
[18:40:51.712] future_by_internal() ... DONE
[18:40:51.713] future_by_internal() ...
- plan('multisession') ...
[18:40:51.713] plan(): Setting new future strategy stack:
[18:40:51.713] List of future strategies:
[18:40:51.713] 1. multisession:
[18:40:51.713]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.713]    - tweaked: FALSE
[18:40:51.713]    - call: plan(strategy)
[18:40:51.714] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[18:40:51.714] multisession:
[18:40:51.714] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[18:40:51.714] - tweaked: FALSE
[18:40:51.714] - call: plan(strategy)
[18:40:51.718] getGlobalsAndPackages() ...
[18:40:51.718] Not searching for globals
[18:40:51.718] - globals: [0] <none>
[18:40:51.719] getGlobalsAndPackages() ... DONE
[18:40:51.719] [local output] makeClusterPSOCK() ...
[18:40:51.757] [local output] Workers: [n = 2] 'localhost', 'localhost'
[18:40:51.764] [local output] Base port: 32045
[18:40:51.764] [local output] Getting setup options for 2 cluster nodes ...
[18:40:51.765] [local output]  - Node #1 of 2 ...
[18:40:51.765] [local output] localMachine=TRUE => revtunnel=FALSE

[18:40:51.767] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmpo3xMbx/worker.rank=1.parallelly.parent=154428.25b3c5a2a4c6f.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/Rtmpo3xMbx/worker.rank=1.parallelly.parent=154428.25b3c5a2a4c6f.pid\")"'
[18:40:52.203] - Possible to infer worker's PID: TRUE
[18:40:52.203] [local output] Rscript port: 32045

[18:40:52.204] [local output]  - Node #2 of 2 ...
[18:40:52.205] [local output] localMachine=TRUE => revtunnel=FALSE

[18:40:52.206] [local output] Rscript port: 32045

[18:40:52.206] [local output] Getting setup options for 2 cluster nodes ... done
[18:40:52.207] [local output]  - Parallel setup requested for some PSOCK nodes
[18:40:52.207] [local output] Setting up PSOCK nodes in parallel
[18:40:52.208] List of 36
[18:40:52.208]  $ worker          : chr "localhost"
[18:40:52.208]   ..- attr(*, "localhost")= logi TRUE
[18:40:52.208]  $ master          : chr "localhost"
[18:40:52.208]  $ port            : int 32045
[18:40:52.208]  $ connectTimeout  : num 120
[18:40:52.208]  $ timeout         : num 120
[18:40:52.208]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[18:40:52.208]  $ homogeneous     : logi TRUE
[18:40:52.208]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_by.R:154428:CRANWIN3:CRAN"| __truncated__
[18:40:52.208]  $ rscript_envs    : NULL
[18:40:52.208]  $ rscript_libs    : chr [1:2] "D:/temp/Rtmpi4y3mu/RLIBS_25080533fa8" "D:/RCompile/recent/R/library"
[18:40:52.208]  $ rscript_startup : NULL
[18:40:52.208]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[18:40:52.208]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:40:52.208]  $ methods         : logi TRUE
[18:40:52.208]  $ socketOptions   : chr "no-delay"
[18:40:52.208]  $ useXDR          : logi FALSE
[18:40:52.208]  $ outfile         : chr "/dev/null"
[18:40:52.208]  $ renice          : int NA
[18:40:52.208]  $ rshcmd          : NULL
[18:40:52.208]  $ user            : chr(0) 
[18:40:52.208]  $ revtunnel       : logi FALSE
[18:40:52.208]  $ rshlogfile      : NULL
[18:40:52.208]  $ rshopts         : chr(0) 
[18:40:52.208]  $ rank            : int 1
[18:40:52.208]  $ manual          : logi FALSE
[18:40:52.208]  $ dryrun          : logi FALSE
[18:40:52.208]  $ quiet           : logi FALSE
[18:40:52.208]  $ setup_strategy  : chr "parallel"
[18:40:52.208]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:40:52.208]  $ pidfile         : chr "D:/temp/Rtmpo3xMbx/worker.rank=1.parallelly.parent=154428.25b3c5a2a4c6f.pid"
[18:40:52.208]  $ rshcmd_label    : NULL
[18:40:52.208]  $ rsh_call        : NULL
[18:40:52.208]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[18:40:52.208]  $ localMachine    : logi TRUE
[18:40:52.208]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[18:40:52.208]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[18:40:52.208]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[18:40:52.208]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[18:40:52.208]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[18:40:52.208]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[18:40:52.208]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[18:40:52.208]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[18:40:52.208]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[18:40:52.208]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[18:40:52.208]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[18:40:52.208]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[18:40:52.208]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[18:40:52.208]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[18:40:52.208]  $ arguments       :List of 28
[18:40:52.208]   ..$ worker          : chr "localhost"
[18:40:52.208]   ..$ master          : NULL
[18:40:52.208]   ..$ port            : int 32045
[18:40:52.208]   ..$ connectTimeout  : num 120
[18:40:52.208]   ..$ timeout         : num 120
[18:40:52.208]   ..$ rscript         : NULL
[18:40:52.208]   ..$ homogeneous     : NULL
[18:40:52.208]   ..$ rscript_args    : NULL
[18:40:52.208]   ..$ rscript_envs    : NULL
[18:40:52.208]   ..$ rscript_libs    : chr [1:2] "D:/temp/Rtmpi4y3mu/RLIBS_25080533fa8" "D:/RCompile/recent/R/library"
[18:40:52.208]   ..$ rscript_startup : NULL
[18:40:52.208]   ..$ rscript_sh      : chr "auto"
[18:40:52.208]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[18:40:52.208]   ..$ methods         : logi TRUE
[18:40:52.208]   ..$ socketOptions   : chr "no-delay"
[18:40:52.208]   ..$ useXDR          : logi FALSE
[18:40:52.208]   ..$ outfile         : chr "/dev/null"
[18:40:52.208]   ..$ renice          : int NA
[18:40:52.208]   ..$ rshcmd          : NULL
[18:40:52.208]   ..$ user            : NULL
[18:40:52.208]   ..$ revtunnel       : logi NA
[18:40:52.208]   ..$ rshlogfile      : NULL
[18:40:52.208]   ..$ rshopts         : NULL
[18:40:52.208]   ..$ rank            : int 1
[18:40:52.208]   ..$ manual          : logi FALSE
[18:40:52.208]   ..$ dryrun          : logi FALSE
[18:40:52.208]   ..$ quiet           : logi FALSE
[18:40:52.208]   ..$ setup_strategy  : chr "parallel"
[18:40:52.208]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[18:40:52.228] [local output] System call to launch all workers:
[18:40:52.228] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_by.R:154428:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmpo3xMbx/worker.rank=1.parallelly.parent=154428.25b3c5a2a4c6f.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/Rtmpi4y3mu/RLIBS_25080533fa8\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=32045 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[18:40:52.229] [local output] Starting PSOCK main server
[18:40:52.235] [local output] Workers launched
[18:40:52.235] [local output] Waiting for workers to connect back
[18:40:52.235]  - [local output] 0 workers out of 2 ready
[18:40:52.459]  - [local output] 0 workers out of 2 ready
[18:40:52.459]  - [local output] 1 workers out of 2 ready
[18:40:52.486]  - [local output] 1 workers out of 2 ready
[18:40:52.486]  - [local output] 2 workers out of 2 ready
[18:40:52.486] [local output] Launching of 2 workers completed
[18:40:52.486] [local output] Number of nodes in cluster: 2
[18:40:52.487] [local output] Collecting session information from 2 workers
[18:40:52.488] [local output]  - Worker #1 of 2
[18:40:52.489] [local output]  - Worker #2 of 2
[18:40:52.489] [local output] makeClusterPSOCK() ... done
[18:40:52.503] Packages needed by the future expression (n = 0): <none>
[18:40:52.503] Packages needed by future strategies (n = 0): <none>
[18:40:52.504] {
[18:40:52.504]     {
[18:40:52.504]         {
[18:40:52.504]             ...future.startTime <- base::Sys.time()
[18:40:52.504]             {
[18:40:52.504]                 {
[18:40:52.504]                   {
[18:40:52.504]                     {
[18:40:52.504]                       base::local({
[18:40:52.504]                         has_future <- base::requireNamespace("future", 
[18:40:52.504]                           quietly = TRUE)
[18:40:52.504]                         if (has_future) {
[18:40:52.504]                           ns <- base::getNamespace("future")
[18:40:52.504]                           version <- ns[[".package"]][["version"]]
[18:40:52.504]                           if (is.null(version)) 
[18:40:52.504]                             version <- utils::packageVersion("future")
[18:40:52.504]                         }
[18:40:52.504]                         else {
[18:40:52.504]                           version <- NULL
[18:40:52.504]                         }
[18:40:52.504]                         if (!has_future || version < "1.8.0") {
[18:40:52.504]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:52.504]                             "", base::R.version$version.string), 
[18:40:52.504]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:52.504]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:52.504]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:52.504]                               "release", "version")], collapse = " "), 
[18:40:52.504]                             hostname = base::Sys.info()[["nodename"]])
[18:40:52.504]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:52.504]                             info)
[18:40:52.504]                           info <- base::paste(info, collapse = "; ")
[18:40:52.504]                           if (!has_future) {
[18:40:52.504]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:52.504]                               info)
[18:40:52.504]                           }
[18:40:52.504]                           else {
[18:40:52.504]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:52.504]                               info, version)
[18:40:52.504]                           }
[18:40:52.504]                           base::stop(msg)
[18:40:52.504]                         }
[18:40:52.504]                       })
[18:40:52.504]                     }
[18:40:52.504]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:52.504]                     base::options(mc.cores = 1L)
[18:40:52.504]                   }
[18:40:52.504]                   ...future.strategy.old <- future::plan("list")
[18:40:52.504]                   options(future.plan = NULL)
[18:40:52.504]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.504]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:52.504]                 }
[18:40:52.504]                 ...future.workdir <- getwd()
[18:40:52.504]             }
[18:40:52.504]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:52.504]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:52.504]         }
[18:40:52.504]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:52.504]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[18:40:52.504]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:52.504]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:52.504]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:52.504]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:52.504]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:52.504]             base::names(...future.oldOptions))
[18:40:52.504]     }
[18:40:52.504]     if (FALSE) {
[18:40:52.504]     }
[18:40:52.504]     else {
[18:40:52.504]         if (TRUE) {
[18:40:52.504]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:52.504]                 open = "w")
[18:40:52.504]         }
[18:40:52.504]         else {
[18:40:52.504]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:52.504]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:52.504]         }
[18:40:52.504]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:52.504]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:52.504]             base::sink(type = "output", split = FALSE)
[18:40:52.504]             base::close(...future.stdout)
[18:40:52.504]         }, add = TRUE)
[18:40:52.504]     }
[18:40:52.504]     ...future.frame <- base::sys.nframe()
[18:40:52.504]     ...future.conditions <- base::list()
[18:40:52.504]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:52.504]     if (FALSE) {
[18:40:52.504]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:52.504]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:52.504]     }
[18:40:52.504]     ...future.result <- base::tryCatch({
[18:40:52.504]         base::withCallingHandlers({
[18:40:52.504]             ...future.value <- base::withVisible(base::local({
[18:40:52.504]                 ...future.makeSendCondition <- base::local({
[18:40:52.504]                   sendCondition <- NULL
[18:40:52.504]                   function(frame = 1L) {
[18:40:52.504]                     if (is.function(sendCondition)) 
[18:40:52.504]                       return(sendCondition)
[18:40:52.504]                     ns <- getNamespace("parallel")
[18:40:52.504]                     if (exists("sendData", mode = "function", 
[18:40:52.504]                       envir = ns)) {
[18:40:52.504]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:52.504]                         envir = ns)
[18:40:52.504]                       envir <- sys.frame(frame)
[18:40:52.504]                       master <- NULL
[18:40:52.504]                       while (!identical(envir, .GlobalEnv) && 
[18:40:52.504]                         !identical(envir, emptyenv())) {
[18:40:52.504]                         if (exists("master", mode = "list", envir = envir, 
[18:40:52.504]                           inherits = FALSE)) {
[18:40:52.504]                           master <- get("master", mode = "list", 
[18:40:52.504]                             envir = envir, inherits = FALSE)
[18:40:52.504]                           if (inherits(master, c("SOCKnode", 
[18:40:52.504]                             "SOCK0node"))) {
[18:40:52.504]                             sendCondition <<- function(cond) {
[18:40:52.504]                               data <- list(type = "VALUE", value = cond, 
[18:40:52.504]                                 success = TRUE)
[18:40:52.504]                               parallel_sendData(master, data)
[18:40:52.504]                             }
[18:40:52.504]                             return(sendCondition)
[18:40:52.504]                           }
[18:40:52.504]                         }
[18:40:52.504]                         frame <- frame + 1L
[18:40:52.504]                         envir <- sys.frame(frame)
[18:40:52.504]                       }
[18:40:52.504]                     }
[18:40:52.504]                     sendCondition <<- function(cond) NULL
[18:40:52.504]                   }
[18:40:52.504]                 })
[18:40:52.504]                 withCallingHandlers({
[18:40:52.504]                   NA
[18:40:52.504]                 }, immediateCondition = function(cond) {
[18:40:52.504]                   sendCondition <- ...future.makeSendCondition()
[18:40:52.504]                   sendCondition(cond)
[18:40:52.504]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.504]                   {
[18:40:52.504]                     inherits <- base::inherits
[18:40:52.504]                     invokeRestart <- base::invokeRestart
[18:40:52.504]                     is.null <- base::is.null
[18:40:52.504]                     muffled <- FALSE
[18:40:52.504]                     if (inherits(cond, "message")) {
[18:40:52.504]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:52.504]                       if (muffled) 
[18:40:52.504]                         invokeRestart("muffleMessage")
[18:40:52.504]                     }
[18:40:52.504]                     else if (inherits(cond, "warning")) {
[18:40:52.504]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:52.504]                       if (muffled) 
[18:40:52.504]                         invokeRestart("muffleWarning")
[18:40:52.504]                     }
[18:40:52.504]                     else if (inherits(cond, "condition")) {
[18:40:52.504]                       if (!is.null(pattern)) {
[18:40:52.504]                         computeRestarts <- base::computeRestarts
[18:40:52.504]                         grepl <- base::grepl
[18:40:52.504]                         restarts <- computeRestarts(cond)
[18:40:52.504]                         for (restart in restarts) {
[18:40:52.504]                           name <- restart$name
[18:40:52.504]                           if (is.null(name)) 
[18:40:52.504]                             next
[18:40:52.504]                           if (!grepl(pattern, name)) 
[18:40:52.504]                             next
[18:40:52.504]                           invokeRestart(restart)
[18:40:52.504]                           muffled <- TRUE
[18:40:52.504]                           break
[18:40:52.504]                         }
[18:40:52.504]                       }
[18:40:52.504]                     }
[18:40:52.504]                     invisible(muffled)
[18:40:52.504]                   }
[18:40:52.504]                   muffleCondition(cond)
[18:40:52.504]                 })
[18:40:52.504]             }))
[18:40:52.504]             future::FutureResult(value = ...future.value$value, 
[18:40:52.504]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.504]                   ...future.rng), globalenv = if (FALSE) 
[18:40:52.504]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:52.504]                     ...future.globalenv.names))
[18:40:52.504]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:52.504]         }, condition = base::local({
[18:40:52.504]             c <- base::c
[18:40:52.504]             inherits <- base::inherits
[18:40:52.504]             invokeRestart <- base::invokeRestart
[18:40:52.504]             length <- base::length
[18:40:52.504]             list <- base::list
[18:40:52.504]             seq.int <- base::seq.int
[18:40:52.504]             signalCondition <- base::signalCondition
[18:40:52.504]             sys.calls <- base::sys.calls
[18:40:52.504]             `[[` <- base::`[[`
[18:40:52.504]             `+` <- base::`+`
[18:40:52.504]             `<<-` <- base::`<<-`
[18:40:52.504]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:52.504]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:52.504]                   3L)]
[18:40:52.504]             }
[18:40:52.504]             function(cond) {
[18:40:52.504]                 is_error <- inherits(cond, "error")
[18:40:52.504]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:52.504]                   NULL)
[18:40:52.504]                 if (is_error) {
[18:40:52.504]                   sessionInformation <- function() {
[18:40:52.504]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:52.504]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:52.504]                       search = base::search(), system = base::Sys.info())
[18:40:52.504]                   }
[18:40:52.504]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.504]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:52.504]                     cond$call), session = sessionInformation(), 
[18:40:52.504]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:52.504]                   signalCondition(cond)
[18:40:52.504]                 }
[18:40:52.504]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:52.504]                 "immediateCondition"))) {
[18:40:52.504]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:52.504]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.504]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:52.504]                   if (TRUE && !signal) {
[18:40:52.504]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.504]                     {
[18:40:52.504]                       inherits <- base::inherits
[18:40:52.504]                       invokeRestart <- base::invokeRestart
[18:40:52.504]                       is.null <- base::is.null
[18:40:52.504]                       muffled <- FALSE
[18:40:52.504]                       if (inherits(cond, "message")) {
[18:40:52.504]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.504]                         if (muffled) 
[18:40:52.504]                           invokeRestart("muffleMessage")
[18:40:52.504]                       }
[18:40:52.504]                       else if (inherits(cond, "warning")) {
[18:40:52.504]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.504]                         if (muffled) 
[18:40:52.504]                           invokeRestart("muffleWarning")
[18:40:52.504]                       }
[18:40:52.504]                       else if (inherits(cond, "condition")) {
[18:40:52.504]                         if (!is.null(pattern)) {
[18:40:52.504]                           computeRestarts <- base::computeRestarts
[18:40:52.504]                           grepl <- base::grepl
[18:40:52.504]                           restarts <- computeRestarts(cond)
[18:40:52.504]                           for (restart in restarts) {
[18:40:52.504]                             name <- restart$name
[18:40:52.504]                             if (is.null(name)) 
[18:40:52.504]                               next
[18:40:52.504]                             if (!grepl(pattern, name)) 
[18:40:52.504]                               next
[18:40:52.504]                             invokeRestart(restart)
[18:40:52.504]                             muffled <- TRUE
[18:40:52.504]                             break
[18:40:52.504]                           }
[18:40:52.504]                         }
[18:40:52.504]                       }
[18:40:52.504]                       invisible(muffled)
[18:40:52.504]                     }
[18:40:52.504]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.504]                   }
[18:40:52.504]                 }
[18:40:52.504]                 else {
[18:40:52.504]                   if (TRUE) {
[18:40:52.504]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.504]                     {
[18:40:52.504]                       inherits <- base::inherits
[18:40:52.504]                       invokeRestart <- base::invokeRestart
[18:40:52.504]                       is.null <- base::is.null
[18:40:52.504]                       muffled <- FALSE
[18:40:52.504]                       if (inherits(cond, "message")) {
[18:40:52.504]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.504]                         if (muffled) 
[18:40:52.504]                           invokeRestart("muffleMessage")
[18:40:52.504]                       }
[18:40:52.504]                       else if (inherits(cond, "warning")) {
[18:40:52.504]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.504]                         if (muffled) 
[18:40:52.504]                           invokeRestart("muffleWarning")
[18:40:52.504]                       }
[18:40:52.504]                       else if (inherits(cond, "condition")) {
[18:40:52.504]                         if (!is.null(pattern)) {
[18:40:52.504]                           computeRestarts <- base::computeRestarts
[18:40:52.504]                           grepl <- base::grepl
[18:40:52.504]                           restarts <- computeRestarts(cond)
[18:40:52.504]                           for (restart in restarts) {
[18:40:52.504]                             name <- restart$name
[18:40:52.504]                             if (is.null(name)) 
[18:40:52.504]                               next
[18:40:52.504]                             if (!grepl(pattern, name)) 
[18:40:52.504]                               next
[18:40:52.504]                             invokeRestart(restart)
[18:40:52.504]                             muffled <- TRUE
[18:40:52.504]                             break
[18:40:52.504]                           }
[18:40:52.504]                         }
[18:40:52.504]                       }
[18:40:52.504]                       invisible(muffled)
[18:40:52.504]                     }
[18:40:52.504]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.504]                   }
[18:40:52.504]                 }
[18:40:52.504]             }
[18:40:52.504]         }))
[18:40:52.504]     }, error = function(ex) {
[18:40:52.504]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:52.504]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.504]                 ...future.rng), started = ...future.startTime, 
[18:40:52.504]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:52.504]             version = "1.8"), class = "FutureResult")
[18:40:52.504]     }, finally = {
[18:40:52.504]         if (!identical(...future.workdir, getwd())) 
[18:40:52.504]             setwd(...future.workdir)
[18:40:52.504]         {
[18:40:52.504]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:52.504]                 ...future.oldOptions$nwarnings <- NULL
[18:40:52.504]             }
[18:40:52.504]             base::options(...future.oldOptions)
[18:40:52.504]             if (.Platform$OS.type == "windows") {
[18:40:52.504]                 old_names <- names(...future.oldEnvVars)
[18:40:52.504]                 envs <- base::Sys.getenv()
[18:40:52.504]                 names <- names(envs)
[18:40:52.504]                 common <- intersect(names, old_names)
[18:40:52.504]                 added <- setdiff(names, old_names)
[18:40:52.504]                 removed <- setdiff(old_names, names)
[18:40:52.504]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:52.504]                   envs[common]]
[18:40:52.504]                 NAMES <- toupper(changed)
[18:40:52.504]                 args <- list()
[18:40:52.504]                 for (kk in seq_along(NAMES)) {
[18:40:52.504]                   name <- changed[[kk]]
[18:40:52.504]                   NAME <- NAMES[[kk]]
[18:40:52.504]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.504]                     next
[18:40:52.504]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.504]                 }
[18:40:52.504]                 NAMES <- toupper(added)
[18:40:52.504]                 for (kk in seq_along(NAMES)) {
[18:40:52.504]                   name <- added[[kk]]
[18:40:52.504]                   NAME <- NAMES[[kk]]
[18:40:52.504]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.504]                     next
[18:40:52.504]                   args[[name]] <- ""
[18:40:52.504]                 }
[18:40:52.504]                 NAMES <- toupper(removed)
[18:40:52.504]                 for (kk in seq_along(NAMES)) {
[18:40:52.504]                   name <- removed[[kk]]
[18:40:52.504]                   NAME <- NAMES[[kk]]
[18:40:52.504]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.504]                     next
[18:40:52.504]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.504]                 }
[18:40:52.504]                 if (length(args) > 0) 
[18:40:52.504]                   base::do.call(base::Sys.setenv, args = args)
[18:40:52.504]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:52.504]             }
[18:40:52.504]             else {
[18:40:52.504]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:52.504]             }
[18:40:52.504]             {
[18:40:52.504]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:52.504]                   0L) {
[18:40:52.504]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:52.504]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:52.504]                   base::options(opts)
[18:40:52.504]                 }
[18:40:52.504]                 {
[18:40:52.504]                   {
[18:40:52.504]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:52.504]                     NULL
[18:40:52.504]                   }
[18:40:52.504]                   options(future.plan = NULL)
[18:40:52.504]                   if (is.na(NA_character_)) 
[18:40:52.504]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.504]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:52.504]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:52.504]                     .init = FALSE)
[18:40:52.504]                 }
[18:40:52.504]             }
[18:40:52.504]         }
[18:40:52.504]     })
[18:40:52.504]     if (TRUE) {
[18:40:52.504]         base::sink(type = "output", split = FALSE)
[18:40:52.504]         if (TRUE) {
[18:40:52.504]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:52.504]         }
[18:40:52.504]         else {
[18:40:52.504]             ...future.result["stdout"] <- base::list(NULL)
[18:40:52.504]         }
[18:40:52.504]         base::close(...future.stdout)
[18:40:52.504]         ...future.stdout <- NULL
[18:40:52.504]     }
[18:40:52.504]     ...future.result$conditions <- ...future.conditions
[18:40:52.504]     ...future.result$finished <- base::Sys.time()
[18:40:52.504]     ...future.result
[18:40:52.504] }
[18:40:52.655] MultisessionFuture started
[18:40:52.655] result() for ClusterFuture ...
[18:40:52.656] receiveMessageFromWorker() for ClusterFuture ...
[18:40:52.656] - Validating connection of MultisessionFuture
[18:40:52.754] - received message: FutureResult
[18:40:52.754] - Received FutureResult
[18:40:52.756] - Erased future from FutureRegistry
[18:40:52.757] result() for ClusterFuture ...
[18:40:52.757] - result already collected: FutureResult
[18:40:52.757] result() for ClusterFuture ... done
[18:40:52.757] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:52.757] result() for ClusterFuture ... done
[18:40:52.757] result() for ClusterFuture ...
[18:40:52.758] - result already collected: FutureResult
[18:40:52.758] result() for ClusterFuture ... done
[18:40:52.758] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[18:40:52.760] plan(): nbrOfWorkers() = 2
[18:40:52.760] future_by_internal() ...
[18:40:52.761] future_lapply() ...
[18:40:52.764] Number of chunks: 2
[18:40:52.764] getGlobalsAndPackagesXApply() ...
[18:40:52.765]  - future.globals: TRUE
[18:40:52.765] getGlobalsAndPackages() ...
[18:40:52.765] Searching for globals...
[18:40:52.766] - globals found: [2] 'FUN', 'UseMethod'
[18:40:52.766] Searching for globals ... DONE
[18:40:52.767] Resolving globals: FALSE
[18:40:52.767] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:52.767] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:52.768] - globals: [1] 'FUN'
[18:40:52.768] 
[18:40:52.768] getGlobalsAndPackages() ... DONE
[18:40:52.768]  - globals found/used: [n=1] 'FUN'
[18:40:52.768]  - needed namespaces: [n=0] 
[18:40:52.768] Finding globals ... DONE
[18:40:52.769]  - use_args: TRUE
[18:40:52.769]  - Getting '...' globals ...
[18:40:52.769] resolve() on list ...
[18:40:52.769]  recursive: 0
[18:40:52.769]  length: 1
[18:40:52.770]  elements: '...'
[18:40:52.770]  length: 0 (resolved future 1)
[18:40:52.770] resolve() on list ... DONE
[18:40:52.770]    - '...' content: [n=0] 
[18:40:52.770] List of 1
[18:40:52.770]  $ ...: list()
[18:40:52.770]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:52.770]  - attr(*, "where")=List of 1
[18:40:52.770]   ..$ ...:<environment: 0x000001cd50e16048> 
[18:40:52.770]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:52.770]  - attr(*, "resolved")= logi TRUE
[18:40:52.770]  - attr(*, "total_size")= num NA
[18:40:52.773]  - Getting '...' globals ... DONE
[18:40:52.773] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:52.774] List of 2
[18:40:52.774]  $ ...future.FUN:function (object, ...)  
[18:40:52.774]  $ ...          : list()
[18:40:52.774]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:52.774]  - attr(*, "where")=List of 2
[18:40:52.774]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:52.774]   ..$ ...          :<environment: 0x000001cd50e16048> 
[18:40:52.774]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:52.774]  - attr(*, "resolved")= logi FALSE
[18:40:52.774]  - attr(*, "total_size")= int 15670
[18:40:52.777] Packages to be attached in all futures: [n=0] 
[18:40:52.777] getGlobalsAndPackagesXApply() ... DONE
[18:40:52.777] Number of futures (= number of chunks): 2
[18:40:52.777] Launching 2 futures (chunks) ...
[18:40:52.778] Chunk #1 of 2 ...
[18:40:52.778]  - Finding globals in 'X' for chunk #1 ...
[18:40:52.778] getGlobalsAndPackages() ...
[18:40:52.778] Searching for globals...
[18:40:52.779] 
[18:40:52.779] Searching for globals ... DONE
[18:40:52.779] - globals: [0] <none>
[18:40:52.779] getGlobalsAndPackages() ... DONE
[18:40:52.779]    + additional globals found: [n=0] 
[18:40:52.779]    + additional namespaces needed: [n=0] 
[18:40:52.779]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:52.780]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:52.780]  - seeds: <none>
[18:40:52.780]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.780] getGlobalsAndPackages() ...
[18:40:52.780] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.781] Resolving globals: FALSE
[18:40:52.781] Tweak future expression to call with '...' arguments ...
[18:40:52.781] {
[18:40:52.781]     do.call(function(...) {
[18:40:52.781]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.781]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:52.781]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.781]             on.exit(options(oopts), add = TRUE)
[18:40:52.781]         }
[18:40:52.781]         {
[18:40:52.781]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:52.781]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.781]                 ...future.FUN(...future.X_jj, ...)
[18:40:52.781]             })
[18:40:52.781]         }
[18:40:52.781]     }, args = future.call.arguments)
[18:40:52.781] }
[18:40:52.781] Tweak future expression to call with '...' arguments ... DONE
[18:40:52.782] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.782] 
[18:40:52.782] getGlobalsAndPackages() ... DONE
[18:40:52.782] run() for 'Future' ...
[18:40:52.783] - state: 'created'
[18:40:52.783] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:52.798] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:52.798] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:52.798]   - Field: 'node'
[18:40:52.799]   - Field: 'label'
[18:40:52.799]   - Field: 'local'
[18:40:52.799]   - Field: 'owner'
[18:40:52.799]   - Field: 'envir'
[18:40:52.799]   - Field: 'workers'
[18:40:52.799]   - Field: 'packages'
[18:40:52.800]   - Field: 'gc'
[18:40:52.800]   - Field: 'conditions'
[18:40:52.800]   - Field: 'persistent'
[18:40:52.800]   - Field: 'expr'
[18:40:52.800]   - Field: 'uuid'
[18:40:52.801]   - Field: 'seed'
[18:40:52.801]   - Field: 'version'
[18:40:52.801]   - Field: 'result'
[18:40:52.801]   - Field: 'asynchronous'
[18:40:52.801]   - Field: 'calls'
[18:40:52.801]   - Field: 'globals'
[18:40:52.802]   - Field: 'stdout'
[18:40:52.802]   - Field: 'earlySignal'
[18:40:52.802]   - Field: 'lazy'
[18:40:52.802]   - Field: 'state'
[18:40:52.802] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:52.802] - Launch lazy future ...
[18:40:52.803] Packages needed by the future expression (n = 0): <none>
[18:40:52.803] Packages needed by future strategies (n = 0): <none>
[18:40:52.803] {
[18:40:52.803]     {
[18:40:52.803]         {
[18:40:52.803]             ...future.startTime <- base::Sys.time()
[18:40:52.803]             {
[18:40:52.803]                 {
[18:40:52.803]                   {
[18:40:52.803]                     {
[18:40:52.803]                       base::local({
[18:40:52.803]                         has_future <- base::requireNamespace("future", 
[18:40:52.803]                           quietly = TRUE)
[18:40:52.803]                         if (has_future) {
[18:40:52.803]                           ns <- base::getNamespace("future")
[18:40:52.803]                           version <- ns[[".package"]][["version"]]
[18:40:52.803]                           if (is.null(version)) 
[18:40:52.803]                             version <- utils::packageVersion("future")
[18:40:52.803]                         }
[18:40:52.803]                         else {
[18:40:52.803]                           version <- NULL
[18:40:52.803]                         }
[18:40:52.803]                         if (!has_future || version < "1.8.0") {
[18:40:52.803]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:52.803]                             "", base::R.version$version.string), 
[18:40:52.803]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:52.803]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:52.803]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:52.803]                               "release", "version")], collapse = " "), 
[18:40:52.803]                             hostname = base::Sys.info()[["nodename"]])
[18:40:52.803]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:52.803]                             info)
[18:40:52.803]                           info <- base::paste(info, collapse = "; ")
[18:40:52.803]                           if (!has_future) {
[18:40:52.803]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:52.803]                               info)
[18:40:52.803]                           }
[18:40:52.803]                           else {
[18:40:52.803]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:52.803]                               info, version)
[18:40:52.803]                           }
[18:40:52.803]                           base::stop(msg)
[18:40:52.803]                         }
[18:40:52.803]                       })
[18:40:52.803]                     }
[18:40:52.803]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:52.803]                     base::options(mc.cores = 1L)
[18:40:52.803]                   }
[18:40:52.803]                   ...future.strategy.old <- future::plan("list")
[18:40:52.803]                   options(future.plan = NULL)
[18:40:52.803]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.803]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:52.803]                 }
[18:40:52.803]                 ...future.workdir <- getwd()
[18:40:52.803]             }
[18:40:52.803]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:52.803]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:52.803]         }
[18:40:52.803]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:52.803]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:52.803]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:52.803]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:52.803]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:52.803]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:52.803]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:52.803]             base::names(...future.oldOptions))
[18:40:52.803]     }
[18:40:52.803]     if (FALSE) {
[18:40:52.803]     }
[18:40:52.803]     else {
[18:40:52.803]         if (TRUE) {
[18:40:52.803]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:52.803]                 open = "w")
[18:40:52.803]         }
[18:40:52.803]         else {
[18:40:52.803]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:52.803]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:52.803]         }
[18:40:52.803]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:52.803]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:52.803]             base::sink(type = "output", split = FALSE)
[18:40:52.803]             base::close(...future.stdout)
[18:40:52.803]         }, add = TRUE)
[18:40:52.803]     }
[18:40:52.803]     ...future.frame <- base::sys.nframe()
[18:40:52.803]     ...future.conditions <- base::list()
[18:40:52.803]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:52.803]     if (FALSE) {
[18:40:52.803]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:52.803]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:52.803]     }
[18:40:52.803]     ...future.result <- base::tryCatch({
[18:40:52.803]         base::withCallingHandlers({
[18:40:52.803]             ...future.value <- base::withVisible(base::local({
[18:40:52.803]                 ...future.makeSendCondition <- base::local({
[18:40:52.803]                   sendCondition <- NULL
[18:40:52.803]                   function(frame = 1L) {
[18:40:52.803]                     if (is.function(sendCondition)) 
[18:40:52.803]                       return(sendCondition)
[18:40:52.803]                     ns <- getNamespace("parallel")
[18:40:52.803]                     if (exists("sendData", mode = "function", 
[18:40:52.803]                       envir = ns)) {
[18:40:52.803]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:52.803]                         envir = ns)
[18:40:52.803]                       envir <- sys.frame(frame)
[18:40:52.803]                       master <- NULL
[18:40:52.803]                       while (!identical(envir, .GlobalEnv) && 
[18:40:52.803]                         !identical(envir, emptyenv())) {
[18:40:52.803]                         if (exists("master", mode = "list", envir = envir, 
[18:40:52.803]                           inherits = FALSE)) {
[18:40:52.803]                           master <- get("master", mode = "list", 
[18:40:52.803]                             envir = envir, inherits = FALSE)
[18:40:52.803]                           if (inherits(master, c("SOCKnode", 
[18:40:52.803]                             "SOCK0node"))) {
[18:40:52.803]                             sendCondition <<- function(cond) {
[18:40:52.803]                               data <- list(type = "VALUE", value = cond, 
[18:40:52.803]                                 success = TRUE)
[18:40:52.803]                               parallel_sendData(master, data)
[18:40:52.803]                             }
[18:40:52.803]                             return(sendCondition)
[18:40:52.803]                           }
[18:40:52.803]                         }
[18:40:52.803]                         frame <- frame + 1L
[18:40:52.803]                         envir <- sys.frame(frame)
[18:40:52.803]                       }
[18:40:52.803]                     }
[18:40:52.803]                     sendCondition <<- function(cond) NULL
[18:40:52.803]                   }
[18:40:52.803]                 })
[18:40:52.803]                 withCallingHandlers({
[18:40:52.803]                   {
[18:40:52.803]                     do.call(function(...) {
[18:40:52.803]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.803]                       if (!identical(...future.globals.maxSize.org, 
[18:40:52.803]                         ...future.globals.maxSize)) {
[18:40:52.803]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.803]                         on.exit(options(oopts), add = TRUE)
[18:40:52.803]                       }
[18:40:52.803]                       {
[18:40:52.803]                         lapply(seq_along(...future.elements_ii), 
[18:40:52.803]                           FUN = function(jj) {
[18:40:52.803]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.803]                             ...future.FUN(...future.X_jj, ...)
[18:40:52.803]                           })
[18:40:52.803]                       }
[18:40:52.803]                     }, args = future.call.arguments)
[18:40:52.803]                   }
[18:40:52.803]                 }, immediateCondition = function(cond) {
[18:40:52.803]                   sendCondition <- ...future.makeSendCondition()
[18:40:52.803]                   sendCondition(cond)
[18:40:52.803]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.803]                   {
[18:40:52.803]                     inherits <- base::inherits
[18:40:52.803]                     invokeRestart <- base::invokeRestart
[18:40:52.803]                     is.null <- base::is.null
[18:40:52.803]                     muffled <- FALSE
[18:40:52.803]                     if (inherits(cond, "message")) {
[18:40:52.803]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:52.803]                       if (muffled) 
[18:40:52.803]                         invokeRestart("muffleMessage")
[18:40:52.803]                     }
[18:40:52.803]                     else if (inherits(cond, "warning")) {
[18:40:52.803]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:52.803]                       if (muffled) 
[18:40:52.803]                         invokeRestart("muffleWarning")
[18:40:52.803]                     }
[18:40:52.803]                     else if (inherits(cond, "condition")) {
[18:40:52.803]                       if (!is.null(pattern)) {
[18:40:52.803]                         computeRestarts <- base::computeRestarts
[18:40:52.803]                         grepl <- base::grepl
[18:40:52.803]                         restarts <- computeRestarts(cond)
[18:40:52.803]                         for (restart in restarts) {
[18:40:52.803]                           name <- restart$name
[18:40:52.803]                           if (is.null(name)) 
[18:40:52.803]                             next
[18:40:52.803]                           if (!grepl(pattern, name)) 
[18:40:52.803]                             next
[18:40:52.803]                           invokeRestart(restart)
[18:40:52.803]                           muffled <- TRUE
[18:40:52.803]                           break
[18:40:52.803]                         }
[18:40:52.803]                       }
[18:40:52.803]                     }
[18:40:52.803]                     invisible(muffled)
[18:40:52.803]                   }
[18:40:52.803]                   muffleCondition(cond)
[18:40:52.803]                 })
[18:40:52.803]             }))
[18:40:52.803]             future::FutureResult(value = ...future.value$value, 
[18:40:52.803]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.803]                   ...future.rng), globalenv = if (FALSE) 
[18:40:52.803]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:52.803]                     ...future.globalenv.names))
[18:40:52.803]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:52.803]         }, condition = base::local({
[18:40:52.803]             c <- base::c
[18:40:52.803]             inherits <- base::inherits
[18:40:52.803]             invokeRestart <- base::invokeRestart
[18:40:52.803]             length <- base::length
[18:40:52.803]             list <- base::list
[18:40:52.803]             seq.int <- base::seq.int
[18:40:52.803]             signalCondition <- base::signalCondition
[18:40:52.803]             sys.calls <- base::sys.calls
[18:40:52.803]             `[[` <- base::`[[`
[18:40:52.803]             `+` <- base::`+`
[18:40:52.803]             `<<-` <- base::`<<-`
[18:40:52.803]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:52.803]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:52.803]                   3L)]
[18:40:52.803]             }
[18:40:52.803]             function(cond) {
[18:40:52.803]                 is_error <- inherits(cond, "error")
[18:40:52.803]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:52.803]                   NULL)
[18:40:52.803]                 if (is_error) {
[18:40:52.803]                   sessionInformation <- function() {
[18:40:52.803]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:52.803]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:52.803]                       search = base::search(), system = base::Sys.info())
[18:40:52.803]                   }
[18:40:52.803]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.803]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:52.803]                     cond$call), session = sessionInformation(), 
[18:40:52.803]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:52.803]                   signalCondition(cond)
[18:40:52.803]                 }
[18:40:52.803]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:52.803]                 "immediateCondition"))) {
[18:40:52.803]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:52.803]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.803]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:52.803]                   if (TRUE && !signal) {
[18:40:52.803]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.803]                     {
[18:40:52.803]                       inherits <- base::inherits
[18:40:52.803]                       invokeRestart <- base::invokeRestart
[18:40:52.803]                       is.null <- base::is.null
[18:40:52.803]                       muffled <- FALSE
[18:40:52.803]                       if (inherits(cond, "message")) {
[18:40:52.803]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.803]                         if (muffled) 
[18:40:52.803]                           invokeRestart("muffleMessage")
[18:40:52.803]                       }
[18:40:52.803]                       else if (inherits(cond, "warning")) {
[18:40:52.803]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.803]                         if (muffled) 
[18:40:52.803]                           invokeRestart("muffleWarning")
[18:40:52.803]                       }
[18:40:52.803]                       else if (inherits(cond, "condition")) {
[18:40:52.803]                         if (!is.null(pattern)) {
[18:40:52.803]                           computeRestarts <- base::computeRestarts
[18:40:52.803]                           grepl <- base::grepl
[18:40:52.803]                           restarts <- computeRestarts(cond)
[18:40:52.803]                           for (restart in restarts) {
[18:40:52.803]                             name <- restart$name
[18:40:52.803]                             if (is.null(name)) 
[18:40:52.803]                               next
[18:40:52.803]                             if (!grepl(pattern, name)) 
[18:40:52.803]                               next
[18:40:52.803]                             invokeRestart(restart)
[18:40:52.803]                             muffled <- TRUE
[18:40:52.803]                             break
[18:40:52.803]                           }
[18:40:52.803]                         }
[18:40:52.803]                       }
[18:40:52.803]                       invisible(muffled)
[18:40:52.803]                     }
[18:40:52.803]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.803]                   }
[18:40:52.803]                 }
[18:40:52.803]                 else {
[18:40:52.803]                   if (TRUE) {
[18:40:52.803]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.803]                     {
[18:40:52.803]                       inherits <- base::inherits
[18:40:52.803]                       invokeRestart <- base::invokeRestart
[18:40:52.803]                       is.null <- base::is.null
[18:40:52.803]                       muffled <- FALSE
[18:40:52.803]                       if (inherits(cond, "message")) {
[18:40:52.803]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.803]                         if (muffled) 
[18:40:52.803]                           invokeRestart("muffleMessage")
[18:40:52.803]                       }
[18:40:52.803]                       else if (inherits(cond, "warning")) {
[18:40:52.803]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.803]                         if (muffled) 
[18:40:52.803]                           invokeRestart("muffleWarning")
[18:40:52.803]                       }
[18:40:52.803]                       else if (inherits(cond, "condition")) {
[18:40:52.803]                         if (!is.null(pattern)) {
[18:40:52.803]                           computeRestarts <- base::computeRestarts
[18:40:52.803]                           grepl <- base::grepl
[18:40:52.803]                           restarts <- computeRestarts(cond)
[18:40:52.803]                           for (restart in restarts) {
[18:40:52.803]                             name <- restart$name
[18:40:52.803]                             if (is.null(name)) 
[18:40:52.803]                               next
[18:40:52.803]                             if (!grepl(pattern, name)) 
[18:40:52.803]                               next
[18:40:52.803]                             invokeRestart(restart)
[18:40:52.803]                             muffled <- TRUE
[18:40:52.803]                             break
[18:40:52.803]                           }
[18:40:52.803]                         }
[18:40:52.803]                       }
[18:40:52.803]                       invisible(muffled)
[18:40:52.803]                     }
[18:40:52.803]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.803]                   }
[18:40:52.803]                 }
[18:40:52.803]             }
[18:40:52.803]         }))
[18:40:52.803]     }, error = function(ex) {
[18:40:52.803]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:52.803]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.803]                 ...future.rng), started = ...future.startTime, 
[18:40:52.803]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:52.803]             version = "1.8"), class = "FutureResult")
[18:40:52.803]     }, finally = {
[18:40:52.803]         if (!identical(...future.workdir, getwd())) 
[18:40:52.803]             setwd(...future.workdir)
[18:40:52.803]         {
[18:40:52.803]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:52.803]                 ...future.oldOptions$nwarnings <- NULL
[18:40:52.803]             }
[18:40:52.803]             base::options(...future.oldOptions)
[18:40:52.803]             if (.Platform$OS.type == "windows") {
[18:40:52.803]                 old_names <- names(...future.oldEnvVars)
[18:40:52.803]                 envs <- base::Sys.getenv()
[18:40:52.803]                 names <- names(envs)
[18:40:52.803]                 common <- intersect(names, old_names)
[18:40:52.803]                 added <- setdiff(names, old_names)
[18:40:52.803]                 removed <- setdiff(old_names, names)
[18:40:52.803]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:52.803]                   envs[common]]
[18:40:52.803]                 NAMES <- toupper(changed)
[18:40:52.803]                 args <- list()
[18:40:52.803]                 for (kk in seq_along(NAMES)) {
[18:40:52.803]                   name <- changed[[kk]]
[18:40:52.803]                   NAME <- NAMES[[kk]]
[18:40:52.803]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.803]                     next
[18:40:52.803]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.803]                 }
[18:40:52.803]                 NAMES <- toupper(added)
[18:40:52.803]                 for (kk in seq_along(NAMES)) {
[18:40:52.803]                   name <- added[[kk]]
[18:40:52.803]                   NAME <- NAMES[[kk]]
[18:40:52.803]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.803]                     next
[18:40:52.803]                   args[[name]] <- ""
[18:40:52.803]                 }
[18:40:52.803]                 NAMES <- toupper(removed)
[18:40:52.803]                 for (kk in seq_along(NAMES)) {
[18:40:52.803]                   name <- removed[[kk]]
[18:40:52.803]                   NAME <- NAMES[[kk]]
[18:40:52.803]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.803]                     next
[18:40:52.803]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.803]                 }
[18:40:52.803]                 if (length(args) > 0) 
[18:40:52.803]                   base::do.call(base::Sys.setenv, args = args)
[18:40:52.803]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:52.803]             }
[18:40:52.803]             else {
[18:40:52.803]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:52.803]             }
[18:40:52.803]             {
[18:40:52.803]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:52.803]                   0L) {
[18:40:52.803]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:52.803]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:52.803]                   base::options(opts)
[18:40:52.803]                 }
[18:40:52.803]                 {
[18:40:52.803]                   {
[18:40:52.803]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:52.803]                     NULL
[18:40:52.803]                   }
[18:40:52.803]                   options(future.plan = NULL)
[18:40:52.803]                   if (is.na(NA_character_)) 
[18:40:52.803]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.803]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:52.803]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:52.803]                     .init = FALSE)
[18:40:52.803]                 }
[18:40:52.803]             }
[18:40:52.803]         }
[18:40:52.803]     })
[18:40:52.803]     if (TRUE) {
[18:40:52.803]         base::sink(type = "output", split = FALSE)
[18:40:52.803]         if (TRUE) {
[18:40:52.803]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:52.803]         }
[18:40:52.803]         else {
[18:40:52.803]             ...future.result["stdout"] <- base::list(NULL)
[18:40:52.803]         }
[18:40:52.803]         base::close(...future.stdout)
[18:40:52.803]         ...future.stdout <- NULL
[18:40:52.803]     }
[18:40:52.803]     ...future.result$conditions <- ...future.conditions
[18:40:52.803]     ...future.result$finished <- base::Sys.time()
[18:40:52.803]     ...future.result
[18:40:52.803] }
[18:40:52.809] Exporting 5 global objects (1.40 KiB) to cluster node #1 ...
[18:40:52.809] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:52.810] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:52.810] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:52.811] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:52.811] Exporting '...future.elements_ii' (564 bytes) to cluster node #1 ...
[18:40:52.811] Exporting '...future.elements_ii' (564 bytes) to cluster node #1 ... DONE
[18:40:52.811] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:52.812] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:52.812] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:52.813] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:52.813] Exporting 5 global objects (1.40 KiB) to cluster node #1 ... DONE
[18:40:52.813] MultisessionFuture started
[18:40:52.814] - Launch lazy future ... done
[18:40:52.814] run() for 'MultisessionFuture' ... done
[18:40:52.814] Created future:
[18:40:52.845] receiveMessageFromWorker() for ClusterFuture ...
[18:40:52.845] - Validating connection of MultisessionFuture
[18:40:52.846] - received message: FutureResult
[18:40:52.846] - Received FutureResult
[18:40:52.846] - Erased future from FutureRegistry
[18:40:52.846] result() for ClusterFuture ...
[18:40:52.846] - result already collected: FutureResult
[18:40:52.847] result() for ClusterFuture ... done
[18:40:52.847] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:52.814] MultisessionFuture:
[18:40:52.814] Label: 'future_by-1'
[18:40:52.814] Expression:
[18:40:52.814] {
[18:40:52.814]     do.call(function(...) {
[18:40:52.814]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.814]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:52.814]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.814]             on.exit(options(oopts), add = TRUE)
[18:40:52.814]         }
[18:40:52.814]         {
[18:40:52.814]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:52.814]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.814]                 ...future.FUN(...future.X_jj, ...)
[18:40:52.814]             })
[18:40:52.814]         }
[18:40:52.814]     }, args = future.call.arguments)
[18:40:52.814] }
[18:40:52.814] Lazy evaluation: FALSE
[18:40:52.814] Asynchronous evaluation: TRUE
[18:40:52.814] Local evaluation: TRUE
[18:40:52.814] Environment: R_GlobalEnv
[18:40:52.814] Capture standard output: TRUE
[18:40:52.814] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:52.814] Globals: 5 objects totaling 996 bytes (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 564 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:52.814] Packages: <none>
[18:40:52.814] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:52.814] Resolved: TRUE
[18:40:52.814] Value: <not collected>
[18:40:52.814] Conditions captured: <none>
[18:40:52.814] Early signaling: FALSE
[18:40:52.814] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:52.814] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:52.847] Chunk #1 of 2 ... DONE
[18:40:52.847] Chunk #2 of 2 ...
[18:40:52.848]  - Finding globals in 'X' for chunk #2 ...
[18:40:52.848] getGlobalsAndPackages() ...
[18:40:52.848] Searching for globals...
[18:40:52.848] 
[18:40:52.849] Searching for globals ... DONE
[18:40:52.849] - globals: [0] <none>
[18:40:52.849] getGlobalsAndPackages() ... DONE
[18:40:52.849]    + additional globals found: [n=0] 
[18:40:52.849]    + additional namespaces needed: [n=0] 
[18:40:52.849]  - Finding globals in 'X' for chunk #2 ... DONE
[18:40:52.850]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:52.850]  - seeds: <none>
[18:40:52.850]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.850] getGlobalsAndPackages() ...
[18:40:52.850] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.850] Resolving globals: FALSE
[18:40:52.851] Tweak future expression to call with '...' arguments ...
[18:40:52.851] {
[18:40:52.851]     do.call(function(...) {
[18:40:52.851]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.851]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:52.851]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.851]             on.exit(options(oopts), add = TRUE)
[18:40:52.851]         }
[18:40:52.851]         {
[18:40:52.851]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:52.851]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.851]                 ...future.FUN(...future.X_jj, ...)
[18:40:52.851]             })
[18:40:52.851]         }
[18:40:52.851]     }, args = future.call.arguments)
[18:40:52.851] }
[18:40:52.851] Tweak future expression to call with '...' arguments ... DONE
[18:40:52.852] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.852] 
[18:40:52.852] getGlobalsAndPackages() ... DONE
[18:40:52.852] run() for 'Future' ...
[18:40:52.853] - state: 'created'
[18:40:52.853] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:52.868] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:52.868] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:52.868]   - Field: 'node'
[18:40:52.868]   - Field: 'label'
[18:40:52.869]   - Field: 'local'
[18:40:52.869]   - Field: 'owner'
[18:40:52.869]   - Field: 'envir'
[18:40:52.869]   - Field: 'workers'
[18:40:52.869]   - Field: 'packages'
[18:40:52.869]   - Field: 'gc'
[18:40:52.870]   - Field: 'conditions'
[18:40:52.870]   - Field: 'persistent'
[18:40:52.870]   - Field: 'expr'
[18:40:52.870]   - Field: 'uuid'
[18:40:52.870]   - Field: 'seed'
[18:40:52.871]   - Field: 'version'
[18:40:52.871]   - Field: 'result'
[18:40:52.871]   - Field: 'asynchronous'
[18:40:52.871]   - Field: 'calls'
[18:40:52.871]   - Field: 'globals'
[18:40:52.871]   - Field: 'stdout'
[18:40:52.872]   - Field: 'earlySignal'
[18:40:52.872]   - Field: 'lazy'
[18:40:52.872]   - Field: 'state'
[18:40:52.872] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:52.872] - Launch lazy future ...
[18:40:52.873] Packages needed by the future expression (n = 0): <none>
[18:40:52.873] Packages needed by future strategies (n = 0): <none>
[18:40:52.873] {
[18:40:52.873]     {
[18:40:52.873]         {
[18:40:52.873]             ...future.startTime <- base::Sys.time()
[18:40:52.873]             {
[18:40:52.873]                 {
[18:40:52.873]                   {
[18:40:52.873]                     {
[18:40:52.873]                       base::local({
[18:40:52.873]                         has_future <- base::requireNamespace("future", 
[18:40:52.873]                           quietly = TRUE)
[18:40:52.873]                         if (has_future) {
[18:40:52.873]                           ns <- base::getNamespace("future")
[18:40:52.873]                           version <- ns[[".package"]][["version"]]
[18:40:52.873]                           if (is.null(version)) 
[18:40:52.873]                             version <- utils::packageVersion("future")
[18:40:52.873]                         }
[18:40:52.873]                         else {
[18:40:52.873]                           version <- NULL
[18:40:52.873]                         }
[18:40:52.873]                         if (!has_future || version < "1.8.0") {
[18:40:52.873]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:52.873]                             "", base::R.version$version.string), 
[18:40:52.873]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:52.873]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:52.873]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:52.873]                               "release", "version")], collapse = " "), 
[18:40:52.873]                             hostname = base::Sys.info()[["nodename"]])
[18:40:52.873]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:52.873]                             info)
[18:40:52.873]                           info <- base::paste(info, collapse = "; ")
[18:40:52.873]                           if (!has_future) {
[18:40:52.873]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:52.873]                               info)
[18:40:52.873]                           }
[18:40:52.873]                           else {
[18:40:52.873]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:52.873]                               info, version)
[18:40:52.873]                           }
[18:40:52.873]                           base::stop(msg)
[18:40:52.873]                         }
[18:40:52.873]                       })
[18:40:52.873]                     }
[18:40:52.873]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:52.873]                     base::options(mc.cores = 1L)
[18:40:52.873]                   }
[18:40:52.873]                   ...future.strategy.old <- future::plan("list")
[18:40:52.873]                   options(future.plan = NULL)
[18:40:52.873]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.873]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:52.873]                 }
[18:40:52.873]                 ...future.workdir <- getwd()
[18:40:52.873]             }
[18:40:52.873]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:52.873]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:52.873]         }
[18:40:52.873]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:52.873]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:52.873]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:52.873]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:52.873]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:52.873]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:52.873]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:52.873]             base::names(...future.oldOptions))
[18:40:52.873]     }
[18:40:52.873]     if (FALSE) {
[18:40:52.873]     }
[18:40:52.873]     else {
[18:40:52.873]         if (TRUE) {
[18:40:52.873]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:52.873]                 open = "w")
[18:40:52.873]         }
[18:40:52.873]         else {
[18:40:52.873]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:52.873]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:52.873]         }
[18:40:52.873]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:52.873]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:52.873]             base::sink(type = "output", split = FALSE)
[18:40:52.873]             base::close(...future.stdout)
[18:40:52.873]         }, add = TRUE)
[18:40:52.873]     }
[18:40:52.873]     ...future.frame <- base::sys.nframe()
[18:40:52.873]     ...future.conditions <- base::list()
[18:40:52.873]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:52.873]     if (FALSE) {
[18:40:52.873]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:52.873]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:52.873]     }
[18:40:52.873]     ...future.result <- base::tryCatch({
[18:40:52.873]         base::withCallingHandlers({
[18:40:52.873]             ...future.value <- base::withVisible(base::local({
[18:40:52.873]                 ...future.makeSendCondition <- base::local({
[18:40:52.873]                   sendCondition <- NULL
[18:40:52.873]                   function(frame = 1L) {
[18:40:52.873]                     if (is.function(sendCondition)) 
[18:40:52.873]                       return(sendCondition)
[18:40:52.873]                     ns <- getNamespace("parallel")
[18:40:52.873]                     if (exists("sendData", mode = "function", 
[18:40:52.873]                       envir = ns)) {
[18:40:52.873]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:52.873]                         envir = ns)
[18:40:52.873]                       envir <- sys.frame(frame)
[18:40:52.873]                       master <- NULL
[18:40:52.873]                       while (!identical(envir, .GlobalEnv) && 
[18:40:52.873]                         !identical(envir, emptyenv())) {
[18:40:52.873]                         if (exists("master", mode = "list", envir = envir, 
[18:40:52.873]                           inherits = FALSE)) {
[18:40:52.873]                           master <- get("master", mode = "list", 
[18:40:52.873]                             envir = envir, inherits = FALSE)
[18:40:52.873]                           if (inherits(master, c("SOCKnode", 
[18:40:52.873]                             "SOCK0node"))) {
[18:40:52.873]                             sendCondition <<- function(cond) {
[18:40:52.873]                               data <- list(type = "VALUE", value = cond, 
[18:40:52.873]                                 success = TRUE)
[18:40:52.873]                               parallel_sendData(master, data)
[18:40:52.873]                             }
[18:40:52.873]                             return(sendCondition)
[18:40:52.873]                           }
[18:40:52.873]                         }
[18:40:52.873]                         frame <- frame + 1L
[18:40:52.873]                         envir <- sys.frame(frame)
[18:40:52.873]                       }
[18:40:52.873]                     }
[18:40:52.873]                     sendCondition <<- function(cond) NULL
[18:40:52.873]                   }
[18:40:52.873]                 })
[18:40:52.873]                 withCallingHandlers({
[18:40:52.873]                   {
[18:40:52.873]                     do.call(function(...) {
[18:40:52.873]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.873]                       if (!identical(...future.globals.maxSize.org, 
[18:40:52.873]                         ...future.globals.maxSize)) {
[18:40:52.873]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.873]                         on.exit(options(oopts), add = TRUE)
[18:40:52.873]                       }
[18:40:52.873]                       {
[18:40:52.873]                         lapply(seq_along(...future.elements_ii), 
[18:40:52.873]                           FUN = function(jj) {
[18:40:52.873]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.873]                             ...future.FUN(...future.X_jj, ...)
[18:40:52.873]                           })
[18:40:52.873]                       }
[18:40:52.873]                     }, args = future.call.arguments)
[18:40:52.873]                   }
[18:40:52.873]                 }, immediateCondition = function(cond) {
[18:40:52.873]                   sendCondition <- ...future.makeSendCondition()
[18:40:52.873]                   sendCondition(cond)
[18:40:52.873]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.873]                   {
[18:40:52.873]                     inherits <- base::inherits
[18:40:52.873]                     invokeRestart <- base::invokeRestart
[18:40:52.873]                     is.null <- base::is.null
[18:40:52.873]                     muffled <- FALSE
[18:40:52.873]                     if (inherits(cond, "message")) {
[18:40:52.873]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:52.873]                       if (muffled) 
[18:40:52.873]                         invokeRestart("muffleMessage")
[18:40:52.873]                     }
[18:40:52.873]                     else if (inherits(cond, "warning")) {
[18:40:52.873]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:52.873]                       if (muffled) 
[18:40:52.873]                         invokeRestart("muffleWarning")
[18:40:52.873]                     }
[18:40:52.873]                     else if (inherits(cond, "condition")) {
[18:40:52.873]                       if (!is.null(pattern)) {
[18:40:52.873]                         computeRestarts <- base::computeRestarts
[18:40:52.873]                         grepl <- base::grepl
[18:40:52.873]                         restarts <- computeRestarts(cond)
[18:40:52.873]                         for (restart in restarts) {
[18:40:52.873]                           name <- restart$name
[18:40:52.873]                           if (is.null(name)) 
[18:40:52.873]                             next
[18:40:52.873]                           if (!grepl(pattern, name)) 
[18:40:52.873]                             next
[18:40:52.873]                           invokeRestart(restart)
[18:40:52.873]                           muffled <- TRUE
[18:40:52.873]                           break
[18:40:52.873]                         }
[18:40:52.873]                       }
[18:40:52.873]                     }
[18:40:52.873]                     invisible(muffled)
[18:40:52.873]                   }
[18:40:52.873]                   muffleCondition(cond)
[18:40:52.873]                 })
[18:40:52.873]             }))
[18:40:52.873]             future::FutureResult(value = ...future.value$value, 
[18:40:52.873]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.873]                   ...future.rng), globalenv = if (FALSE) 
[18:40:52.873]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:52.873]                     ...future.globalenv.names))
[18:40:52.873]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:52.873]         }, condition = base::local({
[18:40:52.873]             c <- base::c
[18:40:52.873]             inherits <- base::inherits
[18:40:52.873]             invokeRestart <- base::invokeRestart
[18:40:52.873]             length <- base::length
[18:40:52.873]             list <- base::list
[18:40:52.873]             seq.int <- base::seq.int
[18:40:52.873]             signalCondition <- base::signalCondition
[18:40:52.873]             sys.calls <- base::sys.calls
[18:40:52.873]             `[[` <- base::`[[`
[18:40:52.873]             `+` <- base::`+`
[18:40:52.873]             `<<-` <- base::`<<-`
[18:40:52.873]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:52.873]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:52.873]                   3L)]
[18:40:52.873]             }
[18:40:52.873]             function(cond) {
[18:40:52.873]                 is_error <- inherits(cond, "error")
[18:40:52.873]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:52.873]                   NULL)
[18:40:52.873]                 if (is_error) {
[18:40:52.873]                   sessionInformation <- function() {
[18:40:52.873]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:52.873]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:52.873]                       search = base::search(), system = base::Sys.info())
[18:40:52.873]                   }
[18:40:52.873]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.873]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:52.873]                     cond$call), session = sessionInformation(), 
[18:40:52.873]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:52.873]                   signalCondition(cond)
[18:40:52.873]                 }
[18:40:52.873]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:52.873]                 "immediateCondition"))) {
[18:40:52.873]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:52.873]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.873]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:52.873]                   if (TRUE && !signal) {
[18:40:52.873]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.873]                     {
[18:40:52.873]                       inherits <- base::inherits
[18:40:52.873]                       invokeRestart <- base::invokeRestart
[18:40:52.873]                       is.null <- base::is.null
[18:40:52.873]                       muffled <- FALSE
[18:40:52.873]                       if (inherits(cond, "message")) {
[18:40:52.873]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.873]                         if (muffled) 
[18:40:52.873]                           invokeRestart("muffleMessage")
[18:40:52.873]                       }
[18:40:52.873]                       else if (inherits(cond, "warning")) {
[18:40:52.873]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.873]                         if (muffled) 
[18:40:52.873]                           invokeRestart("muffleWarning")
[18:40:52.873]                       }
[18:40:52.873]                       else if (inherits(cond, "condition")) {
[18:40:52.873]                         if (!is.null(pattern)) {
[18:40:52.873]                           computeRestarts <- base::computeRestarts
[18:40:52.873]                           grepl <- base::grepl
[18:40:52.873]                           restarts <- computeRestarts(cond)
[18:40:52.873]                           for (restart in restarts) {
[18:40:52.873]                             name <- restart$name
[18:40:52.873]                             if (is.null(name)) 
[18:40:52.873]                               next
[18:40:52.873]                             if (!grepl(pattern, name)) 
[18:40:52.873]                               next
[18:40:52.873]                             invokeRestart(restart)
[18:40:52.873]                             muffled <- TRUE
[18:40:52.873]                             break
[18:40:52.873]                           }
[18:40:52.873]                         }
[18:40:52.873]                       }
[18:40:52.873]                       invisible(muffled)
[18:40:52.873]                     }
[18:40:52.873]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.873]                   }
[18:40:52.873]                 }
[18:40:52.873]                 else {
[18:40:52.873]                   if (TRUE) {
[18:40:52.873]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.873]                     {
[18:40:52.873]                       inherits <- base::inherits
[18:40:52.873]                       invokeRestart <- base::invokeRestart
[18:40:52.873]                       is.null <- base::is.null
[18:40:52.873]                       muffled <- FALSE
[18:40:52.873]                       if (inherits(cond, "message")) {
[18:40:52.873]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.873]                         if (muffled) 
[18:40:52.873]                           invokeRestart("muffleMessage")
[18:40:52.873]                       }
[18:40:52.873]                       else if (inherits(cond, "warning")) {
[18:40:52.873]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.873]                         if (muffled) 
[18:40:52.873]                           invokeRestart("muffleWarning")
[18:40:52.873]                       }
[18:40:52.873]                       else if (inherits(cond, "condition")) {
[18:40:52.873]                         if (!is.null(pattern)) {
[18:40:52.873]                           computeRestarts <- base::computeRestarts
[18:40:52.873]                           grepl <- base::grepl
[18:40:52.873]                           restarts <- computeRestarts(cond)
[18:40:52.873]                           for (restart in restarts) {
[18:40:52.873]                             name <- restart$name
[18:40:52.873]                             if (is.null(name)) 
[18:40:52.873]                               next
[18:40:52.873]                             if (!grepl(pattern, name)) 
[18:40:52.873]                               next
[18:40:52.873]                             invokeRestart(restart)
[18:40:52.873]                             muffled <- TRUE
[18:40:52.873]                             break
[18:40:52.873]                           }
[18:40:52.873]                         }
[18:40:52.873]                       }
[18:40:52.873]                       invisible(muffled)
[18:40:52.873]                     }
[18:40:52.873]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.873]                   }
[18:40:52.873]                 }
[18:40:52.873]             }
[18:40:52.873]         }))
[18:40:52.873]     }, error = function(ex) {
[18:40:52.873]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:52.873]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.873]                 ...future.rng), started = ...future.startTime, 
[18:40:52.873]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:52.873]             version = "1.8"), class = "FutureResult")
[18:40:52.873]     }, finally = {
[18:40:52.873]         if (!identical(...future.workdir, getwd())) 
[18:40:52.873]             setwd(...future.workdir)
[18:40:52.873]         {
[18:40:52.873]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:52.873]                 ...future.oldOptions$nwarnings <- NULL
[18:40:52.873]             }
[18:40:52.873]             base::options(...future.oldOptions)
[18:40:52.873]             if (.Platform$OS.type == "windows") {
[18:40:52.873]                 old_names <- names(...future.oldEnvVars)
[18:40:52.873]                 envs <- base::Sys.getenv()
[18:40:52.873]                 names <- names(envs)
[18:40:52.873]                 common <- intersect(names, old_names)
[18:40:52.873]                 added <- setdiff(names, old_names)
[18:40:52.873]                 removed <- setdiff(old_names, names)
[18:40:52.873]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:52.873]                   envs[common]]
[18:40:52.873]                 NAMES <- toupper(changed)
[18:40:52.873]                 args <- list()
[18:40:52.873]                 for (kk in seq_along(NAMES)) {
[18:40:52.873]                   name <- changed[[kk]]
[18:40:52.873]                   NAME <- NAMES[[kk]]
[18:40:52.873]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.873]                     next
[18:40:52.873]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.873]                 }
[18:40:52.873]                 NAMES <- toupper(added)
[18:40:52.873]                 for (kk in seq_along(NAMES)) {
[18:40:52.873]                   name <- added[[kk]]
[18:40:52.873]                   NAME <- NAMES[[kk]]
[18:40:52.873]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.873]                     next
[18:40:52.873]                   args[[name]] <- ""
[18:40:52.873]                 }
[18:40:52.873]                 NAMES <- toupper(removed)
[18:40:52.873]                 for (kk in seq_along(NAMES)) {
[18:40:52.873]                   name <- removed[[kk]]
[18:40:52.873]                   NAME <- NAMES[[kk]]
[18:40:52.873]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.873]                     next
[18:40:52.873]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.873]                 }
[18:40:52.873]                 if (length(args) > 0) 
[18:40:52.873]                   base::do.call(base::Sys.setenv, args = args)
[18:40:52.873]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:52.873]             }
[18:40:52.873]             else {
[18:40:52.873]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:52.873]             }
[18:40:52.873]             {
[18:40:52.873]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:52.873]                   0L) {
[18:40:52.873]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:52.873]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:52.873]                   base::options(opts)
[18:40:52.873]                 }
[18:40:52.873]                 {
[18:40:52.873]                   {
[18:40:52.873]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:52.873]                     NULL
[18:40:52.873]                   }
[18:40:52.873]                   options(future.plan = NULL)
[18:40:52.873]                   if (is.na(NA_character_)) 
[18:40:52.873]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.873]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:52.873]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:52.873]                     .init = FALSE)
[18:40:52.873]                 }
[18:40:52.873]             }
[18:40:52.873]         }
[18:40:52.873]     })
[18:40:52.873]     if (TRUE) {
[18:40:52.873]         base::sink(type = "output", split = FALSE)
[18:40:52.873]         if (TRUE) {
[18:40:52.873]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:52.873]         }
[18:40:52.873]         else {
[18:40:52.873]             ...future.result["stdout"] <- base::list(NULL)
[18:40:52.873]         }
[18:40:52.873]         base::close(...future.stdout)
[18:40:52.873]         ...future.stdout <- NULL
[18:40:52.873]     }
[18:40:52.873]     ...future.result$conditions <- ...future.conditions
[18:40:52.873]     ...future.result$finished <- base::Sys.time()
[18:40:52.873]     ...future.result
[18:40:52.873] }
[18:40:52.879] Exporting 5 global objects (1.86 KiB) to cluster node #1 ...
[18:40:52.879] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:52.879] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:52.880] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:52.880] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:52.880] Exporting '...future.elements_ii' (1.02 KiB) to cluster node #1 ...
[18:40:52.881] Exporting '...future.elements_ii' (1.02 KiB) to cluster node #1 ... DONE
[18:40:52.881] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:52.881] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:52.882] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:52.882] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:52.882] Exporting 5 global objects (1.86 KiB) to cluster node #1 ... DONE
[18:40:52.883] MultisessionFuture started
[18:40:52.883] - Launch lazy future ... done
[18:40:52.883] run() for 'MultisessionFuture' ... done
[18:40:52.883] Created future:
[18:40:52.913] receiveMessageFromWorker() for ClusterFuture ...
[18:40:52.913] - Validating connection of MultisessionFuture
[18:40:52.914] - received message: FutureResult
[18:40:52.914] - Received FutureResult
[18:40:52.914] - Erased future from FutureRegistry
[18:40:52.914] result() for ClusterFuture ...
[18:40:52.914] - result already collected: FutureResult
[18:40:52.914] result() for ClusterFuture ... done
[18:40:52.915] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:52.884] MultisessionFuture:
[18:40:52.884] Label: 'future_by-2'
[18:40:52.884] Expression:
[18:40:52.884] {
[18:40:52.884]     do.call(function(...) {
[18:40:52.884]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.884]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:52.884]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.884]             on.exit(options(oopts), add = TRUE)
[18:40:52.884]         }
[18:40:52.884]         {
[18:40:52.884]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:52.884]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.884]                 ...future.FUN(...future.X_jj, ...)
[18:40:52.884]             })
[18:40:52.884]         }
[18:40:52.884]     }, args = future.call.arguments)
[18:40:52.884] }
[18:40:52.884] Lazy evaluation: FALSE
[18:40:52.884] Asynchronous evaluation: TRUE
[18:40:52.884] Local evaluation: TRUE
[18:40:52.884] Environment: R_GlobalEnv
[18:40:52.884] Capture standard output: TRUE
[18:40:52.884] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:52.884] Globals: 5 objects totaling 1.44 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.02 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:52.884] Packages: <none>
[18:40:52.884] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:52.884] Resolved: TRUE
[18:40:52.884] Value: <not collected>
[18:40:52.884] Conditions captured: <none>
[18:40:52.884] Early signaling: FALSE
[18:40:52.884] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:52.884] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:52.915] Chunk #2 of 2 ... DONE
[18:40:52.915] Launching 2 futures (chunks) ... DONE
[18:40:52.915] Resolving 2 futures (chunks) ...
[18:40:52.915] resolve() on list ...
[18:40:52.916]  recursive: 0
[18:40:52.916]  length: 2
[18:40:52.916] 
[18:40:52.916] Future #1
[18:40:52.916] result() for ClusterFuture ...
[18:40:52.916] - result already collected: FutureResult
[18:40:52.917] result() for ClusterFuture ... done
[18:40:52.917] result() for ClusterFuture ...
[18:40:52.917] - result already collected: FutureResult
[18:40:52.917] result() for ClusterFuture ... done
[18:40:52.917] signalConditionsASAP(MultisessionFuture, pos=1) ...
[18:40:52.917] - nx: 2
[18:40:52.918] - relay: TRUE
[18:40:52.918] - stdout: TRUE
[18:40:52.918] - signal: TRUE
[18:40:52.918] - resignal: FALSE
[18:40:52.918] - force: TRUE
[18:40:52.918] - relayed: [n=2] FALSE, FALSE
[18:40:52.918] - queued futures: [n=2] FALSE, FALSE
[18:40:52.919]  - until=1
[18:40:52.919]  - relaying element #1
[18:40:52.919] result() for ClusterFuture ...
[18:40:52.919] - result already collected: FutureResult
[18:40:52.919] result() for ClusterFuture ... done
[18:40:52.919] result() for ClusterFuture ...
[18:40:52.919] - result already collected: FutureResult
[18:40:52.920] result() for ClusterFuture ... done
[18:40:52.920] result() for ClusterFuture ...
[18:40:52.920] - result already collected: FutureResult
[18:40:52.920] result() for ClusterFuture ... done
[18:40:52.920] result() for ClusterFuture ...
[18:40:52.920] - result already collected: FutureResult
[18:40:52.921] result() for ClusterFuture ... done
[18:40:52.921] - relayed: [n=2] TRUE, FALSE
[18:40:52.921] - queued futures: [n=2] TRUE, FALSE
[18:40:52.921] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[18:40:52.921]  length: 1 (resolved future 1)
[18:40:52.921] Future #2
[18:40:52.922] result() for ClusterFuture ...
[18:40:52.922] - result already collected: FutureResult
[18:40:52.922] result() for ClusterFuture ... done
[18:40:52.922] result() for ClusterFuture ...
[18:40:52.922] - result already collected: FutureResult
[18:40:52.922] result() for ClusterFuture ... done
[18:40:52.923] signalConditionsASAP(MultisessionFuture, pos=2) ...
[18:40:52.923] - nx: 2
[18:40:52.923] - relay: TRUE
[18:40:52.923] - stdout: TRUE
[18:40:52.923] - signal: TRUE
[18:40:52.923] - resignal: FALSE
[18:40:52.923] - force: TRUE
[18:40:52.924] - relayed: [n=2] TRUE, FALSE
[18:40:52.924] - queued futures: [n=2] TRUE, FALSE
[18:40:52.924]  - until=2
[18:40:52.924]  - relaying element #2
[18:40:52.924] result() for ClusterFuture ...
[18:40:52.924] - result already collected: FutureResult
[18:40:52.924] result() for ClusterFuture ... done
[18:40:52.925] result() for ClusterFuture ...
[18:40:52.925] - result already collected: FutureResult
[18:40:52.925] result() for ClusterFuture ... done
[18:40:52.925] result() for ClusterFuture ...
[18:40:52.925] - result already collected: FutureResult
[18:40:52.925] result() for ClusterFuture ... done
[18:40:52.926] result() for ClusterFuture ...
[18:40:52.926] - result already collected: FutureResult
[18:40:52.926] result() for ClusterFuture ... done
[18:40:52.926] - relayed: [n=2] TRUE, TRUE
[18:40:52.926] - queued futures: [n=2] TRUE, TRUE
[18:40:52.926] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[18:40:52.927]  length: 0 (resolved future 2)
[18:40:52.927] Relaying remaining futures
[18:40:52.927] signalConditionsASAP(NULL, pos=0) ...
[18:40:52.927] - nx: 2
[18:40:52.927] - relay: TRUE
[18:40:52.927] - stdout: TRUE
[18:40:52.927] - signal: TRUE
[18:40:52.928] - resignal: FALSE
[18:40:52.928] - force: TRUE
[18:40:52.928] - relayed: [n=2] TRUE, TRUE
[18:40:52.928] - queued futures: [n=2] TRUE, TRUE
 - flush all
[18:40:52.928] - relayed: [n=2] TRUE, TRUE
[18:40:52.928] - queued futures: [n=2] TRUE, TRUE
[18:40:52.929] signalConditionsASAP(NULL, pos=0) ... done
[18:40:52.929] resolve() on list ... DONE
[18:40:52.929] result() for ClusterFuture ...
[18:40:52.929] - result already collected: FutureResult
[18:40:52.929] result() for ClusterFuture ... done
[18:40:52.929] result() for ClusterFuture ...
[18:40:52.929] - result already collected: FutureResult
[18:40:52.930] result() for ClusterFuture ... done
[18:40:52.930] result() for ClusterFuture ...
[18:40:52.930] - result already collected: FutureResult
[18:40:52.930] result() for ClusterFuture ... done
[18:40:52.930] result() for ClusterFuture ...
[18:40:52.930] - result already collected: FutureResult
[18:40:52.931] result() for ClusterFuture ... done
[18:40:52.931]  - Number of value chunks collected: 2
[18:40:52.931] Resolving 2 futures (chunks) ... DONE
[18:40:52.931] Reducing values from 2 chunks ...
[18:40:52.931]  - Number of values collected after concatenation: 3
[18:40:52.931]  - Number of values expected: 3
[18:40:52.931] Reducing values from 2 chunks ... DONE
[18:40:52.932] future_lapply() ... DONE
[18:40:52.932] future_by_internal() ... DONE
[18:40:52.932] future_by_internal() ...
[18:40:52.933] future_lapply() ...
[18:40:52.935] Number of chunks: 2
[18:40:52.935] getGlobalsAndPackagesXApply() ...
[18:40:52.936]  - future.globals: TRUE
[18:40:52.936] getGlobalsAndPackages() ...
[18:40:52.936] Searching for globals...
[18:40:52.937] - globals found: [2] 'FUN', 'UseMethod'
[18:40:52.938] Searching for globals ... DONE
[18:40:52.938] Resolving globals: FALSE
[18:40:52.938] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:52.939] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:52.939] - globals: [1] 'FUN'
[18:40:52.939] 
[18:40:52.939] getGlobalsAndPackages() ... DONE
[18:40:52.939]  - globals found/used: [n=1] 'FUN'
[18:40:52.939]  - needed namespaces: [n=0] 
[18:40:52.940] Finding globals ... DONE
[18:40:52.940]  - use_args: TRUE
[18:40:52.940]  - Getting '...' globals ...
[18:40:52.940] resolve() on list ...
[18:40:52.941]  recursive: 0
[18:40:52.941]  length: 1
[18:40:52.941]  elements: '...'
[18:40:52.941]  length: 0 (resolved future 1)
[18:40:52.941] resolve() on list ... DONE
[18:40:52.941]    - '...' content: [n=1] 'digits'
[18:40:52.942] List of 1
[18:40:52.942]  $ ...:List of 1
[18:40:52.942]   ..$ digits: int 2
[18:40:52.942]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:52.942]  - attr(*, "where")=List of 1
[18:40:52.942]   ..$ ...:<environment: 0x000001cd51e24d18> 
[18:40:52.942]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:52.942]  - attr(*, "resolved")= logi TRUE
[18:40:52.942]  - attr(*, "total_size")= num NA
[18:40:52.945]  - Getting '...' globals ... DONE
[18:40:52.945] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:52.945] List of 2
[18:40:52.945]  $ ...future.FUN:function (object, ...)  
[18:40:52.945]  $ ...          :List of 1
[18:40:52.945]   ..$ digits: int 2
[18:40:52.945]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:52.945]  - attr(*, "where")=List of 2
[18:40:52.945]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:52.945]   ..$ ...          :<environment: 0x000001cd51e24d18> 
[18:40:52.945]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:52.945]  - attr(*, "resolved")= logi FALSE
[18:40:52.945]  - attr(*, "total_size")= int 13284
[18:40:52.949] Packages to be attached in all futures: [n=0] 
[18:40:52.949] getGlobalsAndPackagesXApply() ... DONE
[18:40:52.949] Number of futures (= number of chunks): 2
[18:40:52.950] Launching 2 futures (chunks) ...
[18:40:52.950] Chunk #1 of 2 ...
[18:40:52.950]  - Finding globals in 'X' for chunk #1 ...
[18:40:52.950] getGlobalsAndPackages() ...
[18:40:52.950] Searching for globals...
[18:40:52.951] 
[18:40:52.951] Searching for globals ... DONE
[18:40:52.951] - globals: [0] <none>
[18:40:52.951] getGlobalsAndPackages() ... DONE
[18:40:52.951]    + additional globals found: [n=0] 
[18:40:52.951]    + additional namespaces needed: [n=0] 
[18:40:52.952]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:52.952]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:52.952]  - seeds: <none>
[18:40:52.952]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.952] getGlobalsAndPackages() ...
[18:40:52.952] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.953] Resolving globals: FALSE
[18:40:52.953] Tweak future expression to call with '...' arguments ...
[18:40:52.953] {
[18:40:52.953]     do.call(function(...) {
[18:40:52.953]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.953]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:52.953]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.953]             on.exit(options(oopts), add = TRUE)
[18:40:52.953]         }
[18:40:52.953]         {
[18:40:52.953]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:52.953]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.953]                 ...future.FUN(...future.X_jj, ...)
[18:40:52.953]             })
[18:40:52.953]         }
[18:40:52.953]     }, args = future.call.arguments)
[18:40:52.953] }
[18:40:52.953] Tweak future expression to call with '...' arguments ... DONE
[18:40:52.954] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:52.954] 
[18:40:52.954] getGlobalsAndPackages() ... DONE
[18:40:52.954] run() for 'Future' ...
[18:40:52.955] - state: 'created'
[18:40:52.955] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:52.970] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:52.970] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:52.970]   - Field: 'node'
[18:40:52.971]   - Field: 'label'
[18:40:52.971]   - Field: 'local'
[18:40:52.971]   - Field: 'owner'
[18:40:52.971]   - Field: 'envir'
[18:40:52.971]   - Field: 'workers'
[18:40:52.972]   - Field: 'packages'
[18:40:52.972]   - Field: 'gc'
[18:40:52.972]   - Field: 'conditions'
[18:40:52.972]   - Field: 'persistent'
[18:40:52.972]   - Field: 'expr'
[18:40:52.972]   - Field: 'uuid'
[18:40:52.973]   - Field: 'seed'
[18:40:52.973]   - Field: 'version'
[18:40:52.973]   - Field: 'result'
[18:40:52.973]   - Field: 'asynchronous'
[18:40:52.973]   - Field: 'calls'
[18:40:52.973]   - Field: 'globals'
[18:40:52.974]   - Field: 'stdout'
[18:40:52.974]   - Field: 'earlySignal'
[18:40:52.974]   - Field: 'lazy'
[18:40:52.974]   - Field: 'state'
[18:40:52.974] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:52.974] - Launch lazy future ...
[18:40:52.975] Packages needed by the future expression (n = 0): <none>
[18:40:52.975] Packages needed by future strategies (n = 0): <none>
[18:40:52.975] {
[18:40:52.975]     {
[18:40:52.975]         {
[18:40:52.975]             ...future.startTime <- base::Sys.time()
[18:40:52.975]             {
[18:40:52.975]                 {
[18:40:52.975]                   {
[18:40:52.975]                     {
[18:40:52.975]                       base::local({
[18:40:52.975]                         has_future <- base::requireNamespace("future", 
[18:40:52.975]                           quietly = TRUE)
[18:40:52.975]                         if (has_future) {
[18:40:52.975]                           ns <- base::getNamespace("future")
[18:40:52.975]                           version <- ns[[".package"]][["version"]]
[18:40:52.975]                           if (is.null(version)) 
[18:40:52.975]                             version <- utils::packageVersion("future")
[18:40:52.975]                         }
[18:40:52.975]                         else {
[18:40:52.975]                           version <- NULL
[18:40:52.975]                         }
[18:40:52.975]                         if (!has_future || version < "1.8.0") {
[18:40:52.975]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:52.975]                             "", base::R.version$version.string), 
[18:40:52.975]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:52.975]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:52.975]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:52.975]                               "release", "version")], collapse = " "), 
[18:40:52.975]                             hostname = base::Sys.info()[["nodename"]])
[18:40:52.975]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:52.975]                             info)
[18:40:52.975]                           info <- base::paste(info, collapse = "; ")
[18:40:52.975]                           if (!has_future) {
[18:40:52.975]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:52.975]                               info)
[18:40:52.975]                           }
[18:40:52.975]                           else {
[18:40:52.975]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:52.975]                               info, version)
[18:40:52.975]                           }
[18:40:52.975]                           base::stop(msg)
[18:40:52.975]                         }
[18:40:52.975]                       })
[18:40:52.975]                     }
[18:40:52.975]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:52.975]                     base::options(mc.cores = 1L)
[18:40:52.975]                   }
[18:40:52.975]                   ...future.strategy.old <- future::plan("list")
[18:40:52.975]                   options(future.plan = NULL)
[18:40:52.975]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.975]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:52.975]                 }
[18:40:52.975]                 ...future.workdir <- getwd()
[18:40:52.975]             }
[18:40:52.975]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:52.975]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:52.975]         }
[18:40:52.975]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:52.975]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:52.975]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:52.975]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:52.975]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:52.975]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:52.975]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:52.975]             base::names(...future.oldOptions))
[18:40:52.975]     }
[18:40:52.975]     if (FALSE) {
[18:40:52.975]     }
[18:40:52.975]     else {
[18:40:52.975]         if (TRUE) {
[18:40:52.975]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:52.975]                 open = "w")
[18:40:52.975]         }
[18:40:52.975]         else {
[18:40:52.975]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:52.975]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:52.975]         }
[18:40:52.975]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:52.975]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:52.975]             base::sink(type = "output", split = FALSE)
[18:40:52.975]             base::close(...future.stdout)
[18:40:52.975]         }, add = TRUE)
[18:40:52.975]     }
[18:40:52.975]     ...future.frame <- base::sys.nframe()
[18:40:52.975]     ...future.conditions <- base::list()
[18:40:52.975]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:52.975]     if (FALSE) {
[18:40:52.975]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:52.975]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:52.975]     }
[18:40:52.975]     ...future.result <- base::tryCatch({
[18:40:52.975]         base::withCallingHandlers({
[18:40:52.975]             ...future.value <- base::withVisible(base::local({
[18:40:52.975]                 ...future.makeSendCondition <- base::local({
[18:40:52.975]                   sendCondition <- NULL
[18:40:52.975]                   function(frame = 1L) {
[18:40:52.975]                     if (is.function(sendCondition)) 
[18:40:52.975]                       return(sendCondition)
[18:40:52.975]                     ns <- getNamespace("parallel")
[18:40:52.975]                     if (exists("sendData", mode = "function", 
[18:40:52.975]                       envir = ns)) {
[18:40:52.975]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:52.975]                         envir = ns)
[18:40:52.975]                       envir <- sys.frame(frame)
[18:40:52.975]                       master <- NULL
[18:40:52.975]                       while (!identical(envir, .GlobalEnv) && 
[18:40:52.975]                         !identical(envir, emptyenv())) {
[18:40:52.975]                         if (exists("master", mode = "list", envir = envir, 
[18:40:52.975]                           inherits = FALSE)) {
[18:40:52.975]                           master <- get("master", mode = "list", 
[18:40:52.975]                             envir = envir, inherits = FALSE)
[18:40:52.975]                           if (inherits(master, c("SOCKnode", 
[18:40:52.975]                             "SOCK0node"))) {
[18:40:52.975]                             sendCondition <<- function(cond) {
[18:40:52.975]                               data <- list(type = "VALUE", value = cond, 
[18:40:52.975]                                 success = TRUE)
[18:40:52.975]                               parallel_sendData(master, data)
[18:40:52.975]                             }
[18:40:52.975]                             return(sendCondition)
[18:40:52.975]                           }
[18:40:52.975]                         }
[18:40:52.975]                         frame <- frame + 1L
[18:40:52.975]                         envir <- sys.frame(frame)
[18:40:52.975]                       }
[18:40:52.975]                     }
[18:40:52.975]                     sendCondition <<- function(cond) NULL
[18:40:52.975]                   }
[18:40:52.975]                 })
[18:40:52.975]                 withCallingHandlers({
[18:40:52.975]                   {
[18:40:52.975]                     do.call(function(...) {
[18:40:52.975]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.975]                       if (!identical(...future.globals.maxSize.org, 
[18:40:52.975]                         ...future.globals.maxSize)) {
[18:40:52.975]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.975]                         on.exit(options(oopts), add = TRUE)
[18:40:52.975]                       }
[18:40:52.975]                       {
[18:40:52.975]                         lapply(seq_along(...future.elements_ii), 
[18:40:52.975]                           FUN = function(jj) {
[18:40:52.975]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.975]                             ...future.FUN(...future.X_jj, ...)
[18:40:52.975]                           })
[18:40:52.975]                       }
[18:40:52.975]                     }, args = future.call.arguments)
[18:40:52.975]                   }
[18:40:52.975]                 }, immediateCondition = function(cond) {
[18:40:52.975]                   sendCondition <- ...future.makeSendCondition()
[18:40:52.975]                   sendCondition(cond)
[18:40:52.975]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.975]                   {
[18:40:52.975]                     inherits <- base::inherits
[18:40:52.975]                     invokeRestart <- base::invokeRestart
[18:40:52.975]                     is.null <- base::is.null
[18:40:52.975]                     muffled <- FALSE
[18:40:52.975]                     if (inherits(cond, "message")) {
[18:40:52.975]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:52.975]                       if (muffled) 
[18:40:52.975]                         invokeRestart("muffleMessage")
[18:40:52.975]                     }
[18:40:52.975]                     else if (inherits(cond, "warning")) {
[18:40:52.975]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:52.975]                       if (muffled) 
[18:40:52.975]                         invokeRestart("muffleWarning")
[18:40:52.975]                     }
[18:40:52.975]                     else if (inherits(cond, "condition")) {
[18:40:52.975]                       if (!is.null(pattern)) {
[18:40:52.975]                         computeRestarts <- base::computeRestarts
[18:40:52.975]                         grepl <- base::grepl
[18:40:52.975]                         restarts <- computeRestarts(cond)
[18:40:52.975]                         for (restart in restarts) {
[18:40:52.975]                           name <- restart$name
[18:40:52.975]                           if (is.null(name)) 
[18:40:52.975]                             next
[18:40:52.975]                           if (!grepl(pattern, name)) 
[18:40:52.975]                             next
[18:40:52.975]                           invokeRestart(restart)
[18:40:52.975]                           muffled <- TRUE
[18:40:52.975]                           break
[18:40:52.975]                         }
[18:40:52.975]                       }
[18:40:52.975]                     }
[18:40:52.975]                     invisible(muffled)
[18:40:52.975]                   }
[18:40:52.975]                   muffleCondition(cond)
[18:40:52.975]                 })
[18:40:52.975]             }))
[18:40:52.975]             future::FutureResult(value = ...future.value$value, 
[18:40:52.975]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.975]                   ...future.rng), globalenv = if (FALSE) 
[18:40:52.975]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:52.975]                     ...future.globalenv.names))
[18:40:52.975]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:52.975]         }, condition = base::local({
[18:40:52.975]             c <- base::c
[18:40:52.975]             inherits <- base::inherits
[18:40:52.975]             invokeRestart <- base::invokeRestart
[18:40:52.975]             length <- base::length
[18:40:52.975]             list <- base::list
[18:40:52.975]             seq.int <- base::seq.int
[18:40:52.975]             signalCondition <- base::signalCondition
[18:40:52.975]             sys.calls <- base::sys.calls
[18:40:52.975]             `[[` <- base::`[[`
[18:40:52.975]             `+` <- base::`+`
[18:40:52.975]             `<<-` <- base::`<<-`
[18:40:52.975]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:52.975]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:52.975]                   3L)]
[18:40:52.975]             }
[18:40:52.975]             function(cond) {
[18:40:52.975]                 is_error <- inherits(cond, "error")
[18:40:52.975]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:52.975]                   NULL)
[18:40:52.975]                 if (is_error) {
[18:40:52.975]                   sessionInformation <- function() {
[18:40:52.975]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:52.975]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:52.975]                       search = base::search(), system = base::Sys.info())
[18:40:52.975]                   }
[18:40:52.975]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.975]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:52.975]                     cond$call), session = sessionInformation(), 
[18:40:52.975]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:52.975]                   signalCondition(cond)
[18:40:52.975]                 }
[18:40:52.975]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:52.975]                 "immediateCondition"))) {
[18:40:52.975]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:52.975]                   ...future.conditions[[length(...future.conditions) + 
[18:40:52.975]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:52.975]                   if (TRUE && !signal) {
[18:40:52.975]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.975]                     {
[18:40:52.975]                       inherits <- base::inherits
[18:40:52.975]                       invokeRestart <- base::invokeRestart
[18:40:52.975]                       is.null <- base::is.null
[18:40:52.975]                       muffled <- FALSE
[18:40:52.975]                       if (inherits(cond, "message")) {
[18:40:52.975]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.975]                         if (muffled) 
[18:40:52.975]                           invokeRestart("muffleMessage")
[18:40:52.975]                       }
[18:40:52.975]                       else if (inherits(cond, "warning")) {
[18:40:52.975]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.975]                         if (muffled) 
[18:40:52.975]                           invokeRestart("muffleWarning")
[18:40:52.975]                       }
[18:40:52.975]                       else if (inherits(cond, "condition")) {
[18:40:52.975]                         if (!is.null(pattern)) {
[18:40:52.975]                           computeRestarts <- base::computeRestarts
[18:40:52.975]                           grepl <- base::grepl
[18:40:52.975]                           restarts <- computeRestarts(cond)
[18:40:52.975]                           for (restart in restarts) {
[18:40:52.975]                             name <- restart$name
[18:40:52.975]                             if (is.null(name)) 
[18:40:52.975]                               next
[18:40:52.975]                             if (!grepl(pattern, name)) 
[18:40:52.975]                               next
[18:40:52.975]                             invokeRestart(restart)
[18:40:52.975]                             muffled <- TRUE
[18:40:52.975]                             break
[18:40:52.975]                           }
[18:40:52.975]                         }
[18:40:52.975]                       }
[18:40:52.975]                       invisible(muffled)
[18:40:52.975]                     }
[18:40:52.975]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.975]                   }
[18:40:52.975]                 }
[18:40:52.975]                 else {
[18:40:52.975]                   if (TRUE) {
[18:40:52.975]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:52.975]                     {
[18:40:52.975]                       inherits <- base::inherits
[18:40:52.975]                       invokeRestart <- base::invokeRestart
[18:40:52.975]                       is.null <- base::is.null
[18:40:52.975]                       muffled <- FALSE
[18:40:52.975]                       if (inherits(cond, "message")) {
[18:40:52.975]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:52.975]                         if (muffled) 
[18:40:52.975]                           invokeRestart("muffleMessage")
[18:40:52.975]                       }
[18:40:52.975]                       else if (inherits(cond, "warning")) {
[18:40:52.975]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:52.975]                         if (muffled) 
[18:40:52.975]                           invokeRestart("muffleWarning")
[18:40:52.975]                       }
[18:40:52.975]                       else if (inherits(cond, "condition")) {
[18:40:52.975]                         if (!is.null(pattern)) {
[18:40:52.975]                           computeRestarts <- base::computeRestarts
[18:40:52.975]                           grepl <- base::grepl
[18:40:52.975]                           restarts <- computeRestarts(cond)
[18:40:52.975]                           for (restart in restarts) {
[18:40:52.975]                             name <- restart$name
[18:40:52.975]                             if (is.null(name)) 
[18:40:52.975]                               next
[18:40:52.975]                             if (!grepl(pattern, name)) 
[18:40:52.975]                               next
[18:40:52.975]                             invokeRestart(restart)
[18:40:52.975]                             muffled <- TRUE
[18:40:52.975]                             break
[18:40:52.975]                           }
[18:40:52.975]                         }
[18:40:52.975]                       }
[18:40:52.975]                       invisible(muffled)
[18:40:52.975]                     }
[18:40:52.975]                     muffleCondition(cond, pattern = "^muffle")
[18:40:52.975]                   }
[18:40:52.975]                 }
[18:40:52.975]             }
[18:40:52.975]         }))
[18:40:52.975]     }, error = function(ex) {
[18:40:52.975]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:52.975]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:52.975]                 ...future.rng), started = ...future.startTime, 
[18:40:52.975]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:52.975]             version = "1.8"), class = "FutureResult")
[18:40:52.975]     }, finally = {
[18:40:52.975]         if (!identical(...future.workdir, getwd())) 
[18:40:52.975]             setwd(...future.workdir)
[18:40:52.975]         {
[18:40:52.975]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:52.975]                 ...future.oldOptions$nwarnings <- NULL
[18:40:52.975]             }
[18:40:52.975]             base::options(...future.oldOptions)
[18:40:52.975]             if (.Platform$OS.type == "windows") {
[18:40:52.975]                 old_names <- names(...future.oldEnvVars)
[18:40:52.975]                 envs <- base::Sys.getenv()
[18:40:52.975]                 names <- names(envs)
[18:40:52.975]                 common <- intersect(names, old_names)
[18:40:52.975]                 added <- setdiff(names, old_names)
[18:40:52.975]                 removed <- setdiff(old_names, names)
[18:40:52.975]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:52.975]                   envs[common]]
[18:40:52.975]                 NAMES <- toupper(changed)
[18:40:52.975]                 args <- list()
[18:40:52.975]                 for (kk in seq_along(NAMES)) {
[18:40:52.975]                   name <- changed[[kk]]
[18:40:52.975]                   NAME <- NAMES[[kk]]
[18:40:52.975]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.975]                     next
[18:40:52.975]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.975]                 }
[18:40:52.975]                 NAMES <- toupper(added)
[18:40:52.975]                 for (kk in seq_along(NAMES)) {
[18:40:52.975]                   name <- added[[kk]]
[18:40:52.975]                   NAME <- NAMES[[kk]]
[18:40:52.975]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.975]                     next
[18:40:52.975]                   args[[name]] <- ""
[18:40:52.975]                 }
[18:40:52.975]                 NAMES <- toupper(removed)
[18:40:52.975]                 for (kk in seq_along(NAMES)) {
[18:40:52.975]                   name <- removed[[kk]]
[18:40:52.975]                   NAME <- NAMES[[kk]]
[18:40:52.975]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:52.975]                     next
[18:40:52.975]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:52.975]                 }
[18:40:52.975]                 if (length(args) > 0) 
[18:40:52.975]                   base::do.call(base::Sys.setenv, args = args)
[18:40:52.975]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:52.975]             }
[18:40:52.975]             else {
[18:40:52.975]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:52.975]             }
[18:40:52.975]             {
[18:40:52.975]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:52.975]                   0L) {
[18:40:52.975]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:52.975]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:52.975]                   base::options(opts)
[18:40:52.975]                 }
[18:40:52.975]                 {
[18:40:52.975]                   {
[18:40:52.975]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:52.975]                     NULL
[18:40:52.975]                   }
[18:40:52.975]                   options(future.plan = NULL)
[18:40:52.975]                   if (is.na(NA_character_)) 
[18:40:52.975]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:52.975]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:52.975]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:52.975]                     .init = FALSE)
[18:40:52.975]                 }
[18:40:52.975]             }
[18:40:52.975]         }
[18:40:52.975]     })
[18:40:52.975]     if (TRUE) {
[18:40:52.975]         base::sink(type = "output", split = FALSE)
[18:40:52.975]         if (TRUE) {
[18:40:52.975]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:52.975]         }
[18:40:52.975]         else {
[18:40:52.975]             ...future.result["stdout"] <- base::list(NULL)
[18:40:52.975]         }
[18:40:52.975]         base::close(...future.stdout)
[18:40:52.975]         ...future.stdout <- NULL
[18:40:52.975]     }
[18:40:52.975]     ...future.result$conditions <- ...future.conditions
[18:40:52.975]     ...future.result$finished <- base::Sys.time()
[18:40:52.975]     ...future.result
[18:40:52.975] }
[18:40:52.981] Exporting 5 global objects (1.18 KiB) to cluster node #1 ...
[18:40:52.981] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:52.981] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:52.981] Exporting 'future.call.arguments' (152 bytes) to cluster node #1 ...
[18:40:52.982] Exporting 'future.call.arguments' (152 bytes) to cluster node #1 ... DONE
[18:40:52.982] Exporting '...future.elements_ii' (271 bytes) to cluster node #1 ...
[18:40:52.982] Exporting '...future.elements_ii' (271 bytes) to cluster node #1 ... DONE
[18:40:52.983] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:52.983] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:52.983] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:52.984] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:52.984] Exporting 5 global objects (1.18 KiB) to cluster node #1 ... DONE
[18:40:52.984] MultisessionFuture started
[18:40:52.985] - Launch lazy future ... done
[18:40:52.985] run() for 'MultisessionFuture' ... done
[18:40:52.985] Created future:
[18:40:53.003] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.003] - Validating connection of MultisessionFuture
[18:40:53.003] - received message: FutureResult
[18:40:53.003] - Received FutureResult
[18:40:53.004] - Erased future from FutureRegistry
[18:40:53.004] result() for ClusterFuture ...
[18:40:53.004] - result already collected: FutureResult
[18:40:53.004] result() for ClusterFuture ... done
[18:40:53.004] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:52.985] MultisessionFuture:
[18:40:52.985] Label: 'future_by-1'
[18:40:52.985] Expression:
[18:40:52.985] {
[18:40:52.985]     do.call(function(...) {
[18:40:52.985]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:52.985]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:52.985]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:52.985]             on.exit(options(oopts), add = TRUE)
[18:40:52.985]         }
[18:40:52.985]         {
[18:40:52.985]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:52.985]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:52.985]                 ...future.FUN(...future.X_jj, ...)
[18:40:52.985]             })
[18:40:52.985]         }
[18:40:52.985]     }, args = future.call.arguments)
[18:40:52.985] }
[18:40:52.985] Lazy evaluation: FALSE
[18:40:52.985] Asynchronous evaluation: TRUE
[18:40:52.985] Local evaluation: TRUE
[18:40:52.985] Environment: R_GlobalEnv
[18:40:52.985] Capture standard output: TRUE
[18:40:52.985] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:52.985] Globals: 5 objects totaling 758 bytes (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 152 bytes, list '...future.elements_ii' of 271 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:52.985] Packages: <none>
[18:40:52.985] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:52.985] Resolved: TRUE
[18:40:52.985] Value: <not collected>
[18:40:52.985] Conditions captured: <none>
[18:40:52.985] Early signaling: FALSE
[18:40:52.985] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:52.985] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.005] Chunk #1 of 2 ... DONE
[18:40:53.005] Chunk #2 of 2 ...
[18:40:53.005]  - Finding globals in 'X' for chunk #2 ...
[18:40:53.005] getGlobalsAndPackages() ...
[18:40:53.005] Searching for globals...
[18:40:53.006] 
[18:40:53.006] Searching for globals ... DONE
[18:40:53.006] - globals: [0] <none>
[18:40:53.006] getGlobalsAndPackages() ... DONE
[18:40:53.006]    + additional globals found: [n=0] 
[18:40:53.006]    + additional namespaces needed: [n=0] 
[18:40:53.007]  - Finding globals in 'X' for chunk #2 ... DONE
[18:40:53.007]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.007]  - seeds: <none>
[18:40:53.007]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.007] getGlobalsAndPackages() ...
[18:40:53.007] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.008] Resolving globals: FALSE
[18:40:53.008] Tweak future expression to call with '...' arguments ...
[18:40:53.008] {
[18:40:53.008]     do.call(function(...) {
[18:40:53.008]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.008]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.008]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.008]             on.exit(options(oopts), add = TRUE)
[18:40:53.008]         }
[18:40:53.008]         {
[18:40:53.008]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.008]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.008]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.008]             })
[18:40:53.008]         }
[18:40:53.008]     }, args = future.call.arguments)
[18:40:53.008] }
[18:40:53.008] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.009] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.009] 
[18:40:53.009] getGlobalsAndPackages() ... DONE
[18:40:53.009] run() for 'Future' ...
[18:40:53.010] - state: 'created'
[18:40:53.010] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.025] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.025] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.025]   - Field: 'node'
[18:40:53.025]   - Field: 'label'
[18:40:53.026]   - Field: 'local'
[18:40:53.026]   - Field: 'owner'
[18:40:53.026]   - Field: 'envir'
[18:40:53.026]   - Field: 'workers'
[18:40:53.026]   - Field: 'packages'
[18:40:53.026]   - Field: 'gc'
[18:40:53.027]   - Field: 'conditions'
[18:40:53.027]   - Field: 'persistent'
[18:40:53.027]   - Field: 'expr'
[18:40:53.027]   - Field: 'uuid'
[18:40:53.027]   - Field: 'seed'
[18:40:53.027]   - Field: 'version'
[18:40:53.028]   - Field: 'result'
[18:40:53.028]   - Field: 'asynchronous'
[18:40:53.028]   - Field: 'calls'
[18:40:53.028]   - Field: 'globals'
[18:40:53.028]   - Field: 'stdout'
[18:40:53.028]   - Field: 'earlySignal'
[18:40:53.029]   - Field: 'lazy'
[18:40:53.029]   - Field: 'state'
[18:40:53.029] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.029] - Launch lazy future ...
[18:40:53.029] Packages needed by the future expression (n = 0): <none>
[18:40:53.030] Packages needed by future strategies (n = 0): <none>
[18:40:53.030] {
[18:40:53.030]     {
[18:40:53.030]         {
[18:40:53.030]             ...future.startTime <- base::Sys.time()
[18:40:53.030]             {
[18:40:53.030]                 {
[18:40:53.030]                   {
[18:40:53.030]                     {
[18:40:53.030]                       base::local({
[18:40:53.030]                         has_future <- base::requireNamespace("future", 
[18:40:53.030]                           quietly = TRUE)
[18:40:53.030]                         if (has_future) {
[18:40:53.030]                           ns <- base::getNamespace("future")
[18:40:53.030]                           version <- ns[[".package"]][["version"]]
[18:40:53.030]                           if (is.null(version)) 
[18:40:53.030]                             version <- utils::packageVersion("future")
[18:40:53.030]                         }
[18:40:53.030]                         else {
[18:40:53.030]                           version <- NULL
[18:40:53.030]                         }
[18:40:53.030]                         if (!has_future || version < "1.8.0") {
[18:40:53.030]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.030]                             "", base::R.version$version.string), 
[18:40:53.030]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:53.030]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:53.030]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.030]                               "release", "version")], collapse = " "), 
[18:40:53.030]                             hostname = base::Sys.info()[["nodename"]])
[18:40:53.030]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.030]                             info)
[18:40:53.030]                           info <- base::paste(info, collapse = "; ")
[18:40:53.030]                           if (!has_future) {
[18:40:53.030]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.030]                               info)
[18:40:53.030]                           }
[18:40:53.030]                           else {
[18:40:53.030]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.030]                               info, version)
[18:40:53.030]                           }
[18:40:53.030]                           base::stop(msg)
[18:40:53.030]                         }
[18:40:53.030]                       })
[18:40:53.030]                     }
[18:40:53.030]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.030]                     base::options(mc.cores = 1L)
[18:40:53.030]                   }
[18:40:53.030]                   ...future.strategy.old <- future::plan("list")
[18:40:53.030]                   options(future.plan = NULL)
[18:40:53.030]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.030]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.030]                 }
[18:40:53.030]                 ...future.workdir <- getwd()
[18:40:53.030]             }
[18:40:53.030]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.030]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.030]         }
[18:40:53.030]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.030]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.030]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.030]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.030]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.030]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.030]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.030]             base::names(...future.oldOptions))
[18:40:53.030]     }
[18:40:53.030]     if (FALSE) {
[18:40:53.030]     }
[18:40:53.030]     else {
[18:40:53.030]         if (TRUE) {
[18:40:53.030]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.030]                 open = "w")
[18:40:53.030]         }
[18:40:53.030]         else {
[18:40:53.030]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.030]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.030]         }
[18:40:53.030]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.030]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.030]             base::sink(type = "output", split = FALSE)
[18:40:53.030]             base::close(...future.stdout)
[18:40:53.030]         }, add = TRUE)
[18:40:53.030]     }
[18:40:53.030]     ...future.frame <- base::sys.nframe()
[18:40:53.030]     ...future.conditions <- base::list()
[18:40:53.030]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.030]     if (FALSE) {
[18:40:53.030]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.030]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.030]     }
[18:40:53.030]     ...future.result <- base::tryCatch({
[18:40:53.030]         base::withCallingHandlers({
[18:40:53.030]             ...future.value <- base::withVisible(base::local({
[18:40:53.030]                 ...future.makeSendCondition <- base::local({
[18:40:53.030]                   sendCondition <- NULL
[18:40:53.030]                   function(frame = 1L) {
[18:40:53.030]                     if (is.function(sendCondition)) 
[18:40:53.030]                       return(sendCondition)
[18:40:53.030]                     ns <- getNamespace("parallel")
[18:40:53.030]                     if (exists("sendData", mode = "function", 
[18:40:53.030]                       envir = ns)) {
[18:40:53.030]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.030]                         envir = ns)
[18:40:53.030]                       envir <- sys.frame(frame)
[18:40:53.030]                       master <- NULL
[18:40:53.030]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.030]                         !identical(envir, emptyenv())) {
[18:40:53.030]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.030]                           inherits = FALSE)) {
[18:40:53.030]                           master <- get("master", mode = "list", 
[18:40:53.030]                             envir = envir, inherits = FALSE)
[18:40:53.030]                           if (inherits(master, c("SOCKnode", 
[18:40:53.030]                             "SOCK0node"))) {
[18:40:53.030]                             sendCondition <<- function(cond) {
[18:40:53.030]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.030]                                 success = TRUE)
[18:40:53.030]                               parallel_sendData(master, data)
[18:40:53.030]                             }
[18:40:53.030]                             return(sendCondition)
[18:40:53.030]                           }
[18:40:53.030]                         }
[18:40:53.030]                         frame <- frame + 1L
[18:40:53.030]                         envir <- sys.frame(frame)
[18:40:53.030]                       }
[18:40:53.030]                     }
[18:40:53.030]                     sendCondition <<- function(cond) NULL
[18:40:53.030]                   }
[18:40:53.030]                 })
[18:40:53.030]                 withCallingHandlers({
[18:40:53.030]                   {
[18:40:53.030]                     do.call(function(...) {
[18:40:53.030]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.030]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.030]                         ...future.globals.maxSize)) {
[18:40:53.030]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.030]                         on.exit(options(oopts), add = TRUE)
[18:40:53.030]                       }
[18:40:53.030]                       {
[18:40:53.030]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.030]                           FUN = function(jj) {
[18:40:53.030]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.030]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.030]                           })
[18:40:53.030]                       }
[18:40:53.030]                     }, args = future.call.arguments)
[18:40:53.030]                   }
[18:40:53.030]                 }, immediateCondition = function(cond) {
[18:40:53.030]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.030]                   sendCondition(cond)
[18:40:53.030]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.030]                   {
[18:40:53.030]                     inherits <- base::inherits
[18:40:53.030]                     invokeRestart <- base::invokeRestart
[18:40:53.030]                     is.null <- base::is.null
[18:40:53.030]                     muffled <- FALSE
[18:40:53.030]                     if (inherits(cond, "message")) {
[18:40:53.030]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.030]                       if (muffled) 
[18:40:53.030]                         invokeRestart("muffleMessage")
[18:40:53.030]                     }
[18:40:53.030]                     else if (inherits(cond, "warning")) {
[18:40:53.030]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.030]                       if (muffled) 
[18:40:53.030]                         invokeRestart("muffleWarning")
[18:40:53.030]                     }
[18:40:53.030]                     else if (inherits(cond, "condition")) {
[18:40:53.030]                       if (!is.null(pattern)) {
[18:40:53.030]                         computeRestarts <- base::computeRestarts
[18:40:53.030]                         grepl <- base::grepl
[18:40:53.030]                         restarts <- computeRestarts(cond)
[18:40:53.030]                         for (restart in restarts) {
[18:40:53.030]                           name <- restart$name
[18:40:53.030]                           if (is.null(name)) 
[18:40:53.030]                             next
[18:40:53.030]                           if (!grepl(pattern, name)) 
[18:40:53.030]                             next
[18:40:53.030]                           invokeRestart(restart)
[18:40:53.030]                           muffled <- TRUE
[18:40:53.030]                           break
[18:40:53.030]                         }
[18:40:53.030]                       }
[18:40:53.030]                     }
[18:40:53.030]                     invisible(muffled)
[18:40:53.030]                   }
[18:40:53.030]                   muffleCondition(cond)
[18:40:53.030]                 })
[18:40:53.030]             }))
[18:40:53.030]             future::FutureResult(value = ...future.value$value, 
[18:40:53.030]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.030]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.030]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.030]                     ...future.globalenv.names))
[18:40:53.030]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.030]         }, condition = base::local({
[18:40:53.030]             c <- base::c
[18:40:53.030]             inherits <- base::inherits
[18:40:53.030]             invokeRestart <- base::invokeRestart
[18:40:53.030]             length <- base::length
[18:40:53.030]             list <- base::list
[18:40:53.030]             seq.int <- base::seq.int
[18:40:53.030]             signalCondition <- base::signalCondition
[18:40:53.030]             sys.calls <- base::sys.calls
[18:40:53.030]             `[[` <- base::`[[`
[18:40:53.030]             `+` <- base::`+`
[18:40:53.030]             `<<-` <- base::`<<-`
[18:40:53.030]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.030]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.030]                   3L)]
[18:40:53.030]             }
[18:40:53.030]             function(cond) {
[18:40:53.030]                 is_error <- inherits(cond, "error")
[18:40:53.030]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.030]                   NULL)
[18:40:53.030]                 if (is_error) {
[18:40:53.030]                   sessionInformation <- function() {
[18:40:53.030]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.030]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.030]                       search = base::search(), system = base::Sys.info())
[18:40:53.030]                   }
[18:40:53.030]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.030]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.030]                     cond$call), session = sessionInformation(), 
[18:40:53.030]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.030]                   signalCondition(cond)
[18:40:53.030]                 }
[18:40:53.030]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.030]                 "immediateCondition"))) {
[18:40:53.030]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.030]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.030]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.030]                   if (TRUE && !signal) {
[18:40:53.030]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.030]                     {
[18:40:53.030]                       inherits <- base::inherits
[18:40:53.030]                       invokeRestart <- base::invokeRestart
[18:40:53.030]                       is.null <- base::is.null
[18:40:53.030]                       muffled <- FALSE
[18:40:53.030]                       if (inherits(cond, "message")) {
[18:40:53.030]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.030]                         if (muffled) 
[18:40:53.030]                           invokeRestart("muffleMessage")
[18:40:53.030]                       }
[18:40:53.030]                       else if (inherits(cond, "warning")) {
[18:40:53.030]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.030]                         if (muffled) 
[18:40:53.030]                           invokeRestart("muffleWarning")
[18:40:53.030]                       }
[18:40:53.030]                       else if (inherits(cond, "condition")) {
[18:40:53.030]                         if (!is.null(pattern)) {
[18:40:53.030]                           computeRestarts <- base::computeRestarts
[18:40:53.030]                           grepl <- base::grepl
[18:40:53.030]                           restarts <- computeRestarts(cond)
[18:40:53.030]                           for (restart in restarts) {
[18:40:53.030]                             name <- restart$name
[18:40:53.030]                             if (is.null(name)) 
[18:40:53.030]                               next
[18:40:53.030]                             if (!grepl(pattern, name)) 
[18:40:53.030]                               next
[18:40:53.030]                             invokeRestart(restart)
[18:40:53.030]                             muffled <- TRUE
[18:40:53.030]                             break
[18:40:53.030]                           }
[18:40:53.030]                         }
[18:40:53.030]                       }
[18:40:53.030]                       invisible(muffled)
[18:40:53.030]                     }
[18:40:53.030]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.030]                   }
[18:40:53.030]                 }
[18:40:53.030]                 else {
[18:40:53.030]                   if (TRUE) {
[18:40:53.030]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.030]                     {
[18:40:53.030]                       inherits <- base::inherits
[18:40:53.030]                       invokeRestart <- base::invokeRestart
[18:40:53.030]                       is.null <- base::is.null
[18:40:53.030]                       muffled <- FALSE
[18:40:53.030]                       if (inherits(cond, "message")) {
[18:40:53.030]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.030]                         if (muffled) 
[18:40:53.030]                           invokeRestart("muffleMessage")
[18:40:53.030]                       }
[18:40:53.030]                       else if (inherits(cond, "warning")) {
[18:40:53.030]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.030]                         if (muffled) 
[18:40:53.030]                           invokeRestart("muffleWarning")
[18:40:53.030]                       }
[18:40:53.030]                       else if (inherits(cond, "condition")) {
[18:40:53.030]                         if (!is.null(pattern)) {
[18:40:53.030]                           computeRestarts <- base::computeRestarts
[18:40:53.030]                           grepl <- base::grepl
[18:40:53.030]                           restarts <- computeRestarts(cond)
[18:40:53.030]                           for (restart in restarts) {
[18:40:53.030]                             name <- restart$name
[18:40:53.030]                             if (is.null(name)) 
[18:40:53.030]                               next
[18:40:53.030]                             if (!grepl(pattern, name)) 
[18:40:53.030]                               next
[18:40:53.030]                             invokeRestart(restart)
[18:40:53.030]                             muffled <- TRUE
[18:40:53.030]                             break
[18:40:53.030]                           }
[18:40:53.030]                         }
[18:40:53.030]                       }
[18:40:53.030]                       invisible(muffled)
[18:40:53.030]                     }
[18:40:53.030]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.030]                   }
[18:40:53.030]                 }
[18:40:53.030]             }
[18:40:53.030]         }))
[18:40:53.030]     }, error = function(ex) {
[18:40:53.030]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.030]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.030]                 ...future.rng), started = ...future.startTime, 
[18:40:53.030]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.030]             version = "1.8"), class = "FutureResult")
[18:40:53.030]     }, finally = {
[18:40:53.030]         if (!identical(...future.workdir, getwd())) 
[18:40:53.030]             setwd(...future.workdir)
[18:40:53.030]         {
[18:40:53.030]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.030]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.030]             }
[18:40:53.030]             base::options(...future.oldOptions)
[18:40:53.030]             if (.Platform$OS.type == "windows") {
[18:40:53.030]                 old_names <- names(...future.oldEnvVars)
[18:40:53.030]                 envs <- base::Sys.getenv()
[18:40:53.030]                 names <- names(envs)
[18:40:53.030]                 common <- intersect(names, old_names)
[18:40:53.030]                 added <- setdiff(names, old_names)
[18:40:53.030]                 removed <- setdiff(old_names, names)
[18:40:53.030]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.030]                   envs[common]]
[18:40:53.030]                 NAMES <- toupper(changed)
[18:40:53.030]                 args <- list()
[18:40:53.030]                 for (kk in seq_along(NAMES)) {
[18:40:53.030]                   name <- changed[[kk]]
[18:40:53.030]                   NAME <- NAMES[[kk]]
[18:40:53.030]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.030]                     next
[18:40:53.030]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.030]                 }
[18:40:53.030]                 NAMES <- toupper(added)
[18:40:53.030]                 for (kk in seq_along(NAMES)) {
[18:40:53.030]                   name <- added[[kk]]
[18:40:53.030]                   NAME <- NAMES[[kk]]
[18:40:53.030]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.030]                     next
[18:40:53.030]                   args[[name]] <- ""
[18:40:53.030]                 }
[18:40:53.030]                 NAMES <- toupper(removed)
[18:40:53.030]                 for (kk in seq_along(NAMES)) {
[18:40:53.030]                   name <- removed[[kk]]
[18:40:53.030]                   NAME <- NAMES[[kk]]
[18:40:53.030]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.030]                     next
[18:40:53.030]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.030]                 }
[18:40:53.030]                 if (length(args) > 0) 
[18:40:53.030]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.030]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.030]             }
[18:40:53.030]             else {
[18:40:53.030]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.030]             }
[18:40:53.030]             {
[18:40:53.030]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.030]                   0L) {
[18:40:53.030]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.030]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.030]                   base::options(opts)
[18:40:53.030]                 }
[18:40:53.030]                 {
[18:40:53.030]                   {
[18:40:53.030]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.030]                     NULL
[18:40:53.030]                   }
[18:40:53.030]                   options(future.plan = NULL)
[18:40:53.030]                   if (is.na(NA_character_)) 
[18:40:53.030]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.030]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.030]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.030]                     .init = FALSE)
[18:40:53.030]                 }
[18:40:53.030]             }
[18:40:53.030]         }
[18:40:53.030]     })
[18:40:53.030]     if (TRUE) {
[18:40:53.030]         base::sink(type = "output", split = FALSE)
[18:40:53.030]         if (TRUE) {
[18:40:53.030]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.030]         }
[18:40:53.030]         else {
[18:40:53.030]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.030]         }
[18:40:53.030]         base::close(...future.stdout)
[18:40:53.030]         ...future.stdout <- NULL
[18:40:53.030]     }
[18:40:53.030]     ...future.result$conditions <- ...future.conditions
[18:40:53.030]     ...future.result$finished <- base::Sys.time()
[18:40:53.030]     ...future.result
[18:40:53.030] }
[18:40:53.036] Exporting 5 global objects (1.18 KiB) to cluster node #1 ...
[18:40:53.036] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:53.036] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:53.036] Exporting 'future.call.arguments' (152 bytes) to cluster node #1 ...
[18:40:53.037] Exporting 'future.call.arguments' (152 bytes) to cluster node #1 ... DONE
[18:40:53.037] Exporting '...future.elements_ii' (271 bytes) to cluster node #1 ...
[18:40:53.037] Exporting '...future.elements_ii' (271 bytes) to cluster node #1 ... DONE
[18:40:53.038] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.038] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.038] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.039] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.039] Exporting 5 global objects (1.18 KiB) to cluster node #1 ... DONE
[18:40:53.039] MultisessionFuture started
[18:40:53.040] - Launch lazy future ... done
[18:40:53.040] run() for 'MultisessionFuture' ... done
[18:40:53.040] Created future:
[18:40:53.055] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.055] - Validating connection of MultisessionFuture
[18:40:53.055] - received message: FutureResult
[18:40:53.056] - Received FutureResult
[18:40:53.056] - Erased future from FutureRegistry
[18:40:53.056] result() for ClusterFuture ...
[18:40:53.056] - result already collected: FutureResult
[18:40:53.056] result() for ClusterFuture ... done
[18:40:53.056] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.040] MultisessionFuture:
[18:40:53.040] Label: 'future_by-2'
[18:40:53.040] Expression:
[18:40:53.040] {
[18:40:53.040]     do.call(function(...) {
[18:40:53.040]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.040]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.040]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.040]             on.exit(options(oopts), add = TRUE)
[18:40:53.040]         }
[18:40:53.040]         {
[18:40:53.040]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.040]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.040]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.040]             })
[18:40:53.040]         }
[18:40:53.040]     }, args = future.call.arguments)
[18:40:53.040] }
[18:40:53.040] Lazy evaluation: FALSE
[18:40:53.040] Asynchronous evaluation: TRUE
[18:40:53.040] Local evaluation: TRUE
[18:40:53.040] Environment: R_GlobalEnv
[18:40:53.040] Capture standard output: TRUE
[18:40:53.040] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.040] Globals: 5 objects totaling 758 bytes (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 152 bytes, list '...future.elements_ii' of 271 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.040] Packages: <none>
[18:40:53.040] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.040] Resolved: TRUE
[18:40:53.040] Value: <not collected>
[18:40:53.040] Conditions captured: <none>
[18:40:53.040] Early signaling: FALSE
[18:40:53.040] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.040] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.057] Chunk #2 of 2 ... DONE
[18:40:53.057] Launching 2 futures (chunks) ... DONE
[18:40:53.057] Resolving 2 futures (chunks) ...
[18:40:53.057] resolve() on list ...
[18:40:53.057]  recursive: 0
[18:40:53.058]  length: 2
[18:40:53.058] 
[18:40:53.058] Future #1
[18:40:53.058] result() for ClusterFuture ...
[18:40:53.058] - result already collected: FutureResult
[18:40:53.058] result() for ClusterFuture ... done
[18:40:53.059] result() for ClusterFuture ...
[18:40:53.059] - result already collected: FutureResult
[18:40:53.059] result() for ClusterFuture ... done
[18:40:53.059] signalConditionsASAP(MultisessionFuture, pos=1) ...
[18:40:53.059] - nx: 2
[18:40:53.059] - relay: TRUE
[18:40:53.059] - stdout: TRUE
[18:40:53.060] - signal: TRUE
[18:40:53.060] - resignal: FALSE
[18:40:53.060] - force: TRUE
[18:40:53.060] - relayed: [n=2] FALSE, FALSE
[18:40:53.060] - queued futures: [n=2] FALSE, FALSE
[18:40:53.060]  - until=1
[18:40:53.060]  - relaying element #1
[18:40:53.061] result() for ClusterFuture ...
[18:40:53.061] - result already collected: FutureResult
[18:40:53.061] result() for ClusterFuture ... done
[18:40:53.061] result() for ClusterFuture ...
[18:40:53.061] - result already collected: FutureResult
[18:40:53.061] result() for ClusterFuture ... done
[18:40:53.062] result() for ClusterFuture ...
[18:40:53.062] - result already collected: FutureResult
[18:40:53.062] result() for ClusterFuture ... done
[18:40:53.062] result() for ClusterFuture ...
[18:40:53.062] - result already collected: FutureResult
[18:40:53.062] result() for ClusterFuture ... done
[18:40:53.063] - relayed: [n=2] TRUE, FALSE
[18:40:53.063] - queued futures: [n=2] TRUE, FALSE
[18:40:53.063] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[18:40:53.063]  length: 1 (resolved future 1)
[18:40:53.063] Future #2
[18:40:53.063] result() for ClusterFuture ...
[18:40:53.064] - result already collected: FutureResult
[18:40:53.064] result() for ClusterFuture ... done
[18:40:53.064] result() for ClusterFuture ...
[18:40:53.064] - result already collected: FutureResult
[18:40:53.064] result() for ClusterFuture ... done
[18:40:53.064] signalConditionsASAP(MultisessionFuture, pos=2) ...
[18:40:53.065] - nx: 2
[18:40:53.065] - relay: TRUE
[18:40:53.065] - stdout: TRUE
[18:40:53.065] - signal: TRUE
[18:40:53.065] - resignal: FALSE
[18:40:53.065] - force: TRUE
[18:40:53.065] - relayed: [n=2] TRUE, FALSE
[18:40:53.066] - queued futures: [n=2] TRUE, FALSE
[18:40:53.066]  - until=2
[18:40:53.066]  - relaying element #2
[18:40:53.066] result() for ClusterFuture ...
[18:40:53.066] - result already collected: FutureResult
[18:40:53.066] result() for ClusterFuture ... done
[18:40:53.067] result() for ClusterFuture ...
[18:40:53.067] - result already collected: FutureResult
[18:40:53.067] result() for ClusterFuture ... done
[18:40:53.067] result() for ClusterFuture ...
[18:40:53.067] - result already collected: FutureResult
[18:40:53.067] result() for ClusterFuture ... done
[18:40:53.067] result() for ClusterFuture ...
[18:40:53.068] - result already collected: FutureResult
[18:40:53.068] result() for ClusterFuture ... done
[18:40:53.068] - relayed: [n=2] TRUE, TRUE
[18:40:53.068] - queued futures: [n=2] TRUE, TRUE
[18:40:53.068] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[18:40:53.068]  length: 0 (resolved future 2)
[18:40:53.069] Relaying remaining futures
[18:40:53.069] signalConditionsASAP(NULL, pos=0) ...
[18:40:53.069] - nx: 2
[18:40:53.069] - relay: TRUE
[18:40:53.069] - stdout: TRUE
[18:40:53.069] - signal: TRUE
[18:40:53.069] - resignal: FALSE
[18:40:53.070] - force: TRUE
[18:40:53.070] - relayed: [n=2] TRUE, TRUE
[18:40:53.070] - queued futures: [n=2] TRUE, TRUE
 - flush all
[18:40:53.070] - relayed: [n=2] TRUE, TRUE
[18:40:53.070] - queued futures: [n=2] TRUE, TRUE
[18:40:53.070] signalConditionsASAP(NULL, pos=0) ... done
[18:40:53.071] resolve() on list ... DONE
[18:40:53.071] result() for ClusterFuture ...
[18:40:53.071] - result already collected: FutureResult
[18:40:53.071] result() for ClusterFuture ... done
[18:40:53.071] result() for ClusterFuture ...
[18:40:53.071] - result already collected: FutureResult
[18:40:53.071] result() for ClusterFuture ... done
[18:40:53.072] result() for ClusterFuture ...
[18:40:53.072] - result already collected: FutureResult
[18:40:53.072] result() for ClusterFuture ... done
[18:40:53.072] result() for ClusterFuture ...
[18:40:53.072] - result already collected: FutureResult
[18:40:53.072] result() for ClusterFuture ... done
[18:40:53.073]  - Number of value chunks collected: 2
[18:40:53.073] Resolving 2 futures (chunks) ... DONE
[18:40:53.073] Reducing values from 2 chunks ...
[18:40:53.073]  - Number of values collected after concatenation: 6
[18:40:53.073]  - Number of values expected: 6
[18:40:53.073] Reducing values from 2 chunks ... DONE
[18:40:53.074] future_lapply() ... DONE
[18:40:53.074] future_by_internal() ... DONE
[18:40:53.075] future_by_internal() ...
[18:40:53.075] future_lapply() ...
[18:40:53.079] Number of chunks: 2
[18:40:53.079] getGlobalsAndPackagesXApply() ...
[18:40:53.079]  - future.globals: TRUE
[18:40:53.079] getGlobalsAndPackages() ...
[18:40:53.079] Searching for globals...
[18:40:53.081] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:53.082] Searching for globals ... DONE
[18:40:53.082] Resolving globals: FALSE
[18:40:53.082] The total size of the 1 globals is 762 bytes (762 bytes)
[18:40:53.083] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 762 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (762 bytes of class 'function')
[18:40:53.083] - globals: [1] 'FUN'
[18:40:53.083] - packages: [1] 'stats'
[18:40:53.083] getGlobalsAndPackages() ... DONE
[18:40:53.083]  - globals found/used: [n=1] 'FUN'
[18:40:53.084]  - needed namespaces: [n=1] 'stats'
[18:40:53.084] Finding globals ... DONE
[18:40:53.084]  - use_args: TRUE
[18:40:53.084]  - Getting '...' globals ...
[18:40:53.085] resolve() on list ...
[18:40:53.085]  recursive: 0
[18:40:53.085]  length: 1
[18:40:53.085]  elements: '...'
[18:40:53.085]  length: 0 (resolved future 1)
[18:40:53.086] resolve() on list ... DONE
[18:40:53.086]    - '...' content: [n=1] 'singular.ok'
[18:40:53.086] List of 1
[18:40:53.086]  $ ...:List of 1
[18:40:53.086]   ..$ singular.ok: logi FALSE
[18:40:53.086]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.086]  - attr(*, "where")=List of 1
[18:40:53.086]   ..$ ...:<environment: 0x000001cd4dd6ea00> 
[18:40:53.086]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.086]  - attr(*, "resolved")= logi TRUE
[18:40:53.086]  - attr(*, "total_size")= num NA
[18:40:53.091]  - Getting '...' globals ... DONE
[18:40:53.091] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:53.092] List of 2
[18:40:53.092]  $ ...future.FUN:function (x, ...)  
[18:40:53.092]  $ ...          :List of 1
[18:40:53.092]   ..$ singular.ok: logi FALSE
[18:40:53.092]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.092]  - attr(*, "where")=List of 2
[18:40:53.092]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:53.092]   ..$ ...          :<environment: 0x000001cd4dd6ea00> 
[18:40:53.092]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.092]  - attr(*, "resolved")= logi FALSE
[18:40:53.092]  - attr(*, "total_size")= int 19977
[18:40:53.096] Packages to be attached in all futures: [n=1] 'stats'
[18:40:53.096] getGlobalsAndPackagesXApply() ... DONE
[18:40:53.096] Number of futures (= number of chunks): 2
[18:40:53.096] Launching 2 futures (chunks) ...
[18:40:53.096] Chunk #1 of 2 ...
[18:40:53.097]  - Finding globals in 'X' for chunk #1 ...
[18:40:53.097] getGlobalsAndPackages() ...
[18:40:53.097] Searching for globals...
[18:40:53.097] 
[18:40:53.097] Searching for globals ... DONE
[18:40:53.098] - globals: [0] <none>
[18:40:53.098] getGlobalsAndPackages() ... DONE
[18:40:53.098]    + additional globals found: [n=0] 
[18:40:53.098]    + additional namespaces needed: [n=0] 
[18:40:53.098]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:53.098]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.099]  - seeds: <none>
[18:40:53.099]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.099] getGlobalsAndPackages() ...
[18:40:53.099] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.099] Resolving globals: FALSE
[18:40:53.099] Tweak future expression to call with '...' arguments ...
[18:40:53.100] {
[18:40:53.100]     do.call(function(...) {
[18:40:53.100]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.100]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.100]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.100]             on.exit(options(oopts), add = TRUE)
[18:40:53.100]         }
[18:40:53.100]         {
[18:40:53.100]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.100]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.100]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.100]             })
[18:40:53.100]         }
[18:40:53.100]     }, args = future.call.arguments)
[18:40:53.100] }
[18:40:53.100] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.100] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.101] 
[18:40:53.101] getGlobalsAndPackages() ... DONE
[18:40:53.101] run() for 'Future' ...
[18:40:53.101] - state: 'created'
[18:40:53.102] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.116] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.117] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.117]   - Field: 'node'
[18:40:53.117]   - Field: 'label'
[18:40:53.117]   - Field: 'local'
[18:40:53.117]   - Field: 'owner'
[18:40:53.117]   - Field: 'envir'
[18:40:53.118]   - Field: 'workers'
[18:40:53.118]   - Field: 'packages'
[18:40:53.118]   - Field: 'gc'
[18:40:53.118]   - Field: 'conditions'
[18:40:53.118]   - Field: 'persistent'
[18:40:53.118]   - Field: 'expr'
[18:40:53.119]   - Field: 'uuid'
[18:40:53.119]   - Field: 'seed'
[18:40:53.119]   - Field: 'version'
[18:40:53.119]   - Field: 'result'
[18:40:53.119]   - Field: 'asynchronous'
[18:40:53.119]   - Field: 'calls'
[18:40:53.120]   - Field: 'globals'
[18:40:53.120]   - Field: 'stdout'
[18:40:53.120]   - Field: 'earlySignal'
[18:40:53.120]   - Field: 'lazy'
[18:40:53.120]   - Field: 'state'
[18:40:53.120] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.121] - Launch lazy future ...
[18:40:53.121] Packages needed by the future expression (n = 1): 'stats'
[18:40:53.121] Packages needed by future strategies (n = 0): <none>
[18:40:53.122] {
[18:40:53.122]     {
[18:40:53.122]         {
[18:40:53.122]             ...future.startTime <- base::Sys.time()
[18:40:53.122]             {
[18:40:53.122]                 {
[18:40:53.122]                   {
[18:40:53.122]                     {
[18:40:53.122]                       {
[18:40:53.122]                         base::local({
[18:40:53.122]                           has_future <- base::requireNamespace("future", 
[18:40:53.122]                             quietly = TRUE)
[18:40:53.122]                           if (has_future) {
[18:40:53.122]                             ns <- base::getNamespace("future")
[18:40:53.122]                             version <- ns[[".package"]][["version"]]
[18:40:53.122]                             if (is.null(version)) 
[18:40:53.122]                               version <- utils::packageVersion("future")
[18:40:53.122]                           }
[18:40:53.122]                           else {
[18:40:53.122]                             version <- NULL
[18:40:53.122]                           }
[18:40:53.122]                           if (!has_future || version < "1.8.0") {
[18:40:53.122]                             info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.122]                               "", base::R.version$version.string), 
[18:40:53.122]                               platform = base::sprintf("%s (%s-bit)", 
[18:40:53.122]                                 base::R.version$platform, 8 * 
[18:40:53.122]                                   base::.Machine$sizeof.pointer), 
[18:40:53.122]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.122]                                 "release", "version")], collapse = " "), 
[18:40:53.122]                               hostname = base::Sys.info()[["nodename"]])
[18:40:53.122]                             info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.122]                               info)
[18:40:53.122]                             info <- base::paste(info, collapse = "; ")
[18:40:53.122]                             if (!has_future) {
[18:40:53.122]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.122]                                 info)
[18:40:53.122]                             }
[18:40:53.122]                             else {
[18:40:53.122]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.122]                                 info, version)
[18:40:53.122]                             }
[18:40:53.122]                             base::stop(msg)
[18:40:53.122]                           }
[18:40:53.122]                         })
[18:40:53.122]                       }
[18:40:53.122]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.122]                       base::options(mc.cores = 1L)
[18:40:53.122]                     }
[18:40:53.122]                     base::local({
[18:40:53.122]                       for (pkg in "stats") {
[18:40:53.122]                         base::loadNamespace(pkg)
[18:40:53.122]                         base::library(pkg, character.only = TRUE)
[18:40:53.122]                       }
[18:40:53.122]                     })
[18:40:53.122]                   }
[18:40:53.122]                   ...future.strategy.old <- future::plan("list")
[18:40:53.122]                   options(future.plan = NULL)
[18:40:53.122]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.122]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.122]                 }
[18:40:53.122]                 ...future.workdir <- getwd()
[18:40:53.122]             }
[18:40:53.122]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.122]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.122]         }
[18:40:53.122]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.122]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.122]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.122]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.122]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.122]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.122]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.122]             base::names(...future.oldOptions))
[18:40:53.122]     }
[18:40:53.122]     if (FALSE) {
[18:40:53.122]     }
[18:40:53.122]     else {
[18:40:53.122]         if (TRUE) {
[18:40:53.122]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.122]                 open = "w")
[18:40:53.122]         }
[18:40:53.122]         else {
[18:40:53.122]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.122]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.122]         }
[18:40:53.122]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.122]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.122]             base::sink(type = "output", split = FALSE)
[18:40:53.122]             base::close(...future.stdout)
[18:40:53.122]         }, add = TRUE)
[18:40:53.122]     }
[18:40:53.122]     ...future.frame <- base::sys.nframe()
[18:40:53.122]     ...future.conditions <- base::list()
[18:40:53.122]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.122]     if (FALSE) {
[18:40:53.122]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.122]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.122]     }
[18:40:53.122]     ...future.result <- base::tryCatch({
[18:40:53.122]         base::withCallingHandlers({
[18:40:53.122]             ...future.value <- base::withVisible(base::local({
[18:40:53.122]                 ...future.makeSendCondition <- base::local({
[18:40:53.122]                   sendCondition <- NULL
[18:40:53.122]                   function(frame = 1L) {
[18:40:53.122]                     if (is.function(sendCondition)) 
[18:40:53.122]                       return(sendCondition)
[18:40:53.122]                     ns <- getNamespace("parallel")
[18:40:53.122]                     if (exists("sendData", mode = "function", 
[18:40:53.122]                       envir = ns)) {
[18:40:53.122]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.122]                         envir = ns)
[18:40:53.122]                       envir <- sys.frame(frame)
[18:40:53.122]                       master <- NULL
[18:40:53.122]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.122]                         !identical(envir, emptyenv())) {
[18:40:53.122]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.122]                           inherits = FALSE)) {
[18:40:53.122]                           master <- get("master", mode = "list", 
[18:40:53.122]                             envir = envir, inherits = FALSE)
[18:40:53.122]                           if (inherits(master, c("SOCKnode", 
[18:40:53.122]                             "SOCK0node"))) {
[18:40:53.122]                             sendCondition <<- function(cond) {
[18:40:53.122]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.122]                                 success = TRUE)
[18:40:53.122]                               parallel_sendData(master, data)
[18:40:53.122]                             }
[18:40:53.122]                             return(sendCondition)
[18:40:53.122]                           }
[18:40:53.122]                         }
[18:40:53.122]                         frame <- frame + 1L
[18:40:53.122]                         envir <- sys.frame(frame)
[18:40:53.122]                       }
[18:40:53.122]                     }
[18:40:53.122]                     sendCondition <<- function(cond) NULL
[18:40:53.122]                   }
[18:40:53.122]                 })
[18:40:53.122]                 withCallingHandlers({
[18:40:53.122]                   {
[18:40:53.122]                     do.call(function(...) {
[18:40:53.122]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.122]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.122]                         ...future.globals.maxSize)) {
[18:40:53.122]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.122]                         on.exit(options(oopts), add = TRUE)
[18:40:53.122]                       }
[18:40:53.122]                       {
[18:40:53.122]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.122]                           FUN = function(jj) {
[18:40:53.122]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.122]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.122]                           })
[18:40:53.122]                       }
[18:40:53.122]                     }, args = future.call.arguments)
[18:40:53.122]                   }
[18:40:53.122]                 }, immediateCondition = function(cond) {
[18:40:53.122]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.122]                   sendCondition(cond)
[18:40:53.122]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.122]                   {
[18:40:53.122]                     inherits <- base::inherits
[18:40:53.122]                     invokeRestart <- base::invokeRestart
[18:40:53.122]                     is.null <- base::is.null
[18:40:53.122]                     muffled <- FALSE
[18:40:53.122]                     if (inherits(cond, "message")) {
[18:40:53.122]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.122]                       if (muffled) 
[18:40:53.122]                         invokeRestart("muffleMessage")
[18:40:53.122]                     }
[18:40:53.122]                     else if (inherits(cond, "warning")) {
[18:40:53.122]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.122]                       if (muffled) 
[18:40:53.122]                         invokeRestart("muffleWarning")
[18:40:53.122]                     }
[18:40:53.122]                     else if (inherits(cond, "condition")) {
[18:40:53.122]                       if (!is.null(pattern)) {
[18:40:53.122]                         computeRestarts <- base::computeRestarts
[18:40:53.122]                         grepl <- base::grepl
[18:40:53.122]                         restarts <- computeRestarts(cond)
[18:40:53.122]                         for (restart in restarts) {
[18:40:53.122]                           name <- restart$name
[18:40:53.122]                           if (is.null(name)) 
[18:40:53.122]                             next
[18:40:53.122]                           if (!grepl(pattern, name)) 
[18:40:53.122]                             next
[18:40:53.122]                           invokeRestart(restart)
[18:40:53.122]                           muffled <- TRUE
[18:40:53.122]                           break
[18:40:53.122]                         }
[18:40:53.122]                       }
[18:40:53.122]                     }
[18:40:53.122]                     invisible(muffled)
[18:40:53.122]                   }
[18:40:53.122]                   muffleCondition(cond)
[18:40:53.122]                 })
[18:40:53.122]             }))
[18:40:53.122]             future::FutureResult(value = ...future.value$value, 
[18:40:53.122]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.122]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.122]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.122]                     ...future.globalenv.names))
[18:40:53.122]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.122]         }, condition = base::local({
[18:40:53.122]             c <- base::c
[18:40:53.122]             inherits <- base::inherits
[18:40:53.122]             invokeRestart <- base::invokeRestart
[18:40:53.122]             length <- base::length
[18:40:53.122]             list <- base::list
[18:40:53.122]             seq.int <- base::seq.int
[18:40:53.122]             signalCondition <- base::signalCondition
[18:40:53.122]             sys.calls <- base::sys.calls
[18:40:53.122]             `[[` <- base::`[[`
[18:40:53.122]             `+` <- base::`+`
[18:40:53.122]             `<<-` <- base::`<<-`
[18:40:53.122]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.122]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.122]                   3L)]
[18:40:53.122]             }
[18:40:53.122]             function(cond) {
[18:40:53.122]                 is_error <- inherits(cond, "error")
[18:40:53.122]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.122]                   NULL)
[18:40:53.122]                 if (is_error) {
[18:40:53.122]                   sessionInformation <- function() {
[18:40:53.122]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.122]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.122]                       search = base::search(), system = base::Sys.info())
[18:40:53.122]                   }
[18:40:53.122]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.122]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.122]                     cond$call), session = sessionInformation(), 
[18:40:53.122]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.122]                   signalCondition(cond)
[18:40:53.122]                 }
[18:40:53.122]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.122]                 "immediateCondition"))) {
[18:40:53.122]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.122]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.122]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.122]                   if (TRUE && !signal) {
[18:40:53.122]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.122]                     {
[18:40:53.122]                       inherits <- base::inherits
[18:40:53.122]                       invokeRestart <- base::invokeRestart
[18:40:53.122]                       is.null <- base::is.null
[18:40:53.122]                       muffled <- FALSE
[18:40:53.122]                       if (inherits(cond, "message")) {
[18:40:53.122]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.122]                         if (muffled) 
[18:40:53.122]                           invokeRestart("muffleMessage")
[18:40:53.122]                       }
[18:40:53.122]                       else if (inherits(cond, "warning")) {
[18:40:53.122]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.122]                         if (muffled) 
[18:40:53.122]                           invokeRestart("muffleWarning")
[18:40:53.122]                       }
[18:40:53.122]                       else if (inherits(cond, "condition")) {
[18:40:53.122]                         if (!is.null(pattern)) {
[18:40:53.122]                           computeRestarts <- base::computeRestarts
[18:40:53.122]                           grepl <- base::grepl
[18:40:53.122]                           restarts <- computeRestarts(cond)
[18:40:53.122]                           for (restart in restarts) {
[18:40:53.122]                             name <- restart$name
[18:40:53.122]                             if (is.null(name)) 
[18:40:53.122]                               next
[18:40:53.122]                             if (!grepl(pattern, name)) 
[18:40:53.122]                               next
[18:40:53.122]                             invokeRestart(restart)
[18:40:53.122]                             muffled <- TRUE
[18:40:53.122]                             break
[18:40:53.122]                           }
[18:40:53.122]                         }
[18:40:53.122]                       }
[18:40:53.122]                       invisible(muffled)
[18:40:53.122]                     }
[18:40:53.122]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.122]                   }
[18:40:53.122]                 }
[18:40:53.122]                 else {
[18:40:53.122]                   if (TRUE) {
[18:40:53.122]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.122]                     {
[18:40:53.122]                       inherits <- base::inherits
[18:40:53.122]                       invokeRestart <- base::invokeRestart
[18:40:53.122]                       is.null <- base::is.null
[18:40:53.122]                       muffled <- FALSE
[18:40:53.122]                       if (inherits(cond, "message")) {
[18:40:53.122]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.122]                         if (muffled) 
[18:40:53.122]                           invokeRestart("muffleMessage")
[18:40:53.122]                       }
[18:40:53.122]                       else if (inherits(cond, "warning")) {
[18:40:53.122]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.122]                         if (muffled) 
[18:40:53.122]                           invokeRestart("muffleWarning")
[18:40:53.122]                       }
[18:40:53.122]                       else if (inherits(cond, "condition")) {
[18:40:53.122]                         if (!is.null(pattern)) {
[18:40:53.122]                           computeRestarts <- base::computeRestarts
[18:40:53.122]                           grepl <- base::grepl
[18:40:53.122]                           restarts <- computeRestarts(cond)
[18:40:53.122]                           for (restart in restarts) {
[18:40:53.122]                             name <- restart$name
[18:40:53.122]                             if (is.null(name)) 
[18:40:53.122]                               next
[18:40:53.122]                             if (!grepl(pattern, name)) 
[18:40:53.122]                               next
[18:40:53.122]                             invokeRestart(restart)
[18:40:53.122]                             muffled <- TRUE
[18:40:53.122]                             break
[18:40:53.122]                           }
[18:40:53.122]                         }
[18:40:53.122]                       }
[18:40:53.122]                       invisible(muffled)
[18:40:53.122]                     }
[18:40:53.122]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.122]                   }
[18:40:53.122]                 }
[18:40:53.122]             }
[18:40:53.122]         }))
[18:40:53.122]     }, error = function(ex) {
[18:40:53.122]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.122]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.122]                 ...future.rng), started = ...future.startTime, 
[18:40:53.122]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.122]             version = "1.8"), class = "FutureResult")
[18:40:53.122]     }, finally = {
[18:40:53.122]         if (!identical(...future.workdir, getwd())) 
[18:40:53.122]             setwd(...future.workdir)
[18:40:53.122]         {
[18:40:53.122]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.122]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.122]             }
[18:40:53.122]             base::options(...future.oldOptions)
[18:40:53.122]             if (.Platform$OS.type == "windows") {
[18:40:53.122]                 old_names <- names(...future.oldEnvVars)
[18:40:53.122]                 envs <- base::Sys.getenv()
[18:40:53.122]                 names <- names(envs)
[18:40:53.122]                 common <- intersect(names, old_names)
[18:40:53.122]                 added <- setdiff(names, old_names)
[18:40:53.122]                 removed <- setdiff(old_names, names)
[18:40:53.122]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.122]                   envs[common]]
[18:40:53.122]                 NAMES <- toupper(changed)
[18:40:53.122]                 args <- list()
[18:40:53.122]                 for (kk in seq_along(NAMES)) {
[18:40:53.122]                   name <- changed[[kk]]
[18:40:53.122]                   NAME <- NAMES[[kk]]
[18:40:53.122]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.122]                     next
[18:40:53.122]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.122]                 }
[18:40:53.122]                 NAMES <- toupper(added)
[18:40:53.122]                 for (kk in seq_along(NAMES)) {
[18:40:53.122]                   name <- added[[kk]]
[18:40:53.122]                   NAME <- NAMES[[kk]]
[18:40:53.122]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.122]                     next
[18:40:53.122]                   args[[name]] <- ""
[18:40:53.122]                 }
[18:40:53.122]                 NAMES <- toupper(removed)
[18:40:53.122]                 for (kk in seq_along(NAMES)) {
[18:40:53.122]                   name <- removed[[kk]]
[18:40:53.122]                   NAME <- NAMES[[kk]]
[18:40:53.122]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.122]                     next
[18:40:53.122]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.122]                 }
[18:40:53.122]                 if (length(args) > 0) 
[18:40:53.122]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.122]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.122]             }
[18:40:53.122]             else {
[18:40:53.122]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.122]             }
[18:40:53.122]             {
[18:40:53.122]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.122]                   0L) {
[18:40:53.122]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.122]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.122]                   base::options(opts)
[18:40:53.122]                 }
[18:40:53.122]                 {
[18:40:53.122]                   {
[18:40:53.122]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.122]                     NULL
[18:40:53.122]                   }
[18:40:53.122]                   options(future.plan = NULL)
[18:40:53.122]                   if (is.na(NA_character_)) 
[18:40:53.122]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.122]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.122]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.122]                     .init = FALSE)
[18:40:53.122]                 }
[18:40:53.122]             }
[18:40:53.122]         }
[18:40:53.122]     })
[18:40:53.122]     if (TRUE) {
[18:40:53.122]         base::sink(type = "output", split = FALSE)
[18:40:53.122]         if (TRUE) {
[18:40:53.122]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.122]         }
[18:40:53.122]         else {
[18:40:53.122]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.122]         }
[18:40:53.122]         base::close(...future.stdout)
[18:40:53.122]         ...future.stdout <- NULL
[18:40:53.122]     }
[18:40:53.122]     ...future.result$conditions <- ...future.conditions
[18:40:53.122]     ...future.result$finished <- base::Sys.time()
[18:40:53.122]     ...future.result
[18:40:53.122] }
[18:40:53.127] Exporting 5 global objects (2.08 KiB) to cluster node #1 ...
[18:40:53.127] Exporting '...future.FUN' (762 bytes) to cluster node #1 ...
[18:40:53.128] Exporting '...future.FUN' (762 bytes) to cluster node #1 ... DONE
[18:40:53.128] Exporting 'future.call.arguments' (157 bytes) to cluster node #1 ...
[18:40:53.128] Exporting 'future.call.arguments' (157 bytes) to cluster node #1 ... DONE
[18:40:53.129] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ...
[18:40:53.129] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ... DONE
[18:40:53.129] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.130] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.130] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.130] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.130] Exporting 5 global objects (2.08 KiB) to cluster node #1 ... DONE
[18:40:53.131] MultisessionFuture started
[18:40:53.131] - Launch lazy future ... done
[18:40:53.131] run() for 'MultisessionFuture' ... done
[18:40:53.132] Created future:
[18:40:53.153] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.154] - Validating connection of MultisessionFuture
[18:40:53.154] - received message: FutureResult
[18:40:53.154] - Received FutureResult
[18:40:53.154] - Erased future from FutureRegistry
[18:40:53.154] result() for ClusterFuture ...
[18:40:53.155] - result already collected: FutureResult
[18:40:53.155] result() for ClusterFuture ... done
[18:40:53.155] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.132] MultisessionFuture:
[18:40:53.132] Label: 'future_by-1'
[18:40:53.132] Expression:
[18:40:53.132] {
[18:40:53.132]     do.call(function(...) {
[18:40:53.132]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.132]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.132]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.132]             on.exit(options(oopts), add = TRUE)
[18:40:53.132]         }
[18:40:53.132]         {
[18:40:53.132]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.132]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.132]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.132]             })
[18:40:53.132]         }
[18:40:53.132]     }, args = future.call.arguments)
[18:40:53.132] }
[18:40:53.132] Lazy evaluation: FALSE
[18:40:53.132] Asynchronous evaluation: TRUE
[18:40:53.132] Local evaluation: TRUE
[18:40:53.132] Environment: R_GlobalEnv
[18:40:53.132] Capture standard output: TRUE
[18:40:53.132] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.132] Globals: 5 objects totaling 1.67 KiB (function '...future.FUN' of 762 bytes, DotDotDotList 'future.call.arguments' of 157 bytes, list '...future.elements_ii' of 736 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.132] Packages: 1 packages ('stats')
[18:40:53.132] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.132] Resolved: TRUE
[18:40:53.132] Value: <not collected>
[18:40:53.132] Conditions captured: <none>
[18:40:53.132] Early signaling: FALSE
[18:40:53.132] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.132] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.155] Chunk #1 of 2 ... DONE
[18:40:53.156] Chunk #2 of 2 ...
[18:40:53.156]  - Finding globals in 'X' for chunk #2 ...
[18:40:53.156] getGlobalsAndPackages() ...
[18:40:53.156] Searching for globals...
[18:40:53.157] 
[18:40:53.157] Searching for globals ... DONE
[18:40:53.157] - globals: [0] <none>
[18:40:53.157] getGlobalsAndPackages() ... DONE
[18:40:53.157]    + additional globals found: [n=0] 
[18:40:53.157]    + additional namespaces needed: [n=0] 
[18:40:53.158]  - Finding globals in 'X' for chunk #2 ... DONE
[18:40:53.158]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.158]  - seeds: <none>
[18:40:53.158]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.158] getGlobalsAndPackages() ...
[18:40:53.158] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.158] Resolving globals: FALSE
[18:40:53.159] Tweak future expression to call with '...' arguments ...
[18:40:53.159] {
[18:40:53.159]     do.call(function(...) {
[18:40:53.159]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.159]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.159]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.159]             on.exit(options(oopts), add = TRUE)
[18:40:53.159]         }
[18:40:53.159]         {
[18:40:53.159]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.159]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.159]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.159]             })
[18:40:53.159]         }
[18:40:53.159]     }, args = future.call.arguments)
[18:40:53.159] }
[18:40:53.159] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.160] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.160] 
[18:40:53.160] getGlobalsAndPackages() ... DONE
[18:40:53.160] run() for 'Future' ...
[18:40:53.161] - state: 'created'
[18:40:53.161] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.176] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.176] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.176]   - Field: 'node'
[18:40:53.176]   - Field: 'label'
[18:40:53.177]   - Field: 'local'
[18:40:53.177]   - Field: 'owner'
[18:40:53.177]   - Field: 'envir'
[18:40:53.177]   - Field: 'workers'
[18:40:53.177]   - Field: 'packages'
[18:40:53.177]   - Field: 'gc'
[18:40:53.178]   - Field: 'conditions'
[18:40:53.178]   - Field: 'persistent'
[18:40:53.178]   - Field: 'expr'
[18:40:53.178]   - Field: 'uuid'
[18:40:53.178]   - Field: 'seed'
[18:40:53.178]   - Field: 'version'
[18:40:53.179]   - Field: 'result'
[18:40:53.179]   - Field: 'asynchronous'
[18:40:53.179]   - Field: 'calls'
[18:40:53.179]   - Field: 'globals'
[18:40:53.179]   - Field: 'stdout'
[18:40:53.179]   - Field: 'earlySignal'
[18:40:53.180]   - Field: 'lazy'
[18:40:53.180]   - Field: 'state'
[18:40:53.180] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.180] - Launch lazy future ...
[18:40:53.180] Packages needed by the future expression (n = 1): 'stats'
[18:40:53.181] Packages needed by future strategies (n = 0): <none>
[18:40:53.181] {
[18:40:53.181]     {
[18:40:53.181]         {
[18:40:53.181]             ...future.startTime <- base::Sys.time()
[18:40:53.181]             {
[18:40:53.181]                 {
[18:40:53.181]                   {
[18:40:53.181]                     {
[18:40:53.181]                       {
[18:40:53.181]                         base::local({
[18:40:53.181]                           has_future <- base::requireNamespace("future", 
[18:40:53.181]                             quietly = TRUE)
[18:40:53.181]                           if (has_future) {
[18:40:53.181]                             ns <- base::getNamespace("future")
[18:40:53.181]                             version <- ns[[".package"]][["version"]]
[18:40:53.181]                             if (is.null(version)) 
[18:40:53.181]                               version <- utils::packageVersion("future")
[18:40:53.181]                           }
[18:40:53.181]                           else {
[18:40:53.181]                             version <- NULL
[18:40:53.181]                           }
[18:40:53.181]                           if (!has_future || version < "1.8.0") {
[18:40:53.181]                             info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.181]                               "", base::R.version$version.string), 
[18:40:53.181]                               platform = base::sprintf("%s (%s-bit)", 
[18:40:53.181]                                 base::R.version$platform, 8 * 
[18:40:53.181]                                   base::.Machine$sizeof.pointer), 
[18:40:53.181]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.181]                                 "release", "version")], collapse = " "), 
[18:40:53.181]                               hostname = base::Sys.info()[["nodename"]])
[18:40:53.181]                             info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.181]                               info)
[18:40:53.181]                             info <- base::paste(info, collapse = "; ")
[18:40:53.181]                             if (!has_future) {
[18:40:53.181]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.181]                                 info)
[18:40:53.181]                             }
[18:40:53.181]                             else {
[18:40:53.181]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.181]                                 info, version)
[18:40:53.181]                             }
[18:40:53.181]                             base::stop(msg)
[18:40:53.181]                           }
[18:40:53.181]                         })
[18:40:53.181]                       }
[18:40:53.181]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.181]                       base::options(mc.cores = 1L)
[18:40:53.181]                     }
[18:40:53.181]                     base::local({
[18:40:53.181]                       for (pkg in "stats") {
[18:40:53.181]                         base::loadNamespace(pkg)
[18:40:53.181]                         base::library(pkg, character.only = TRUE)
[18:40:53.181]                       }
[18:40:53.181]                     })
[18:40:53.181]                   }
[18:40:53.181]                   ...future.strategy.old <- future::plan("list")
[18:40:53.181]                   options(future.plan = NULL)
[18:40:53.181]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.181]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.181]                 }
[18:40:53.181]                 ...future.workdir <- getwd()
[18:40:53.181]             }
[18:40:53.181]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.181]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.181]         }
[18:40:53.181]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.181]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.181]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.181]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.181]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.181]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.181]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.181]             base::names(...future.oldOptions))
[18:40:53.181]     }
[18:40:53.181]     if (FALSE) {
[18:40:53.181]     }
[18:40:53.181]     else {
[18:40:53.181]         if (TRUE) {
[18:40:53.181]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.181]                 open = "w")
[18:40:53.181]         }
[18:40:53.181]         else {
[18:40:53.181]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.181]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.181]         }
[18:40:53.181]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.181]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.181]             base::sink(type = "output", split = FALSE)
[18:40:53.181]             base::close(...future.stdout)
[18:40:53.181]         }, add = TRUE)
[18:40:53.181]     }
[18:40:53.181]     ...future.frame <- base::sys.nframe()
[18:40:53.181]     ...future.conditions <- base::list()
[18:40:53.181]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.181]     if (FALSE) {
[18:40:53.181]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.181]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.181]     }
[18:40:53.181]     ...future.result <- base::tryCatch({
[18:40:53.181]         base::withCallingHandlers({
[18:40:53.181]             ...future.value <- base::withVisible(base::local({
[18:40:53.181]                 ...future.makeSendCondition <- base::local({
[18:40:53.181]                   sendCondition <- NULL
[18:40:53.181]                   function(frame = 1L) {
[18:40:53.181]                     if (is.function(sendCondition)) 
[18:40:53.181]                       return(sendCondition)
[18:40:53.181]                     ns <- getNamespace("parallel")
[18:40:53.181]                     if (exists("sendData", mode = "function", 
[18:40:53.181]                       envir = ns)) {
[18:40:53.181]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.181]                         envir = ns)
[18:40:53.181]                       envir <- sys.frame(frame)
[18:40:53.181]                       master <- NULL
[18:40:53.181]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.181]                         !identical(envir, emptyenv())) {
[18:40:53.181]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.181]                           inherits = FALSE)) {
[18:40:53.181]                           master <- get("master", mode = "list", 
[18:40:53.181]                             envir = envir, inherits = FALSE)
[18:40:53.181]                           if (inherits(master, c("SOCKnode", 
[18:40:53.181]                             "SOCK0node"))) {
[18:40:53.181]                             sendCondition <<- function(cond) {
[18:40:53.181]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.181]                                 success = TRUE)
[18:40:53.181]                               parallel_sendData(master, data)
[18:40:53.181]                             }
[18:40:53.181]                             return(sendCondition)
[18:40:53.181]                           }
[18:40:53.181]                         }
[18:40:53.181]                         frame <- frame + 1L
[18:40:53.181]                         envir <- sys.frame(frame)
[18:40:53.181]                       }
[18:40:53.181]                     }
[18:40:53.181]                     sendCondition <<- function(cond) NULL
[18:40:53.181]                   }
[18:40:53.181]                 })
[18:40:53.181]                 withCallingHandlers({
[18:40:53.181]                   {
[18:40:53.181]                     do.call(function(...) {
[18:40:53.181]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.181]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.181]                         ...future.globals.maxSize)) {
[18:40:53.181]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.181]                         on.exit(options(oopts), add = TRUE)
[18:40:53.181]                       }
[18:40:53.181]                       {
[18:40:53.181]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.181]                           FUN = function(jj) {
[18:40:53.181]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.181]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.181]                           })
[18:40:53.181]                       }
[18:40:53.181]                     }, args = future.call.arguments)
[18:40:53.181]                   }
[18:40:53.181]                 }, immediateCondition = function(cond) {
[18:40:53.181]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.181]                   sendCondition(cond)
[18:40:53.181]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.181]                   {
[18:40:53.181]                     inherits <- base::inherits
[18:40:53.181]                     invokeRestart <- base::invokeRestart
[18:40:53.181]                     is.null <- base::is.null
[18:40:53.181]                     muffled <- FALSE
[18:40:53.181]                     if (inherits(cond, "message")) {
[18:40:53.181]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.181]                       if (muffled) 
[18:40:53.181]                         invokeRestart("muffleMessage")
[18:40:53.181]                     }
[18:40:53.181]                     else if (inherits(cond, "warning")) {
[18:40:53.181]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.181]                       if (muffled) 
[18:40:53.181]                         invokeRestart("muffleWarning")
[18:40:53.181]                     }
[18:40:53.181]                     else if (inherits(cond, "condition")) {
[18:40:53.181]                       if (!is.null(pattern)) {
[18:40:53.181]                         computeRestarts <- base::computeRestarts
[18:40:53.181]                         grepl <- base::grepl
[18:40:53.181]                         restarts <- computeRestarts(cond)
[18:40:53.181]                         for (restart in restarts) {
[18:40:53.181]                           name <- restart$name
[18:40:53.181]                           if (is.null(name)) 
[18:40:53.181]                             next
[18:40:53.181]                           if (!grepl(pattern, name)) 
[18:40:53.181]                             next
[18:40:53.181]                           invokeRestart(restart)
[18:40:53.181]                           muffled <- TRUE
[18:40:53.181]                           break
[18:40:53.181]                         }
[18:40:53.181]                       }
[18:40:53.181]                     }
[18:40:53.181]                     invisible(muffled)
[18:40:53.181]                   }
[18:40:53.181]                   muffleCondition(cond)
[18:40:53.181]                 })
[18:40:53.181]             }))
[18:40:53.181]             future::FutureResult(value = ...future.value$value, 
[18:40:53.181]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.181]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.181]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.181]                     ...future.globalenv.names))
[18:40:53.181]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.181]         }, condition = base::local({
[18:40:53.181]             c <- base::c
[18:40:53.181]             inherits <- base::inherits
[18:40:53.181]             invokeRestart <- base::invokeRestart
[18:40:53.181]             length <- base::length
[18:40:53.181]             list <- base::list
[18:40:53.181]             seq.int <- base::seq.int
[18:40:53.181]             signalCondition <- base::signalCondition
[18:40:53.181]             sys.calls <- base::sys.calls
[18:40:53.181]             `[[` <- base::`[[`
[18:40:53.181]             `+` <- base::`+`
[18:40:53.181]             `<<-` <- base::`<<-`
[18:40:53.181]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.181]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.181]                   3L)]
[18:40:53.181]             }
[18:40:53.181]             function(cond) {
[18:40:53.181]                 is_error <- inherits(cond, "error")
[18:40:53.181]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.181]                   NULL)
[18:40:53.181]                 if (is_error) {
[18:40:53.181]                   sessionInformation <- function() {
[18:40:53.181]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.181]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.181]                       search = base::search(), system = base::Sys.info())
[18:40:53.181]                   }
[18:40:53.181]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.181]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.181]                     cond$call), session = sessionInformation(), 
[18:40:53.181]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.181]                   signalCondition(cond)
[18:40:53.181]                 }
[18:40:53.181]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.181]                 "immediateCondition"))) {
[18:40:53.181]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.181]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.181]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.181]                   if (TRUE && !signal) {
[18:40:53.181]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.181]                     {
[18:40:53.181]                       inherits <- base::inherits
[18:40:53.181]                       invokeRestart <- base::invokeRestart
[18:40:53.181]                       is.null <- base::is.null
[18:40:53.181]                       muffled <- FALSE
[18:40:53.181]                       if (inherits(cond, "message")) {
[18:40:53.181]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.181]                         if (muffled) 
[18:40:53.181]                           invokeRestart("muffleMessage")
[18:40:53.181]                       }
[18:40:53.181]                       else if (inherits(cond, "warning")) {
[18:40:53.181]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.181]                         if (muffled) 
[18:40:53.181]                           invokeRestart("muffleWarning")
[18:40:53.181]                       }
[18:40:53.181]                       else if (inherits(cond, "condition")) {
[18:40:53.181]                         if (!is.null(pattern)) {
[18:40:53.181]                           computeRestarts <- base::computeRestarts
[18:40:53.181]                           grepl <- base::grepl
[18:40:53.181]                           restarts <- computeRestarts(cond)
[18:40:53.181]                           for (restart in restarts) {
[18:40:53.181]                             name <- restart$name
[18:40:53.181]                             if (is.null(name)) 
[18:40:53.181]                               next
[18:40:53.181]                             if (!grepl(pattern, name)) 
[18:40:53.181]                               next
[18:40:53.181]                             invokeRestart(restart)
[18:40:53.181]                             muffled <- TRUE
[18:40:53.181]                             break
[18:40:53.181]                           }
[18:40:53.181]                         }
[18:40:53.181]                       }
[18:40:53.181]                       invisible(muffled)
[18:40:53.181]                     }
[18:40:53.181]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.181]                   }
[18:40:53.181]                 }
[18:40:53.181]                 else {
[18:40:53.181]                   if (TRUE) {
[18:40:53.181]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.181]                     {
[18:40:53.181]                       inherits <- base::inherits
[18:40:53.181]                       invokeRestart <- base::invokeRestart
[18:40:53.181]                       is.null <- base::is.null
[18:40:53.181]                       muffled <- FALSE
[18:40:53.181]                       if (inherits(cond, "message")) {
[18:40:53.181]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.181]                         if (muffled) 
[18:40:53.181]                           invokeRestart("muffleMessage")
[18:40:53.181]                       }
[18:40:53.181]                       else if (inherits(cond, "warning")) {
[18:40:53.181]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.181]                         if (muffled) 
[18:40:53.181]                           invokeRestart("muffleWarning")
[18:40:53.181]                       }
[18:40:53.181]                       else if (inherits(cond, "condition")) {
[18:40:53.181]                         if (!is.null(pattern)) {
[18:40:53.181]                           computeRestarts <- base::computeRestarts
[18:40:53.181]                           grepl <- base::grepl
[18:40:53.181]                           restarts <- computeRestarts(cond)
[18:40:53.181]                           for (restart in restarts) {
[18:40:53.181]                             name <- restart$name
[18:40:53.181]                             if (is.null(name)) 
[18:40:53.181]                               next
[18:40:53.181]                             if (!grepl(pattern, name)) 
[18:40:53.181]                               next
[18:40:53.181]                             invokeRestart(restart)
[18:40:53.181]                             muffled <- TRUE
[18:40:53.181]                             break
[18:40:53.181]                           }
[18:40:53.181]                         }
[18:40:53.181]                       }
[18:40:53.181]                       invisible(muffled)
[18:40:53.181]                     }
[18:40:53.181]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.181]                   }
[18:40:53.181]                 }
[18:40:53.181]             }
[18:40:53.181]         }))
[18:40:53.181]     }, error = function(ex) {
[18:40:53.181]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.181]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.181]                 ...future.rng), started = ...future.startTime, 
[18:40:53.181]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.181]             version = "1.8"), class = "FutureResult")
[18:40:53.181]     }, finally = {
[18:40:53.181]         if (!identical(...future.workdir, getwd())) 
[18:40:53.181]             setwd(...future.workdir)
[18:40:53.181]         {
[18:40:53.181]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.181]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.181]             }
[18:40:53.181]             base::options(...future.oldOptions)
[18:40:53.181]             if (.Platform$OS.type == "windows") {
[18:40:53.181]                 old_names <- names(...future.oldEnvVars)
[18:40:53.181]                 envs <- base::Sys.getenv()
[18:40:53.181]                 names <- names(envs)
[18:40:53.181]                 common <- intersect(names, old_names)
[18:40:53.181]                 added <- setdiff(names, old_names)
[18:40:53.181]                 removed <- setdiff(old_names, names)
[18:40:53.181]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.181]                   envs[common]]
[18:40:53.181]                 NAMES <- toupper(changed)
[18:40:53.181]                 args <- list()
[18:40:53.181]                 for (kk in seq_along(NAMES)) {
[18:40:53.181]                   name <- changed[[kk]]
[18:40:53.181]                   NAME <- NAMES[[kk]]
[18:40:53.181]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.181]                     next
[18:40:53.181]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.181]                 }
[18:40:53.181]                 NAMES <- toupper(added)
[18:40:53.181]                 for (kk in seq_along(NAMES)) {
[18:40:53.181]                   name <- added[[kk]]
[18:40:53.181]                   NAME <- NAMES[[kk]]
[18:40:53.181]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.181]                     next
[18:40:53.181]                   args[[name]] <- ""
[18:40:53.181]                 }
[18:40:53.181]                 NAMES <- toupper(removed)
[18:40:53.181]                 for (kk in seq_along(NAMES)) {
[18:40:53.181]                   name <- removed[[kk]]
[18:40:53.181]                   NAME <- NAMES[[kk]]
[18:40:53.181]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.181]                     next
[18:40:53.181]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.181]                 }
[18:40:53.181]                 if (length(args) > 0) 
[18:40:53.181]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.181]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.181]             }
[18:40:53.181]             else {
[18:40:53.181]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.181]             }
[18:40:53.181]             {
[18:40:53.181]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.181]                   0L) {
[18:40:53.181]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.181]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.181]                   base::options(opts)
[18:40:53.181]                 }
[18:40:53.181]                 {
[18:40:53.181]                   {
[18:40:53.181]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.181]                     NULL
[18:40:53.181]                   }
[18:40:53.181]                   options(future.plan = NULL)
[18:40:53.181]                   if (is.na(NA_character_)) 
[18:40:53.181]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.181]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.181]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.181]                     .init = FALSE)
[18:40:53.181]                 }
[18:40:53.181]             }
[18:40:53.181]         }
[18:40:53.181]     })
[18:40:53.181]     if (TRUE) {
[18:40:53.181]         base::sink(type = "output", split = FALSE)
[18:40:53.181]         if (TRUE) {
[18:40:53.181]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.181]         }
[18:40:53.181]         else {
[18:40:53.181]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.181]         }
[18:40:53.181]         base::close(...future.stdout)
[18:40:53.181]         ...future.stdout <- NULL
[18:40:53.181]     }
[18:40:53.181]     ...future.result$conditions <- ...future.conditions
[18:40:53.181]     ...future.result$finished <- base::Sys.time()
[18:40:53.181]     ...future.result
[18:40:53.181] }
[18:40:53.187] Exporting 5 global objects (2.72 KiB) to cluster node #1 ...
[18:40:53.187] Exporting '...future.FUN' (762 bytes) to cluster node #1 ...
[18:40:53.187] Exporting '...future.FUN' (762 bytes) to cluster node #1 ... DONE
[18:40:53.188] Exporting 'future.call.arguments' (157 bytes) to cluster node #1 ...
[18:40:53.188] Exporting 'future.call.arguments' (157 bytes) to cluster node #1 ... DONE
[18:40:53.188] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ...
[18:40:53.189] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ... DONE
[18:40:53.189] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.189] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.189] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.190] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.190] Exporting 5 global objects (2.72 KiB) to cluster node #1 ... DONE
[18:40:53.191] MultisessionFuture started
[18:40:53.191] - Launch lazy future ... done
[18:40:53.191] run() for 'MultisessionFuture' ... done
[18:40:53.191] Created future:
[18:40:53.210] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.210] - Validating connection of MultisessionFuture
[18:40:53.211] - received message: FutureResult
[18:40:53.211] - Received FutureResult
[18:40:53.211] - Erased future from FutureRegistry
[18:40:53.211] result() for ClusterFuture ...
[18:40:53.211] - result already collected: FutureResult
[18:40:53.212] result() for ClusterFuture ... done
[18:40:53.212] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.191] MultisessionFuture:
[18:40:53.191] Label: 'future_by-2'
[18:40:53.191] Expression:
[18:40:53.191] {
[18:40:53.191]     do.call(function(...) {
[18:40:53.191]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.191]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.191]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.191]             on.exit(options(oopts), add = TRUE)
[18:40:53.191]         }
[18:40:53.191]         {
[18:40:53.191]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.191]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.191]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.191]             })
[18:40:53.191]         }
[18:40:53.191]     }, args = future.call.arguments)
[18:40:53.191] }
[18:40:53.191] Lazy evaluation: FALSE
[18:40:53.191] Asynchronous evaluation: TRUE
[18:40:53.191] Local evaluation: TRUE
[18:40:53.191] Environment: R_GlobalEnv
[18:40:53.191] Capture standard output: TRUE
[18:40:53.191] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.191] Globals: 5 objects totaling 2.30 KiB (function '...future.FUN' of 762 bytes, DotDotDotList 'future.call.arguments' of 157 bytes, list '...future.elements_ii' of 1.35 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.191] Packages: 1 packages ('stats')
[18:40:53.191] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.191] Resolved: TRUE
[18:40:53.191] Value: <not collected>
[18:40:53.191] Conditions captured: <none>
[18:40:53.191] Early signaling: FALSE
[18:40:53.191] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.191] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.212] Chunk #2 of 2 ... DONE
[18:40:53.212] Launching 2 futures (chunks) ... DONE
[18:40:53.212] Resolving 2 futures (chunks) ...
[18:40:53.213] resolve() on list ...
[18:40:53.213]  recursive: 0
[18:40:53.213]  length: 2
[18:40:53.213] 
[18:40:53.213] Future #1
[18:40:53.213] result() for ClusterFuture ...
[18:40:53.214] - result already collected: FutureResult
[18:40:53.214] result() for ClusterFuture ... done
[18:40:53.214] result() for ClusterFuture ...
[18:40:53.214] - result already collected: FutureResult
[18:40:53.214] result() for ClusterFuture ... done
[18:40:53.214] signalConditionsASAP(MultisessionFuture, pos=1) ...
[18:40:53.215] - nx: 2
[18:40:53.215] - relay: TRUE
[18:40:53.215] - stdout: TRUE
[18:40:53.215] - signal: TRUE
[18:40:53.215] - resignal: FALSE
[18:40:53.215] - force: TRUE
[18:40:53.215] - relayed: [n=2] FALSE, FALSE
[18:40:53.216] - queued futures: [n=2] FALSE, FALSE
[18:40:53.216]  - until=1
[18:40:53.216]  - relaying element #1
[18:40:53.216] result() for ClusterFuture ...
[18:40:53.216] - result already collected: FutureResult
[18:40:53.216] result() for ClusterFuture ... done
[18:40:53.216] result() for ClusterFuture ...
[18:40:53.217] - result already collected: FutureResult
[18:40:53.217] result() for ClusterFuture ... done
[18:40:53.217] result() for ClusterFuture ...
[18:40:53.217] - result already collected: FutureResult
[18:40:53.217] result() for ClusterFuture ... done
[18:40:53.217] result() for ClusterFuture ...
[18:40:53.218] - result already collected: FutureResult
[18:40:53.218] result() for ClusterFuture ... done
[18:40:53.218] - relayed: [n=2] TRUE, FALSE
[18:40:53.218] - queued futures: [n=2] TRUE, FALSE
[18:40:53.218] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[18:40:53.218]  length: 1 (resolved future 1)
[18:40:53.219] Future #2
[18:40:53.219] result() for ClusterFuture ...
[18:40:53.219] - result already collected: FutureResult
[18:40:53.219] result() for ClusterFuture ... done
[18:40:53.219] result() for ClusterFuture ...
[18:40:53.219] - result already collected: FutureResult
[18:40:53.219] result() for ClusterFuture ... done
[18:40:53.220] signalConditionsASAP(MultisessionFuture, pos=2) ...
[18:40:53.220] - nx: 2
[18:40:53.220] - relay: TRUE
[18:40:53.220] - stdout: TRUE
[18:40:53.220] - signal: TRUE
[18:40:53.220] - resignal: FALSE
[18:40:53.221] - force: TRUE
[18:40:53.221] - relayed: [n=2] TRUE, FALSE
[18:40:53.221] - queued futures: [n=2] TRUE, FALSE
[18:40:53.221]  - until=2
[18:40:53.221]  - relaying element #2
[18:40:53.221] result() for ClusterFuture ...
[18:40:53.221] - result already collected: FutureResult
[18:40:53.222] result() for ClusterFuture ... done
[18:40:53.222] result() for ClusterFuture ...
[18:40:53.222] - result already collected: FutureResult
[18:40:53.222] result() for ClusterFuture ... done
[18:40:53.222] result() for ClusterFuture ...
[18:40:53.222] - result already collected: FutureResult
[18:40:53.223] result() for ClusterFuture ... done
[18:40:53.223] result() for ClusterFuture ...
[18:40:53.223] - result already collected: FutureResult
[18:40:53.223] result() for ClusterFuture ... done
[18:40:53.223] - relayed: [n=2] TRUE, TRUE
[18:40:53.223] - queued futures: [n=2] TRUE, TRUE
[18:40:53.223] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[18:40:53.224]  length: 0 (resolved future 2)
[18:40:53.224] Relaying remaining futures
[18:40:53.224] signalConditionsASAP(NULL, pos=0) ...
[18:40:53.224] - nx: 2
[18:40:53.224] - relay: TRUE
[18:40:53.224] - stdout: TRUE
[18:40:53.225] - signal: TRUE
[18:40:53.225] - resignal: FALSE
[18:40:53.225] - force: TRUE
[18:40:53.225] - relayed: [n=2] TRUE, TRUE
[18:40:53.225] - queued futures: [n=2] TRUE, TRUE
 - flush all
[18:40:53.225] - relayed: [n=2] TRUE, TRUE
[18:40:53.226] - queued futures: [n=2] TRUE, TRUE
[18:40:53.226] signalConditionsASAP(NULL, pos=0) ... done
[18:40:53.226] resolve() on list ... DONE
[18:40:53.226] result() for ClusterFuture ...
[18:40:53.226] - result already collected: FutureResult
[18:40:53.226] result() for ClusterFuture ... done
[18:40:53.226] result() for ClusterFuture ...
[18:40:53.227] - result already collected: FutureResult
[18:40:53.227] result() for ClusterFuture ... done
[18:40:53.227] result() for ClusterFuture ...
[18:40:53.227] - result already collected: FutureResult
[18:40:53.227] result() for ClusterFuture ... done
[18:40:53.227] result() for ClusterFuture ...
[18:40:53.228] - result already collected: FutureResult
[18:40:53.228] result() for ClusterFuture ... done
[18:40:53.228]  - Number of value chunks collected: 2
[18:40:53.228] Resolving 2 futures (chunks) ... DONE
[18:40:53.228] Reducing values from 2 chunks ...
[18:40:53.228]  - Number of values collected after concatenation: 3
[18:40:53.228]  - Number of values expected: 3
[18:40:53.229] Reducing values from 2 chunks ... DONE
[18:40:53.229] future_lapply() ... DONE
[18:40:53.229] future_by_internal() ... DONE
[18:40:53.234] future_by_internal() ...
[18:40:53.234] future_lapply() ...
[18:40:53.237] Number of chunks: 2
[18:40:53.238] getGlobalsAndPackagesXApply() ...
[18:40:53.238]  - future.globals: TRUE
[18:40:53.238] getGlobalsAndPackages() ...
[18:40:53.238] Searching for globals...
[18:40:53.240] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[18:40:53.240] Searching for globals ... DONE
[18:40:53.240] Resolving globals: FALSE
[18:40:53.241] The total size of the 3 globals is 2.07 KiB (2118 bytes)
[18:40:53.242] The total size of the 3 globals exported for future expression ('FUN()') is 2.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.28 KiB of class 'function'), 'breaks' (463 bytes of class 'numeric') and 'wool' (342 bytes of class 'numeric')
[18:40:53.242] - globals: [3] 'FUN', 'breaks', 'wool'
[18:40:53.242] - packages: [1] 'stats'
[18:40:53.242] getGlobalsAndPackages() ... DONE
[18:40:53.242]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[18:40:53.243]  - needed namespaces: [n=1] 'stats'
[18:40:53.243] Finding globals ... DONE
[18:40:53.243]  - use_args: TRUE
[18:40:53.243]  - Getting '...' globals ...
[18:40:53.243] resolve() on list ...
[18:40:53.244]  recursive: 0
[18:40:53.244]  length: 1
[18:40:53.244]  elements: '...'
[18:40:53.244]  length: 0 (resolved future 1)
[18:40:53.244] resolve() on list ... DONE
[18:40:53.245]    - '...' content: [n=0] 
[18:40:53.245] List of 1
[18:40:53.245]  $ ...: list()
[18:40:53.245]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.245]  - attr(*, "where")=List of 1
[18:40:53.245]   ..$ ...:<environment: 0x000001cd5072e4e0> 
[18:40:53.245]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.245]  - attr(*, "resolved")= logi TRUE
[18:40:53.245]  - attr(*, "total_size")= num NA
[18:40:53.248]  - Getting '...' globals ... DONE
[18:40:53.248] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[18:40:53.248] List of 4
[18:40:53.248]  $ ...future.FUN:function (x)  
[18:40:53.248]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[18:40:53.248]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[18:40:53.248]  $ ...          : list()
[18:40:53.248]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.248]  - attr(*, "where")=List of 4
[18:40:53.248]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:53.248]   ..$ breaks       :<environment: R_EmptyEnv> 
[18:40:53.248]   ..$ wool         :<environment: R_EmptyEnv> 
[18:40:53.248]   ..$ ...          :<environment: 0x000001cd5072e4e0> 
[18:40:53.248]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.248]  - attr(*, "resolved")= logi FALSE
[18:40:53.248]  - attr(*, "total_size")= int 18867
[18:40:53.253] Packages to be attached in all futures: [n=1] 'stats'
[18:40:53.253] getGlobalsAndPackagesXApply() ... DONE
[18:40:53.253] Number of futures (= number of chunks): 2
[18:40:53.254] Launching 2 futures (chunks) ...
[18:40:53.254] Chunk #1 of 2 ...
[18:40:53.254]  - Finding globals in 'X' for chunk #1 ...
[18:40:53.254] getGlobalsAndPackages() ...
[18:40:53.254] Searching for globals...
[18:40:53.255] 
[18:40:53.255] Searching for globals ... DONE
[18:40:53.255] - globals: [0] <none>
[18:40:53.255] getGlobalsAndPackages() ... DONE
[18:40:53.255]    + additional globals found: [n=0] 
[18:40:53.256]    + additional namespaces needed: [n=0] 
[18:40:53.256]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:53.256]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.256]  - seeds: <none>
[18:40:53.256]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.256] getGlobalsAndPackages() ...
[18:40:53.256] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.257] Resolving globals: FALSE
[18:40:53.257] Tweak future expression to call with '...' arguments ...
[18:40:53.257] {
[18:40:53.257]     do.call(function(...) {
[18:40:53.257]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.257]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.257]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.257]             on.exit(options(oopts), add = TRUE)
[18:40:53.257]         }
[18:40:53.257]         {
[18:40:53.257]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.257]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.257]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.257]             })
[18:40:53.257]         }
[18:40:53.257]     }, args = future.call.arguments)
[18:40:53.257] }
[18:40:53.257] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.258] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.258] 
[18:40:53.258] getGlobalsAndPackages() ... DONE
[18:40:53.259] run() for 'Future' ...
[18:40:53.259] - state: 'created'
[18:40:53.259] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.274] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.275] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.275]   - Field: 'node'
[18:40:53.275]   - Field: 'label'
[18:40:53.275]   - Field: 'local'
[18:40:53.275]   - Field: 'owner'
[18:40:53.276]   - Field: 'envir'
[18:40:53.276]   - Field: 'workers'
[18:40:53.276]   - Field: 'packages'
[18:40:53.276]   - Field: 'gc'
[18:40:53.276]   - Field: 'conditions'
[18:40:53.276]   - Field: 'persistent'
[18:40:53.277]   - Field: 'expr'
[18:40:53.277]   - Field: 'uuid'
[18:40:53.277]   - Field: 'seed'
[18:40:53.277]   - Field: 'version'
[18:40:53.277]   - Field: 'result'
[18:40:53.278]   - Field: 'asynchronous'
[18:40:53.278]   - Field: 'calls'
[18:40:53.278]   - Field: 'globals'
[18:40:53.278]   - Field: 'stdout'
[18:40:53.278]   - Field: 'earlySignal'
[18:40:53.278]   - Field: 'lazy'
[18:40:53.279]   - Field: 'state'
[18:40:53.279] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.279] - Launch lazy future ...
[18:40:53.279] Packages needed by the future expression (n = 1): 'stats'
[18:40:53.279] Packages needed by future strategies (n = 0): <none>
[18:40:53.280] {
[18:40:53.280]     {
[18:40:53.280]         {
[18:40:53.280]             ...future.startTime <- base::Sys.time()
[18:40:53.280]             {
[18:40:53.280]                 {
[18:40:53.280]                   {
[18:40:53.280]                     {
[18:40:53.280]                       {
[18:40:53.280]                         base::local({
[18:40:53.280]                           has_future <- base::requireNamespace("future", 
[18:40:53.280]                             quietly = TRUE)
[18:40:53.280]                           if (has_future) {
[18:40:53.280]                             ns <- base::getNamespace("future")
[18:40:53.280]                             version <- ns[[".package"]][["version"]]
[18:40:53.280]                             if (is.null(version)) 
[18:40:53.280]                               version <- utils::packageVersion("future")
[18:40:53.280]                           }
[18:40:53.280]                           else {
[18:40:53.280]                             version <- NULL
[18:40:53.280]                           }
[18:40:53.280]                           if (!has_future || version < "1.8.0") {
[18:40:53.280]                             info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.280]                               "", base::R.version$version.string), 
[18:40:53.280]                               platform = base::sprintf("%s (%s-bit)", 
[18:40:53.280]                                 base::R.version$platform, 8 * 
[18:40:53.280]                                   base::.Machine$sizeof.pointer), 
[18:40:53.280]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.280]                                 "release", "version")], collapse = " "), 
[18:40:53.280]                               hostname = base::Sys.info()[["nodename"]])
[18:40:53.280]                             info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.280]                               info)
[18:40:53.280]                             info <- base::paste(info, collapse = "; ")
[18:40:53.280]                             if (!has_future) {
[18:40:53.280]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.280]                                 info)
[18:40:53.280]                             }
[18:40:53.280]                             else {
[18:40:53.280]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.280]                                 info, version)
[18:40:53.280]                             }
[18:40:53.280]                             base::stop(msg)
[18:40:53.280]                           }
[18:40:53.280]                         })
[18:40:53.280]                       }
[18:40:53.280]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.280]                       base::options(mc.cores = 1L)
[18:40:53.280]                     }
[18:40:53.280]                     base::local({
[18:40:53.280]                       for (pkg in "stats") {
[18:40:53.280]                         base::loadNamespace(pkg)
[18:40:53.280]                         base::library(pkg, character.only = TRUE)
[18:40:53.280]                       }
[18:40:53.280]                     })
[18:40:53.280]                   }
[18:40:53.280]                   ...future.strategy.old <- future::plan("list")
[18:40:53.280]                   options(future.plan = NULL)
[18:40:53.280]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.280]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.280]                 }
[18:40:53.280]                 ...future.workdir <- getwd()
[18:40:53.280]             }
[18:40:53.280]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.280]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.280]         }
[18:40:53.280]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.280]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.280]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.280]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.280]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.280]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.280]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.280]             base::names(...future.oldOptions))
[18:40:53.280]     }
[18:40:53.280]     if (FALSE) {
[18:40:53.280]     }
[18:40:53.280]     else {
[18:40:53.280]         if (TRUE) {
[18:40:53.280]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.280]                 open = "w")
[18:40:53.280]         }
[18:40:53.280]         else {
[18:40:53.280]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.280]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.280]         }
[18:40:53.280]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.280]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.280]             base::sink(type = "output", split = FALSE)
[18:40:53.280]             base::close(...future.stdout)
[18:40:53.280]         }, add = TRUE)
[18:40:53.280]     }
[18:40:53.280]     ...future.frame <- base::sys.nframe()
[18:40:53.280]     ...future.conditions <- base::list()
[18:40:53.280]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.280]     if (FALSE) {
[18:40:53.280]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.280]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.280]     }
[18:40:53.280]     ...future.result <- base::tryCatch({
[18:40:53.280]         base::withCallingHandlers({
[18:40:53.280]             ...future.value <- base::withVisible(base::local({
[18:40:53.280]                 ...future.makeSendCondition <- base::local({
[18:40:53.280]                   sendCondition <- NULL
[18:40:53.280]                   function(frame = 1L) {
[18:40:53.280]                     if (is.function(sendCondition)) 
[18:40:53.280]                       return(sendCondition)
[18:40:53.280]                     ns <- getNamespace("parallel")
[18:40:53.280]                     if (exists("sendData", mode = "function", 
[18:40:53.280]                       envir = ns)) {
[18:40:53.280]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.280]                         envir = ns)
[18:40:53.280]                       envir <- sys.frame(frame)
[18:40:53.280]                       master <- NULL
[18:40:53.280]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.280]                         !identical(envir, emptyenv())) {
[18:40:53.280]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.280]                           inherits = FALSE)) {
[18:40:53.280]                           master <- get("master", mode = "list", 
[18:40:53.280]                             envir = envir, inherits = FALSE)
[18:40:53.280]                           if (inherits(master, c("SOCKnode", 
[18:40:53.280]                             "SOCK0node"))) {
[18:40:53.280]                             sendCondition <<- function(cond) {
[18:40:53.280]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.280]                                 success = TRUE)
[18:40:53.280]                               parallel_sendData(master, data)
[18:40:53.280]                             }
[18:40:53.280]                             return(sendCondition)
[18:40:53.280]                           }
[18:40:53.280]                         }
[18:40:53.280]                         frame <- frame + 1L
[18:40:53.280]                         envir <- sys.frame(frame)
[18:40:53.280]                       }
[18:40:53.280]                     }
[18:40:53.280]                     sendCondition <<- function(cond) NULL
[18:40:53.280]                   }
[18:40:53.280]                 })
[18:40:53.280]                 withCallingHandlers({
[18:40:53.280]                   {
[18:40:53.280]                     do.call(function(...) {
[18:40:53.280]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.280]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.280]                         ...future.globals.maxSize)) {
[18:40:53.280]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.280]                         on.exit(options(oopts), add = TRUE)
[18:40:53.280]                       }
[18:40:53.280]                       {
[18:40:53.280]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.280]                           FUN = function(jj) {
[18:40:53.280]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.280]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.280]                           })
[18:40:53.280]                       }
[18:40:53.280]                     }, args = future.call.arguments)
[18:40:53.280]                   }
[18:40:53.280]                 }, immediateCondition = function(cond) {
[18:40:53.280]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.280]                   sendCondition(cond)
[18:40:53.280]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.280]                   {
[18:40:53.280]                     inherits <- base::inherits
[18:40:53.280]                     invokeRestart <- base::invokeRestart
[18:40:53.280]                     is.null <- base::is.null
[18:40:53.280]                     muffled <- FALSE
[18:40:53.280]                     if (inherits(cond, "message")) {
[18:40:53.280]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.280]                       if (muffled) 
[18:40:53.280]                         invokeRestart("muffleMessage")
[18:40:53.280]                     }
[18:40:53.280]                     else if (inherits(cond, "warning")) {
[18:40:53.280]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.280]                       if (muffled) 
[18:40:53.280]                         invokeRestart("muffleWarning")
[18:40:53.280]                     }
[18:40:53.280]                     else if (inherits(cond, "condition")) {
[18:40:53.280]                       if (!is.null(pattern)) {
[18:40:53.280]                         computeRestarts <- base::computeRestarts
[18:40:53.280]                         grepl <- base::grepl
[18:40:53.280]                         restarts <- computeRestarts(cond)
[18:40:53.280]                         for (restart in restarts) {
[18:40:53.280]                           name <- restart$name
[18:40:53.280]                           if (is.null(name)) 
[18:40:53.280]                             next
[18:40:53.280]                           if (!grepl(pattern, name)) 
[18:40:53.280]                             next
[18:40:53.280]                           invokeRestart(restart)
[18:40:53.280]                           muffled <- TRUE
[18:40:53.280]                           break
[18:40:53.280]                         }
[18:40:53.280]                       }
[18:40:53.280]                     }
[18:40:53.280]                     invisible(muffled)
[18:40:53.280]                   }
[18:40:53.280]                   muffleCondition(cond)
[18:40:53.280]                 })
[18:40:53.280]             }))
[18:40:53.280]             future::FutureResult(value = ...future.value$value, 
[18:40:53.280]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.280]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.280]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.280]                     ...future.globalenv.names))
[18:40:53.280]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.280]         }, condition = base::local({
[18:40:53.280]             c <- base::c
[18:40:53.280]             inherits <- base::inherits
[18:40:53.280]             invokeRestart <- base::invokeRestart
[18:40:53.280]             length <- base::length
[18:40:53.280]             list <- base::list
[18:40:53.280]             seq.int <- base::seq.int
[18:40:53.280]             signalCondition <- base::signalCondition
[18:40:53.280]             sys.calls <- base::sys.calls
[18:40:53.280]             `[[` <- base::`[[`
[18:40:53.280]             `+` <- base::`+`
[18:40:53.280]             `<<-` <- base::`<<-`
[18:40:53.280]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.280]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.280]                   3L)]
[18:40:53.280]             }
[18:40:53.280]             function(cond) {
[18:40:53.280]                 is_error <- inherits(cond, "error")
[18:40:53.280]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.280]                   NULL)
[18:40:53.280]                 if (is_error) {
[18:40:53.280]                   sessionInformation <- function() {
[18:40:53.280]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.280]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.280]                       search = base::search(), system = base::Sys.info())
[18:40:53.280]                   }
[18:40:53.280]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.280]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.280]                     cond$call), session = sessionInformation(), 
[18:40:53.280]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.280]                   signalCondition(cond)
[18:40:53.280]                 }
[18:40:53.280]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.280]                 "immediateCondition"))) {
[18:40:53.280]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.280]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.280]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.280]                   if (TRUE && !signal) {
[18:40:53.280]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.280]                     {
[18:40:53.280]                       inherits <- base::inherits
[18:40:53.280]                       invokeRestart <- base::invokeRestart
[18:40:53.280]                       is.null <- base::is.null
[18:40:53.280]                       muffled <- FALSE
[18:40:53.280]                       if (inherits(cond, "message")) {
[18:40:53.280]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.280]                         if (muffled) 
[18:40:53.280]                           invokeRestart("muffleMessage")
[18:40:53.280]                       }
[18:40:53.280]                       else if (inherits(cond, "warning")) {
[18:40:53.280]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.280]                         if (muffled) 
[18:40:53.280]                           invokeRestart("muffleWarning")
[18:40:53.280]                       }
[18:40:53.280]                       else if (inherits(cond, "condition")) {
[18:40:53.280]                         if (!is.null(pattern)) {
[18:40:53.280]                           computeRestarts <- base::computeRestarts
[18:40:53.280]                           grepl <- base::grepl
[18:40:53.280]                           restarts <- computeRestarts(cond)
[18:40:53.280]                           for (restart in restarts) {
[18:40:53.280]                             name <- restart$name
[18:40:53.280]                             if (is.null(name)) 
[18:40:53.280]                               next
[18:40:53.280]                             if (!grepl(pattern, name)) 
[18:40:53.280]                               next
[18:40:53.280]                             invokeRestart(restart)
[18:40:53.280]                             muffled <- TRUE
[18:40:53.280]                             break
[18:40:53.280]                           }
[18:40:53.280]                         }
[18:40:53.280]                       }
[18:40:53.280]                       invisible(muffled)
[18:40:53.280]                     }
[18:40:53.280]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.280]                   }
[18:40:53.280]                 }
[18:40:53.280]                 else {
[18:40:53.280]                   if (TRUE) {
[18:40:53.280]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.280]                     {
[18:40:53.280]                       inherits <- base::inherits
[18:40:53.280]                       invokeRestart <- base::invokeRestart
[18:40:53.280]                       is.null <- base::is.null
[18:40:53.280]                       muffled <- FALSE
[18:40:53.280]                       if (inherits(cond, "message")) {
[18:40:53.280]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.280]                         if (muffled) 
[18:40:53.280]                           invokeRestart("muffleMessage")
[18:40:53.280]                       }
[18:40:53.280]                       else if (inherits(cond, "warning")) {
[18:40:53.280]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.280]                         if (muffled) 
[18:40:53.280]                           invokeRestart("muffleWarning")
[18:40:53.280]                       }
[18:40:53.280]                       else if (inherits(cond, "condition")) {
[18:40:53.280]                         if (!is.null(pattern)) {
[18:40:53.280]                           computeRestarts <- base::computeRestarts
[18:40:53.280]                           grepl <- base::grepl
[18:40:53.280]                           restarts <- computeRestarts(cond)
[18:40:53.280]                           for (restart in restarts) {
[18:40:53.280]                             name <- restart$name
[18:40:53.280]                             if (is.null(name)) 
[18:40:53.280]                               next
[18:40:53.280]                             if (!grepl(pattern, name)) 
[18:40:53.280]                               next
[18:40:53.280]                             invokeRestart(restart)
[18:40:53.280]                             muffled <- TRUE
[18:40:53.280]                             break
[18:40:53.280]                           }
[18:40:53.280]                         }
[18:40:53.280]                       }
[18:40:53.280]                       invisible(muffled)
[18:40:53.280]                     }
[18:40:53.280]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.280]                   }
[18:40:53.280]                 }
[18:40:53.280]             }
[18:40:53.280]         }))
[18:40:53.280]     }, error = function(ex) {
[18:40:53.280]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.280]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.280]                 ...future.rng), started = ...future.startTime, 
[18:40:53.280]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.280]             version = "1.8"), class = "FutureResult")
[18:40:53.280]     }, finally = {
[18:40:53.280]         if (!identical(...future.workdir, getwd())) 
[18:40:53.280]             setwd(...future.workdir)
[18:40:53.280]         {
[18:40:53.280]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.280]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.280]             }
[18:40:53.280]             base::options(...future.oldOptions)
[18:40:53.280]             if (.Platform$OS.type == "windows") {
[18:40:53.280]                 old_names <- names(...future.oldEnvVars)
[18:40:53.280]                 envs <- base::Sys.getenv()
[18:40:53.280]                 names <- names(envs)
[18:40:53.280]                 common <- intersect(names, old_names)
[18:40:53.280]                 added <- setdiff(names, old_names)
[18:40:53.280]                 removed <- setdiff(old_names, names)
[18:40:53.280]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.280]                   envs[common]]
[18:40:53.280]                 NAMES <- toupper(changed)
[18:40:53.280]                 args <- list()
[18:40:53.280]                 for (kk in seq_along(NAMES)) {
[18:40:53.280]                   name <- changed[[kk]]
[18:40:53.280]                   NAME <- NAMES[[kk]]
[18:40:53.280]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.280]                     next
[18:40:53.280]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.280]                 }
[18:40:53.280]                 NAMES <- toupper(added)
[18:40:53.280]                 for (kk in seq_along(NAMES)) {
[18:40:53.280]                   name <- added[[kk]]
[18:40:53.280]                   NAME <- NAMES[[kk]]
[18:40:53.280]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.280]                     next
[18:40:53.280]                   args[[name]] <- ""
[18:40:53.280]                 }
[18:40:53.280]                 NAMES <- toupper(removed)
[18:40:53.280]                 for (kk in seq_along(NAMES)) {
[18:40:53.280]                   name <- removed[[kk]]
[18:40:53.280]                   NAME <- NAMES[[kk]]
[18:40:53.280]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.280]                     next
[18:40:53.280]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.280]                 }
[18:40:53.280]                 if (length(args) > 0) 
[18:40:53.280]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.280]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.280]             }
[18:40:53.280]             else {
[18:40:53.280]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.280]             }
[18:40:53.280]             {
[18:40:53.280]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.280]                   0L) {
[18:40:53.280]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.280]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.280]                   base::options(opts)
[18:40:53.280]                 }
[18:40:53.280]                 {
[18:40:53.280]                   {
[18:40:53.280]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.280]                     NULL
[18:40:53.280]                   }
[18:40:53.280]                   options(future.plan = NULL)
[18:40:53.280]                   if (is.na(NA_character_)) 
[18:40:53.280]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.280]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.280]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.280]                     .init = FALSE)
[18:40:53.280]                 }
[18:40:53.280]             }
[18:40:53.280]         }
[18:40:53.280]     })
[18:40:53.280]     if (TRUE) {
[18:40:53.280]         base::sink(type = "output", split = FALSE)
[18:40:53.280]         if (TRUE) {
[18:40:53.280]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.280]         }
[18:40:53.280]         else {
[18:40:53.280]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.280]         }
[18:40:53.280]         base::close(...future.stdout)
[18:40:53.280]         ...future.stdout <- NULL
[18:40:53.280]     }
[18:40:53.280]     ...future.result$conditions <- ...future.conditions
[18:40:53.280]     ...future.result$finished <- base::Sys.time()
[18:40:53.280]     ...future.result
[18:40:53.280] }
[18:40:53.285] Exporting 7 global objects (3.33 KiB) to cluster node #1 ...
[18:40:53.286] Exporting '...future.FUN' (1.28 KiB) to cluster node #1 ...
[18:40:53.288] Exporting '...future.FUN' (1.28 KiB) to cluster node #1 ... DONE
[18:40:53.288] Exporting 'breaks' (463 bytes) to cluster node #1 ...
[18:40:53.289] Exporting 'breaks' (463 bytes) to cluster node #1 ... DONE
[18:40:53.289] Exporting 'wool' (342 bytes) to cluster node #1 ...
[18:40:53.289] Exporting 'wool' (342 bytes) to cluster node #1 ... DONE
[18:40:53.289] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:53.290] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:53.290] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ...
[18:40:53.290] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ... DONE
[18:40:53.291] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.291] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.291] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.292] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.292] Exporting 7 global objects (3.33 KiB) to cluster node #1 ... DONE
[18:40:53.292] MultisessionFuture started
[18:40:53.293] - Launch lazy future ... done
[18:40:53.293] run() for 'MultisessionFuture' ... done
[18:40:53.293] Created future:
[18:40:53.310] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.310] - Validating connection of MultisessionFuture
[18:40:53.311] - received message: FutureResult
[18:40:53.311] - Received FutureResult
[18:40:53.311] - Erased future from FutureRegistry
[18:40:53.311] result() for ClusterFuture ...
[18:40:53.312] - result already collected: FutureResult
[18:40:53.312] result() for ClusterFuture ... done
[18:40:53.312] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.293] MultisessionFuture:
[18:40:53.293] Label: 'future_by-1'
[18:40:53.293] Expression:
[18:40:53.293] {
[18:40:53.293]     do.call(function(...) {
[18:40:53.293]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.293]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.293]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.293]             on.exit(options(oopts), add = TRUE)
[18:40:53.293]         }
[18:40:53.293]         {
[18:40:53.293]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.293]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.293]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.293]             })
[18:40:53.293]         }
[18:40:53.293]     }, args = future.call.arguments)
[18:40:53.293] }
[18:40:53.293] Lazy evaluation: FALSE
[18:40:53.293] Asynchronous evaluation: TRUE
[18:40:53.293] Local evaluation: TRUE
[18:40:53.293] Environment: 0x000001cd5075ad28
[18:40:53.293] Capture standard output: TRUE
[18:40:53.293] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.293] Globals: 7 objects totaling 2.93 KiB (function '...future.FUN' of 1.28 KiB, numeric 'breaks' of 463 bytes, factor 'wool' of 342 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 736 bytes, ...)
[18:40:53.293] Packages: 1 packages ('stats')
[18:40:53.293] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.293] Resolved: TRUE
[18:40:53.293] Value: <not collected>
[18:40:53.293] Conditions captured: <none>
[18:40:53.293] Early signaling: FALSE
[18:40:53.293] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.293] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.312] Chunk #1 of 2 ... DONE
[18:40:53.312] Chunk #2 of 2 ...
[18:40:53.313]  - Finding globals in 'X' for chunk #2 ...
[18:40:53.313] getGlobalsAndPackages() ...
[18:40:53.313] Searching for globals...
[18:40:53.313] 
[18:40:53.314] Searching for globals ... DONE
[18:40:53.314] - globals: [0] <none>
[18:40:53.314] getGlobalsAndPackages() ... DONE
[18:40:53.314]    + additional globals found: [n=0] 
[18:40:53.314]    + additional namespaces needed: [n=0] 
[18:40:53.314]  - Finding globals in 'X' for chunk #2 ... DONE
[18:40:53.314]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.315]  - seeds: <none>
[18:40:53.315]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.315] getGlobalsAndPackages() ...
[18:40:53.315] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.315] Resolving globals: FALSE
[18:40:53.315] Tweak future expression to call with '...' arguments ...
[18:40:53.316] {
[18:40:53.316]     do.call(function(...) {
[18:40:53.316]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.316]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.316]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.316]             on.exit(options(oopts), add = TRUE)
[18:40:53.316]         }
[18:40:53.316]         {
[18:40:53.316]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.316]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.316]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.316]             })
[18:40:53.316]         }
[18:40:53.316]     }, args = future.call.arguments)
[18:40:53.316] }
[18:40:53.316] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.317] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.317] 
[18:40:53.317] getGlobalsAndPackages() ... DONE
[18:40:53.317] run() for 'Future' ...
[18:40:53.318] - state: 'created'
[18:40:53.318] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.332] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.333] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.333]   - Field: 'node'
[18:40:53.333]   - Field: 'label'
[18:40:53.333]   - Field: 'local'
[18:40:53.333]   - Field: 'owner'
[18:40:53.334]   - Field: 'envir'
[18:40:53.334]   - Field: 'workers'
[18:40:53.334]   - Field: 'packages'
[18:40:53.334]   - Field: 'gc'
[18:40:53.334]   - Field: 'conditions'
[18:40:53.334]   - Field: 'persistent'
[18:40:53.335]   - Field: 'expr'
[18:40:53.335]   - Field: 'uuid'
[18:40:53.335]   - Field: 'seed'
[18:40:53.335]   - Field: 'version'
[18:40:53.335]   - Field: 'result'
[18:40:53.335]   - Field: 'asynchronous'
[18:40:53.336]   - Field: 'calls'
[18:40:53.336]   - Field: 'globals'
[18:40:53.336]   - Field: 'stdout'
[18:40:53.336]   - Field: 'earlySignal'
[18:40:53.336]   - Field: 'lazy'
[18:40:53.336]   - Field: 'state'
[18:40:53.337] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.337] - Launch lazy future ...
[18:40:53.337] Packages needed by the future expression (n = 1): 'stats'
[18:40:53.337] Packages needed by future strategies (n = 0): <none>
[18:40:53.338] {
[18:40:53.338]     {
[18:40:53.338]         {
[18:40:53.338]             ...future.startTime <- base::Sys.time()
[18:40:53.338]             {
[18:40:53.338]                 {
[18:40:53.338]                   {
[18:40:53.338]                     {
[18:40:53.338]                       {
[18:40:53.338]                         base::local({
[18:40:53.338]                           has_future <- base::requireNamespace("future", 
[18:40:53.338]                             quietly = TRUE)
[18:40:53.338]                           if (has_future) {
[18:40:53.338]                             ns <- base::getNamespace("future")
[18:40:53.338]                             version <- ns[[".package"]][["version"]]
[18:40:53.338]                             if (is.null(version)) 
[18:40:53.338]                               version <- utils::packageVersion("future")
[18:40:53.338]                           }
[18:40:53.338]                           else {
[18:40:53.338]                             version <- NULL
[18:40:53.338]                           }
[18:40:53.338]                           if (!has_future || version < "1.8.0") {
[18:40:53.338]                             info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.338]                               "", base::R.version$version.string), 
[18:40:53.338]                               platform = base::sprintf("%s (%s-bit)", 
[18:40:53.338]                                 base::R.version$platform, 8 * 
[18:40:53.338]                                   base::.Machine$sizeof.pointer), 
[18:40:53.338]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.338]                                 "release", "version")], collapse = " "), 
[18:40:53.338]                               hostname = base::Sys.info()[["nodename"]])
[18:40:53.338]                             info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.338]                               info)
[18:40:53.338]                             info <- base::paste(info, collapse = "; ")
[18:40:53.338]                             if (!has_future) {
[18:40:53.338]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.338]                                 info)
[18:40:53.338]                             }
[18:40:53.338]                             else {
[18:40:53.338]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.338]                                 info, version)
[18:40:53.338]                             }
[18:40:53.338]                             base::stop(msg)
[18:40:53.338]                           }
[18:40:53.338]                         })
[18:40:53.338]                       }
[18:40:53.338]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.338]                       base::options(mc.cores = 1L)
[18:40:53.338]                     }
[18:40:53.338]                     base::local({
[18:40:53.338]                       for (pkg in "stats") {
[18:40:53.338]                         base::loadNamespace(pkg)
[18:40:53.338]                         base::library(pkg, character.only = TRUE)
[18:40:53.338]                       }
[18:40:53.338]                     })
[18:40:53.338]                   }
[18:40:53.338]                   ...future.strategy.old <- future::plan("list")
[18:40:53.338]                   options(future.plan = NULL)
[18:40:53.338]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.338]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.338]                 }
[18:40:53.338]                 ...future.workdir <- getwd()
[18:40:53.338]             }
[18:40:53.338]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.338]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.338]         }
[18:40:53.338]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.338]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.338]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.338]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.338]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.338]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.338]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.338]             base::names(...future.oldOptions))
[18:40:53.338]     }
[18:40:53.338]     if (FALSE) {
[18:40:53.338]     }
[18:40:53.338]     else {
[18:40:53.338]         if (TRUE) {
[18:40:53.338]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.338]                 open = "w")
[18:40:53.338]         }
[18:40:53.338]         else {
[18:40:53.338]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.338]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.338]         }
[18:40:53.338]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.338]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.338]             base::sink(type = "output", split = FALSE)
[18:40:53.338]             base::close(...future.stdout)
[18:40:53.338]         }, add = TRUE)
[18:40:53.338]     }
[18:40:53.338]     ...future.frame <- base::sys.nframe()
[18:40:53.338]     ...future.conditions <- base::list()
[18:40:53.338]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.338]     if (FALSE) {
[18:40:53.338]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.338]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.338]     }
[18:40:53.338]     ...future.result <- base::tryCatch({
[18:40:53.338]         base::withCallingHandlers({
[18:40:53.338]             ...future.value <- base::withVisible(base::local({
[18:40:53.338]                 ...future.makeSendCondition <- base::local({
[18:40:53.338]                   sendCondition <- NULL
[18:40:53.338]                   function(frame = 1L) {
[18:40:53.338]                     if (is.function(sendCondition)) 
[18:40:53.338]                       return(sendCondition)
[18:40:53.338]                     ns <- getNamespace("parallel")
[18:40:53.338]                     if (exists("sendData", mode = "function", 
[18:40:53.338]                       envir = ns)) {
[18:40:53.338]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.338]                         envir = ns)
[18:40:53.338]                       envir <- sys.frame(frame)
[18:40:53.338]                       master <- NULL
[18:40:53.338]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.338]                         !identical(envir, emptyenv())) {
[18:40:53.338]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.338]                           inherits = FALSE)) {
[18:40:53.338]                           master <- get("master", mode = "list", 
[18:40:53.338]                             envir = envir, inherits = FALSE)
[18:40:53.338]                           if (inherits(master, c("SOCKnode", 
[18:40:53.338]                             "SOCK0node"))) {
[18:40:53.338]                             sendCondition <<- function(cond) {
[18:40:53.338]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.338]                                 success = TRUE)
[18:40:53.338]                               parallel_sendData(master, data)
[18:40:53.338]                             }
[18:40:53.338]                             return(sendCondition)
[18:40:53.338]                           }
[18:40:53.338]                         }
[18:40:53.338]                         frame <- frame + 1L
[18:40:53.338]                         envir <- sys.frame(frame)
[18:40:53.338]                       }
[18:40:53.338]                     }
[18:40:53.338]                     sendCondition <<- function(cond) NULL
[18:40:53.338]                   }
[18:40:53.338]                 })
[18:40:53.338]                 withCallingHandlers({
[18:40:53.338]                   {
[18:40:53.338]                     do.call(function(...) {
[18:40:53.338]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.338]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.338]                         ...future.globals.maxSize)) {
[18:40:53.338]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.338]                         on.exit(options(oopts), add = TRUE)
[18:40:53.338]                       }
[18:40:53.338]                       {
[18:40:53.338]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.338]                           FUN = function(jj) {
[18:40:53.338]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.338]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.338]                           })
[18:40:53.338]                       }
[18:40:53.338]                     }, args = future.call.arguments)
[18:40:53.338]                   }
[18:40:53.338]                 }, immediateCondition = function(cond) {
[18:40:53.338]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.338]                   sendCondition(cond)
[18:40:53.338]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.338]                   {
[18:40:53.338]                     inherits <- base::inherits
[18:40:53.338]                     invokeRestart <- base::invokeRestart
[18:40:53.338]                     is.null <- base::is.null
[18:40:53.338]                     muffled <- FALSE
[18:40:53.338]                     if (inherits(cond, "message")) {
[18:40:53.338]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.338]                       if (muffled) 
[18:40:53.338]                         invokeRestart("muffleMessage")
[18:40:53.338]                     }
[18:40:53.338]                     else if (inherits(cond, "warning")) {
[18:40:53.338]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.338]                       if (muffled) 
[18:40:53.338]                         invokeRestart("muffleWarning")
[18:40:53.338]                     }
[18:40:53.338]                     else if (inherits(cond, "condition")) {
[18:40:53.338]                       if (!is.null(pattern)) {
[18:40:53.338]                         computeRestarts <- base::computeRestarts
[18:40:53.338]                         grepl <- base::grepl
[18:40:53.338]                         restarts <- computeRestarts(cond)
[18:40:53.338]                         for (restart in restarts) {
[18:40:53.338]                           name <- restart$name
[18:40:53.338]                           if (is.null(name)) 
[18:40:53.338]                             next
[18:40:53.338]                           if (!grepl(pattern, name)) 
[18:40:53.338]                             next
[18:40:53.338]                           invokeRestart(restart)
[18:40:53.338]                           muffled <- TRUE
[18:40:53.338]                           break
[18:40:53.338]                         }
[18:40:53.338]                       }
[18:40:53.338]                     }
[18:40:53.338]                     invisible(muffled)
[18:40:53.338]                   }
[18:40:53.338]                   muffleCondition(cond)
[18:40:53.338]                 })
[18:40:53.338]             }))
[18:40:53.338]             future::FutureResult(value = ...future.value$value, 
[18:40:53.338]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.338]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.338]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.338]                     ...future.globalenv.names))
[18:40:53.338]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.338]         }, condition = base::local({
[18:40:53.338]             c <- base::c
[18:40:53.338]             inherits <- base::inherits
[18:40:53.338]             invokeRestart <- base::invokeRestart
[18:40:53.338]             length <- base::length
[18:40:53.338]             list <- base::list
[18:40:53.338]             seq.int <- base::seq.int
[18:40:53.338]             signalCondition <- base::signalCondition
[18:40:53.338]             sys.calls <- base::sys.calls
[18:40:53.338]             `[[` <- base::`[[`
[18:40:53.338]             `+` <- base::`+`
[18:40:53.338]             `<<-` <- base::`<<-`
[18:40:53.338]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.338]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.338]                   3L)]
[18:40:53.338]             }
[18:40:53.338]             function(cond) {
[18:40:53.338]                 is_error <- inherits(cond, "error")
[18:40:53.338]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.338]                   NULL)
[18:40:53.338]                 if (is_error) {
[18:40:53.338]                   sessionInformation <- function() {
[18:40:53.338]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.338]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.338]                       search = base::search(), system = base::Sys.info())
[18:40:53.338]                   }
[18:40:53.338]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.338]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.338]                     cond$call), session = sessionInformation(), 
[18:40:53.338]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.338]                   signalCondition(cond)
[18:40:53.338]                 }
[18:40:53.338]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.338]                 "immediateCondition"))) {
[18:40:53.338]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.338]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.338]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.338]                   if (TRUE && !signal) {
[18:40:53.338]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.338]                     {
[18:40:53.338]                       inherits <- base::inherits
[18:40:53.338]                       invokeRestart <- base::invokeRestart
[18:40:53.338]                       is.null <- base::is.null
[18:40:53.338]                       muffled <- FALSE
[18:40:53.338]                       if (inherits(cond, "message")) {
[18:40:53.338]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.338]                         if (muffled) 
[18:40:53.338]                           invokeRestart("muffleMessage")
[18:40:53.338]                       }
[18:40:53.338]                       else if (inherits(cond, "warning")) {
[18:40:53.338]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.338]                         if (muffled) 
[18:40:53.338]                           invokeRestart("muffleWarning")
[18:40:53.338]                       }
[18:40:53.338]                       else if (inherits(cond, "condition")) {
[18:40:53.338]                         if (!is.null(pattern)) {
[18:40:53.338]                           computeRestarts <- base::computeRestarts
[18:40:53.338]                           grepl <- base::grepl
[18:40:53.338]                           restarts <- computeRestarts(cond)
[18:40:53.338]                           for (restart in restarts) {
[18:40:53.338]                             name <- restart$name
[18:40:53.338]                             if (is.null(name)) 
[18:40:53.338]                               next
[18:40:53.338]                             if (!grepl(pattern, name)) 
[18:40:53.338]                               next
[18:40:53.338]                             invokeRestart(restart)
[18:40:53.338]                             muffled <- TRUE
[18:40:53.338]                             break
[18:40:53.338]                           }
[18:40:53.338]                         }
[18:40:53.338]                       }
[18:40:53.338]                       invisible(muffled)
[18:40:53.338]                     }
[18:40:53.338]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.338]                   }
[18:40:53.338]                 }
[18:40:53.338]                 else {
[18:40:53.338]                   if (TRUE) {
[18:40:53.338]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.338]                     {
[18:40:53.338]                       inherits <- base::inherits
[18:40:53.338]                       invokeRestart <- base::invokeRestart
[18:40:53.338]                       is.null <- base::is.null
[18:40:53.338]                       muffled <- FALSE
[18:40:53.338]                       if (inherits(cond, "message")) {
[18:40:53.338]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.338]                         if (muffled) 
[18:40:53.338]                           invokeRestart("muffleMessage")
[18:40:53.338]                       }
[18:40:53.338]                       else if (inherits(cond, "warning")) {
[18:40:53.338]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.338]                         if (muffled) 
[18:40:53.338]                           invokeRestart("muffleWarning")
[18:40:53.338]                       }
[18:40:53.338]                       else if (inherits(cond, "condition")) {
[18:40:53.338]                         if (!is.null(pattern)) {
[18:40:53.338]                           computeRestarts <- base::computeRestarts
[18:40:53.338]                           grepl <- base::grepl
[18:40:53.338]                           restarts <- computeRestarts(cond)
[18:40:53.338]                           for (restart in restarts) {
[18:40:53.338]                             name <- restart$name
[18:40:53.338]                             if (is.null(name)) 
[18:40:53.338]                               next
[18:40:53.338]                             if (!grepl(pattern, name)) 
[18:40:53.338]                               next
[18:40:53.338]                             invokeRestart(restart)
[18:40:53.338]                             muffled <- TRUE
[18:40:53.338]                             break
[18:40:53.338]                           }
[18:40:53.338]                         }
[18:40:53.338]                       }
[18:40:53.338]                       invisible(muffled)
[18:40:53.338]                     }
[18:40:53.338]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.338]                   }
[18:40:53.338]                 }
[18:40:53.338]             }
[18:40:53.338]         }))
[18:40:53.338]     }, error = function(ex) {
[18:40:53.338]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.338]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.338]                 ...future.rng), started = ...future.startTime, 
[18:40:53.338]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.338]             version = "1.8"), class = "FutureResult")
[18:40:53.338]     }, finally = {
[18:40:53.338]         if (!identical(...future.workdir, getwd())) 
[18:40:53.338]             setwd(...future.workdir)
[18:40:53.338]         {
[18:40:53.338]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.338]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.338]             }
[18:40:53.338]             base::options(...future.oldOptions)
[18:40:53.338]             if (.Platform$OS.type == "windows") {
[18:40:53.338]                 old_names <- names(...future.oldEnvVars)
[18:40:53.338]                 envs <- base::Sys.getenv()
[18:40:53.338]                 names <- names(envs)
[18:40:53.338]                 common <- intersect(names, old_names)
[18:40:53.338]                 added <- setdiff(names, old_names)
[18:40:53.338]                 removed <- setdiff(old_names, names)
[18:40:53.338]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.338]                   envs[common]]
[18:40:53.338]                 NAMES <- toupper(changed)
[18:40:53.338]                 args <- list()
[18:40:53.338]                 for (kk in seq_along(NAMES)) {
[18:40:53.338]                   name <- changed[[kk]]
[18:40:53.338]                   NAME <- NAMES[[kk]]
[18:40:53.338]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.338]                     next
[18:40:53.338]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.338]                 }
[18:40:53.338]                 NAMES <- toupper(added)
[18:40:53.338]                 for (kk in seq_along(NAMES)) {
[18:40:53.338]                   name <- added[[kk]]
[18:40:53.338]                   NAME <- NAMES[[kk]]
[18:40:53.338]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.338]                     next
[18:40:53.338]                   args[[name]] <- ""
[18:40:53.338]                 }
[18:40:53.338]                 NAMES <- toupper(removed)
[18:40:53.338]                 for (kk in seq_along(NAMES)) {
[18:40:53.338]                   name <- removed[[kk]]
[18:40:53.338]                   NAME <- NAMES[[kk]]
[18:40:53.338]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.338]                     next
[18:40:53.338]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.338]                 }
[18:40:53.338]                 if (length(args) > 0) 
[18:40:53.338]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.338]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.338]             }
[18:40:53.338]             else {
[18:40:53.338]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.338]             }
[18:40:53.338]             {
[18:40:53.338]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.338]                   0L) {
[18:40:53.338]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.338]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.338]                   base::options(opts)
[18:40:53.338]                 }
[18:40:53.338]                 {
[18:40:53.338]                   {
[18:40:53.338]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.338]                     NULL
[18:40:53.338]                   }
[18:40:53.338]                   options(future.plan = NULL)
[18:40:53.338]                   if (is.na(NA_character_)) 
[18:40:53.338]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.338]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.338]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.338]                     .init = FALSE)
[18:40:53.338]                 }
[18:40:53.338]             }
[18:40:53.338]         }
[18:40:53.338]     })
[18:40:53.338]     if (TRUE) {
[18:40:53.338]         base::sink(type = "output", split = FALSE)
[18:40:53.338]         if (TRUE) {
[18:40:53.338]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.338]         }
[18:40:53.338]         else {
[18:40:53.338]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.338]         }
[18:40:53.338]         base::close(...future.stdout)
[18:40:53.338]         ...future.stdout <- NULL
[18:40:53.338]     }
[18:40:53.338]     ...future.result$conditions <- ...future.conditions
[18:40:53.338]     ...future.result$finished <- base::Sys.time()
[18:40:53.338]     ...future.result
[18:40:53.338] }
[18:40:53.343] Exporting 7 global objects (3.97 KiB) to cluster node #1 ...
[18:40:53.344] Exporting '...future.FUN' (1.28 KiB) to cluster node #1 ...
[18:40:53.344] Exporting '...future.FUN' (1.28 KiB) to cluster node #1 ... DONE
[18:40:53.344] Exporting 'breaks' (463 bytes) to cluster node #1 ...
[18:40:53.345] Exporting 'breaks' (463 bytes) to cluster node #1 ... DONE
[18:40:53.345] Exporting 'wool' (342 bytes) to cluster node #1 ...
[18:40:53.345] Exporting 'wool' (342 bytes) to cluster node #1 ... DONE
[18:40:53.345] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:53.346] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:53.346] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ...
[18:40:53.346] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ... DONE
[18:40:53.347] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.347] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.347] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.348] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.348] Exporting 7 global objects (3.97 KiB) to cluster node #1 ... DONE
[18:40:53.348] MultisessionFuture started
[18:40:53.349] - Launch lazy future ... done
[18:40:53.349] run() for 'MultisessionFuture' ... done
[18:40:53.349] Created future:
[18:40:53.368] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.368] - Validating connection of MultisessionFuture
[18:40:53.369] - received message: FutureResult
[18:40:53.369] - Received FutureResult
[18:40:53.369] - Erased future from FutureRegistry
[18:40:53.369] result() for ClusterFuture ...
[18:40:53.369] - result already collected: FutureResult
[18:40:53.369] result() for ClusterFuture ... done
[18:40:53.370] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.349] MultisessionFuture:
[18:40:53.349] Label: 'future_by-2'
[18:40:53.349] Expression:
[18:40:53.349] {
[18:40:53.349]     do.call(function(...) {
[18:40:53.349]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.349]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.349]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.349]             on.exit(options(oopts), add = TRUE)
[18:40:53.349]         }
[18:40:53.349]         {
[18:40:53.349]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.349]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.349]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.349]             })
[18:40:53.349]         }
[18:40:53.349]     }, args = future.call.arguments)
[18:40:53.349] }
[18:40:53.349] Lazy evaluation: FALSE
[18:40:53.349] Asynchronous evaluation: TRUE
[18:40:53.349] Local evaluation: TRUE
[18:40:53.349] Environment: 0x000001cd5075ad28
[18:40:53.349] Capture standard output: TRUE
[18:40:53.349] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.349] Globals: 7 objects totaling 3.57 KiB (function '...future.FUN' of 1.28 KiB, numeric 'breaks' of 463 bytes, factor 'wool' of 342 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.35 KiB, ...)
[18:40:53.349] Packages: 1 packages ('stats')
[18:40:53.349] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.349] Resolved: TRUE
[18:40:53.349] Value: <not collected>
[18:40:53.349] Conditions captured: <none>
[18:40:53.349] Early signaling: FALSE
[18:40:53.349] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.349] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.370] Chunk #2 of 2 ... DONE
[18:40:53.370] Launching 2 futures (chunks) ... DONE
[18:40:53.370] Resolving 2 futures (chunks) ...
[18:40:53.371] resolve() on list ...
[18:40:53.371]  recursive: 0
[18:40:53.371]  length: 2
[18:40:53.371] 
[18:40:53.371] Future #1
[18:40:53.371] result() for ClusterFuture ...
[18:40:53.371] - result already collected: FutureResult
[18:40:53.372] result() for ClusterFuture ... done
[18:40:53.372] result() for ClusterFuture ...
[18:40:53.372] - result already collected: FutureResult
[18:40:53.372] result() for ClusterFuture ... done
[18:40:53.372] signalConditionsASAP(MultisessionFuture, pos=1) ...
[18:40:53.372] - nx: 2
[18:40:53.373] - relay: TRUE
[18:40:53.373] - stdout: TRUE
[18:40:53.373] - signal: TRUE
[18:40:53.373] - resignal: FALSE
[18:40:53.373] - force: TRUE
[18:40:53.373] - relayed: [n=2] FALSE, FALSE
[18:40:53.373] - queued futures: [n=2] FALSE, FALSE
[18:40:53.374]  - until=1
[18:40:53.374]  - relaying element #1
[18:40:53.374] result() for ClusterFuture ...
[18:40:53.374] - result already collected: FutureResult
[18:40:53.374] result() for ClusterFuture ... done
[18:40:53.374] result() for ClusterFuture ...
[18:40:53.375] - result already collected: FutureResult
[18:40:53.375] result() for ClusterFuture ... done
[18:40:53.375] result() for ClusterFuture ...
[18:40:53.375] - result already collected: FutureResult
[18:40:53.375] result() for ClusterFuture ... done
[18:40:53.375] result() for ClusterFuture ...
[18:40:53.375] - result already collected: FutureResult
[18:40:53.376] result() for ClusterFuture ... done
[18:40:53.376] - relayed: [n=2] TRUE, FALSE
[18:40:53.376] - queued futures: [n=2] TRUE, FALSE
[18:40:53.376] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[18:40:53.376]  length: 1 (resolved future 1)
[18:40:53.376] Future #2
[18:40:53.377] result() for ClusterFuture ...
[18:40:53.377] - result already collected: FutureResult
[18:40:53.377] result() for ClusterFuture ... done
[18:40:53.377] result() for ClusterFuture ...
[18:40:53.377] - result already collected: FutureResult
[18:40:53.377] result() for ClusterFuture ... done
[18:40:53.378] signalConditionsASAP(MultisessionFuture, pos=2) ...
[18:40:53.378] - nx: 2
[18:40:53.378] - relay: TRUE
[18:40:53.378] - stdout: TRUE
[18:40:53.378] - signal: TRUE
[18:40:53.378] - resignal: FALSE
[18:40:53.378] - force: TRUE
[18:40:53.379] - relayed: [n=2] TRUE, FALSE
[18:40:53.379] - queued futures: [n=2] TRUE, FALSE
[18:40:53.379]  - until=2
[18:40:53.379]  - relaying element #2
[18:40:53.379] result() for ClusterFuture ...
[18:40:53.379] - result already collected: FutureResult
[18:40:53.379] result() for ClusterFuture ... done
[18:40:53.380] result() for ClusterFuture ...
[18:40:53.380] - result already collected: FutureResult
[18:40:53.380] result() for ClusterFuture ... done
[18:40:53.380] result() for ClusterFuture ...
[18:40:53.380] - result already collected: FutureResult
[18:40:53.380] result() for ClusterFuture ... done
[18:40:53.381] result() for ClusterFuture ...
[18:40:53.381] - result already collected: FutureResult
[18:40:53.381] result() for ClusterFuture ... done
[18:40:53.381] - relayed: [n=2] TRUE, TRUE
[18:40:53.381] - queued futures: [n=2] TRUE, TRUE
[18:40:53.381] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[18:40:53.382]  length: 0 (resolved future 2)
[18:40:53.382] Relaying remaining futures
[18:40:53.382] signalConditionsASAP(NULL, pos=0) ...
[18:40:53.382] - nx: 2
[18:40:53.382] - relay: TRUE
[18:40:53.382] - stdout: TRUE
[18:40:53.382] - signal: TRUE
[18:40:53.383] - resignal: FALSE
[18:40:53.383] - force: TRUE
[18:40:53.383] - relayed: [n=2] TRUE, TRUE
[18:40:53.383] - queued futures: [n=2] TRUE, TRUE
 - flush all
[18:40:53.383] - relayed: [n=2] TRUE, TRUE
[18:40:53.383] - queued futures: [n=2] TRUE, TRUE
[18:40:53.384] signalConditionsASAP(NULL, pos=0) ... done
[18:40:53.384] resolve() on list ... DONE
[18:40:53.384] result() for ClusterFuture ...
[18:40:53.384] - result already collected: FutureResult
[18:40:53.384] result() for ClusterFuture ... done
[18:40:53.384] result() for ClusterFuture ...
[18:40:53.384] - result already collected: FutureResult
[18:40:53.385] result() for ClusterFuture ... done
[18:40:53.385] result() for ClusterFuture ...
[18:40:53.385] - result already collected: FutureResult
[18:40:53.385] result() for ClusterFuture ... done
[18:40:53.385] result() for ClusterFuture ...
[18:40:53.385] - result already collected: FutureResult
[18:40:53.386] result() for ClusterFuture ... done
[18:40:53.386]  - Number of value chunks collected: 2
[18:40:53.386] Resolving 2 futures (chunks) ... DONE
[18:40:53.386] Reducing values from 2 chunks ...
[18:40:53.386]  - Number of values collected after concatenation: 3
[18:40:53.386]  - Number of values expected: 3
[18:40:53.386] Reducing values from 2 chunks ... DONE
[18:40:53.387] future_lapply() ... DONE
[18:40:53.387] future_by_internal() ... DONE
[18:40:53.387] future_by_internal() ...
[18:40:53.388] future_lapply() ...
[18:40:53.391] Number of chunks: 2
[18:40:53.391] getGlobalsAndPackagesXApply() ...
[18:40:53.391]  - future.globals: TRUE
[18:40:53.391] getGlobalsAndPackages() ...
[18:40:53.391] Searching for globals...
[18:40:53.393] - globals found: [2] 'FUN', 'UseMethod'
[18:40:53.393] Searching for globals ... DONE
[18:40:53.393] Resolving globals: FALSE
[18:40:53.393] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:53.394] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:53.394] - globals: [1] 'FUN'
[18:40:53.394] 
[18:40:53.394] getGlobalsAndPackages() ... DONE
[18:40:53.394]  - globals found/used: [n=1] 'FUN'
[18:40:53.395]  - needed namespaces: [n=0] 
[18:40:53.395] Finding globals ... DONE
[18:40:53.395]  - use_args: TRUE
[18:40:53.395]  - Getting '...' globals ...
[18:40:53.396] resolve() on list ...
[18:40:53.396]  recursive: 0
[18:40:53.396]  length: 1
[18:40:53.396]  elements: '...'
[18:40:53.396]  length: 0 (resolved future 1)
[18:40:53.396] resolve() on list ... DONE
[18:40:53.397]    - '...' content: [n=0] 
[18:40:53.397] List of 1
[18:40:53.397]  $ ...: list()
[18:40:53.397]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.397]  - attr(*, "where")=List of 1
[18:40:53.397]   ..$ ...:<environment: 0x000001cd51323b68> 
[18:40:53.397]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.397]  - attr(*, "resolved")= logi TRUE
[18:40:53.397]  - attr(*, "total_size")= num NA
[18:40:53.400]  - Getting '...' globals ... DONE
[18:40:53.400] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:53.400] List of 2
[18:40:53.400]  $ ...future.FUN:function (object, ...)  
[18:40:53.400]  $ ...          : list()
[18:40:53.400]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.400]  - attr(*, "where")=List of 2
[18:40:53.400]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:53.400]   ..$ ...          :<environment: 0x000001cd51323b68> 
[18:40:53.400]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.400]  - attr(*, "resolved")= logi FALSE
[18:40:53.400]  - attr(*, "total_size")= int 19278
[18:40:53.403] Packages to be attached in all futures: [n=0] 
[18:40:53.403] getGlobalsAndPackagesXApply() ... DONE
[18:40:53.404] Number of futures (= number of chunks): 2
[18:40:53.404] Launching 2 futures (chunks) ...
[18:40:53.404] Chunk #1 of 2 ...
[18:40:53.404]  - Finding globals in 'X' for chunk #1 ...
[18:40:53.404] getGlobalsAndPackages() ...
[18:40:53.405] Searching for globals...
[18:40:53.405] 
[18:40:53.405] Searching for globals ... DONE
[18:40:53.406] - globals: [0] <none>
[18:40:53.406] getGlobalsAndPackages() ... DONE
[18:40:53.406]    + additional globals found: [n=0] 
[18:40:53.406]    + additional namespaces needed: [n=0] 
[18:40:53.406]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:53.407]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.407]  - seeds: <none>
[18:40:53.407]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.407] getGlobalsAndPackages() ...
[18:40:53.408] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.408] Resolving globals: FALSE
[18:40:53.408] Tweak future expression to call with '...' arguments ...
[18:40:53.409] {
[18:40:53.409]     do.call(function(...) {
[18:40:53.409]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.409]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.409]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.409]             on.exit(options(oopts), add = TRUE)
[18:40:53.409]         }
[18:40:53.409]         {
[18:40:53.409]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.409]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.409]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.409]             })
[18:40:53.409]         }
[18:40:53.409]     }, args = future.call.arguments)
[18:40:53.409] }
[18:40:53.409] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.410] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.410] 
[18:40:53.410] getGlobalsAndPackages() ... DONE
[18:40:53.411] run() for 'Future' ...
[18:40:53.411] - state: 'created'
[18:40:53.411] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.429] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.430] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.430]   - Field: 'node'
[18:40:53.430]   - Field: 'label'
[18:40:53.430]   - Field: 'local'
[18:40:53.431]   - Field: 'owner'
[18:40:53.431]   - Field: 'envir'
[18:40:53.431]   - Field: 'workers'
[18:40:53.431]   - Field: 'packages'
[18:40:53.432]   - Field: 'gc'
[18:40:53.432]   - Field: 'conditions'
[18:40:53.432]   - Field: 'persistent'
[18:40:53.432]   - Field: 'expr'
[18:40:53.433]   - Field: 'uuid'
[18:40:53.433]   - Field: 'seed'
[18:40:53.433]   - Field: 'version'
[18:40:53.433]   - Field: 'result'
[18:40:53.434]   - Field: 'asynchronous'
[18:40:53.434]   - Field: 'calls'
[18:40:53.434]   - Field: 'globals'
[18:40:53.434]   - Field: 'stdout'
[18:40:53.435]   - Field: 'earlySignal'
[18:40:53.435]   - Field: 'lazy'
[18:40:53.435]   - Field: 'state'
[18:40:53.435] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.436] - Launch lazy future ...
[18:40:53.436] Packages needed by the future expression (n = 0): <none>
[18:40:53.437] Packages needed by future strategies (n = 0): <none>
[18:40:53.437] {
[18:40:53.437]     {
[18:40:53.437]         {
[18:40:53.437]             ...future.startTime <- base::Sys.time()
[18:40:53.437]             {
[18:40:53.437]                 {
[18:40:53.437]                   {
[18:40:53.437]                     {
[18:40:53.437]                       base::local({
[18:40:53.437]                         has_future <- base::requireNamespace("future", 
[18:40:53.437]                           quietly = TRUE)
[18:40:53.437]                         if (has_future) {
[18:40:53.437]                           ns <- base::getNamespace("future")
[18:40:53.437]                           version <- ns[[".package"]][["version"]]
[18:40:53.437]                           if (is.null(version)) 
[18:40:53.437]                             version <- utils::packageVersion("future")
[18:40:53.437]                         }
[18:40:53.437]                         else {
[18:40:53.437]                           version <- NULL
[18:40:53.437]                         }
[18:40:53.437]                         if (!has_future || version < "1.8.0") {
[18:40:53.437]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.437]                             "", base::R.version$version.string), 
[18:40:53.437]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:53.437]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:53.437]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.437]                               "release", "version")], collapse = " "), 
[18:40:53.437]                             hostname = base::Sys.info()[["nodename"]])
[18:40:53.437]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.437]                             info)
[18:40:53.437]                           info <- base::paste(info, collapse = "; ")
[18:40:53.437]                           if (!has_future) {
[18:40:53.437]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.437]                               info)
[18:40:53.437]                           }
[18:40:53.437]                           else {
[18:40:53.437]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.437]                               info, version)
[18:40:53.437]                           }
[18:40:53.437]                           base::stop(msg)
[18:40:53.437]                         }
[18:40:53.437]                       })
[18:40:53.437]                     }
[18:40:53.437]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.437]                     base::options(mc.cores = 1L)
[18:40:53.437]                   }
[18:40:53.437]                   ...future.strategy.old <- future::plan("list")
[18:40:53.437]                   options(future.plan = NULL)
[18:40:53.437]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.437]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.437]                 }
[18:40:53.437]                 ...future.workdir <- getwd()
[18:40:53.437]             }
[18:40:53.437]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.437]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.437]         }
[18:40:53.437]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.437]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.437]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.437]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.437]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.437]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.437]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.437]             base::names(...future.oldOptions))
[18:40:53.437]     }
[18:40:53.437]     if (FALSE) {
[18:40:53.437]     }
[18:40:53.437]     else {
[18:40:53.437]         if (TRUE) {
[18:40:53.437]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.437]                 open = "w")
[18:40:53.437]         }
[18:40:53.437]         else {
[18:40:53.437]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.437]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.437]         }
[18:40:53.437]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.437]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.437]             base::sink(type = "output", split = FALSE)
[18:40:53.437]             base::close(...future.stdout)
[18:40:53.437]         }, add = TRUE)
[18:40:53.437]     }
[18:40:53.437]     ...future.frame <- base::sys.nframe()
[18:40:53.437]     ...future.conditions <- base::list()
[18:40:53.437]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.437]     if (FALSE) {
[18:40:53.437]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.437]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.437]     }
[18:40:53.437]     ...future.result <- base::tryCatch({
[18:40:53.437]         base::withCallingHandlers({
[18:40:53.437]             ...future.value <- base::withVisible(base::local({
[18:40:53.437]                 ...future.makeSendCondition <- base::local({
[18:40:53.437]                   sendCondition <- NULL
[18:40:53.437]                   function(frame = 1L) {
[18:40:53.437]                     if (is.function(sendCondition)) 
[18:40:53.437]                       return(sendCondition)
[18:40:53.437]                     ns <- getNamespace("parallel")
[18:40:53.437]                     if (exists("sendData", mode = "function", 
[18:40:53.437]                       envir = ns)) {
[18:40:53.437]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.437]                         envir = ns)
[18:40:53.437]                       envir <- sys.frame(frame)
[18:40:53.437]                       master <- NULL
[18:40:53.437]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.437]                         !identical(envir, emptyenv())) {
[18:40:53.437]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.437]                           inherits = FALSE)) {
[18:40:53.437]                           master <- get("master", mode = "list", 
[18:40:53.437]                             envir = envir, inherits = FALSE)
[18:40:53.437]                           if (inherits(master, c("SOCKnode", 
[18:40:53.437]                             "SOCK0node"))) {
[18:40:53.437]                             sendCondition <<- function(cond) {
[18:40:53.437]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.437]                                 success = TRUE)
[18:40:53.437]                               parallel_sendData(master, data)
[18:40:53.437]                             }
[18:40:53.437]                             return(sendCondition)
[18:40:53.437]                           }
[18:40:53.437]                         }
[18:40:53.437]                         frame <- frame + 1L
[18:40:53.437]                         envir <- sys.frame(frame)
[18:40:53.437]                       }
[18:40:53.437]                     }
[18:40:53.437]                     sendCondition <<- function(cond) NULL
[18:40:53.437]                   }
[18:40:53.437]                 })
[18:40:53.437]                 withCallingHandlers({
[18:40:53.437]                   {
[18:40:53.437]                     do.call(function(...) {
[18:40:53.437]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.437]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.437]                         ...future.globals.maxSize)) {
[18:40:53.437]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.437]                         on.exit(options(oopts), add = TRUE)
[18:40:53.437]                       }
[18:40:53.437]                       {
[18:40:53.437]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.437]                           FUN = function(jj) {
[18:40:53.437]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.437]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.437]                           })
[18:40:53.437]                       }
[18:40:53.437]                     }, args = future.call.arguments)
[18:40:53.437]                   }
[18:40:53.437]                 }, immediateCondition = function(cond) {
[18:40:53.437]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.437]                   sendCondition(cond)
[18:40:53.437]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.437]                   {
[18:40:53.437]                     inherits <- base::inherits
[18:40:53.437]                     invokeRestart <- base::invokeRestart
[18:40:53.437]                     is.null <- base::is.null
[18:40:53.437]                     muffled <- FALSE
[18:40:53.437]                     if (inherits(cond, "message")) {
[18:40:53.437]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.437]                       if (muffled) 
[18:40:53.437]                         invokeRestart("muffleMessage")
[18:40:53.437]                     }
[18:40:53.437]                     else if (inherits(cond, "warning")) {
[18:40:53.437]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.437]                       if (muffled) 
[18:40:53.437]                         invokeRestart("muffleWarning")
[18:40:53.437]                     }
[18:40:53.437]                     else if (inherits(cond, "condition")) {
[18:40:53.437]                       if (!is.null(pattern)) {
[18:40:53.437]                         computeRestarts <- base::computeRestarts
[18:40:53.437]                         grepl <- base::grepl
[18:40:53.437]                         restarts <- computeRestarts(cond)
[18:40:53.437]                         for (restart in restarts) {
[18:40:53.437]                           name <- restart$name
[18:40:53.437]                           if (is.null(name)) 
[18:40:53.437]                             next
[18:40:53.437]                           if (!grepl(pattern, name)) 
[18:40:53.437]                             next
[18:40:53.437]                           invokeRestart(restart)
[18:40:53.437]                           muffled <- TRUE
[18:40:53.437]                           break
[18:40:53.437]                         }
[18:40:53.437]                       }
[18:40:53.437]                     }
[18:40:53.437]                     invisible(muffled)
[18:40:53.437]                   }
[18:40:53.437]                   muffleCondition(cond)
[18:40:53.437]                 })
[18:40:53.437]             }))
[18:40:53.437]             future::FutureResult(value = ...future.value$value, 
[18:40:53.437]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.437]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.437]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.437]                     ...future.globalenv.names))
[18:40:53.437]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.437]         }, condition = base::local({
[18:40:53.437]             c <- base::c
[18:40:53.437]             inherits <- base::inherits
[18:40:53.437]             invokeRestart <- base::invokeRestart
[18:40:53.437]             length <- base::length
[18:40:53.437]             list <- base::list
[18:40:53.437]             seq.int <- base::seq.int
[18:40:53.437]             signalCondition <- base::signalCondition
[18:40:53.437]             sys.calls <- base::sys.calls
[18:40:53.437]             `[[` <- base::`[[`
[18:40:53.437]             `+` <- base::`+`
[18:40:53.437]             `<<-` <- base::`<<-`
[18:40:53.437]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.437]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.437]                   3L)]
[18:40:53.437]             }
[18:40:53.437]             function(cond) {
[18:40:53.437]                 is_error <- inherits(cond, "error")
[18:40:53.437]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.437]                   NULL)
[18:40:53.437]                 if (is_error) {
[18:40:53.437]                   sessionInformation <- function() {
[18:40:53.437]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.437]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.437]                       search = base::search(), system = base::Sys.info())
[18:40:53.437]                   }
[18:40:53.437]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.437]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.437]                     cond$call), session = sessionInformation(), 
[18:40:53.437]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.437]                   signalCondition(cond)
[18:40:53.437]                 }
[18:40:53.437]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.437]                 "immediateCondition"))) {
[18:40:53.437]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.437]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.437]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.437]                   if (TRUE && !signal) {
[18:40:53.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.437]                     {
[18:40:53.437]                       inherits <- base::inherits
[18:40:53.437]                       invokeRestart <- base::invokeRestart
[18:40:53.437]                       is.null <- base::is.null
[18:40:53.437]                       muffled <- FALSE
[18:40:53.437]                       if (inherits(cond, "message")) {
[18:40:53.437]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.437]                         if (muffled) 
[18:40:53.437]                           invokeRestart("muffleMessage")
[18:40:53.437]                       }
[18:40:53.437]                       else if (inherits(cond, "warning")) {
[18:40:53.437]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.437]                         if (muffled) 
[18:40:53.437]                           invokeRestart("muffleWarning")
[18:40:53.437]                       }
[18:40:53.437]                       else if (inherits(cond, "condition")) {
[18:40:53.437]                         if (!is.null(pattern)) {
[18:40:53.437]                           computeRestarts <- base::computeRestarts
[18:40:53.437]                           grepl <- base::grepl
[18:40:53.437]                           restarts <- computeRestarts(cond)
[18:40:53.437]                           for (restart in restarts) {
[18:40:53.437]                             name <- restart$name
[18:40:53.437]                             if (is.null(name)) 
[18:40:53.437]                               next
[18:40:53.437]                             if (!grepl(pattern, name)) 
[18:40:53.437]                               next
[18:40:53.437]                             invokeRestart(restart)
[18:40:53.437]                             muffled <- TRUE
[18:40:53.437]                             break
[18:40:53.437]                           }
[18:40:53.437]                         }
[18:40:53.437]                       }
[18:40:53.437]                       invisible(muffled)
[18:40:53.437]                     }
[18:40:53.437]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.437]                   }
[18:40:53.437]                 }
[18:40:53.437]                 else {
[18:40:53.437]                   if (TRUE) {
[18:40:53.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.437]                     {
[18:40:53.437]                       inherits <- base::inherits
[18:40:53.437]                       invokeRestart <- base::invokeRestart
[18:40:53.437]                       is.null <- base::is.null
[18:40:53.437]                       muffled <- FALSE
[18:40:53.437]                       if (inherits(cond, "message")) {
[18:40:53.437]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.437]                         if (muffled) 
[18:40:53.437]                           invokeRestart("muffleMessage")
[18:40:53.437]                       }
[18:40:53.437]                       else if (inherits(cond, "warning")) {
[18:40:53.437]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.437]                         if (muffled) 
[18:40:53.437]                           invokeRestart("muffleWarning")
[18:40:53.437]                       }
[18:40:53.437]                       else if (inherits(cond, "condition")) {
[18:40:53.437]                         if (!is.null(pattern)) {
[18:40:53.437]                           computeRestarts <- base::computeRestarts
[18:40:53.437]                           grepl <- base::grepl
[18:40:53.437]                           restarts <- computeRestarts(cond)
[18:40:53.437]                           for (restart in restarts) {
[18:40:53.437]                             name <- restart$name
[18:40:53.437]                             if (is.null(name)) 
[18:40:53.437]                               next
[18:40:53.437]                             if (!grepl(pattern, name)) 
[18:40:53.437]                               next
[18:40:53.437]                             invokeRestart(restart)
[18:40:53.437]                             muffled <- TRUE
[18:40:53.437]                             break
[18:40:53.437]                           }
[18:40:53.437]                         }
[18:40:53.437]                       }
[18:40:53.437]                       invisible(muffled)
[18:40:53.437]                     }
[18:40:53.437]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.437]                   }
[18:40:53.437]                 }
[18:40:53.437]             }
[18:40:53.437]         }))
[18:40:53.437]     }, error = function(ex) {
[18:40:53.437]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.437]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.437]                 ...future.rng), started = ...future.startTime, 
[18:40:53.437]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.437]             version = "1.8"), class = "FutureResult")
[18:40:53.437]     }, finally = {
[18:40:53.437]         if (!identical(...future.workdir, getwd())) 
[18:40:53.437]             setwd(...future.workdir)
[18:40:53.437]         {
[18:40:53.437]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.437]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.437]             }
[18:40:53.437]             base::options(...future.oldOptions)
[18:40:53.437]             if (.Platform$OS.type == "windows") {
[18:40:53.437]                 old_names <- names(...future.oldEnvVars)
[18:40:53.437]                 envs <- base::Sys.getenv()
[18:40:53.437]                 names <- names(envs)
[18:40:53.437]                 common <- intersect(names, old_names)
[18:40:53.437]                 added <- setdiff(names, old_names)
[18:40:53.437]                 removed <- setdiff(old_names, names)
[18:40:53.437]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.437]                   envs[common]]
[18:40:53.437]                 NAMES <- toupper(changed)
[18:40:53.437]                 args <- list()
[18:40:53.437]                 for (kk in seq_along(NAMES)) {
[18:40:53.437]                   name <- changed[[kk]]
[18:40:53.437]                   NAME <- NAMES[[kk]]
[18:40:53.437]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.437]                     next
[18:40:53.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.437]                 }
[18:40:53.437]                 NAMES <- toupper(added)
[18:40:53.437]                 for (kk in seq_along(NAMES)) {
[18:40:53.437]                   name <- added[[kk]]
[18:40:53.437]                   NAME <- NAMES[[kk]]
[18:40:53.437]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.437]                     next
[18:40:53.437]                   args[[name]] <- ""
[18:40:53.437]                 }
[18:40:53.437]                 NAMES <- toupper(removed)
[18:40:53.437]                 for (kk in seq_along(NAMES)) {
[18:40:53.437]                   name <- removed[[kk]]
[18:40:53.437]                   NAME <- NAMES[[kk]]
[18:40:53.437]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.437]                     next
[18:40:53.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.437]                 }
[18:40:53.437]                 if (length(args) > 0) 
[18:40:53.437]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.437]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.437]             }
[18:40:53.437]             else {
[18:40:53.437]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.437]             }
[18:40:53.437]             {
[18:40:53.437]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.437]                   0L) {
[18:40:53.437]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.437]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.437]                   base::options(opts)
[18:40:53.437]                 }
[18:40:53.437]                 {
[18:40:53.437]                   {
[18:40:53.437]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.437]                     NULL
[18:40:53.437]                   }
[18:40:53.437]                   options(future.plan = NULL)
[18:40:53.437]                   if (is.na(NA_character_)) 
[18:40:53.437]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.437]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.437]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.437]                     .init = FALSE)
[18:40:53.437]                 }
[18:40:53.437]             }
[18:40:53.437]         }
[18:40:53.437]     })
[18:40:53.437]     if (TRUE) {
[18:40:53.437]         base::sink(type = "output", split = FALSE)
[18:40:53.437]         if (TRUE) {
[18:40:53.437]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.437]         }
[18:40:53.437]         else {
[18:40:53.437]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.437]         }
[18:40:53.437]         base::close(...future.stdout)
[18:40:53.437]         ...future.stdout <- NULL
[18:40:53.437]     }
[18:40:53.437]     ...future.result$conditions <- ...future.conditions
[18:40:53.437]     ...future.result$finished <- base::Sys.time()
[18:40:53.437]     ...future.result
[18:40:53.437] }
[18:40:53.445] Exporting 5 global objects (1.57 KiB) to cluster node #1 ...
[18:40:53.446] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:53.446] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:53.446] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:53.447] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:53.447] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ...
[18:40:53.447] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ... DONE
[18:40:53.448] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.448] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.448] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.449] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.449] Exporting 5 global objects (1.57 KiB) to cluster node #1 ... DONE
[18:40:53.450] MultisessionFuture started
[18:40:53.450] - Launch lazy future ... done
[18:40:53.450] run() for 'MultisessionFuture' ... done
[18:40:53.450] Created future:
[18:40:53.475] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.475] - Validating connection of MultisessionFuture
[18:40:53.475] - received message: FutureResult
[18:40:53.475] - Received FutureResult
[18:40:53.476] - Erased future from FutureRegistry
[18:40:53.476] result() for ClusterFuture ...
[18:40:53.476] - result already collected: FutureResult
[18:40:53.476] result() for ClusterFuture ... done
[18:40:53.476] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.450] MultisessionFuture:
[18:40:53.450] Label: 'future_by-1'
[18:40:53.450] Expression:
[18:40:53.450] {
[18:40:53.450]     do.call(function(...) {
[18:40:53.450]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.450]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.450]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.450]             on.exit(options(oopts), add = TRUE)
[18:40:53.450]         }
[18:40:53.450]         {
[18:40:53.450]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.450]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.450]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.450]             })
[18:40:53.450]         }
[18:40:53.450]     }, args = future.call.arguments)
[18:40:53.450] }
[18:40:53.450] Lazy evaluation: FALSE
[18:40:53.450] Asynchronous evaluation: TRUE
[18:40:53.450] Local evaluation: TRUE
[18:40:53.450] Environment: 0x000001cd51358238
[18:40:53.450] Capture standard output: TRUE
[18:40:53.450] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.450] Globals: 5 objects totaling 1.14 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 736 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.450] Packages: <none>
[18:40:53.450] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.450] Resolved: TRUE
[18:40:53.450] Value: <not collected>
[18:40:53.450] Conditions captured: <none>
[18:40:53.450] Early signaling: FALSE
[18:40:53.450] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.450] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.477] Chunk #1 of 2 ... DONE
[18:40:53.477] Chunk #2 of 2 ...
[18:40:53.477]  - Finding globals in 'X' for chunk #2 ...
[18:40:53.477] getGlobalsAndPackages() ...
[18:40:53.477] Searching for globals...
[18:40:53.478] 
[18:40:53.478] Searching for globals ... DONE
[18:40:53.478] - globals: [0] <none>
[18:40:53.478] getGlobalsAndPackages() ... DONE
[18:40:53.479]    + additional globals found: [n=0] 
[18:40:53.479]    + additional namespaces needed: [n=0] 
[18:40:53.479]  - Finding globals in 'X' for chunk #2 ... DONE
[18:40:53.479]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.479]  - seeds: <none>
[18:40:53.479]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.480] getGlobalsAndPackages() ...
[18:40:53.480] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.480] Resolving globals: FALSE
[18:40:53.480] Tweak future expression to call with '...' arguments ...
[18:40:53.480] {
[18:40:53.480]     do.call(function(...) {
[18:40:53.480]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.480]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.480]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.480]             on.exit(options(oopts), add = TRUE)
[18:40:53.480]         }
[18:40:53.480]         {
[18:40:53.480]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.480]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.480]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.480]             })
[18:40:53.480]         }
[18:40:53.480]     }, args = future.call.arguments)
[18:40:53.480] }
[18:40:53.481] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.481] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.481] 
[18:40:53.482] getGlobalsAndPackages() ... DONE
[18:40:53.482] run() for 'Future' ...
[18:40:53.482] - state: 'created'
[18:40:53.482] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.498] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.498] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.498]   - Field: 'node'
[18:40:53.499]   - Field: 'label'
[18:40:53.499]   - Field: 'local'
[18:40:53.499]   - Field: 'owner'
[18:40:53.499]   - Field: 'envir'
[18:40:53.499]   - Field: 'workers'
[18:40:53.500]   - Field: 'packages'
[18:40:53.500]   - Field: 'gc'
[18:40:53.500]   - Field: 'conditions'
[18:40:53.500]   - Field: 'persistent'
[18:40:53.500]   - Field: 'expr'
[18:40:53.500]   - Field: 'uuid'
[18:40:53.501]   - Field: 'seed'
[18:40:53.501]   - Field: 'version'
[18:40:53.501]   - Field: 'result'
[18:40:53.501]   - Field: 'asynchronous'
[18:40:53.501]   - Field: 'calls'
[18:40:53.501]   - Field: 'globals'
[18:40:53.502]   - Field: 'stdout'
[18:40:53.502]   - Field: 'earlySignal'
[18:40:53.502]   - Field: 'lazy'
[18:40:53.502]   - Field: 'state'
[18:40:53.502] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.502] - Launch lazy future ...
[18:40:53.503] Packages needed by the future expression (n = 0): <none>
[18:40:53.503] Packages needed by future strategies (n = 0): <none>
[18:40:53.504] {
[18:40:53.504]     {
[18:40:53.504]         {
[18:40:53.504]             ...future.startTime <- base::Sys.time()
[18:40:53.504]             {
[18:40:53.504]                 {
[18:40:53.504]                   {
[18:40:53.504]                     {
[18:40:53.504]                       base::local({
[18:40:53.504]                         has_future <- base::requireNamespace("future", 
[18:40:53.504]                           quietly = TRUE)
[18:40:53.504]                         if (has_future) {
[18:40:53.504]                           ns <- base::getNamespace("future")
[18:40:53.504]                           version <- ns[[".package"]][["version"]]
[18:40:53.504]                           if (is.null(version)) 
[18:40:53.504]                             version <- utils::packageVersion("future")
[18:40:53.504]                         }
[18:40:53.504]                         else {
[18:40:53.504]                           version <- NULL
[18:40:53.504]                         }
[18:40:53.504]                         if (!has_future || version < "1.8.0") {
[18:40:53.504]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.504]                             "", base::R.version$version.string), 
[18:40:53.504]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:53.504]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:53.504]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.504]                               "release", "version")], collapse = " "), 
[18:40:53.504]                             hostname = base::Sys.info()[["nodename"]])
[18:40:53.504]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.504]                             info)
[18:40:53.504]                           info <- base::paste(info, collapse = "; ")
[18:40:53.504]                           if (!has_future) {
[18:40:53.504]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.504]                               info)
[18:40:53.504]                           }
[18:40:53.504]                           else {
[18:40:53.504]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.504]                               info, version)
[18:40:53.504]                           }
[18:40:53.504]                           base::stop(msg)
[18:40:53.504]                         }
[18:40:53.504]                       })
[18:40:53.504]                     }
[18:40:53.504]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.504]                     base::options(mc.cores = 1L)
[18:40:53.504]                   }
[18:40:53.504]                   ...future.strategy.old <- future::plan("list")
[18:40:53.504]                   options(future.plan = NULL)
[18:40:53.504]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.504]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.504]                 }
[18:40:53.504]                 ...future.workdir <- getwd()
[18:40:53.504]             }
[18:40:53.504]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.504]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.504]         }
[18:40:53.504]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.504]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.504]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.504]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.504]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.504]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.504]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.504]             base::names(...future.oldOptions))
[18:40:53.504]     }
[18:40:53.504]     if (FALSE) {
[18:40:53.504]     }
[18:40:53.504]     else {
[18:40:53.504]         if (TRUE) {
[18:40:53.504]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.504]                 open = "w")
[18:40:53.504]         }
[18:40:53.504]         else {
[18:40:53.504]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.504]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.504]         }
[18:40:53.504]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.504]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.504]             base::sink(type = "output", split = FALSE)
[18:40:53.504]             base::close(...future.stdout)
[18:40:53.504]         }, add = TRUE)
[18:40:53.504]     }
[18:40:53.504]     ...future.frame <- base::sys.nframe()
[18:40:53.504]     ...future.conditions <- base::list()
[18:40:53.504]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.504]     if (FALSE) {
[18:40:53.504]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.504]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.504]     }
[18:40:53.504]     ...future.result <- base::tryCatch({
[18:40:53.504]         base::withCallingHandlers({
[18:40:53.504]             ...future.value <- base::withVisible(base::local({
[18:40:53.504]                 ...future.makeSendCondition <- base::local({
[18:40:53.504]                   sendCondition <- NULL
[18:40:53.504]                   function(frame = 1L) {
[18:40:53.504]                     if (is.function(sendCondition)) 
[18:40:53.504]                       return(sendCondition)
[18:40:53.504]                     ns <- getNamespace("parallel")
[18:40:53.504]                     if (exists("sendData", mode = "function", 
[18:40:53.504]                       envir = ns)) {
[18:40:53.504]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.504]                         envir = ns)
[18:40:53.504]                       envir <- sys.frame(frame)
[18:40:53.504]                       master <- NULL
[18:40:53.504]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.504]                         !identical(envir, emptyenv())) {
[18:40:53.504]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.504]                           inherits = FALSE)) {
[18:40:53.504]                           master <- get("master", mode = "list", 
[18:40:53.504]                             envir = envir, inherits = FALSE)
[18:40:53.504]                           if (inherits(master, c("SOCKnode", 
[18:40:53.504]                             "SOCK0node"))) {
[18:40:53.504]                             sendCondition <<- function(cond) {
[18:40:53.504]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.504]                                 success = TRUE)
[18:40:53.504]                               parallel_sendData(master, data)
[18:40:53.504]                             }
[18:40:53.504]                             return(sendCondition)
[18:40:53.504]                           }
[18:40:53.504]                         }
[18:40:53.504]                         frame <- frame + 1L
[18:40:53.504]                         envir <- sys.frame(frame)
[18:40:53.504]                       }
[18:40:53.504]                     }
[18:40:53.504]                     sendCondition <<- function(cond) NULL
[18:40:53.504]                   }
[18:40:53.504]                 })
[18:40:53.504]                 withCallingHandlers({
[18:40:53.504]                   {
[18:40:53.504]                     do.call(function(...) {
[18:40:53.504]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.504]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.504]                         ...future.globals.maxSize)) {
[18:40:53.504]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.504]                         on.exit(options(oopts), add = TRUE)
[18:40:53.504]                       }
[18:40:53.504]                       {
[18:40:53.504]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.504]                           FUN = function(jj) {
[18:40:53.504]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.504]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.504]                           })
[18:40:53.504]                       }
[18:40:53.504]                     }, args = future.call.arguments)
[18:40:53.504]                   }
[18:40:53.504]                 }, immediateCondition = function(cond) {
[18:40:53.504]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.504]                   sendCondition(cond)
[18:40:53.504]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.504]                   {
[18:40:53.504]                     inherits <- base::inherits
[18:40:53.504]                     invokeRestart <- base::invokeRestart
[18:40:53.504]                     is.null <- base::is.null
[18:40:53.504]                     muffled <- FALSE
[18:40:53.504]                     if (inherits(cond, "message")) {
[18:40:53.504]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.504]                       if (muffled) 
[18:40:53.504]                         invokeRestart("muffleMessage")
[18:40:53.504]                     }
[18:40:53.504]                     else if (inherits(cond, "warning")) {
[18:40:53.504]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.504]                       if (muffled) 
[18:40:53.504]                         invokeRestart("muffleWarning")
[18:40:53.504]                     }
[18:40:53.504]                     else if (inherits(cond, "condition")) {
[18:40:53.504]                       if (!is.null(pattern)) {
[18:40:53.504]                         computeRestarts <- base::computeRestarts
[18:40:53.504]                         grepl <- base::grepl
[18:40:53.504]                         restarts <- computeRestarts(cond)
[18:40:53.504]                         for (restart in restarts) {
[18:40:53.504]                           name <- restart$name
[18:40:53.504]                           if (is.null(name)) 
[18:40:53.504]                             next
[18:40:53.504]                           if (!grepl(pattern, name)) 
[18:40:53.504]                             next
[18:40:53.504]                           invokeRestart(restart)
[18:40:53.504]                           muffled <- TRUE
[18:40:53.504]                           break
[18:40:53.504]                         }
[18:40:53.504]                       }
[18:40:53.504]                     }
[18:40:53.504]                     invisible(muffled)
[18:40:53.504]                   }
[18:40:53.504]                   muffleCondition(cond)
[18:40:53.504]                 })
[18:40:53.504]             }))
[18:40:53.504]             future::FutureResult(value = ...future.value$value, 
[18:40:53.504]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.504]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.504]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.504]                     ...future.globalenv.names))
[18:40:53.504]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.504]         }, condition = base::local({
[18:40:53.504]             c <- base::c
[18:40:53.504]             inherits <- base::inherits
[18:40:53.504]             invokeRestart <- base::invokeRestart
[18:40:53.504]             length <- base::length
[18:40:53.504]             list <- base::list
[18:40:53.504]             seq.int <- base::seq.int
[18:40:53.504]             signalCondition <- base::signalCondition
[18:40:53.504]             sys.calls <- base::sys.calls
[18:40:53.504]             `[[` <- base::`[[`
[18:40:53.504]             `+` <- base::`+`
[18:40:53.504]             `<<-` <- base::`<<-`
[18:40:53.504]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.504]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.504]                   3L)]
[18:40:53.504]             }
[18:40:53.504]             function(cond) {
[18:40:53.504]                 is_error <- inherits(cond, "error")
[18:40:53.504]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.504]                   NULL)
[18:40:53.504]                 if (is_error) {
[18:40:53.504]                   sessionInformation <- function() {
[18:40:53.504]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.504]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.504]                       search = base::search(), system = base::Sys.info())
[18:40:53.504]                   }
[18:40:53.504]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.504]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.504]                     cond$call), session = sessionInformation(), 
[18:40:53.504]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.504]                   signalCondition(cond)
[18:40:53.504]                 }
[18:40:53.504]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.504]                 "immediateCondition"))) {
[18:40:53.504]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.504]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.504]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.504]                   if (TRUE && !signal) {
[18:40:53.504]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.504]                     {
[18:40:53.504]                       inherits <- base::inherits
[18:40:53.504]                       invokeRestart <- base::invokeRestart
[18:40:53.504]                       is.null <- base::is.null
[18:40:53.504]                       muffled <- FALSE
[18:40:53.504]                       if (inherits(cond, "message")) {
[18:40:53.504]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.504]                         if (muffled) 
[18:40:53.504]                           invokeRestart("muffleMessage")
[18:40:53.504]                       }
[18:40:53.504]                       else if (inherits(cond, "warning")) {
[18:40:53.504]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.504]                         if (muffled) 
[18:40:53.504]                           invokeRestart("muffleWarning")
[18:40:53.504]                       }
[18:40:53.504]                       else if (inherits(cond, "condition")) {
[18:40:53.504]                         if (!is.null(pattern)) {
[18:40:53.504]                           computeRestarts <- base::computeRestarts
[18:40:53.504]                           grepl <- base::grepl
[18:40:53.504]                           restarts <- computeRestarts(cond)
[18:40:53.504]                           for (restart in restarts) {
[18:40:53.504]                             name <- restart$name
[18:40:53.504]                             if (is.null(name)) 
[18:40:53.504]                               next
[18:40:53.504]                             if (!grepl(pattern, name)) 
[18:40:53.504]                               next
[18:40:53.504]                             invokeRestart(restart)
[18:40:53.504]                             muffled <- TRUE
[18:40:53.504]                             break
[18:40:53.504]                           }
[18:40:53.504]                         }
[18:40:53.504]                       }
[18:40:53.504]                       invisible(muffled)
[18:40:53.504]                     }
[18:40:53.504]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.504]                   }
[18:40:53.504]                 }
[18:40:53.504]                 else {
[18:40:53.504]                   if (TRUE) {
[18:40:53.504]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.504]                     {
[18:40:53.504]                       inherits <- base::inherits
[18:40:53.504]                       invokeRestart <- base::invokeRestart
[18:40:53.504]                       is.null <- base::is.null
[18:40:53.504]                       muffled <- FALSE
[18:40:53.504]                       if (inherits(cond, "message")) {
[18:40:53.504]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.504]                         if (muffled) 
[18:40:53.504]                           invokeRestart("muffleMessage")
[18:40:53.504]                       }
[18:40:53.504]                       else if (inherits(cond, "warning")) {
[18:40:53.504]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.504]                         if (muffled) 
[18:40:53.504]                           invokeRestart("muffleWarning")
[18:40:53.504]                       }
[18:40:53.504]                       else if (inherits(cond, "condition")) {
[18:40:53.504]                         if (!is.null(pattern)) {
[18:40:53.504]                           computeRestarts <- base::computeRestarts
[18:40:53.504]                           grepl <- base::grepl
[18:40:53.504]                           restarts <- computeRestarts(cond)
[18:40:53.504]                           for (restart in restarts) {
[18:40:53.504]                             name <- restart$name
[18:40:53.504]                             if (is.null(name)) 
[18:40:53.504]                               next
[18:40:53.504]                             if (!grepl(pattern, name)) 
[18:40:53.504]                               next
[18:40:53.504]                             invokeRestart(restart)
[18:40:53.504]                             muffled <- TRUE
[18:40:53.504]                             break
[18:40:53.504]                           }
[18:40:53.504]                         }
[18:40:53.504]                       }
[18:40:53.504]                       invisible(muffled)
[18:40:53.504]                     }
[18:40:53.504]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.504]                   }
[18:40:53.504]                 }
[18:40:53.504]             }
[18:40:53.504]         }))
[18:40:53.504]     }, error = function(ex) {
[18:40:53.504]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.504]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.504]                 ...future.rng), started = ...future.startTime, 
[18:40:53.504]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.504]             version = "1.8"), class = "FutureResult")
[18:40:53.504]     }, finally = {
[18:40:53.504]         if (!identical(...future.workdir, getwd())) 
[18:40:53.504]             setwd(...future.workdir)
[18:40:53.504]         {
[18:40:53.504]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.504]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.504]             }
[18:40:53.504]             base::options(...future.oldOptions)
[18:40:53.504]             if (.Platform$OS.type == "windows") {
[18:40:53.504]                 old_names <- names(...future.oldEnvVars)
[18:40:53.504]                 envs <- base::Sys.getenv()
[18:40:53.504]                 names <- names(envs)
[18:40:53.504]                 common <- intersect(names, old_names)
[18:40:53.504]                 added <- setdiff(names, old_names)
[18:40:53.504]                 removed <- setdiff(old_names, names)
[18:40:53.504]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.504]                   envs[common]]
[18:40:53.504]                 NAMES <- toupper(changed)
[18:40:53.504]                 args <- list()
[18:40:53.504]                 for (kk in seq_along(NAMES)) {
[18:40:53.504]                   name <- changed[[kk]]
[18:40:53.504]                   NAME <- NAMES[[kk]]
[18:40:53.504]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.504]                     next
[18:40:53.504]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.504]                 }
[18:40:53.504]                 NAMES <- toupper(added)
[18:40:53.504]                 for (kk in seq_along(NAMES)) {
[18:40:53.504]                   name <- added[[kk]]
[18:40:53.504]                   NAME <- NAMES[[kk]]
[18:40:53.504]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.504]                     next
[18:40:53.504]                   args[[name]] <- ""
[18:40:53.504]                 }
[18:40:53.504]                 NAMES <- toupper(removed)
[18:40:53.504]                 for (kk in seq_along(NAMES)) {
[18:40:53.504]                   name <- removed[[kk]]
[18:40:53.504]                   NAME <- NAMES[[kk]]
[18:40:53.504]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.504]                     next
[18:40:53.504]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.504]                 }
[18:40:53.504]                 if (length(args) > 0) 
[18:40:53.504]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.504]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.504]             }
[18:40:53.504]             else {
[18:40:53.504]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.504]             }
[18:40:53.504]             {
[18:40:53.504]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.504]                   0L) {
[18:40:53.504]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.504]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.504]                   base::options(opts)
[18:40:53.504]                 }
[18:40:53.504]                 {
[18:40:53.504]                   {
[18:40:53.504]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.504]                     NULL
[18:40:53.504]                   }
[18:40:53.504]                   options(future.plan = NULL)
[18:40:53.504]                   if (is.na(NA_character_)) 
[18:40:53.504]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.504]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.504]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.504]                     .init = FALSE)
[18:40:53.504]                 }
[18:40:53.504]             }
[18:40:53.504]         }
[18:40:53.504]     })
[18:40:53.504]     if (TRUE) {
[18:40:53.504]         base::sink(type = "output", split = FALSE)
[18:40:53.504]         if (TRUE) {
[18:40:53.504]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.504]         }
[18:40:53.504]         else {
[18:40:53.504]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.504]         }
[18:40:53.504]         base::close(...future.stdout)
[18:40:53.504]         ...future.stdout <- NULL
[18:40:53.504]     }
[18:40:53.504]     ...future.result$conditions <- ...future.conditions
[18:40:53.504]     ...future.result$finished <- base::Sys.time()
[18:40:53.504]     ...future.result
[18:40:53.504] }
[18:40:53.509] Exporting 5 global objects (2.20 KiB) to cluster node #1 ...
[18:40:53.509] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:53.510] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:53.510] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:53.510] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:53.510] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ...
[18:40:53.511] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ... DONE
[18:40:53.511] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.512] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.512] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.512] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.512] Exporting 5 global objects (2.20 KiB) to cluster node #1 ... DONE
[18:40:53.513] MultisessionFuture started
[18:40:53.513] - Launch lazy future ... done
[18:40:53.513] run() for 'MultisessionFuture' ... done
[18:40:53.513] Created future:
[18:40:53.534] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.534] - Validating connection of MultisessionFuture
[18:40:53.535] - received message: FutureResult
[18:40:53.535] - Received FutureResult
[18:40:53.535] - Erased future from FutureRegistry
[18:40:53.535] result() for ClusterFuture ...
[18:40:53.535] - result already collected: FutureResult
[18:40:53.536] result() for ClusterFuture ... done
[18:40:53.536] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.514] MultisessionFuture:
[18:40:53.514] Label: 'future_by-2'
[18:40:53.514] Expression:
[18:40:53.514] {
[18:40:53.514]     do.call(function(...) {
[18:40:53.514]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.514]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.514]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.514]             on.exit(options(oopts), add = TRUE)
[18:40:53.514]         }
[18:40:53.514]         {
[18:40:53.514]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.514]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.514]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.514]             })
[18:40:53.514]         }
[18:40:53.514]     }, args = future.call.arguments)
[18:40:53.514] }
[18:40:53.514] Lazy evaluation: FALSE
[18:40:53.514] Asynchronous evaluation: TRUE
[18:40:53.514] Local evaluation: TRUE
[18:40:53.514] Environment: 0x000001cd51358238
[18:40:53.514] Capture standard output: TRUE
[18:40:53.514] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.514] Globals: 5 objects totaling 1.77 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.35 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.514] Packages: <none>
[18:40:53.514] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.514] Resolved: TRUE
[18:40:53.514] Value: <not collected>
[18:40:53.514] Conditions captured: <none>
[18:40:53.514] Early signaling: FALSE
[18:40:53.514] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.514] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.536] Chunk #2 of 2 ... DONE
[18:40:53.536] Launching 2 futures (chunks) ... DONE
[18:40:53.536] Resolving 2 futures (chunks) ...
[18:40:53.537] resolve() on list ...
[18:40:53.537]  recursive: 0
[18:40:53.537]  length: 2
[18:40:53.537] 
[18:40:53.537] Future #1
[18:40:53.537] result() for ClusterFuture ...
[18:40:53.538] - result already collected: FutureResult
[18:40:53.538] result() for ClusterFuture ... done
[18:40:53.538] result() for ClusterFuture ...
[18:40:53.538] - result already collected: FutureResult
[18:40:53.538] result() for ClusterFuture ... done
[18:40:53.538] signalConditionsASAP(MultisessionFuture, pos=1) ...
[18:40:53.539] - nx: 2
[18:40:53.539] - relay: TRUE
[18:40:53.539] - stdout: TRUE
[18:40:53.539] - signal: TRUE
[18:40:53.539] - resignal: FALSE
[18:40:53.539] - force: TRUE
[18:40:53.539] - relayed: [n=2] FALSE, FALSE
[18:40:53.540] - queued futures: [n=2] FALSE, FALSE
[18:40:53.540]  - until=1
[18:40:53.540]  - relaying element #1
[18:40:53.540] result() for ClusterFuture ...
[18:40:53.540] - result already collected: FutureResult
[18:40:53.540] result() for ClusterFuture ... done
[18:40:53.541] result() for ClusterFuture ...
[18:40:53.541] - result already collected: FutureResult
[18:40:53.541] result() for ClusterFuture ... done
[18:40:53.541] result() for ClusterFuture ...
[18:40:53.541] - result already collected: FutureResult
[18:40:53.541] result() for ClusterFuture ... done
[18:40:53.542] result() for ClusterFuture ...
[18:40:53.542] - result already collected: FutureResult
[18:40:53.542] result() for ClusterFuture ... done
[18:40:53.542] - relayed: [n=2] TRUE, FALSE
[18:40:53.544] - queued futures: [n=2] TRUE, FALSE
[18:40:53.544] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[18:40:53.545]  length: 1 (resolved future 1)
[18:40:53.545] Future #2
[18:40:53.545] result() for ClusterFuture ...
[18:40:53.545] - result already collected: FutureResult
[18:40:53.545] result() for ClusterFuture ... done
[18:40:53.545] result() for ClusterFuture ...
[18:40:53.546] - result already collected: FutureResult
[18:40:53.546] result() for ClusterFuture ... done
[18:40:53.546] signalConditionsASAP(MultisessionFuture, pos=2) ...
[18:40:53.546] - nx: 2
[18:40:53.546] - relay: TRUE
[18:40:53.546] - stdout: TRUE
[18:40:53.547] - signal: TRUE
[18:40:53.547] - resignal: FALSE
[18:40:53.547] - force: TRUE
[18:40:53.547] - relayed: [n=2] TRUE, FALSE
[18:40:53.547] - queued futures: [n=2] TRUE, FALSE
[18:40:53.547]  - until=2
[18:40:53.547]  - relaying element #2
[18:40:53.548] result() for ClusterFuture ...
[18:40:53.548] - result already collected: FutureResult
[18:40:53.548] result() for ClusterFuture ... done
[18:40:53.548] result() for ClusterFuture ...
[18:40:53.548] - result already collected: FutureResult
[18:40:53.548] result() for ClusterFuture ... done
[18:40:53.549] result() for ClusterFuture ...
[18:40:53.549] - result already collected: FutureResult
[18:40:53.549] result() for ClusterFuture ... done
[18:40:53.549] result() for ClusterFuture ...
[18:40:53.549] - result already collected: FutureResult
[18:40:53.549] result() for ClusterFuture ... done
[18:40:53.550] - relayed: [n=2] TRUE, TRUE
[18:40:53.550] - queued futures: [n=2] TRUE, TRUE
[18:40:53.550] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[18:40:53.550]  length: 0 (resolved future 2)
[18:40:53.550] Relaying remaining futures
[18:40:53.550] signalConditionsASAP(NULL, pos=0) ...
[18:40:53.550] - nx: 2
[18:40:53.551] - relay: TRUE
[18:40:53.551] - stdout: TRUE
[18:40:53.551] - signal: TRUE
[18:40:53.551] - resignal: FALSE
[18:40:53.551] - force: TRUE
[18:40:53.551] - relayed: [n=2] TRUE, TRUE
[18:40:53.551] - queued futures: [n=2] TRUE, TRUE
 - flush all
[18:40:53.552] - relayed: [n=2] TRUE, TRUE
[18:40:53.552] - queued futures: [n=2] TRUE, TRUE
[18:40:53.552] signalConditionsASAP(NULL, pos=0) ... done
[18:40:53.552] resolve() on list ... DONE
[18:40:53.552] result() for ClusterFuture ...
[18:40:53.552] - result already collected: FutureResult
[18:40:53.553] result() for ClusterFuture ... done
[18:40:53.553] result() for ClusterFuture ...
[18:40:53.553] - result already collected: FutureResult
[18:40:53.553] result() for ClusterFuture ... done
[18:40:53.553] result() for ClusterFuture ...
[18:40:53.553] - result already collected: FutureResult
[18:40:53.554] result() for ClusterFuture ... done
[18:40:53.554] result() for ClusterFuture ...
[18:40:53.554] - result already collected: FutureResult
[18:40:53.554] result() for ClusterFuture ... done
[18:40:53.554]  - Number of value chunks collected: 2
[18:40:53.554] Resolving 2 futures (chunks) ... DONE
[18:40:53.555] Reducing values from 2 chunks ...
[18:40:53.555]  - Number of values collected after concatenation: 3
[18:40:53.555]  - Number of values expected: 3
[18:40:53.555] Reducing values from 2 chunks ... DONE
[18:40:53.555] future_lapply() ... DONE
[18:40:53.555] future_by_internal() ... DONE
[18:40:53.556] future_by_internal() ...
Warning in future_by_match_FUN(FUN) :
  Specifying the function 'FUN' for future_by() as a character string is deprecated in future.apply (>= 1.10.0) [2022-11-04], because base::by() does not support it. Instead, specify it as a function, e.g. FUN = sqrt and FUN = `[[`. It is deprecated.
[18:40:53.557] future_lapply() ...
[18:40:53.560] Number of chunks: 2
[18:40:53.560] getGlobalsAndPackagesXApply() ...
[18:40:53.560]  - future.globals: TRUE
[18:40:53.560] getGlobalsAndPackages() ...
[18:40:53.560] Searching for globals...
[18:40:53.562] - globals found: [2] 'FUN', 'UseMethod'
[18:40:53.562] Searching for globals ... DONE
[18:40:53.562] Resolving globals: FALSE
[18:40:53.563] The total size of the 1 globals is 281 bytes (281 bytes)
[18:40:53.563] The total size of the 1 globals exported for future expression ('FUN()') is 281 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (281 bytes of class 'function')
[18:40:53.563] - globals: [1] 'FUN'
[18:40:53.563] 
[18:40:53.564] getGlobalsAndPackages() ... DONE
[18:40:53.564]  - globals found/used: [n=1] 'FUN'
[18:40:53.564]  - needed namespaces: [n=0] 
[18:40:53.564] Finding globals ... DONE
[18:40:53.564]  - use_args: TRUE
[18:40:53.564]  - Getting '...' globals ...
[18:40:53.565] resolve() on list ...
[18:40:53.565]  recursive: 0
[18:40:53.565]  length: 1
[18:40:53.565]  elements: '...'
[18:40:53.565]  length: 0 (resolved future 1)
[18:40:53.566] resolve() on list ... DONE
[18:40:53.566]    - '...' content: [n=0] 
[18:40:53.566] List of 1
[18:40:53.566]  $ ...: list()
[18:40:53.566]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.566]  - attr(*, "where")=List of 1
[18:40:53.566]   ..$ ...:<environment: 0x000001cd520a5cb8> 
[18:40:53.566]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.566]  - attr(*, "resolved")= logi TRUE
[18:40:53.566]  - attr(*, "total_size")= num NA
[18:40:53.569]  - Getting '...' globals ... DONE
[18:40:53.569] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[18:40:53.569] List of 2
[18:40:53.569]  $ ...future.FUN:function (object, ...)  
[18:40:53.569]  $ ...          : list()
[18:40:53.569]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[18:40:53.569]  - attr(*, "where")=List of 2
[18:40:53.569]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[18:40:53.569]   ..$ ...          :<environment: 0x000001cd520a5cb8> 
[18:40:53.569]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[18:40:53.569]  - attr(*, "resolved")= logi FALSE
[18:40:53.569]  - attr(*, "total_size")= int 18647
[18:40:53.573] Packages to be attached in all futures: [n=0] 
[18:40:53.573] getGlobalsAndPackagesXApply() ... DONE
[18:40:53.573] Number of futures (= number of chunks): 2
[18:40:53.573] Launching 2 futures (chunks) ...
[18:40:53.573] Chunk #1 of 2 ...
[18:40:53.574]  - Finding globals in 'X' for chunk #1 ...
[18:40:53.574] getGlobalsAndPackages() ...
[18:40:53.574] Searching for globals...
[18:40:53.574] 
[18:40:53.574] Searching for globals ... DONE
[18:40:53.575] - globals: [0] <none>
[18:40:53.575] getGlobalsAndPackages() ... DONE
[18:40:53.575]    + additional globals found: [n=0] 
[18:40:53.575]    + additional namespaces needed: [n=0] 
[18:40:53.575]  - Finding globals in 'X' for chunk #1 ... DONE
[18:40:53.575]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.576]  - seeds: <none>
[18:40:53.576]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.576] getGlobalsAndPackages() ...
[18:40:53.576] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.576] Resolving globals: FALSE
[18:40:53.576] Tweak future expression to call with '...' arguments ...
[18:40:53.577] {
[18:40:53.577]     do.call(function(...) {
[18:40:53.577]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.577]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.577]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.577]             on.exit(options(oopts), add = TRUE)
[18:40:53.577]         }
[18:40:53.577]         {
[18:40:53.577]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.577]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.577]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.577]             })
[18:40:53.577]         }
[18:40:53.577]     }, args = future.call.arguments)
[18:40:53.577] }
[18:40:53.577] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.578] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.578] 
[18:40:53.578] getGlobalsAndPackages() ... DONE
[18:40:53.578] run() for 'Future' ...
[18:40:53.578] - state: 'created'
[18:40:53.579] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.594] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.594] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.594]   - Field: 'node'
[18:40:53.594]   - Field: 'label'
[18:40:53.594]   - Field: 'local'
[18:40:53.595]   - Field: 'owner'
[18:40:53.595]   - Field: 'envir'
[18:40:53.595]   - Field: 'workers'
[18:40:53.595]   - Field: 'packages'
[18:40:53.595]   - Field: 'gc'
[18:40:53.595]   - Field: 'conditions'
[18:40:53.596]   - Field: 'persistent'
[18:40:53.596]   - Field: 'expr'
[18:40:53.596]   - Field: 'uuid'
[18:40:53.596]   - Field: 'seed'
[18:40:53.596]   - Field: 'version'
[18:40:53.596]   - Field: 'result'
[18:40:53.597]   - Field: 'asynchronous'
[18:40:53.597]   - Field: 'calls'
[18:40:53.597]   - Field: 'globals'
[18:40:53.597]   - Field: 'stdout'
[18:40:53.597]   - Field: 'earlySignal'
[18:40:53.597]   - Field: 'lazy'
[18:40:53.598]   - Field: 'state'
[18:40:53.598] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.598] - Launch lazy future ...
[18:40:53.598] Packages needed by the future expression (n = 0): <none>
[18:40:53.598] Packages needed by future strategies (n = 0): <none>
[18:40:53.599] {
[18:40:53.599]     {
[18:40:53.599]         {
[18:40:53.599]             ...future.startTime <- base::Sys.time()
[18:40:53.599]             {
[18:40:53.599]                 {
[18:40:53.599]                   {
[18:40:53.599]                     {
[18:40:53.599]                       base::local({
[18:40:53.599]                         has_future <- base::requireNamespace("future", 
[18:40:53.599]                           quietly = TRUE)
[18:40:53.599]                         if (has_future) {
[18:40:53.599]                           ns <- base::getNamespace("future")
[18:40:53.599]                           version <- ns[[".package"]][["version"]]
[18:40:53.599]                           if (is.null(version)) 
[18:40:53.599]                             version <- utils::packageVersion("future")
[18:40:53.599]                         }
[18:40:53.599]                         else {
[18:40:53.599]                           version <- NULL
[18:40:53.599]                         }
[18:40:53.599]                         if (!has_future || version < "1.8.0") {
[18:40:53.599]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.599]                             "", base::R.version$version.string), 
[18:40:53.599]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:53.599]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:53.599]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.599]                               "release", "version")], collapse = " "), 
[18:40:53.599]                             hostname = base::Sys.info()[["nodename"]])
[18:40:53.599]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.599]                             info)
[18:40:53.599]                           info <- base::paste(info, collapse = "; ")
[18:40:53.599]                           if (!has_future) {
[18:40:53.599]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.599]                               info)
[18:40:53.599]                           }
[18:40:53.599]                           else {
[18:40:53.599]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.599]                               info, version)
[18:40:53.599]                           }
[18:40:53.599]                           base::stop(msg)
[18:40:53.599]                         }
[18:40:53.599]                       })
[18:40:53.599]                     }
[18:40:53.599]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.599]                     base::options(mc.cores = 1L)
[18:40:53.599]                   }
[18:40:53.599]                   ...future.strategy.old <- future::plan("list")
[18:40:53.599]                   options(future.plan = NULL)
[18:40:53.599]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.599]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.599]                 }
[18:40:53.599]                 ...future.workdir <- getwd()
[18:40:53.599]             }
[18:40:53.599]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.599]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.599]         }
[18:40:53.599]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.599]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.599]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.599]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.599]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.599]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.599]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.599]             base::names(...future.oldOptions))
[18:40:53.599]     }
[18:40:53.599]     if (FALSE) {
[18:40:53.599]     }
[18:40:53.599]     else {
[18:40:53.599]         if (TRUE) {
[18:40:53.599]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.599]                 open = "w")
[18:40:53.599]         }
[18:40:53.599]         else {
[18:40:53.599]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.599]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.599]         }
[18:40:53.599]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.599]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.599]             base::sink(type = "output", split = FALSE)
[18:40:53.599]             base::close(...future.stdout)
[18:40:53.599]         }, add = TRUE)
[18:40:53.599]     }
[18:40:53.599]     ...future.frame <- base::sys.nframe()
[18:40:53.599]     ...future.conditions <- base::list()
[18:40:53.599]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.599]     if (FALSE) {
[18:40:53.599]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.599]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.599]     }
[18:40:53.599]     ...future.result <- base::tryCatch({
[18:40:53.599]         base::withCallingHandlers({
[18:40:53.599]             ...future.value <- base::withVisible(base::local({
[18:40:53.599]                 ...future.makeSendCondition <- base::local({
[18:40:53.599]                   sendCondition <- NULL
[18:40:53.599]                   function(frame = 1L) {
[18:40:53.599]                     if (is.function(sendCondition)) 
[18:40:53.599]                       return(sendCondition)
[18:40:53.599]                     ns <- getNamespace("parallel")
[18:40:53.599]                     if (exists("sendData", mode = "function", 
[18:40:53.599]                       envir = ns)) {
[18:40:53.599]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.599]                         envir = ns)
[18:40:53.599]                       envir <- sys.frame(frame)
[18:40:53.599]                       master <- NULL
[18:40:53.599]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.599]                         !identical(envir, emptyenv())) {
[18:40:53.599]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.599]                           inherits = FALSE)) {
[18:40:53.599]                           master <- get("master", mode = "list", 
[18:40:53.599]                             envir = envir, inherits = FALSE)
[18:40:53.599]                           if (inherits(master, c("SOCKnode", 
[18:40:53.599]                             "SOCK0node"))) {
[18:40:53.599]                             sendCondition <<- function(cond) {
[18:40:53.599]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.599]                                 success = TRUE)
[18:40:53.599]                               parallel_sendData(master, data)
[18:40:53.599]                             }
[18:40:53.599]                             return(sendCondition)
[18:40:53.599]                           }
[18:40:53.599]                         }
[18:40:53.599]                         frame <- frame + 1L
[18:40:53.599]                         envir <- sys.frame(frame)
[18:40:53.599]                       }
[18:40:53.599]                     }
[18:40:53.599]                     sendCondition <<- function(cond) NULL
[18:40:53.599]                   }
[18:40:53.599]                 })
[18:40:53.599]                 withCallingHandlers({
[18:40:53.599]                   {
[18:40:53.599]                     do.call(function(...) {
[18:40:53.599]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.599]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.599]                         ...future.globals.maxSize)) {
[18:40:53.599]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.599]                         on.exit(options(oopts), add = TRUE)
[18:40:53.599]                       }
[18:40:53.599]                       {
[18:40:53.599]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.599]                           FUN = function(jj) {
[18:40:53.599]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.599]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.599]                           })
[18:40:53.599]                       }
[18:40:53.599]                     }, args = future.call.arguments)
[18:40:53.599]                   }
[18:40:53.599]                 }, immediateCondition = function(cond) {
[18:40:53.599]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.599]                   sendCondition(cond)
[18:40:53.599]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.599]                   {
[18:40:53.599]                     inherits <- base::inherits
[18:40:53.599]                     invokeRestart <- base::invokeRestart
[18:40:53.599]                     is.null <- base::is.null
[18:40:53.599]                     muffled <- FALSE
[18:40:53.599]                     if (inherits(cond, "message")) {
[18:40:53.599]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.599]                       if (muffled) 
[18:40:53.599]                         invokeRestart("muffleMessage")
[18:40:53.599]                     }
[18:40:53.599]                     else if (inherits(cond, "warning")) {
[18:40:53.599]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.599]                       if (muffled) 
[18:40:53.599]                         invokeRestart("muffleWarning")
[18:40:53.599]                     }
[18:40:53.599]                     else if (inherits(cond, "condition")) {
[18:40:53.599]                       if (!is.null(pattern)) {
[18:40:53.599]                         computeRestarts <- base::computeRestarts
[18:40:53.599]                         grepl <- base::grepl
[18:40:53.599]                         restarts <- computeRestarts(cond)
[18:40:53.599]                         for (restart in restarts) {
[18:40:53.599]                           name <- restart$name
[18:40:53.599]                           if (is.null(name)) 
[18:40:53.599]                             next
[18:40:53.599]                           if (!grepl(pattern, name)) 
[18:40:53.599]                             next
[18:40:53.599]                           invokeRestart(restart)
[18:40:53.599]                           muffled <- TRUE
[18:40:53.599]                           break
[18:40:53.599]                         }
[18:40:53.599]                       }
[18:40:53.599]                     }
[18:40:53.599]                     invisible(muffled)
[18:40:53.599]                   }
[18:40:53.599]                   muffleCondition(cond)
[18:40:53.599]                 })
[18:40:53.599]             }))
[18:40:53.599]             future::FutureResult(value = ...future.value$value, 
[18:40:53.599]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.599]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.599]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.599]                     ...future.globalenv.names))
[18:40:53.599]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.599]         }, condition = base::local({
[18:40:53.599]             c <- base::c
[18:40:53.599]             inherits <- base::inherits
[18:40:53.599]             invokeRestart <- base::invokeRestart
[18:40:53.599]             length <- base::length
[18:40:53.599]             list <- base::list
[18:40:53.599]             seq.int <- base::seq.int
[18:40:53.599]             signalCondition <- base::signalCondition
[18:40:53.599]             sys.calls <- base::sys.calls
[18:40:53.599]             `[[` <- base::`[[`
[18:40:53.599]             `+` <- base::`+`
[18:40:53.599]             `<<-` <- base::`<<-`
[18:40:53.599]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.599]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.599]                   3L)]
[18:40:53.599]             }
[18:40:53.599]             function(cond) {
[18:40:53.599]                 is_error <- inherits(cond, "error")
[18:40:53.599]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.599]                   NULL)
[18:40:53.599]                 if (is_error) {
[18:40:53.599]                   sessionInformation <- function() {
[18:40:53.599]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.599]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.599]                       search = base::search(), system = base::Sys.info())
[18:40:53.599]                   }
[18:40:53.599]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.599]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.599]                     cond$call), session = sessionInformation(), 
[18:40:53.599]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.599]                   signalCondition(cond)
[18:40:53.599]                 }
[18:40:53.599]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.599]                 "immediateCondition"))) {
[18:40:53.599]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.599]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.599]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.599]                   if (TRUE && !signal) {
[18:40:53.599]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.599]                     {
[18:40:53.599]                       inherits <- base::inherits
[18:40:53.599]                       invokeRestart <- base::invokeRestart
[18:40:53.599]                       is.null <- base::is.null
[18:40:53.599]                       muffled <- FALSE
[18:40:53.599]                       if (inherits(cond, "message")) {
[18:40:53.599]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.599]                         if (muffled) 
[18:40:53.599]                           invokeRestart("muffleMessage")
[18:40:53.599]                       }
[18:40:53.599]                       else if (inherits(cond, "warning")) {
[18:40:53.599]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.599]                         if (muffled) 
[18:40:53.599]                           invokeRestart("muffleWarning")
[18:40:53.599]                       }
[18:40:53.599]                       else if (inherits(cond, "condition")) {
[18:40:53.599]                         if (!is.null(pattern)) {
[18:40:53.599]                           computeRestarts <- base::computeRestarts
[18:40:53.599]                           grepl <- base::grepl
[18:40:53.599]                           restarts <- computeRestarts(cond)
[18:40:53.599]                           for (restart in restarts) {
[18:40:53.599]                             name <- restart$name
[18:40:53.599]                             if (is.null(name)) 
[18:40:53.599]                               next
[18:40:53.599]                             if (!grepl(pattern, name)) 
[18:40:53.599]                               next
[18:40:53.599]                             invokeRestart(restart)
[18:40:53.599]                             muffled <- TRUE
[18:40:53.599]                             break
[18:40:53.599]                           }
[18:40:53.599]                         }
[18:40:53.599]                       }
[18:40:53.599]                       invisible(muffled)
[18:40:53.599]                     }
[18:40:53.599]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.599]                   }
[18:40:53.599]                 }
[18:40:53.599]                 else {
[18:40:53.599]                   if (TRUE) {
[18:40:53.599]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.599]                     {
[18:40:53.599]                       inherits <- base::inherits
[18:40:53.599]                       invokeRestart <- base::invokeRestart
[18:40:53.599]                       is.null <- base::is.null
[18:40:53.599]                       muffled <- FALSE
[18:40:53.599]                       if (inherits(cond, "message")) {
[18:40:53.599]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.599]                         if (muffled) 
[18:40:53.599]                           invokeRestart("muffleMessage")
[18:40:53.599]                       }
[18:40:53.599]                       else if (inherits(cond, "warning")) {
[18:40:53.599]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.599]                         if (muffled) 
[18:40:53.599]                           invokeRestart("muffleWarning")
[18:40:53.599]                       }
[18:40:53.599]                       else if (inherits(cond, "condition")) {
[18:40:53.599]                         if (!is.null(pattern)) {
[18:40:53.599]                           computeRestarts <- base::computeRestarts
[18:40:53.599]                           grepl <- base::grepl
[18:40:53.599]                           restarts <- computeRestarts(cond)
[18:40:53.599]                           for (restart in restarts) {
[18:40:53.599]                             name <- restart$name
[18:40:53.599]                             if (is.null(name)) 
[18:40:53.599]                               next
[18:40:53.599]                             if (!grepl(pattern, name)) 
[18:40:53.599]                               next
[18:40:53.599]                             invokeRestart(restart)
[18:40:53.599]                             muffled <- TRUE
[18:40:53.599]                             break
[18:40:53.599]                           }
[18:40:53.599]                         }
[18:40:53.599]                       }
[18:40:53.599]                       invisible(muffled)
[18:40:53.599]                     }
[18:40:53.599]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.599]                   }
[18:40:53.599]                 }
[18:40:53.599]             }
[18:40:53.599]         }))
[18:40:53.599]     }, error = function(ex) {
[18:40:53.599]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.599]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.599]                 ...future.rng), started = ...future.startTime, 
[18:40:53.599]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.599]             version = "1.8"), class = "FutureResult")
[18:40:53.599]     }, finally = {
[18:40:53.599]         if (!identical(...future.workdir, getwd())) 
[18:40:53.599]             setwd(...future.workdir)
[18:40:53.599]         {
[18:40:53.599]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.599]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.599]             }
[18:40:53.599]             base::options(...future.oldOptions)
[18:40:53.599]             if (.Platform$OS.type == "windows") {
[18:40:53.599]                 old_names <- names(...future.oldEnvVars)
[18:40:53.599]                 envs <- base::Sys.getenv()
[18:40:53.599]                 names <- names(envs)
[18:40:53.599]                 common <- intersect(names, old_names)
[18:40:53.599]                 added <- setdiff(names, old_names)
[18:40:53.599]                 removed <- setdiff(old_names, names)
[18:40:53.599]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.599]                   envs[common]]
[18:40:53.599]                 NAMES <- toupper(changed)
[18:40:53.599]                 args <- list()
[18:40:53.599]                 for (kk in seq_along(NAMES)) {
[18:40:53.599]                   name <- changed[[kk]]
[18:40:53.599]                   NAME <- NAMES[[kk]]
[18:40:53.599]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.599]                     next
[18:40:53.599]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.599]                 }
[18:40:53.599]                 NAMES <- toupper(added)
[18:40:53.599]                 for (kk in seq_along(NAMES)) {
[18:40:53.599]                   name <- added[[kk]]
[18:40:53.599]                   NAME <- NAMES[[kk]]
[18:40:53.599]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.599]                     next
[18:40:53.599]                   args[[name]] <- ""
[18:40:53.599]                 }
[18:40:53.599]                 NAMES <- toupper(removed)
[18:40:53.599]                 for (kk in seq_along(NAMES)) {
[18:40:53.599]                   name <- removed[[kk]]
[18:40:53.599]                   NAME <- NAMES[[kk]]
[18:40:53.599]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.599]                     next
[18:40:53.599]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.599]                 }
[18:40:53.599]                 if (length(args) > 0) 
[18:40:53.599]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.599]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.599]             }
[18:40:53.599]             else {
[18:40:53.599]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.599]             }
[18:40:53.599]             {
[18:40:53.599]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.599]                   0L) {
[18:40:53.599]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.599]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.599]                   base::options(opts)
[18:40:53.599]                 }
[18:40:53.599]                 {
[18:40:53.599]                   {
[18:40:53.599]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.599]                     NULL
[18:40:53.599]                   }
[18:40:53.599]                   options(future.plan = NULL)
[18:40:53.599]                   if (is.na(NA_character_)) 
[18:40:53.599]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.599]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.599]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.599]                     .init = FALSE)
[18:40:53.599]                 }
[18:40:53.599]             }
[18:40:53.599]         }
[18:40:53.599]     })
[18:40:53.599]     if (TRUE) {
[18:40:53.599]         base::sink(type = "output", split = FALSE)
[18:40:53.599]         if (TRUE) {
[18:40:53.599]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.599]         }
[18:40:53.599]         else {
[18:40:53.599]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.599]         }
[18:40:53.599]         base::close(...future.stdout)
[18:40:53.599]         ...future.stdout <- NULL
[18:40:53.599]     }
[18:40:53.599]     ...future.result$conditions <- ...future.conditions
[18:40:53.599]     ...future.result$finished <- base::Sys.time()
[18:40:53.599]     ...future.result
[18:40:53.599] }
[18:40:53.605] Exporting 5 global objects (1.57 KiB) to cluster node #1 ...
[18:40:53.605] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:53.606] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:53.606] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:53.606] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:53.606] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ...
[18:40:53.607] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ... DONE
[18:40:53.607] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.608] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.608] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.608] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.609] Exporting 5 global objects (1.57 KiB) to cluster node #1 ... DONE
[18:40:53.610] MultisessionFuture started
[18:40:53.610] - Launch lazy future ... done
[18:40:53.610] run() for 'MultisessionFuture' ... done
[18:40:53.611] Created future:
[18:40:53.634] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.634] - Validating connection of MultisessionFuture
[18:40:53.635] - received message: FutureResult
[18:40:53.635] - Received FutureResult
[18:40:53.635] - Erased future from FutureRegistry
[18:40:53.635] result() for ClusterFuture ...
[18:40:53.635] - result already collected: FutureResult
[18:40:53.636] result() for ClusterFuture ... done
[18:40:53.636] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.611] MultisessionFuture:
[18:40:53.611] Label: 'future_by-1'
[18:40:53.611] Expression:
[18:40:53.611] {
[18:40:53.611]     do.call(function(...) {
[18:40:53.611]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.611]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.611]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.611]             on.exit(options(oopts), add = TRUE)
[18:40:53.611]         }
[18:40:53.611]         {
[18:40:53.611]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.611]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.611]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.611]             })
[18:40:53.611]         }
[18:40:53.611]     }, args = future.call.arguments)
[18:40:53.611] }
[18:40:53.611] Lazy evaluation: FALSE
[18:40:53.611] Asynchronous evaluation: TRUE
[18:40:53.611] Local evaluation: TRUE
[18:40:53.611] Environment: 0x000001cd52119938
[18:40:53.611] Capture standard output: TRUE
[18:40:53.611] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.611] Globals: 5 objects totaling 1.14 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 736 bytes, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.611] Packages: <none>
[18:40:53.611] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.611] Resolved: TRUE
[18:40:53.611] Value: <not collected>
[18:40:53.611] Conditions captured: <none>
[18:40:53.611] Early signaling: FALSE
[18:40:53.611] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.611] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.636] Chunk #1 of 2 ... DONE
[18:40:53.636] Chunk #2 of 2 ...
[18:40:53.636]  - Finding globals in 'X' for chunk #2 ...
[18:40:53.637] getGlobalsAndPackages() ...
[18:40:53.637] Searching for globals...
[18:40:53.637] 
[18:40:53.638] Searching for globals ... DONE
[18:40:53.638] - globals: [0] <none>
[18:40:53.638] getGlobalsAndPackages() ... DONE
[18:40:53.638]    + additional globals found: [n=0] 
[18:40:53.638]    + additional namespaces needed: [n=0] 
[18:40:53.638]  - Finding globals in 'X' for chunk #2 ... DONE
[18:40:53.638]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[18:40:53.639]  - seeds: <none>
[18:40:53.639]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.639] getGlobalsAndPackages() ...
[18:40:53.639] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.639] Resolving globals: FALSE
[18:40:53.639] Tweak future expression to call with '...' arguments ...
[18:40:53.640] {
[18:40:53.640]     do.call(function(...) {
[18:40:53.640]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.640]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.640]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.640]             on.exit(options(oopts), add = TRUE)
[18:40:53.640]         }
[18:40:53.640]         {
[18:40:53.640]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.640]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.640]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.640]             })
[18:40:53.640]         }
[18:40:53.640]     }, args = future.call.arguments)
[18:40:53.640] }
[18:40:53.640] Tweak future expression to call with '...' arguments ... DONE
[18:40:53.641] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[18:40:53.641] 
[18:40:53.641] getGlobalsAndPackages() ... DONE
[18:40:53.641] run() for 'Future' ...
[18:40:53.641] - state: 'created'
[18:40:53.642] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[18:40:53.657] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.657] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[18:40:53.657]   - Field: 'node'
[18:40:53.657]   - Field: 'label'
[18:40:53.657]   - Field: 'local'
[18:40:53.658]   - Field: 'owner'
[18:40:53.658]   - Field: 'envir'
[18:40:53.658]   - Field: 'workers'
[18:40:53.658]   - Field: 'packages'
[18:40:53.658]   - Field: 'gc'
[18:40:53.658]   - Field: 'conditions'
[18:40:53.659]   - Field: 'persistent'
[18:40:53.659]   - Field: 'expr'
[18:40:53.659]   - Field: 'uuid'
[18:40:53.659]   - Field: 'seed'
[18:40:53.659]   - Field: 'version'
[18:40:53.660]   - Field: 'result'
[18:40:53.660]   - Field: 'asynchronous'
[18:40:53.660]   - Field: 'calls'
[18:40:53.660]   - Field: 'globals'
[18:40:53.660]   - Field: 'stdout'
[18:40:53.660]   - Field: 'earlySignal'
[18:40:53.661]   - Field: 'lazy'
[18:40:53.661]   - Field: 'state'
[18:40:53.661] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[18:40:53.661] - Launch lazy future ...
[18:40:53.661] Packages needed by the future expression (n = 0): <none>
[18:40:53.662] Packages needed by future strategies (n = 0): <none>
[18:40:53.662] {
[18:40:53.662]     {
[18:40:53.662]         {
[18:40:53.662]             ...future.startTime <- base::Sys.time()
[18:40:53.662]             {
[18:40:53.662]                 {
[18:40:53.662]                   {
[18:40:53.662]                     {
[18:40:53.662]                       base::local({
[18:40:53.662]                         has_future <- base::requireNamespace("future", 
[18:40:53.662]                           quietly = TRUE)
[18:40:53.662]                         if (has_future) {
[18:40:53.662]                           ns <- base::getNamespace("future")
[18:40:53.662]                           version <- ns[[".package"]][["version"]]
[18:40:53.662]                           if (is.null(version)) 
[18:40:53.662]                             version <- utils::packageVersion("future")
[18:40:53.662]                         }
[18:40:53.662]                         else {
[18:40:53.662]                           version <- NULL
[18:40:53.662]                         }
[18:40:53.662]                         if (!has_future || version < "1.8.0") {
[18:40:53.662]                           info <- base::c(r_version = base::gsub("R version ", 
[18:40:53.662]                             "", base::R.version$version.string), 
[18:40:53.662]                             platform = base::sprintf("%s (%s-bit)", 
[18:40:53.662]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[18:40:53.662]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[18:40:53.662]                               "release", "version")], collapse = " "), 
[18:40:53.662]                             hostname = base::Sys.info()[["nodename"]])
[18:40:53.662]                           info <- base::sprintf("%s: %s", base::names(info), 
[18:40:53.662]                             info)
[18:40:53.662]                           info <- base::paste(info, collapse = "; ")
[18:40:53.662]                           if (!has_future) {
[18:40:53.662]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[18:40:53.662]                               info)
[18:40:53.662]                           }
[18:40:53.662]                           else {
[18:40:53.662]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[18:40:53.662]                               info, version)
[18:40:53.662]                           }
[18:40:53.662]                           base::stop(msg)
[18:40:53.662]                         }
[18:40:53.662]                       })
[18:40:53.662]                     }
[18:40:53.662]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[18:40:53.662]                     base::options(mc.cores = 1L)
[18:40:53.662]                   }
[18:40:53.662]                   ...future.strategy.old <- future::plan("list")
[18:40:53.662]                   options(future.plan = NULL)
[18:40:53.662]                   Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.662]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[18:40:53.662]                 }
[18:40:53.662]                 ...future.workdir <- getwd()
[18:40:53.662]             }
[18:40:53.662]             ...future.oldOptions <- base::as.list(base::.Options)
[18:40:53.662]             ...future.oldEnvVars <- base::Sys.getenv()
[18:40:53.662]         }
[18:40:53.662]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[18:40:53.662]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[18:40:53.662]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[18:40:53.662]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[18:40:53.662]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[18:40:53.662]             future.stdout.windows.reencode = NULL, width = 80L)
[18:40:53.662]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[18:40:53.662]             base::names(...future.oldOptions))
[18:40:53.662]     }
[18:40:53.662]     if (FALSE) {
[18:40:53.662]     }
[18:40:53.662]     else {
[18:40:53.662]         if (TRUE) {
[18:40:53.662]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[18:40:53.662]                 open = "w")
[18:40:53.662]         }
[18:40:53.662]         else {
[18:40:53.662]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[18:40:53.662]                 windows = "NUL", "/dev/null"), open = "w")
[18:40:53.662]         }
[18:40:53.662]         base::sink(...future.stdout, type = "output", split = FALSE)
[18:40:53.662]         base::on.exit(if (!base::is.null(...future.stdout)) {
[18:40:53.662]             base::sink(type = "output", split = FALSE)
[18:40:53.662]             base::close(...future.stdout)
[18:40:53.662]         }, add = TRUE)
[18:40:53.662]     }
[18:40:53.662]     ...future.frame <- base::sys.nframe()
[18:40:53.662]     ...future.conditions <- base::list()
[18:40:53.662]     ...future.rng <- base::globalenv()$.Random.seed
[18:40:53.662]     if (FALSE) {
[18:40:53.662]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[18:40:53.662]             "...future.value", "...future.globalenv.names", ".Random.seed")
[18:40:53.662]     }
[18:40:53.662]     ...future.result <- base::tryCatch({
[18:40:53.662]         base::withCallingHandlers({
[18:40:53.662]             ...future.value <- base::withVisible(base::local({
[18:40:53.662]                 ...future.makeSendCondition <- base::local({
[18:40:53.662]                   sendCondition <- NULL
[18:40:53.662]                   function(frame = 1L) {
[18:40:53.662]                     if (is.function(sendCondition)) 
[18:40:53.662]                       return(sendCondition)
[18:40:53.662]                     ns <- getNamespace("parallel")
[18:40:53.662]                     if (exists("sendData", mode = "function", 
[18:40:53.662]                       envir = ns)) {
[18:40:53.662]                       parallel_sendData <- get("sendData", mode = "function", 
[18:40:53.662]                         envir = ns)
[18:40:53.662]                       envir <- sys.frame(frame)
[18:40:53.662]                       master <- NULL
[18:40:53.662]                       while (!identical(envir, .GlobalEnv) && 
[18:40:53.662]                         !identical(envir, emptyenv())) {
[18:40:53.662]                         if (exists("master", mode = "list", envir = envir, 
[18:40:53.662]                           inherits = FALSE)) {
[18:40:53.662]                           master <- get("master", mode = "list", 
[18:40:53.662]                             envir = envir, inherits = FALSE)
[18:40:53.662]                           if (inherits(master, c("SOCKnode", 
[18:40:53.662]                             "SOCK0node"))) {
[18:40:53.662]                             sendCondition <<- function(cond) {
[18:40:53.662]                               data <- list(type = "VALUE", value = cond, 
[18:40:53.662]                                 success = TRUE)
[18:40:53.662]                               parallel_sendData(master, data)
[18:40:53.662]                             }
[18:40:53.662]                             return(sendCondition)
[18:40:53.662]                           }
[18:40:53.662]                         }
[18:40:53.662]                         frame <- frame + 1L
[18:40:53.662]                         envir <- sys.frame(frame)
[18:40:53.662]                       }
[18:40:53.662]                     }
[18:40:53.662]                     sendCondition <<- function(cond) NULL
[18:40:53.662]                   }
[18:40:53.662]                 })
[18:40:53.662]                 withCallingHandlers({
[18:40:53.662]                   {
[18:40:53.662]                     do.call(function(...) {
[18:40:53.662]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.662]                       if (!identical(...future.globals.maxSize.org, 
[18:40:53.662]                         ...future.globals.maxSize)) {
[18:40:53.662]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.662]                         on.exit(options(oopts), add = TRUE)
[18:40:53.662]                       }
[18:40:53.662]                       {
[18:40:53.662]                         lapply(seq_along(...future.elements_ii), 
[18:40:53.662]                           FUN = function(jj) {
[18:40:53.662]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.662]                             ...future.FUN(...future.X_jj, ...)
[18:40:53.662]                           })
[18:40:53.662]                       }
[18:40:53.662]                     }, args = future.call.arguments)
[18:40:53.662]                   }
[18:40:53.662]                 }, immediateCondition = function(cond) {
[18:40:53.662]                   sendCondition <- ...future.makeSendCondition()
[18:40:53.662]                   sendCondition(cond)
[18:40:53.662]                   muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.662]                   {
[18:40:53.662]                     inherits <- base::inherits
[18:40:53.662]                     invokeRestart <- base::invokeRestart
[18:40:53.662]                     is.null <- base::is.null
[18:40:53.662]                     muffled <- FALSE
[18:40:53.662]                     if (inherits(cond, "message")) {
[18:40:53.662]                       muffled <- grepl(pattern, "muffleMessage")
[18:40:53.662]                       if (muffled) 
[18:40:53.662]                         invokeRestart("muffleMessage")
[18:40:53.662]                     }
[18:40:53.662]                     else if (inherits(cond, "warning")) {
[18:40:53.662]                       muffled <- grepl(pattern, "muffleWarning")
[18:40:53.662]                       if (muffled) 
[18:40:53.662]                         invokeRestart("muffleWarning")
[18:40:53.662]                     }
[18:40:53.662]                     else if (inherits(cond, "condition")) {
[18:40:53.662]                       if (!is.null(pattern)) {
[18:40:53.662]                         computeRestarts <- base::computeRestarts
[18:40:53.662]                         grepl <- base::grepl
[18:40:53.662]                         restarts <- computeRestarts(cond)
[18:40:53.662]                         for (restart in restarts) {
[18:40:53.662]                           name <- restart$name
[18:40:53.662]                           if (is.null(name)) 
[18:40:53.662]                             next
[18:40:53.662]                           if (!grepl(pattern, name)) 
[18:40:53.662]                             next
[18:40:53.662]                           invokeRestart(restart)
[18:40:53.662]                           muffled <- TRUE
[18:40:53.662]                           break
[18:40:53.662]                         }
[18:40:53.662]                       }
[18:40:53.662]                     }
[18:40:53.662]                     invisible(muffled)
[18:40:53.662]                   }
[18:40:53.662]                   muffleCondition(cond)
[18:40:53.662]                 })
[18:40:53.662]             }))
[18:40:53.662]             future::FutureResult(value = ...future.value$value, 
[18:40:53.662]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.662]                   ...future.rng), globalenv = if (FALSE) 
[18:40:53.662]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[18:40:53.662]                     ...future.globalenv.names))
[18:40:53.662]                 else NULL, started = ...future.startTime, version = "1.8")
[18:40:53.662]         }, condition = base::local({
[18:40:53.662]             c <- base::c
[18:40:53.662]             inherits <- base::inherits
[18:40:53.662]             invokeRestart <- base::invokeRestart
[18:40:53.662]             length <- base::length
[18:40:53.662]             list <- base::list
[18:40:53.662]             seq.int <- base::seq.int
[18:40:53.662]             signalCondition <- base::signalCondition
[18:40:53.662]             sys.calls <- base::sys.calls
[18:40:53.662]             `[[` <- base::`[[`
[18:40:53.662]             `+` <- base::`+`
[18:40:53.662]             `<<-` <- base::`<<-`
[18:40:53.662]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[18:40:53.662]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[18:40:53.662]                   3L)]
[18:40:53.662]             }
[18:40:53.662]             function(cond) {
[18:40:53.662]                 is_error <- inherits(cond, "error")
[18:40:53.662]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[18:40:53.662]                   NULL)
[18:40:53.662]                 if (is_error) {
[18:40:53.662]                   sessionInformation <- function() {
[18:40:53.662]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[18:40:53.662]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[18:40:53.662]                       search = base::search(), system = base::Sys.info())
[18:40:53.662]                   }
[18:40:53.662]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.662]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[18:40:53.662]                     cond$call), session = sessionInformation(), 
[18:40:53.662]                     timestamp = base::Sys.time(), signaled = 0L)
[18:40:53.662]                   signalCondition(cond)
[18:40:53.662]                 }
[18:40:53.662]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[18:40:53.662]                 "immediateCondition"))) {
[18:40:53.662]                   signal <- TRUE && inherits(cond, "immediateCondition")
[18:40:53.662]                   ...future.conditions[[length(...future.conditions) + 
[18:40:53.662]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[18:40:53.662]                   if (TRUE && !signal) {
[18:40:53.662]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.662]                     {
[18:40:53.662]                       inherits <- base::inherits
[18:40:53.662]                       invokeRestart <- base::invokeRestart
[18:40:53.662]                       is.null <- base::is.null
[18:40:53.662]                       muffled <- FALSE
[18:40:53.662]                       if (inherits(cond, "message")) {
[18:40:53.662]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.662]                         if (muffled) 
[18:40:53.662]                           invokeRestart("muffleMessage")
[18:40:53.662]                       }
[18:40:53.662]                       else if (inherits(cond, "warning")) {
[18:40:53.662]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.662]                         if (muffled) 
[18:40:53.662]                           invokeRestart("muffleWarning")
[18:40:53.662]                       }
[18:40:53.662]                       else if (inherits(cond, "condition")) {
[18:40:53.662]                         if (!is.null(pattern)) {
[18:40:53.662]                           computeRestarts <- base::computeRestarts
[18:40:53.662]                           grepl <- base::grepl
[18:40:53.662]                           restarts <- computeRestarts(cond)
[18:40:53.662]                           for (restart in restarts) {
[18:40:53.662]                             name <- restart$name
[18:40:53.662]                             if (is.null(name)) 
[18:40:53.662]                               next
[18:40:53.662]                             if (!grepl(pattern, name)) 
[18:40:53.662]                               next
[18:40:53.662]                             invokeRestart(restart)
[18:40:53.662]                             muffled <- TRUE
[18:40:53.662]                             break
[18:40:53.662]                           }
[18:40:53.662]                         }
[18:40:53.662]                       }
[18:40:53.662]                       invisible(muffled)
[18:40:53.662]                     }
[18:40:53.662]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.662]                   }
[18:40:53.662]                 }
[18:40:53.662]                 else {
[18:40:53.662]                   if (TRUE) {
[18:40:53.662]                     muffleCondition <- function (cond, pattern = "^muffle") 
[18:40:53.662]                     {
[18:40:53.662]                       inherits <- base::inherits
[18:40:53.662]                       invokeRestart <- base::invokeRestart
[18:40:53.662]                       is.null <- base::is.null
[18:40:53.662]                       muffled <- FALSE
[18:40:53.662]                       if (inherits(cond, "message")) {
[18:40:53.662]                         muffled <- grepl(pattern, "muffleMessage")
[18:40:53.662]                         if (muffled) 
[18:40:53.662]                           invokeRestart("muffleMessage")
[18:40:53.662]                       }
[18:40:53.662]                       else if (inherits(cond, "warning")) {
[18:40:53.662]                         muffled <- grepl(pattern, "muffleWarning")
[18:40:53.662]                         if (muffled) 
[18:40:53.662]                           invokeRestart("muffleWarning")
[18:40:53.662]                       }
[18:40:53.662]                       else if (inherits(cond, "condition")) {
[18:40:53.662]                         if (!is.null(pattern)) {
[18:40:53.662]                           computeRestarts <- base::computeRestarts
[18:40:53.662]                           grepl <- base::grepl
[18:40:53.662]                           restarts <- computeRestarts(cond)
[18:40:53.662]                           for (restart in restarts) {
[18:40:53.662]                             name <- restart$name
[18:40:53.662]                             if (is.null(name)) 
[18:40:53.662]                               next
[18:40:53.662]                             if (!grepl(pattern, name)) 
[18:40:53.662]                               next
[18:40:53.662]                             invokeRestart(restart)
[18:40:53.662]                             muffled <- TRUE
[18:40:53.662]                             break
[18:40:53.662]                           }
[18:40:53.662]                         }
[18:40:53.662]                       }
[18:40:53.662]                       invisible(muffled)
[18:40:53.662]                     }
[18:40:53.662]                     muffleCondition(cond, pattern = "^muffle")
[18:40:53.662]                   }
[18:40:53.662]                 }
[18:40:53.662]             }
[18:40:53.662]         }))
[18:40:53.662]     }, error = function(ex) {
[18:40:53.662]         base::structure(base::list(value = NULL, visible = NULL, 
[18:40:53.662]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[18:40:53.662]                 ...future.rng), started = ...future.startTime, 
[18:40:53.662]             finished = Sys.time(), session_uuid = NA_character_, 
[18:40:53.662]             version = "1.8"), class = "FutureResult")
[18:40:53.662]     }, finally = {
[18:40:53.662]         if (!identical(...future.workdir, getwd())) 
[18:40:53.662]             setwd(...future.workdir)
[18:40:53.662]         {
[18:40:53.662]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[18:40:53.662]                 ...future.oldOptions$nwarnings <- NULL
[18:40:53.662]             }
[18:40:53.662]             base::options(...future.oldOptions)
[18:40:53.662]             if (.Platform$OS.type == "windows") {
[18:40:53.662]                 old_names <- names(...future.oldEnvVars)
[18:40:53.662]                 envs <- base::Sys.getenv()
[18:40:53.662]                 names <- names(envs)
[18:40:53.662]                 common <- intersect(names, old_names)
[18:40:53.662]                 added <- setdiff(names, old_names)
[18:40:53.662]                 removed <- setdiff(old_names, names)
[18:40:53.662]                 changed <- common[...future.oldEnvVars[common] != 
[18:40:53.662]                   envs[common]]
[18:40:53.662]                 NAMES <- toupper(changed)
[18:40:53.662]                 args <- list()
[18:40:53.662]                 for (kk in seq_along(NAMES)) {
[18:40:53.662]                   name <- changed[[kk]]
[18:40:53.662]                   NAME <- NAMES[[kk]]
[18:40:53.662]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.662]                     next
[18:40:53.662]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.662]                 }
[18:40:53.662]                 NAMES <- toupper(added)
[18:40:53.662]                 for (kk in seq_along(NAMES)) {
[18:40:53.662]                   name <- added[[kk]]
[18:40:53.662]                   NAME <- NAMES[[kk]]
[18:40:53.662]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.662]                     next
[18:40:53.662]                   args[[name]] <- ""
[18:40:53.662]                 }
[18:40:53.662]                 NAMES <- toupper(removed)
[18:40:53.662]                 for (kk in seq_along(NAMES)) {
[18:40:53.662]                   name <- removed[[kk]]
[18:40:53.662]                   NAME <- NAMES[[kk]]
[18:40:53.662]                   if (name != NAME && is.element(NAME, old_names)) 
[18:40:53.662]                     next
[18:40:53.662]                   args[[name]] <- ...future.oldEnvVars[[name]]
[18:40:53.662]                 }
[18:40:53.662]                 if (length(args) > 0) 
[18:40:53.662]                   base::do.call(base::Sys.setenv, args = args)
[18:40:53.662]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[18:40:53.662]             }
[18:40:53.662]             else {
[18:40:53.662]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[18:40:53.662]             }
[18:40:53.662]             {
[18:40:53.662]                 if (base::length(...future.futureOptionsAdded) > 
[18:40:53.662]                   0L) {
[18:40:53.662]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[18:40:53.662]                   base::names(opts) <- ...future.futureOptionsAdded
[18:40:53.662]                   base::options(opts)
[18:40:53.662]                 }
[18:40:53.662]                 {
[18:40:53.662]                   {
[18:40:53.662]                     base::options(mc.cores = ...future.mc.cores.old)
[18:40:53.662]                     NULL
[18:40:53.662]                   }
[18:40:53.662]                   options(future.plan = NULL)
[18:40:53.662]                   if (is.na(NA_character_)) 
[18:40:53.662]                     Sys.unsetenv("R_FUTURE_PLAN")
[18:40:53.662]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[18:40:53.662]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[18:40:53.662]                     .init = FALSE)
[18:40:53.662]                 }
[18:40:53.662]             }
[18:40:53.662]         }
[18:40:53.662]     })
[18:40:53.662]     if (TRUE) {
[18:40:53.662]         base::sink(type = "output", split = FALSE)
[18:40:53.662]         if (TRUE) {
[18:40:53.662]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[18:40:53.662]         }
[18:40:53.662]         else {
[18:40:53.662]             ...future.result["stdout"] <- base::list(NULL)
[18:40:53.662]         }
[18:40:53.662]         base::close(...future.stdout)
[18:40:53.662]         ...future.stdout <- NULL
[18:40:53.662]     }
[18:40:53.662]     ...future.result$conditions <- ...future.conditions
[18:40:53.662]     ...future.result$finished <- base::Sys.time()
[18:40:53.662]     ...future.result
[18:40:53.662] }
[18:40:53.668] Exporting 5 global objects (2.20 KiB) to cluster node #1 ...
[18:40:53.668] Exporting '...future.FUN' (281 bytes) to cluster node #1 ...
[18:40:53.669] Exporting '...future.FUN' (281 bytes) to cluster node #1 ... DONE
[18:40:53.669] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ...
[18:40:53.670] Exporting 'future.call.arguments' (97 bytes) to cluster node #1 ... DONE
[18:40:53.670] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ...
[18:40:53.670] Exporting '...future.elements_ii' (1.35 KiB) to cluster node #1 ... DONE
[18:40:53.671] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ...
[18:40:53.671] Exporting '...future.seeds_ii' (27 bytes) to cluster node #1 ... DONE
[18:40:53.671] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ...
[18:40:53.672] Exporting '...future.globals.maxSize' (27 bytes) to cluster node #1 ... DONE
[18:40:53.672] Exporting 5 global objects (2.20 KiB) to cluster node #1 ... DONE
[18:40:53.673] MultisessionFuture started
[18:40:53.673] - Launch lazy future ... done
[18:40:53.673] run() for 'MultisessionFuture' ... done
[18:40:53.673] Created future:
[18:40:53.716] receiveMessageFromWorker() for ClusterFuture ...
[18:40:53.717] - Validating connection of MultisessionFuture
[18:40:53.717] - received message: FutureResult
[18:40:53.718] - Received FutureResult
[18:40:53.718] - Erased future from FutureRegistry
[18:40:53.718] result() for ClusterFuture ...
[18:40:53.718] - result already collected: FutureResult
[18:40:53.718] result() for ClusterFuture ... done
[18:40:53.718] receiveMessageFromWorker() for ClusterFuture ... done
[18:40:53.673] MultisessionFuture:
[18:40:53.673] Label: 'future_by-2'
[18:40:53.673] Expression:
[18:40:53.673] {
[18:40:53.673]     do.call(function(...) {
[18:40:53.673]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[18:40:53.673]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[18:40:53.673]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[18:40:53.673]             on.exit(options(oopts), add = TRUE)
[18:40:53.673]         }
[18:40:53.673]         {
[18:40:53.673]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[18:40:53.673]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[18:40:53.673]                 ...future.FUN(...future.X_jj, ...)
[18:40:53.673]             })
[18:40:53.673]         }
[18:40:53.673]     }, args = future.call.arguments)
[18:40:53.673] }
[18:40:53.673] Lazy evaluation: FALSE
[18:40:53.673] Asynchronous evaluation: TRUE
[18:40:53.673] Local evaluation: TRUE
[18:40:53.673] Environment: 0x000001cd52119938
[18:40:53.673] Capture standard output: TRUE
[18:40:53.673] Capture condition classes: 'condition' (excluding 'nothing')
[18:40:53.673] Globals: 5 objects totaling 1.77 KiB (function '...future.FUN' of 281 bytes, DotDotDotList 'future.call.arguments' of 97 bytes, list '...future.elements_ii' of 1.35 KiB, NULL '...future.seeds_ii' of 27 bytes, NULL '...future.globals.maxSize' of 27 bytes)
[18:40:53.673] Packages: <none>
[18:40:53.673] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[18:40:53.673] Resolved: TRUE
[18:40:53.673] Value: <not collected>
[18:40:53.673] Conditions captured: <none>
[18:40:53.673] Early signaling: FALSE
[18:40:53.673] Owner process: 74d1a24f-4d88-f4f0-f0f2-99b2d7cee214
[18:40:53.673] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[18:40:53.719] Chunk #2 of 2 ... DONE
[18:40:53.719] Launching 2 futures (chunks) ... DONE
[18:40:53.719] Resolving 2 futures (chunks) ...
[18:40:53.719] resolve() on list ...
[18:40:53.720]  recursive: 0
[18:40:53.720]  length: 2
[18:40:53.720] 
[18:40:53.720] Future #1
[18:40:53.720] result() for ClusterFuture ...
[18:40:53.720] - result already collected: FutureResult
[18:40:53.721] result() for ClusterFuture ... done
[18:40:53.721] result() for ClusterFuture ...
[18:40:53.721] - result already collected: FutureResult
[18:40:53.721] result() for ClusterFuture ... done
[18:40:53.721] signalConditionsASAP(MultisessionFuture, pos=1) ...
[18:40:53.721] - nx: 2
[18:40:53.722] - relay: TRUE
[18:40:53.722] - stdout: TRUE
[18:40:53.722] - signal: TRUE
[18:40:53.722] - resignal: FALSE
[18:40:53.722] - force: TRUE
[18:40:53.722] - relayed: [n=2] FALSE, FALSE
[18:40:53.722] - queued futures: [n=2] FALSE, FALSE
[18:40:53.723]  - until=1
[18:40:53.723]  - relaying element #1
[18:40:53.723] result() for ClusterFuture ...
[18:40:53.723] - result already collected: FutureResult
[18:40:53.723] result() for ClusterFuture ... done
[18:40:53.723] result() for ClusterFuture ...
[18:40:53.723] - result already collected: FutureResult
[18:40:53.724] result() for ClusterFuture ... done
[18:40:53.724] result() for ClusterFuture ...
[18:40:53.724] - result already collected: FutureResult
[18:40:53.724] result() for ClusterFuture ... done
[18:40:53.724] result() for ClusterFuture ...
[18:40:53.724] - result already collected: FutureResult
[18:40:53.725] result() for ClusterFuture ... done
[18:40:53.725] - relayed: [n=2] TRUE, FALSE
[18:40:53.725] - queued futures: [n=2] TRUE, FALSE
[18:40:53.725] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[18:40:53.725]  length: 1 (resolved future 1)
[18:40:53.725] Future #2
[18:40:53.726] result() for ClusterFuture ...
[18:40:53.726] - result already collected: FutureResult
[18:40:53.726] result() for ClusterFuture ... done
[18:40:53.726] result() for ClusterFuture ...
[18:40:53.726] - result already collected: FutureResult
[18:40:53.726] result() for ClusterFuture ... done
[18:40:53.727] signalConditionsASAP(MultisessionFuture, pos=2) ...
[18:40:53.727] - nx: 2
[18:40:53.727] - relay: TRUE
[18:40:53.727] - stdout: TRUE
[18:40:53.727] - signal: TRUE
[18:40:53.727] - resignal: FALSE
[18:40:53.727] - force: TRUE
[18:40:53.728] - relayed: [n=2] TRUE, FALSE
[18:40:53.728] - queued futures: [n=2] TRUE, FALSE
[18:40:53.728]  - until=2
[18:40:53.728]  - relaying element #2
[18:40:53.728] result() for ClusterFuture ...
[18:40:53.728] - result already collected: FutureResult
[18:40:53.728] result() for ClusterFuture ... done
[18:40:53.729] result() for ClusterFuture ...
[18:40:53.729] - result already collected: FutureResult
[18:40:53.729] result() for ClusterFuture ... done
[18:40:53.729] result() for ClusterFuture ...
[18:40:53.729] - result already collected: FutureResult
[18:40:53.729] result() for ClusterFuture ... done
[18:40:53.730] result() for ClusterFuture ...
[18:40:53.730] - result already collected: FutureResult
[18:40:53.730] result() for ClusterFuture ... done
[18:40:53.730] - relayed: [n=2] TRUE, TRUE
[18:40:53.730] - queued futures: [n=2] TRUE, TRUE
[18:40:53.730] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[18:40:53.731]  length: 0 (resolved future 2)
[18:40:53.731] Relaying remaining futures
[18:40:53.731] signalConditionsASAP(NULL, pos=0) ...
[18:40:53.731] - nx: 2
[18:40:53.731] - relay: TRUE
[18:40:53.731] - stdout: TRUE
[18:40:53.731] - signal: TRUE
[18:40:53.732] - resignal: FALSE
[18:40:53.732] - force: TRUE
[18:40:53.732] - relayed: [n=2] TRUE, TRUE
[18:40:53.732] - queued futures: [n=2] TRUE, TRUE
 - flush all
[18:40:53.732] - relayed: [n=2] TRUE, TRUE
[18:40:53.732] - queued futures: [n=2] TRUE, TRUE
[18:40:53.733] signalConditionsASAP(NULL, pos=0) ... done
[18:40:53.733] resolve() on list ... DONE
[18:40:53.733] result() for ClusterFuture ...
[18:40:53.733] - result already collected: FutureResult
[18:40:53.733] result() for ClusterFuture ... done
[18:40:53.733] result() for ClusterFuture ...
[18:40:53.734] - result already collected: FutureResult
[18:40:53.734] result() for ClusterFuture ... done
[18:40:53.734] result() for ClusterFuture ...
[18:40:53.734] - result already collected: FutureResult
[18:40:53.734] result() for ClusterFuture ... done
[18:40:53.734] result() for ClusterFuture ...
[18:40:53.734] - result already collected: FutureResult
[18:40:53.735] result() for ClusterFuture ... done
[18:40:53.735]  - Number of value chunks collected: 2
[18:40:53.735] Resolving 2 futures (chunks) ... DONE
[18:40:53.735] Reducing values from 2 chunks ...
[18:40:53.735]  - Number of values collected after concatenation: 3
[18:40:53.735]  - Number of values expected: 3
[18:40:53.736] Reducing values from 2 chunks ... DONE
[18:40:53.736] future_lapply() ... DONE
[18:40:53.736] future_by_internal() ... DONE
[18:40:53.737] future_by_internal() ...
Testing with 2 cores ... DONE
> 
> message("*** future_by() ... DONE")
*** future_by() ... DONE
> 
> source("incl/end.R")
[18:40:53.739] plan(): Setting new future strategy stack:
[18:40:53.739] List of future strategies:
[18:40:53.739] 1. FutureStrategy:
[18:40:53.739]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[18:40:53.739]    - tweaked: FALSE
[18:40:53.739]    - call: future::plan(oplan)
[18:40:53.747] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   2.26    0.17    3.64