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

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

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

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

> source("incl/start.R")
Loading required package: future
[15:31:09.390] plan(): Setting new future strategy stack:
[15:31:09.391] List of future strategies:
[15:31:09.391] 1. sequential:
[15:31:09.391]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.391]    - tweaked: FALSE
[15:31:09.391]    - call: future::plan("sequential")
[15:31:09.410] 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') ...
[15:31:09.540] plan(): Setting new future strategy stack:
[15:31:09.540] List of future strategies:
[15:31:09.540] 1. sequential:
[15:31:09.540]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.540]    - tweaked: FALSE
[15:31:09.540]    - call: plan(strategy)
[15:31:09.560] plan(): nbrOfWorkers() = 1
[15:31:09.561] future_by_internal() ...
[15:31:09.562] future_lapply() ...
[15:31:09.569] Number of chunks: 1
[15:31:09.569] getGlobalsAndPackagesXApply() ...
[15:31:09.570]  - future.globals: TRUE
[15:31:09.571] getGlobalsAndPackages() ...
[15:31:09.572] Searching for globals...
[15:31:09.577] - globals found: [2] 'FUN', 'UseMethod'
[15:31:09.578] Searching for globals ... DONE
[15:31:09.578] Resolving globals: FALSE
[15:31:09.580] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:09.581] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:09.582] - globals: [1] 'FUN'
[15:31:09.582] 
[15:31:09.582] getGlobalsAndPackages() ... DONE
[15:31:09.583]  - globals found/used: [n=1] 'FUN'
[15:31:09.583]  - needed namespaces: [n=0] 
[15:31:09.584] Finding globals ... DONE
[15:31:09.584]  - use_args: TRUE
[15:31:09.584]  - Getting '...' globals ...
[15:31:09.586] resolve() on list ...
[15:31:09.586]  recursive: 0
[15:31:09.587]  length: 1
[15:31:09.587]  elements: '...'
[15:31:09.588]  length: 0 (resolved future 1)
[15:31:09.588] resolve() on list ... DONE
[15:31:09.589]    - '...' content: [n=0] 
[15:31:09.589] List of 1
[15:31:09.589]  $ ...: list()
[15:31:09.589]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.589]  - attr(*, "where")=List of 1
[15:31:09.589]   ..$ ...:<environment: 0x0000019c7dc28618> 
[15:31:09.589]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.589]  - attr(*, "resolved")= logi TRUE
[15:31:09.589]  - attr(*, "total_size")= num NA
[15:31:09.599]  - Getting '...' globals ... DONE
[15:31:09.600] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:09.600] List of 2
[15:31:09.600]  $ ...future.FUN:function (object, ...)  
[15:31:09.600]  $ ...          : list()
[15:31:09.600]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.600]  - attr(*, "where")=List of 2
[15:31:09.600]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:09.600]   ..$ ...          :<environment: 0x0000019c7dc28618> 
[15:31:09.600]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.600]  - attr(*, "resolved")= logi FALSE
[15:31:09.600]  - attr(*, "total_size")= num 1240
[15:31:09.607] Packages to be attached in all futures: [n=0] 
[15:31:09.608] getGlobalsAndPackagesXApply() ... DONE
[15:31:09.608] Number of futures (= number of chunks): 1
[15:31:09.609] Launching 1 futures (chunks) ...
[15:31:09.609] Chunk #1 of 1 ...
[15:31:09.610]  - Finding globals in 'X' for chunk #1 ...
[15:31:09.610] getGlobalsAndPackages() ...
[15:31:09.611] Searching for globals...
[15:31:09.612] 
[15:31:09.612] Searching for globals ... DONE
[15:31:09.613] - globals: [0] <none>
[15:31:09.613] getGlobalsAndPackages() ... DONE
[15:31:09.613]    + additional globals found: [n=0] 
[15:31:09.614]    + additional namespaces needed: [n=0] 
[15:31:09.614]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:09.614]  - seeds: <none>
[15:31:09.615]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.615] getGlobalsAndPackages() ...
[15:31:09.616] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.616] Resolving globals: FALSE
[15:31:09.616] Tweak future expression to call with '...' arguments ...
[15:31:09.617] {
[15:31:09.617]     do.call(function(...) {
[15:31:09.617]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.617]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:09.617]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.617]             on.exit(options(oopts), add = TRUE)
[15:31:09.617]         }
[15:31:09.617]         {
[15:31:09.617]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:09.617]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.617]                 ...future.FUN(...future.X_jj, ...)
[15:31:09.617]             })
[15:31:09.617]         }
[15:31:09.617]     }, args = future.call.arguments)
[15:31:09.617] }
[15:31:09.618] Tweak future expression to call with '...' arguments ... DONE
[15:31:09.619] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.619] 
[15:31:09.619] getGlobalsAndPackages() ... DONE
[15:31:09.621] run() for 'Future' ...
[15:31:09.621] - state: 'created'
[15:31:09.623] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:09.624] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:09.624] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:09.625]   - Field: 'label'
[15:31:09.625]   - Field: 'local'
[15:31:09.625]   - Field: 'owner'
[15:31:09.626]   - Field: 'envir'
[15:31:09.626]   - Field: 'packages'
[15:31:09.626]   - Field: 'gc'
[15:31:09.626]   - Field: 'conditions'
[15:31:09.632]   - Field: 'expr'
[15:31:09.633]   - Field: 'uuid'
[15:31:09.633]   - Field: 'seed'
[15:31:09.634]   - Field: 'version'
[15:31:09.634]   - Field: 'result'
[15:31:09.634]   - Field: 'asynchronous'
[15:31:09.635]   - Field: 'calls'
[15:31:09.635]   - Field: 'globals'
[15:31:09.635]   - Field: 'stdout'
[15:31:09.636]   - Field: 'earlySignal'
[15:31:09.636]   - Field: 'lazy'
[15:31:09.637]   - Field: 'state'
[15:31:09.637] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:09.637] - Launch lazy future ...
[15:31:09.639] Packages needed by the future expression (n = 0): <none>
[15:31:09.640] Packages needed by future strategies (n = 0): <none>
[15:31:09.642] {
[15:31:09.642]     {
[15:31:09.642]         {
[15:31:09.642]             ...future.startTime <- base::Sys.time()
[15:31:09.642]             {
[15:31:09.642]                 {
[15:31:09.642]                   {
[15:31:09.642]                     base::local({
[15:31:09.642]                       has_future <- base::requireNamespace("future", 
[15:31:09.642]                         quietly = TRUE)
[15:31:09.642]                       if (has_future) {
[15:31:09.642]                         ns <- base::getNamespace("future")
[15:31:09.642]                         version <- ns[[".package"]][["version"]]
[15:31:09.642]                         if (is.null(version)) 
[15:31:09.642]                           version <- utils::packageVersion("future")
[15:31:09.642]                       }
[15:31:09.642]                       else {
[15:31:09.642]                         version <- NULL
[15:31:09.642]                       }
[15:31:09.642]                       if (!has_future || version < "1.8.0") {
[15:31:09.642]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:09.642]                           "", base::R.version$version.string), 
[15:31:09.642]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:09.642]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:09.642]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:09.642]                             "release", "version")], collapse = " "), 
[15:31:09.642]                           hostname = base::Sys.info()[["nodename"]])
[15:31:09.642]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:09.642]                           info)
[15:31:09.642]                         info <- base::paste(info, collapse = "; ")
[15:31:09.642]                         if (!has_future) {
[15:31:09.642]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:09.642]                             info)
[15:31:09.642]                         }
[15:31:09.642]                         else {
[15:31:09.642]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:09.642]                             info, version)
[15:31:09.642]                         }
[15:31:09.642]                         base::stop(msg)
[15:31:09.642]                       }
[15:31:09.642]                     })
[15:31:09.642]                   }
[15:31:09.642]                   ...future.strategy.old <- future::plan("list")
[15:31:09.642]                   options(future.plan = NULL)
[15:31:09.642]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:09.642]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:09.642]                 }
[15:31:09.642]                 ...future.workdir <- getwd()
[15:31:09.642]             }
[15:31:09.642]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:09.642]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:09.642]         }
[15:31:09.642]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:09.642]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:09.642]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:09.642]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:09.642]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:09.642]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:09.642]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:09.642]             base::names(...future.oldOptions))
[15:31:09.642]     }
[15:31:09.642]     if (FALSE) {
[15:31:09.642]     }
[15:31:09.642]     else {
[15:31:09.642]         if (TRUE) {
[15:31:09.642]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:09.642]                 open = "w")
[15:31:09.642]         }
[15:31:09.642]         else {
[15:31:09.642]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:09.642]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:09.642]         }
[15:31:09.642]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:09.642]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:09.642]             base::sink(type = "output", split = FALSE)
[15:31:09.642]             base::close(...future.stdout)
[15:31:09.642]         }, add = TRUE)
[15:31:09.642]     }
[15:31:09.642]     ...future.frame <- base::sys.nframe()
[15:31:09.642]     ...future.conditions <- base::list()
[15:31:09.642]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:09.642]     if (FALSE) {
[15:31:09.642]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:09.642]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:09.642]     }
[15:31:09.642]     ...future.result <- base::tryCatch({
[15:31:09.642]         base::withCallingHandlers({
[15:31:09.642]             ...future.value <- base::withVisible(base::local({
[15:31:09.642]                 do.call(function(...) {
[15:31:09.642]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.642]                   if (!identical(...future.globals.maxSize.org, 
[15:31:09.642]                     ...future.globals.maxSize)) {
[15:31:09.642]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.642]                     on.exit(options(oopts), add = TRUE)
[15:31:09.642]                   }
[15:31:09.642]                   {
[15:31:09.642]                     lapply(seq_along(...future.elements_ii), 
[15:31:09.642]                       FUN = function(jj) {
[15:31:09.642]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.642]                         ...future.FUN(...future.X_jj, ...)
[15:31:09.642]                       })
[15:31:09.642]                   }
[15:31:09.642]                 }, args = future.call.arguments)
[15:31:09.642]             }))
[15:31:09.642]             future::FutureResult(value = ...future.value$value, 
[15:31:09.642]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:09.642]                   ...future.rng), globalenv = if (FALSE) 
[15:31:09.642]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:09.642]                     ...future.globalenv.names))
[15:31:09.642]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:09.642]         }, condition = base::local({
[15:31:09.642]             c <- base::c
[15:31:09.642]             inherits <- base::inherits
[15:31:09.642]             invokeRestart <- base::invokeRestart
[15:31:09.642]             length <- base::length
[15:31:09.642]             list <- base::list
[15:31:09.642]             seq.int <- base::seq.int
[15:31:09.642]             signalCondition <- base::signalCondition
[15:31:09.642]             sys.calls <- base::sys.calls
[15:31:09.642]             `[[` <- base::`[[`
[15:31:09.642]             `+` <- base::`+`
[15:31:09.642]             `<<-` <- base::`<<-`
[15:31:09.642]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:09.642]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:09.642]                   3L)]
[15:31:09.642]             }
[15:31:09.642]             function(cond) {
[15:31:09.642]                 is_error <- inherits(cond, "error")
[15:31:09.642]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:09.642]                   NULL)
[15:31:09.642]                 if (is_error) {
[15:31:09.642]                   sessionInformation <- function() {
[15:31:09.642]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:09.642]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:09.642]                       search = base::search(), system = base::Sys.info())
[15:31:09.642]                   }
[15:31:09.642]                   ...future.conditions[[length(...future.conditions) + 
[15:31:09.642]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:09.642]                     cond$call), session = sessionInformation(), 
[15:31:09.642]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:09.642]                   signalCondition(cond)
[15:31:09.642]                 }
[15:31:09.642]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:09.642]                 "immediateCondition"))) {
[15:31:09.642]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:09.642]                   ...future.conditions[[length(...future.conditions) + 
[15:31:09.642]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:09.642]                   if (TRUE && !signal) {
[15:31:09.642]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:09.642]                     {
[15:31:09.642]                       inherits <- base::inherits
[15:31:09.642]                       invokeRestart <- base::invokeRestart
[15:31:09.642]                       is.null <- base::is.null
[15:31:09.642]                       muffled <- FALSE
[15:31:09.642]                       if (inherits(cond, "message")) {
[15:31:09.642]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:09.642]                         if (muffled) 
[15:31:09.642]                           invokeRestart("muffleMessage")
[15:31:09.642]                       }
[15:31:09.642]                       else if (inherits(cond, "warning")) {
[15:31:09.642]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:09.642]                         if (muffled) 
[15:31:09.642]                           invokeRestart("muffleWarning")
[15:31:09.642]                       }
[15:31:09.642]                       else if (inherits(cond, "condition")) {
[15:31:09.642]                         if (!is.null(pattern)) {
[15:31:09.642]                           computeRestarts <- base::computeRestarts
[15:31:09.642]                           grepl <- base::grepl
[15:31:09.642]                           restarts <- computeRestarts(cond)
[15:31:09.642]                           for (restart in restarts) {
[15:31:09.642]                             name <- restart$name
[15:31:09.642]                             if (is.null(name)) 
[15:31:09.642]                               next
[15:31:09.642]                             if (!grepl(pattern, name)) 
[15:31:09.642]                               next
[15:31:09.642]                             invokeRestart(restart)
[15:31:09.642]                             muffled <- TRUE
[15:31:09.642]                             break
[15:31:09.642]                           }
[15:31:09.642]                         }
[15:31:09.642]                       }
[15:31:09.642]                       invisible(muffled)
[15:31:09.642]                     }
[15:31:09.642]                     muffleCondition(cond, pattern = "^muffle")
[15:31:09.642]                   }
[15:31:09.642]                 }
[15:31:09.642]                 else {
[15:31:09.642]                   if (TRUE) {
[15:31:09.642]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:09.642]                     {
[15:31:09.642]                       inherits <- base::inherits
[15:31:09.642]                       invokeRestart <- base::invokeRestart
[15:31:09.642]                       is.null <- base::is.null
[15:31:09.642]                       muffled <- FALSE
[15:31:09.642]                       if (inherits(cond, "message")) {
[15:31:09.642]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:09.642]                         if (muffled) 
[15:31:09.642]                           invokeRestart("muffleMessage")
[15:31:09.642]                       }
[15:31:09.642]                       else if (inherits(cond, "warning")) {
[15:31:09.642]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:09.642]                         if (muffled) 
[15:31:09.642]                           invokeRestart("muffleWarning")
[15:31:09.642]                       }
[15:31:09.642]                       else if (inherits(cond, "condition")) {
[15:31:09.642]                         if (!is.null(pattern)) {
[15:31:09.642]                           computeRestarts <- base::computeRestarts
[15:31:09.642]                           grepl <- base::grepl
[15:31:09.642]                           restarts <- computeRestarts(cond)
[15:31:09.642]                           for (restart in restarts) {
[15:31:09.642]                             name <- restart$name
[15:31:09.642]                             if (is.null(name)) 
[15:31:09.642]                               next
[15:31:09.642]                             if (!grepl(pattern, name)) 
[15:31:09.642]                               next
[15:31:09.642]                             invokeRestart(restart)
[15:31:09.642]                             muffled <- TRUE
[15:31:09.642]                             break
[15:31:09.642]                           }
[15:31:09.642]                         }
[15:31:09.642]                       }
[15:31:09.642]                       invisible(muffled)
[15:31:09.642]                     }
[15:31:09.642]                     muffleCondition(cond, pattern = "^muffle")
[15:31:09.642]                   }
[15:31:09.642]                 }
[15:31:09.642]             }
[15:31:09.642]         }))
[15:31:09.642]     }, error = function(ex) {
[15:31:09.642]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:09.642]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:09.642]                 ...future.rng), started = ...future.startTime, 
[15:31:09.642]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:09.642]             version = "1.8"), class = "FutureResult")
[15:31:09.642]     }, finally = {
[15:31:09.642]         if (!identical(...future.workdir, getwd())) 
[15:31:09.642]             setwd(...future.workdir)
[15:31:09.642]         {
[15:31:09.642]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:09.642]                 ...future.oldOptions$nwarnings <- NULL
[15:31:09.642]             }
[15:31:09.642]             base::options(...future.oldOptions)
[15:31:09.642]             if (.Platform$OS.type == "windows") {
[15:31:09.642]                 old_names <- names(...future.oldEnvVars)
[15:31:09.642]                 envs <- base::Sys.getenv()
[15:31:09.642]                 names <- names(envs)
[15:31:09.642]                 common <- intersect(names, old_names)
[15:31:09.642]                 added <- setdiff(names, old_names)
[15:31:09.642]                 removed <- setdiff(old_names, names)
[15:31:09.642]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:09.642]                   envs[common]]
[15:31:09.642]                 NAMES <- toupper(changed)
[15:31:09.642]                 args <- list()
[15:31:09.642]                 for (kk in seq_along(NAMES)) {
[15:31:09.642]                   name <- changed[[kk]]
[15:31:09.642]                   NAME <- NAMES[[kk]]
[15:31:09.642]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.642]                     next
[15:31:09.642]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:09.642]                 }
[15:31:09.642]                 NAMES <- toupper(added)
[15:31:09.642]                 for (kk in seq_along(NAMES)) {
[15:31:09.642]                   name <- added[[kk]]
[15:31:09.642]                   NAME <- NAMES[[kk]]
[15:31:09.642]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.642]                     next
[15:31:09.642]                   args[[name]] <- ""
[15:31:09.642]                 }
[15:31:09.642]                 NAMES <- toupper(removed)
[15:31:09.642]                 for (kk in seq_along(NAMES)) {
[15:31:09.642]                   name <- removed[[kk]]
[15:31:09.642]                   NAME <- NAMES[[kk]]
[15:31:09.642]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.642]                     next
[15:31:09.642]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:09.642]                 }
[15:31:09.642]                 if (length(args) > 0) 
[15:31:09.642]                   base::do.call(base::Sys.setenv, args = args)
[15:31:09.642]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:09.642]             }
[15:31:09.642]             else {
[15:31:09.642]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:09.642]             }
[15:31:09.642]             {
[15:31:09.642]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:09.642]                   0L) {
[15:31:09.642]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:09.642]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:09.642]                   base::options(opts)
[15:31:09.642]                 }
[15:31:09.642]                 {
[15:31:09.642]                   {
[15:31:09.642]                     NULL
[15:31:09.642]                     RNGkind("Mersenne-Twister")
[15:31:09.642]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:09.642]                       inherits = FALSE)
[15:31:09.642]                   }
[15:31:09.642]                   options(future.plan = NULL)
[15:31:09.642]                   if (is.na(NA_character_)) 
[15:31:09.642]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:09.642]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:09.642]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:09.642]                     .init = FALSE)
[15:31:09.642]                 }
[15:31:09.642]             }
[15:31:09.642]         }
[15:31:09.642]     })
[15:31:09.642]     if (TRUE) {
[15:31:09.642]         base::sink(type = "output", split = FALSE)
[15:31:09.642]         if (TRUE) {
[15:31:09.642]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:09.642]         }
[15:31:09.642]         else {
[15:31:09.642]             ...future.result["stdout"] <- base::list(NULL)
[15:31:09.642]         }
[15:31:09.642]         base::close(...future.stdout)
[15:31:09.642]         ...future.stdout <- NULL
[15:31:09.642]     }
[15:31:09.642]     ...future.result$conditions <- ...future.conditions
[15:31:09.642]     ...future.result$finished <- base::Sys.time()
[15:31:09.642]     ...future.result
[15:31:09.642] }
[15:31:09.650] assign_globals() ...
[15:31:09.651] List of 5
[15:31:09.651]  $ ...future.FUN            :function (object, ...)  
[15:31:09.651]  $ future.call.arguments    : list()
[15:31:09.651]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.651]  $ ...future.elements_ii    :List of 3
[15:31:09.651]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:09.651]   .. ..$ breaks: num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:09.651]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:09.651]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:09.651]   .. ..$ breaks: num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:09.651]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:09.651]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:09.651]   .. ..$ breaks: num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:09.651]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:09.651]  $ ...future.seeds_ii       : NULL
[15:31:09.651]  $ ...future.globals.maxSize: NULL
[15:31:09.651]  - attr(*, "where")=List of 5
[15:31:09.651]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:09.651]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:09.651]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:09.651]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:09.651]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:09.651]  - attr(*, "resolved")= logi FALSE
[15:31:09.651]  - attr(*, "total_size")= num 1240
[15:31:09.651]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.651]  - attr(*, "already-done")= logi TRUE
[15:31:09.668] - copied '...future.FUN' to environment
[15:31:09.668] - copied 'future.call.arguments' to environment
[15:31:09.669] - copied '...future.elements_ii' to environment
[15:31:09.669] - copied '...future.seeds_ii' to environment
[15:31:09.669] - copied '...future.globals.maxSize' to environment
[15:31:09.670] assign_globals() ... done
[15:31:09.671] plan(): Setting new future strategy stack:
[15:31:09.671] List of future strategies:
[15:31:09.671] 1. sequential:
[15:31:09.671]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.671]    - tweaked: FALSE
[15:31:09.671]    - call: NULL
[15:31:09.672] plan(): nbrOfWorkers() = 1
[15:31:09.678] plan(): Setting new future strategy stack:
[15:31:09.679] List of future strategies:
[15:31:09.679] 1. sequential:
[15:31:09.679]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.679]    - tweaked: FALSE
[15:31:09.679]    - call: plan(strategy)
[15:31:09.680] plan(): nbrOfWorkers() = 1
[15:31:09.680] SequentialFuture started (and completed)
[15:31:09.681] - Launch lazy future ... done
[15:31:09.681] run() for 'SequentialFuture' ... done
[15:31:09.682] Created future:
[15:31:09.682] SequentialFuture:
[15:31:09.682] Label: 'future_by-1'
[15:31:09.682] Expression:
[15:31:09.682] {
[15:31:09.682]     do.call(function(...) {
[15:31:09.682]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.682]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:09.682]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.682]             on.exit(options(oopts), add = TRUE)
[15:31:09.682]         }
[15:31:09.682]         {
[15:31:09.682]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:09.682]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.682]                 ...future.FUN(...future.X_jj, ...)
[15:31:09.682]             })
[15:31:09.682]         }
[15:31:09.682]     }, args = future.call.arguments)
[15:31:09.682] }
[15:31:09.682] Lazy evaluation: FALSE
[15:31:09.682] Asynchronous evaluation: FALSE
[15:31:09.682] Local evaluation: TRUE
[15:31:09.682] Environment: R_GlobalEnv
[15:31:09.682] Capture standard output: TRUE
[15:31:09.682] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:09.682] Globals: 5 objects totaling 3.79 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 2.58 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:09.682] Packages: <none>
[15:31:09.682] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:09.682] Resolved: TRUE
[15:31:09.682] Value: 4.62 KiB of class 'list'
[15:31:09.682] Early signaling: FALSE
[15:31:09.682] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:09.682] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:09.685] Chunk #1 of 1 ... DONE
[15:31:09.686] Launching 1 futures (chunks) ... DONE
[15:31:09.686] Resolving 1 futures (chunks) ...
[15:31:09.686] resolve() on list ...
[15:31:09.691]  recursive: 0
[15:31:09.691]  length: 1
[15:31:09.692] 
[15:31:09.692] resolved() for 'SequentialFuture' ...
[15:31:09.692] - state: 'finished'
[15:31:09.693] - run: TRUE
[15:31:09.693] - result: 'FutureResult'
[15:31:09.693] resolved() for 'SequentialFuture' ... done
[15:31:09.694] Future #1
[15:31:09.694] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:09.695] - nx: 1
[15:31:09.695] - relay: TRUE
[15:31:09.695] - stdout: TRUE
[15:31:09.695] - signal: TRUE
[15:31:09.696] - resignal: FALSE
[15:31:09.696] - force: TRUE
[15:31:09.696] - relayed: [n=1] FALSE
[15:31:09.696] - queued futures: [n=1] FALSE
[15:31:09.697]  - until=1
[15:31:09.697]  - relaying element #1
[15:31:09.698] - relayed: [n=1] TRUE
[15:31:09.698] - queued futures: [n=1] TRUE
[15:31:09.698] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:09.699]  length: 0 (resolved future 1)
[15:31:09.699] Relaying remaining futures
[15:31:09.699] signalConditionsASAP(NULL, pos=0) ...
[15:31:09.699] - nx: 1
[15:31:09.700] - relay: TRUE
[15:31:09.700] - stdout: TRUE
[15:31:09.700] - signal: TRUE
[15:31:09.701] - resignal: FALSE
[15:31:09.701] - force: TRUE
[15:31:09.701] - relayed: [n=1] TRUE
[15:31:09.701] - queued futures: [n=1] TRUE
 - flush all
[15:31:09.702] - relayed: [n=1] TRUE
[15:31:09.702] - queued futures: [n=1] TRUE
[15:31:09.702] signalConditionsASAP(NULL, pos=0) ... done
[15:31:09.703] resolve() on list ... DONE
[15:31:09.703]  - Number of value chunks collected: 1
[15:31:09.704] Resolving 1 futures (chunks) ... DONE
[15:31:09.704] Reducing values from 1 chunks ...
[15:31:09.704]  - Number of values collected after concatenation: 3
[15:31:09.704]  - Number of values expected: 3
[15:31:09.705] Reducing values from 1 chunks ... DONE
[15:31:09.705] future_lapply() ... DONE
[15:31:09.705] future_by_internal() ... DONE
[15:31:09.707] future_by_internal() ...
[15:31:09.707] future_lapply() ...
[15:31:09.709] Number of chunks: 1
[15:31:09.709] getGlobalsAndPackagesXApply() ...
[15:31:09.709]  - future.globals: TRUE
[15:31:09.710] getGlobalsAndPackages() ...
[15:31:09.710] Searching for globals...
[15:31:09.712] - globals found: [2] 'FUN', 'UseMethod'
[15:31:09.712] Searching for globals ... DONE
[15:31:09.713] Resolving globals: FALSE
[15:31:09.713] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:09.714] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:09.715] - globals: [1] 'FUN'
[15:31:09.715] 
[15:31:09.715] getGlobalsAndPackages() ... DONE
[15:31:09.715]  - globals found/used: [n=1] 'FUN'
[15:31:09.716]  - needed namespaces: [n=0] 
[15:31:09.716] Finding globals ... DONE
[15:31:09.716]  - use_args: TRUE
[15:31:09.716]  - Getting '...' globals ...
[15:31:09.717] resolve() on list ...
[15:31:09.718]  recursive: 0
[15:31:09.718]  length: 1
[15:31:09.718]  elements: '...'
[15:31:09.718]  length: 0 (resolved future 1)
[15:31:09.719] resolve() on list ... DONE
[15:31:09.719]    - '...' content: [n=1] 'digits'
[15:31:09.719] List of 1
[15:31:09.719]  $ ...:List of 1
[15:31:09.719]   ..$ digits: int 2
[15:31:09.719]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.719]  - attr(*, "where")=List of 1
[15:31:09.719]   ..$ ...:<environment: 0x0000019c7df9a760> 
[15:31:09.719]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.719]  - attr(*, "resolved")= logi TRUE
[15:31:09.719]  - attr(*, "total_size")= num NA
[15:31:09.725]  - Getting '...' globals ... DONE
[15:31:09.726] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:09.726] List of 2
[15:31:09.726]  $ ...future.FUN:function (object, ...)  
[15:31:09.726]  $ ...          :List of 1
[15:31:09.726]   ..$ digits: int 2
[15:31:09.726]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.726]  - attr(*, "where")=List of 2
[15:31:09.726]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:09.726]   ..$ ...          :<environment: 0x0000019c7df9a760> 
[15:31:09.726]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.726]  - attr(*, "resolved")= logi FALSE
[15:31:09.726]  - attr(*, "total_size")= num 1296
[15:31:09.737] Packages to be attached in all futures: [n=0] 
[15:31:09.737] getGlobalsAndPackagesXApply() ... DONE
[15:31:09.737] Number of futures (= number of chunks): 1
[15:31:09.738] Launching 1 futures (chunks) ...
[15:31:09.738] Chunk #1 of 1 ...
[15:31:09.738]  - Finding globals in 'X' for chunk #1 ...
[15:31:09.739] getGlobalsAndPackages() ...
[15:31:09.739] Searching for globals...
[15:31:09.739] 
[15:31:09.740] Searching for globals ... DONE
[15:31:09.740] - globals: [0] <none>
[15:31:09.740] getGlobalsAndPackages() ... DONE
[15:31:09.740]    + additional globals found: [n=0] 
[15:31:09.741]    + additional namespaces needed: [n=0] 
[15:31:09.741]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:09.741]  - seeds: <none>
[15:31:09.742]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.742] getGlobalsAndPackages() ...
[15:31:09.742] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.742] Resolving globals: FALSE
[15:31:09.743] Tweak future expression to call with '...' arguments ...
[15:31:09.743] {
[15:31:09.743]     do.call(function(...) {
[15:31:09.743]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.743]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:09.743]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.743]             on.exit(options(oopts), add = TRUE)
[15:31:09.743]         }
[15:31:09.743]         {
[15:31:09.743]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:09.743]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.743]                 ...future.FUN(...future.X_jj, ...)
[15:31:09.743]             })
[15:31:09.743]         }
[15:31:09.743]     }, args = future.call.arguments)
[15:31:09.743] }
[15:31:09.744] Tweak future expression to call with '...' arguments ... DONE
[15:31:09.745] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.745] 
[15:31:09.745] getGlobalsAndPackages() ... DONE
[15:31:09.746] run() for 'Future' ...
[15:31:09.746] - state: 'created'
[15:31:09.747] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:09.747] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:09.748] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:09.748]   - Field: 'label'
[15:31:09.748]   - Field: 'local'
[15:31:09.749]   - Field: 'owner'
[15:31:09.749]   - Field: 'envir'
[15:31:09.749]   - Field: 'packages'
[15:31:09.750]   - Field: 'gc'
[15:31:09.750]   - Field: 'conditions'
[15:31:09.750]   - Field: 'expr'
[15:31:09.751]   - Field: 'uuid'
[15:31:09.751]   - Field: 'seed'
[15:31:09.751]   - Field: 'version'
[15:31:09.752]   - Field: 'result'
[15:31:09.752]   - Field: 'asynchronous'
[15:31:09.752]   - Field: 'calls'
[15:31:09.753]   - Field: 'globals'
[15:31:09.753]   - Field: 'stdout'
[15:31:09.753]   - Field: 'earlySignal'
[15:31:09.754]   - Field: 'lazy'
[15:31:09.754]   - Field: 'state'
[15:31:09.754] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:09.754] - Launch lazy future ...
[15:31:09.755] Packages needed by the future expression (n = 0): <none>
[15:31:09.755] Packages needed by future strategies (n = 0): <none>
[15:31:09.757] {
[15:31:09.757]     {
[15:31:09.757]         {
[15:31:09.757]             ...future.startTime <- base::Sys.time()
[15:31:09.757]             {
[15:31:09.757]                 {
[15:31:09.757]                   {
[15:31:09.757]                     base::local({
[15:31:09.757]                       has_future <- base::requireNamespace("future", 
[15:31:09.757]                         quietly = TRUE)
[15:31:09.757]                       if (has_future) {
[15:31:09.757]                         ns <- base::getNamespace("future")
[15:31:09.757]                         version <- ns[[".package"]][["version"]]
[15:31:09.757]                         if (is.null(version)) 
[15:31:09.757]                           version <- utils::packageVersion("future")
[15:31:09.757]                       }
[15:31:09.757]                       else {
[15:31:09.757]                         version <- NULL
[15:31:09.757]                       }
[15:31:09.757]                       if (!has_future || version < "1.8.0") {
[15:31:09.757]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:09.757]                           "", base::R.version$version.string), 
[15:31:09.757]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:09.757]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:09.757]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:09.757]                             "release", "version")], collapse = " "), 
[15:31:09.757]                           hostname = base::Sys.info()[["nodename"]])
[15:31:09.757]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:09.757]                           info)
[15:31:09.757]                         info <- base::paste(info, collapse = "; ")
[15:31:09.757]                         if (!has_future) {
[15:31:09.757]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:09.757]                             info)
[15:31:09.757]                         }
[15:31:09.757]                         else {
[15:31:09.757]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:09.757]                             info, version)
[15:31:09.757]                         }
[15:31:09.757]                         base::stop(msg)
[15:31:09.757]                       }
[15:31:09.757]                     })
[15:31:09.757]                   }
[15:31:09.757]                   ...future.strategy.old <- future::plan("list")
[15:31:09.757]                   options(future.plan = NULL)
[15:31:09.757]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:09.757]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:09.757]                 }
[15:31:09.757]                 ...future.workdir <- getwd()
[15:31:09.757]             }
[15:31:09.757]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:09.757]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:09.757]         }
[15:31:09.757]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:09.757]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:09.757]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:09.757]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:09.757]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:09.757]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:09.757]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:09.757]             base::names(...future.oldOptions))
[15:31:09.757]     }
[15:31:09.757]     if (FALSE) {
[15:31:09.757]     }
[15:31:09.757]     else {
[15:31:09.757]         if (TRUE) {
[15:31:09.757]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:09.757]                 open = "w")
[15:31:09.757]         }
[15:31:09.757]         else {
[15:31:09.757]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:09.757]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:09.757]         }
[15:31:09.757]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:09.757]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:09.757]             base::sink(type = "output", split = FALSE)
[15:31:09.757]             base::close(...future.stdout)
[15:31:09.757]         }, add = TRUE)
[15:31:09.757]     }
[15:31:09.757]     ...future.frame <- base::sys.nframe()
[15:31:09.757]     ...future.conditions <- base::list()
[15:31:09.757]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:09.757]     if (FALSE) {
[15:31:09.757]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:09.757]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:09.757]     }
[15:31:09.757]     ...future.result <- base::tryCatch({
[15:31:09.757]         base::withCallingHandlers({
[15:31:09.757]             ...future.value <- base::withVisible(base::local({
[15:31:09.757]                 do.call(function(...) {
[15:31:09.757]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.757]                   if (!identical(...future.globals.maxSize.org, 
[15:31:09.757]                     ...future.globals.maxSize)) {
[15:31:09.757]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.757]                     on.exit(options(oopts), add = TRUE)
[15:31:09.757]                   }
[15:31:09.757]                   {
[15:31:09.757]                     lapply(seq_along(...future.elements_ii), 
[15:31:09.757]                       FUN = function(jj) {
[15:31:09.757]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.757]                         ...future.FUN(...future.X_jj, ...)
[15:31:09.757]                       })
[15:31:09.757]                   }
[15:31:09.757]                 }, args = future.call.arguments)
[15:31:09.757]             }))
[15:31:09.757]             future::FutureResult(value = ...future.value$value, 
[15:31:09.757]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:09.757]                   ...future.rng), globalenv = if (FALSE) 
[15:31:09.757]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:09.757]                     ...future.globalenv.names))
[15:31:09.757]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:09.757]         }, condition = base::local({
[15:31:09.757]             c <- base::c
[15:31:09.757]             inherits <- base::inherits
[15:31:09.757]             invokeRestart <- base::invokeRestart
[15:31:09.757]             length <- base::length
[15:31:09.757]             list <- base::list
[15:31:09.757]             seq.int <- base::seq.int
[15:31:09.757]             signalCondition <- base::signalCondition
[15:31:09.757]             sys.calls <- base::sys.calls
[15:31:09.757]             `[[` <- base::`[[`
[15:31:09.757]             `+` <- base::`+`
[15:31:09.757]             `<<-` <- base::`<<-`
[15:31:09.757]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:09.757]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:09.757]                   3L)]
[15:31:09.757]             }
[15:31:09.757]             function(cond) {
[15:31:09.757]                 is_error <- inherits(cond, "error")
[15:31:09.757]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:09.757]                   NULL)
[15:31:09.757]                 if (is_error) {
[15:31:09.757]                   sessionInformation <- function() {
[15:31:09.757]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:09.757]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:09.757]                       search = base::search(), system = base::Sys.info())
[15:31:09.757]                   }
[15:31:09.757]                   ...future.conditions[[length(...future.conditions) + 
[15:31:09.757]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:09.757]                     cond$call), session = sessionInformation(), 
[15:31:09.757]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:09.757]                   signalCondition(cond)
[15:31:09.757]                 }
[15:31:09.757]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:09.757]                 "immediateCondition"))) {
[15:31:09.757]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:09.757]                   ...future.conditions[[length(...future.conditions) + 
[15:31:09.757]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:09.757]                   if (TRUE && !signal) {
[15:31:09.757]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:09.757]                     {
[15:31:09.757]                       inherits <- base::inherits
[15:31:09.757]                       invokeRestart <- base::invokeRestart
[15:31:09.757]                       is.null <- base::is.null
[15:31:09.757]                       muffled <- FALSE
[15:31:09.757]                       if (inherits(cond, "message")) {
[15:31:09.757]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:09.757]                         if (muffled) 
[15:31:09.757]                           invokeRestart("muffleMessage")
[15:31:09.757]                       }
[15:31:09.757]                       else if (inherits(cond, "warning")) {
[15:31:09.757]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:09.757]                         if (muffled) 
[15:31:09.757]                           invokeRestart("muffleWarning")
[15:31:09.757]                       }
[15:31:09.757]                       else if (inherits(cond, "condition")) {
[15:31:09.757]                         if (!is.null(pattern)) {
[15:31:09.757]                           computeRestarts <- base::computeRestarts
[15:31:09.757]                           grepl <- base::grepl
[15:31:09.757]                           restarts <- computeRestarts(cond)
[15:31:09.757]                           for (restart in restarts) {
[15:31:09.757]                             name <- restart$name
[15:31:09.757]                             if (is.null(name)) 
[15:31:09.757]                               next
[15:31:09.757]                             if (!grepl(pattern, name)) 
[15:31:09.757]                               next
[15:31:09.757]                             invokeRestart(restart)
[15:31:09.757]                             muffled <- TRUE
[15:31:09.757]                             break
[15:31:09.757]                           }
[15:31:09.757]                         }
[15:31:09.757]                       }
[15:31:09.757]                       invisible(muffled)
[15:31:09.757]                     }
[15:31:09.757]                     muffleCondition(cond, pattern = "^muffle")
[15:31:09.757]                   }
[15:31:09.757]                 }
[15:31:09.757]                 else {
[15:31:09.757]                   if (TRUE) {
[15:31:09.757]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:09.757]                     {
[15:31:09.757]                       inherits <- base::inherits
[15:31:09.757]                       invokeRestart <- base::invokeRestart
[15:31:09.757]                       is.null <- base::is.null
[15:31:09.757]                       muffled <- FALSE
[15:31:09.757]                       if (inherits(cond, "message")) {
[15:31:09.757]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:09.757]                         if (muffled) 
[15:31:09.757]                           invokeRestart("muffleMessage")
[15:31:09.757]                       }
[15:31:09.757]                       else if (inherits(cond, "warning")) {
[15:31:09.757]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:09.757]                         if (muffled) 
[15:31:09.757]                           invokeRestart("muffleWarning")
[15:31:09.757]                       }
[15:31:09.757]                       else if (inherits(cond, "condition")) {
[15:31:09.757]                         if (!is.null(pattern)) {
[15:31:09.757]                           computeRestarts <- base::computeRestarts
[15:31:09.757]                           grepl <- base::grepl
[15:31:09.757]                           restarts <- computeRestarts(cond)
[15:31:09.757]                           for (restart in restarts) {
[15:31:09.757]                             name <- restart$name
[15:31:09.757]                             if (is.null(name)) 
[15:31:09.757]                               next
[15:31:09.757]                             if (!grepl(pattern, name)) 
[15:31:09.757]                               next
[15:31:09.757]                             invokeRestart(restart)
[15:31:09.757]                             muffled <- TRUE
[15:31:09.757]                             break
[15:31:09.757]                           }
[15:31:09.757]                         }
[15:31:09.757]                       }
[15:31:09.757]                       invisible(muffled)
[15:31:09.757]                     }
[15:31:09.757]                     muffleCondition(cond, pattern = "^muffle")
[15:31:09.757]                   }
[15:31:09.757]                 }
[15:31:09.757]             }
[15:31:09.757]         }))
[15:31:09.757]     }, error = function(ex) {
[15:31:09.757]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:09.757]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:09.757]                 ...future.rng), started = ...future.startTime, 
[15:31:09.757]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:09.757]             version = "1.8"), class = "FutureResult")
[15:31:09.757]     }, finally = {
[15:31:09.757]         if (!identical(...future.workdir, getwd())) 
[15:31:09.757]             setwd(...future.workdir)
[15:31:09.757]         {
[15:31:09.757]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:09.757]                 ...future.oldOptions$nwarnings <- NULL
[15:31:09.757]             }
[15:31:09.757]             base::options(...future.oldOptions)
[15:31:09.757]             if (.Platform$OS.type == "windows") {
[15:31:09.757]                 old_names <- names(...future.oldEnvVars)
[15:31:09.757]                 envs <- base::Sys.getenv()
[15:31:09.757]                 names <- names(envs)
[15:31:09.757]                 common <- intersect(names, old_names)
[15:31:09.757]                 added <- setdiff(names, old_names)
[15:31:09.757]                 removed <- setdiff(old_names, names)
[15:31:09.757]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:09.757]                   envs[common]]
[15:31:09.757]                 NAMES <- toupper(changed)
[15:31:09.757]                 args <- list()
[15:31:09.757]                 for (kk in seq_along(NAMES)) {
[15:31:09.757]                   name <- changed[[kk]]
[15:31:09.757]                   NAME <- NAMES[[kk]]
[15:31:09.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.757]                     next
[15:31:09.757]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:09.757]                 }
[15:31:09.757]                 NAMES <- toupper(added)
[15:31:09.757]                 for (kk in seq_along(NAMES)) {
[15:31:09.757]                   name <- added[[kk]]
[15:31:09.757]                   NAME <- NAMES[[kk]]
[15:31:09.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.757]                     next
[15:31:09.757]                   args[[name]] <- ""
[15:31:09.757]                 }
[15:31:09.757]                 NAMES <- toupper(removed)
[15:31:09.757]                 for (kk in seq_along(NAMES)) {
[15:31:09.757]                   name <- removed[[kk]]
[15:31:09.757]                   NAME <- NAMES[[kk]]
[15:31:09.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.757]                     next
[15:31:09.757]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:09.757]                 }
[15:31:09.757]                 if (length(args) > 0) 
[15:31:09.757]                   base::do.call(base::Sys.setenv, args = args)
[15:31:09.757]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:09.757]             }
[15:31:09.757]             else {
[15:31:09.757]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:09.757]             }
[15:31:09.757]             {
[15:31:09.757]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:09.757]                   0L) {
[15:31:09.757]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:09.757]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:09.757]                   base::options(opts)
[15:31:09.757]                 }
[15:31:09.757]                 {
[15:31:09.757]                   {
[15:31:09.757]                     NULL
[15:31:09.757]                     RNGkind("Mersenne-Twister")
[15:31:09.757]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:09.757]                       inherits = FALSE)
[15:31:09.757]                   }
[15:31:09.757]                   options(future.plan = NULL)
[15:31:09.757]                   if (is.na(NA_character_)) 
[15:31:09.757]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:09.757]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:09.757]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:09.757]                     .init = FALSE)
[15:31:09.757]                 }
[15:31:09.757]             }
[15:31:09.757]         }
[15:31:09.757]     })
[15:31:09.757]     if (TRUE) {
[15:31:09.757]         base::sink(type = "output", split = FALSE)
[15:31:09.757]         if (TRUE) {
[15:31:09.757]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:09.757]         }
[15:31:09.757]         else {
[15:31:09.757]             ...future.result["stdout"] <- base::list(NULL)
[15:31:09.757]         }
[15:31:09.757]         base::close(...future.stdout)
[15:31:09.757]         ...future.stdout <- NULL
[15:31:09.757]     }
[15:31:09.757]     ...future.result$conditions <- ...future.conditions
[15:31:09.757]     ...future.result$finished <- base::Sys.time()
[15:31:09.757]     ...future.result
[15:31:09.757] }
[15:31:09.764] assign_globals() ...
[15:31:09.764] List of 5
[15:31:09.764]  $ ...future.FUN            :function (object, ...)  
[15:31:09.764]  $ future.call.arguments    :List of 1
[15:31:09.764]   ..$ digits: int 2
[15:31:09.764]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.764]  $ ...future.elements_ii    :List of 6
[15:31:09.764]   ..$ : num [1:9] 26 30 54 25 70 52 51 26 67
[15:31:09.764]   ..$ : num [1:9] 27 14 29 19 29 31 41 20 44
[15:31:09.764]   ..$ : num [1:9] 18 21 29 17 12 18 35 30 36
[15:31:09.764]   ..$ : num [1:9] 42 26 19 16 39 28 21 39 29
[15:31:09.764]   ..$ : num [1:9] 36 21 24 18 10 43 28 15 26
[15:31:09.764]   ..$ : num [1:9] 20 21 24 17 13 15 15 16 28
[15:31:09.764]  $ ...future.seeds_ii       : NULL
[15:31:09.764]  $ ...future.globals.maxSize: NULL
[15:31:09.764]  - attr(*, "where")=List of 5
[15:31:09.764]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:09.764]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:09.764]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:09.764]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:09.764]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:09.764]  - attr(*, "resolved")= logi FALSE
[15:31:09.764]  - attr(*, "total_size")= num 1296
[15:31:09.764]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.764]  - attr(*, "already-done")= logi TRUE
[15:31:09.779] - copied '...future.FUN' to environment
[15:31:09.779] - copied 'future.call.arguments' to environment
[15:31:09.779] - copied '...future.elements_ii' to environment
[15:31:09.780] - copied '...future.seeds_ii' to environment
[15:31:09.780] - copied '...future.globals.maxSize' to environment
[15:31:09.840] assign_globals() ... done
[15:31:09.841] plan(): Setting new future strategy stack:
[15:31:09.841] List of future strategies:
[15:31:09.841] 1. sequential:
[15:31:09.841]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.841]    - tweaked: FALSE
[15:31:09.841]    - call: NULL
[15:31:09.843] plan(): nbrOfWorkers() = 1
[15:31:09.848] plan(): Setting new future strategy stack:
[15:31:09.849] List of future strategies:
[15:31:09.849] 1. sequential:
[15:31:09.849]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.849]    - tweaked: FALSE
[15:31:09.849]    - call: plan(strategy)
[15:31:09.850] plan(): nbrOfWorkers() = 1
[15:31:09.850] SequentialFuture started (and completed)
[15:31:09.851] - Launch lazy future ... done
[15:31:09.851] run() for 'SequentialFuture' ... done
[15:31:09.852] Created future:
[15:31:09.852] SequentialFuture:
[15:31:09.852] Label: 'future_by-1'
[15:31:09.852] Expression:
[15:31:09.852] {
[15:31:09.852]     do.call(function(...) {
[15:31:09.852]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.852]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:09.852]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.852]             on.exit(options(oopts), add = TRUE)
[15:31:09.852]         }
[15:31:09.852]         {
[15:31:09.852]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:09.852]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.852]                 ...future.FUN(...future.X_jj, ...)
[15:31:09.852]             })
[15:31:09.852]         }
[15:31:09.852]     }, args = future.call.arguments)
[15:31:09.852] }
[15:31:09.852] Lazy evaluation: FALSE
[15:31:09.852] Asynchronous evaluation: FALSE
[15:31:09.852] Local evaluation: TRUE
[15:31:09.852] Environment: R_GlobalEnv
[15:31:09.852] Capture standard output: TRUE
[15:31:09.852] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:09.852] Globals: 5 objects totaling 2.30 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 1.03 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:09.852] Packages: <none>
[15:31:09.852] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:09.852] Resolved: TRUE
[15:31:09.852] Value: 5.48 KiB of class 'list'
[15:31:09.852] Early signaling: FALSE
[15:31:09.852] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:09.852] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:09.854] Chunk #1 of 1 ... DONE
[15:31:09.855] Launching 1 futures (chunks) ... DONE
[15:31:09.855] Resolving 1 futures (chunks) ...
[15:31:09.855] resolve() on list ...
[15:31:09.856]  recursive: 0
[15:31:09.856]  length: 1
[15:31:09.856] 
[15:31:09.857] resolved() for 'SequentialFuture' ...
[15:31:09.857] - state: 'finished'
[15:31:09.857] - run: TRUE
[15:31:09.858] - result: 'FutureResult'
[15:31:09.858] resolved() for 'SequentialFuture' ... done
[15:31:09.858] Future #1
[15:31:09.859] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:09.859] - nx: 1
[15:31:09.859] - relay: TRUE
[15:31:09.860] - stdout: TRUE
[15:31:09.860] - signal: TRUE
[15:31:09.860] - resignal: FALSE
[15:31:09.860] - force: TRUE
[15:31:09.861] - relayed: [n=1] FALSE
[15:31:09.861] - queued futures: [n=1] FALSE
[15:31:09.861]  - until=1
[15:31:09.862]  - relaying element #1
[15:31:09.862] - relayed: [n=1] TRUE
[15:31:09.862] - queued futures: [n=1] TRUE
[15:31:09.863] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:09.863]  length: 0 (resolved future 1)
[15:31:09.863] Relaying remaining futures
[15:31:09.864] signalConditionsASAP(NULL, pos=0) ...
[15:31:09.864] - nx: 1
[15:31:09.864] - relay: TRUE
[15:31:09.864] - stdout: TRUE
[15:31:09.865] - signal: TRUE
[15:31:09.865] - resignal: FALSE
[15:31:09.865] - force: TRUE
[15:31:09.865] - relayed: [n=1] TRUE
[15:31:09.866] - queued futures: [n=1] TRUE
 - flush all
[15:31:09.866] - relayed: [n=1] TRUE
[15:31:09.867] - queued futures: [n=1] TRUE
[15:31:09.867] signalConditionsASAP(NULL, pos=0) ... done
[15:31:09.867] resolve() on list ... DONE
[15:31:09.868]  - Number of value chunks collected: 1
[15:31:09.868] Resolving 1 futures (chunks) ... DONE
[15:31:09.868] Reducing values from 1 chunks ...
[15:31:09.869]  - Number of values collected after concatenation: 6
[15:31:09.869]  - Number of values expected: 6
[15:31:09.869] Reducing values from 1 chunks ... DONE
[15:31:09.869] future_lapply() ... DONE
[15:31:09.870] future_by_internal() ... DONE
[15:31:09.877] future_by_internal() ...
[15:31:09.878] future_lapply() ...
[15:31:09.880] Number of chunks: 1
[15:31:09.880] getGlobalsAndPackagesXApply() ...
[15:31:09.881]  - future.globals: TRUE
[15:31:09.881] getGlobalsAndPackages() ...
[15:31:09.881] Searching for globals...
[15:31:09.885] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:09.889] Searching for globals ... DONE
[15:31:09.889] Resolving globals: FALSE
[15:31:09.891] The total size of the 1 globals is 5.20 KiB (5328 bytes)
[15:31:09.891] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 5.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (5.20 KiB of class 'function')
[15:31:09.892] - globals: [1] 'FUN'
[15:31:09.892] - packages: [1] 'stats'
[15:31:09.893] getGlobalsAndPackages() ... DONE
[15:31:09.893]  - globals found/used: [n=1] 'FUN'
[15:31:09.893]  - needed namespaces: [n=1] 'stats'
[15:31:09.893] Finding globals ... DONE
[15:31:09.894]  - use_args: TRUE
[15:31:09.894]  - Getting '...' globals ...
[15:31:09.895] resolve() on list ...
[15:31:09.895]  recursive: 0
[15:31:09.895]  length: 1
[15:31:09.896]  elements: '...'
[15:31:09.896]  length: 0 (resolved future 1)
[15:31:09.896] resolve() on list ... DONE
[15:31:09.897]    - '...' content: [n=1] 'singular.ok'
[15:31:09.897] List of 1
[15:31:09.897]  $ ...:List of 1
[15:31:09.897]   ..$ singular.ok: logi FALSE
[15:31:09.897]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.897]  - attr(*, "where")=List of 1
[15:31:09.897]   ..$ ...:<environment: 0x0000019c7fd21258> 
[15:31:09.897]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.897]  - attr(*, "resolved")= logi TRUE
[15:31:09.897]  - attr(*, "total_size")= num NA
[15:31:09.904]  - Getting '...' globals ... DONE
[15:31:09.904] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:09.904] List of 2
[15:31:09.904]  $ ...future.FUN:function (x, ...)  
[15:31:09.904]  $ ...          :List of 1
[15:31:09.904]   ..$ singular.ok: logi FALSE
[15:31:09.904]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.904]  - attr(*, "where")=List of 2
[15:31:09.904]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:09.904]   ..$ ...          :<environment: 0x0000019c7fd21258> 
[15:31:09.904]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.904]  - attr(*, "resolved")= logi FALSE
[15:31:09.904]  - attr(*, "total_size")= num 5384
[15:31:09.911] Packages to be attached in all futures: [n=1] 'stats'
[15:31:09.911] getGlobalsAndPackagesXApply() ... DONE
[15:31:09.912] Number of futures (= number of chunks): 1
[15:31:09.912] Launching 1 futures (chunks) ...
[15:31:09.912] Chunk #1 of 1 ...
[15:31:09.913]  - Finding globals in 'X' for chunk #1 ...
[15:31:09.913] getGlobalsAndPackages() ...
[15:31:09.913] Searching for globals...
[15:31:09.915] 
[15:31:09.915] Searching for globals ... DONE
[15:31:09.915] - globals: [0] <none>
[15:31:09.916] getGlobalsAndPackages() ... DONE
[15:31:09.916]    + additional globals found: [n=0] 
[15:31:09.916]    + additional namespaces needed: [n=0] 
[15:31:09.916]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:09.917]  - seeds: <none>
[15:31:09.917]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.917] getGlobalsAndPackages() ...
[15:31:09.918] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.918] Resolving globals: FALSE
[15:31:09.918] Tweak future expression to call with '...' arguments ...
[15:31:09.919] {
[15:31:09.919]     do.call(function(...) {
[15:31:09.919]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.919]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:09.919]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.919]             on.exit(options(oopts), add = TRUE)
[15:31:09.919]         }
[15:31:09.919]         {
[15:31:09.919]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:09.919]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.919]                 ...future.FUN(...future.X_jj, ...)
[15:31:09.919]             })
[15:31:09.919]         }
[15:31:09.919]     }, args = future.call.arguments)
[15:31:09.919] }
[15:31:09.920] Tweak future expression to call with '...' arguments ... DONE
[15:31:09.920] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:09.921] 
[15:31:09.921] getGlobalsAndPackages() ... DONE
[15:31:09.922] run() for 'Future' ...
[15:31:09.922] - state: 'created'
[15:31:09.923] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:09.923] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:09.924] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:09.924]   - Field: 'label'
[15:31:09.924]   - Field: 'local'
[15:31:09.925]   - Field: 'owner'
[15:31:09.925]   - Field: 'envir'
[15:31:09.925]   - Field: 'packages'
[15:31:09.926]   - Field: 'gc'
[15:31:09.926]   - Field: 'conditions'
[15:31:09.926]   - Field: 'expr'
[15:31:09.927]   - Field: 'uuid'
[15:31:09.927]   - Field: 'seed'
[15:31:09.927]   - Field: 'version'
[15:31:09.928]   - Field: 'result'
[15:31:09.928]   - Field: 'asynchronous'
[15:31:09.928]   - Field: 'calls'
[15:31:09.928]   - Field: 'globals'
[15:31:09.929]   - Field: 'stdout'
[15:31:09.929]   - Field: 'earlySignal'
[15:31:09.929]   - Field: 'lazy'
[15:31:09.929]   - Field: 'state'
[15:31:09.930] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:09.930] - Launch lazy future ...
[15:31:09.931] Packages needed by the future expression (n = 1): 'stats'
[15:31:09.931] Packages needed by future strategies (n = 0): <none>
[15:31:09.936] {
[15:31:09.936]     {
[15:31:09.936]         {
[15:31:09.936]             ...future.startTime <- base::Sys.time()
[15:31:09.936]             {
[15:31:09.936]                 {
[15:31:09.936]                   {
[15:31:09.936]                     {
[15:31:09.936]                       base::local({
[15:31:09.936]                         has_future <- base::requireNamespace("future", 
[15:31:09.936]                           quietly = TRUE)
[15:31:09.936]                         if (has_future) {
[15:31:09.936]                           ns <- base::getNamespace("future")
[15:31:09.936]                           version <- ns[[".package"]][["version"]]
[15:31:09.936]                           if (is.null(version)) 
[15:31:09.936]                             version <- utils::packageVersion("future")
[15:31:09.936]                         }
[15:31:09.936]                         else {
[15:31:09.936]                           version <- NULL
[15:31:09.936]                         }
[15:31:09.936]                         if (!has_future || version < "1.8.0") {
[15:31:09.936]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:09.936]                             "", base::R.version$version.string), 
[15:31:09.936]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:09.936]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:09.936]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:09.936]                               "release", "version")], collapse = " "), 
[15:31:09.936]                             hostname = base::Sys.info()[["nodename"]])
[15:31:09.936]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:09.936]                             info)
[15:31:09.936]                           info <- base::paste(info, collapse = "; ")
[15:31:09.936]                           if (!has_future) {
[15:31:09.936]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:09.936]                               info)
[15:31:09.936]                           }
[15:31:09.936]                           else {
[15:31:09.936]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:09.936]                               info, version)
[15:31:09.936]                           }
[15:31:09.936]                           base::stop(msg)
[15:31:09.936]                         }
[15:31:09.936]                       })
[15:31:09.936]                     }
[15:31:09.936]                     base::local({
[15:31:09.936]                       for (pkg in "stats") {
[15:31:09.936]                         base::loadNamespace(pkg)
[15:31:09.936]                         base::library(pkg, character.only = TRUE)
[15:31:09.936]                       }
[15:31:09.936]                     })
[15:31:09.936]                   }
[15:31:09.936]                   ...future.strategy.old <- future::plan("list")
[15:31:09.936]                   options(future.plan = NULL)
[15:31:09.936]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:09.936]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:09.936]                 }
[15:31:09.936]                 ...future.workdir <- getwd()
[15:31:09.936]             }
[15:31:09.936]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:09.936]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:09.936]         }
[15:31:09.936]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:09.936]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:09.936]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:09.936]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:09.936]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:09.936]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:09.936]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:09.936]             base::names(...future.oldOptions))
[15:31:09.936]     }
[15:31:09.936]     if (FALSE) {
[15:31:09.936]     }
[15:31:09.936]     else {
[15:31:09.936]         if (TRUE) {
[15:31:09.936]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:09.936]                 open = "w")
[15:31:09.936]         }
[15:31:09.936]         else {
[15:31:09.936]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:09.936]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:09.936]         }
[15:31:09.936]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:09.936]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:09.936]             base::sink(type = "output", split = FALSE)
[15:31:09.936]             base::close(...future.stdout)
[15:31:09.936]         }, add = TRUE)
[15:31:09.936]     }
[15:31:09.936]     ...future.frame <- base::sys.nframe()
[15:31:09.936]     ...future.conditions <- base::list()
[15:31:09.936]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:09.936]     if (FALSE) {
[15:31:09.936]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:09.936]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:09.936]     }
[15:31:09.936]     ...future.result <- base::tryCatch({
[15:31:09.936]         base::withCallingHandlers({
[15:31:09.936]             ...future.value <- base::withVisible(base::local({
[15:31:09.936]                 do.call(function(...) {
[15:31:09.936]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.936]                   if (!identical(...future.globals.maxSize.org, 
[15:31:09.936]                     ...future.globals.maxSize)) {
[15:31:09.936]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.936]                     on.exit(options(oopts), add = TRUE)
[15:31:09.936]                   }
[15:31:09.936]                   {
[15:31:09.936]                     lapply(seq_along(...future.elements_ii), 
[15:31:09.936]                       FUN = function(jj) {
[15:31:09.936]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.936]                         ...future.FUN(...future.X_jj, ...)
[15:31:09.936]                       })
[15:31:09.936]                   }
[15:31:09.936]                 }, args = future.call.arguments)
[15:31:09.936]             }))
[15:31:09.936]             future::FutureResult(value = ...future.value$value, 
[15:31:09.936]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:09.936]                   ...future.rng), globalenv = if (FALSE) 
[15:31:09.936]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:09.936]                     ...future.globalenv.names))
[15:31:09.936]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:09.936]         }, condition = base::local({
[15:31:09.936]             c <- base::c
[15:31:09.936]             inherits <- base::inherits
[15:31:09.936]             invokeRestart <- base::invokeRestart
[15:31:09.936]             length <- base::length
[15:31:09.936]             list <- base::list
[15:31:09.936]             seq.int <- base::seq.int
[15:31:09.936]             signalCondition <- base::signalCondition
[15:31:09.936]             sys.calls <- base::sys.calls
[15:31:09.936]             `[[` <- base::`[[`
[15:31:09.936]             `+` <- base::`+`
[15:31:09.936]             `<<-` <- base::`<<-`
[15:31:09.936]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:09.936]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:09.936]                   3L)]
[15:31:09.936]             }
[15:31:09.936]             function(cond) {
[15:31:09.936]                 is_error <- inherits(cond, "error")
[15:31:09.936]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:09.936]                   NULL)
[15:31:09.936]                 if (is_error) {
[15:31:09.936]                   sessionInformation <- function() {
[15:31:09.936]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:09.936]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:09.936]                       search = base::search(), system = base::Sys.info())
[15:31:09.936]                   }
[15:31:09.936]                   ...future.conditions[[length(...future.conditions) + 
[15:31:09.936]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:09.936]                     cond$call), session = sessionInformation(), 
[15:31:09.936]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:09.936]                   signalCondition(cond)
[15:31:09.936]                 }
[15:31:09.936]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:09.936]                 "immediateCondition"))) {
[15:31:09.936]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:09.936]                   ...future.conditions[[length(...future.conditions) + 
[15:31:09.936]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:09.936]                   if (TRUE && !signal) {
[15:31:09.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:09.936]                     {
[15:31:09.936]                       inherits <- base::inherits
[15:31:09.936]                       invokeRestart <- base::invokeRestart
[15:31:09.936]                       is.null <- base::is.null
[15:31:09.936]                       muffled <- FALSE
[15:31:09.936]                       if (inherits(cond, "message")) {
[15:31:09.936]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:09.936]                         if (muffled) 
[15:31:09.936]                           invokeRestart("muffleMessage")
[15:31:09.936]                       }
[15:31:09.936]                       else if (inherits(cond, "warning")) {
[15:31:09.936]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:09.936]                         if (muffled) 
[15:31:09.936]                           invokeRestart("muffleWarning")
[15:31:09.936]                       }
[15:31:09.936]                       else if (inherits(cond, "condition")) {
[15:31:09.936]                         if (!is.null(pattern)) {
[15:31:09.936]                           computeRestarts <- base::computeRestarts
[15:31:09.936]                           grepl <- base::grepl
[15:31:09.936]                           restarts <- computeRestarts(cond)
[15:31:09.936]                           for (restart in restarts) {
[15:31:09.936]                             name <- restart$name
[15:31:09.936]                             if (is.null(name)) 
[15:31:09.936]                               next
[15:31:09.936]                             if (!grepl(pattern, name)) 
[15:31:09.936]                               next
[15:31:09.936]                             invokeRestart(restart)
[15:31:09.936]                             muffled <- TRUE
[15:31:09.936]                             break
[15:31:09.936]                           }
[15:31:09.936]                         }
[15:31:09.936]                       }
[15:31:09.936]                       invisible(muffled)
[15:31:09.936]                     }
[15:31:09.936]                     muffleCondition(cond, pattern = "^muffle")
[15:31:09.936]                   }
[15:31:09.936]                 }
[15:31:09.936]                 else {
[15:31:09.936]                   if (TRUE) {
[15:31:09.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:09.936]                     {
[15:31:09.936]                       inherits <- base::inherits
[15:31:09.936]                       invokeRestart <- base::invokeRestart
[15:31:09.936]                       is.null <- base::is.null
[15:31:09.936]                       muffled <- FALSE
[15:31:09.936]                       if (inherits(cond, "message")) {
[15:31:09.936]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:09.936]                         if (muffled) 
[15:31:09.936]                           invokeRestart("muffleMessage")
[15:31:09.936]                       }
[15:31:09.936]                       else if (inherits(cond, "warning")) {
[15:31:09.936]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:09.936]                         if (muffled) 
[15:31:09.936]                           invokeRestart("muffleWarning")
[15:31:09.936]                       }
[15:31:09.936]                       else if (inherits(cond, "condition")) {
[15:31:09.936]                         if (!is.null(pattern)) {
[15:31:09.936]                           computeRestarts <- base::computeRestarts
[15:31:09.936]                           grepl <- base::grepl
[15:31:09.936]                           restarts <- computeRestarts(cond)
[15:31:09.936]                           for (restart in restarts) {
[15:31:09.936]                             name <- restart$name
[15:31:09.936]                             if (is.null(name)) 
[15:31:09.936]                               next
[15:31:09.936]                             if (!grepl(pattern, name)) 
[15:31:09.936]                               next
[15:31:09.936]                             invokeRestart(restart)
[15:31:09.936]                             muffled <- TRUE
[15:31:09.936]                             break
[15:31:09.936]                           }
[15:31:09.936]                         }
[15:31:09.936]                       }
[15:31:09.936]                       invisible(muffled)
[15:31:09.936]                     }
[15:31:09.936]                     muffleCondition(cond, pattern = "^muffle")
[15:31:09.936]                   }
[15:31:09.936]                 }
[15:31:09.936]             }
[15:31:09.936]         }))
[15:31:09.936]     }, error = function(ex) {
[15:31:09.936]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:09.936]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:09.936]                 ...future.rng), started = ...future.startTime, 
[15:31:09.936]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:09.936]             version = "1.8"), class = "FutureResult")
[15:31:09.936]     }, finally = {
[15:31:09.936]         if (!identical(...future.workdir, getwd())) 
[15:31:09.936]             setwd(...future.workdir)
[15:31:09.936]         {
[15:31:09.936]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:09.936]                 ...future.oldOptions$nwarnings <- NULL
[15:31:09.936]             }
[15:31:09.936]             base::options(...future.oldOptions)
[15:31:09.936]             if (.Platform$OS.type == "windows") {
[15:31:09.936]                 old_names <- names(...future.oldEnvVars)
[15:31:09.936]                 envs <- base::Sys.getenv()
[15:31:09.936]                 names <- names(envs)
[15:31:09.936]                 common <- intersect(names, old_names)
[15:31:09.936]                 added <- setdiff(names, old_names)
[15:31:09.936]                 removed <- setdiff(old_names, names)
[15:31:09.936]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:09.936]                   envs[common]]
[15:31:09.936]                 NAMES <- toupper(changed)
[15:31:09.936]                 args <- list()
[15:31:09.936]                 for (kk in seq_along(NAMES)) {
[15:31:09.936]                   name <- changed[[kk]]
[15:31:09.936]                   NAME <- NAMES[[kk]]
[15:31:09.936]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.936]                     next
[15:31:09.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:09.936]                 }
[15:31:09.936]                 NAMES <- toupper(added)
[15:31:09.936]                 for (kk in seq_along(NAMES)) {
[15:31:09.936]                   name <- added[[kk]]
[15:31:09.936]                   NAME <- NAMES[[kk]]
[15:31:09.936]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.936]                     next
[15:31:09.936]                   args[[name]] <- ""
[15:31:09.936]                 }
[15:31:09.936]                 NAMES <- toupper(removed)
[15:31:09.936]                 for (kk in seq_along(NAMES)) {
[15:31:09.936]                   name <- removed[[kk]]
[15:31:09.936]                   NAME <- NAMES[[kk]]
[15:31:09.936]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:09.936]                     next
[15:31:09.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:09.936]                 }
[15:31:09.936]                 if (length(args) > 0) 
[15:31:09.936]                   base::do.call(base::Sys.setenv, args = args)
[15:31:09.936]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:09.936]             }
[15:31:09.936]             else {
[15:31:09.936]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:09.936]             }
[15:31:09.936]             {
[15:31:09.936]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:09.936]                   0L) {
[15:31:09.936]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:09.936]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:09.936]                   base::options(opts)
[15:31:09.936]                 }
[15:31:09.936]                 {
[15:31:09.936]                   {
[15:31:09.936]                     NULL
[15:31:09.936]                     RNGkind("Mersenne-Twister")
[15:31:09.936]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:09.936]                       inherits = FALSE)
[15:31:09.936]                   }
[15:31:09.936]                   options(future.plan = NULL)
[15:31:09.936]                   if (is.na(NA_character_)) 
[15:31:09.936]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:09.936]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:09.936]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:09.936]                     .init = FALSE)
[15:31:09.936]                 }
[15:31:09.936]             }
[15:31:09.936]         }
[15:31:09.936]     })
[15:31:09.936]     if (TRUE) {
[15:31:09.936]         base::sink(type = "output", split = FALSE)
[15:31:09.936]         if (TRUE) {
[15:31:09.936]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:09.936]         }
[15:31:09.936]         else {
[15:31:09.936]             ...future.result["stdout"] <- base::list(NULL)
[15:31:09.936]         }
[15:31:09.936]         base::close(...future.stdout)
[15:31:09.936]         ...future.stdout <- NULL
[15:31:09.936]     }
[15:31:09.936]     ...future.result$conditions <- ...future.conditions
[15:31:09.936]     ...future.result$finished <- base::Sys.time()
[15:31:09.936]     ...future.result
[15:31:09.936] }
[15:31:09.941] assign_globals() ...
[15:31:09.941] List of 5
[15:31:09.941]  $ ...future.FUN            :function (x, ...)  
[15:31:09.941]  $ future.call.arguments    :List of 1
[15:31:09.941]   ..$ singular.ok: logi FALSE
[15:31:09.941]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:09.941]  $ ...future.elements_ii    :List of 3
[15:31:09.941]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:09.941]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:09.941]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:09.941]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:09.941]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:09.941]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:09.941]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:09.941]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:09.941]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:09.941]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:09.941]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:09.941]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:09.941]  $ ...future.seeds_ii       : NULL
[15:31:09.941]  $ ...future.globals.maxSize: NULL
[15:31:09.941]  - attr(*, "where")=List of 5
[15:31:09.941]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:09.941]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:09.941]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:09.941]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:09.941]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:09.941]  - attr(*, "resolved")= logi FALSE
[15:31:09.941]  - attr(*, "total_size")= num 5384
[15:31:09.941]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:09.941]  - attr(*, "already-done")= logi TRUE
[15:31:09.956] - reassign environment for '...future.FUN'
[15:31:09.956] - copied '...future.FUN' to environment
[15:31:09.956] - copied 'future.call.arguments' to environment
[15:31:09.957] - copied '...future.elements_ii' to environment
[15:31:09.957] - copied '...future.seeds_ii' to environment
[15:31:09.957] - copied '...future.globals.maxSize' to environment
[15:31:09.958] assign_globals() ... done
[15:31:09.959] plan(): Setting new future strategy stack:
[15:31:09.959] List of future strategies:
[15:31:09.959] 1. sequential:
[15:31:09.959]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.959]    - tweaked: FALSE
[15:31:09.959]    - call: NULL
[15:31:09.960] plan(): nbrOfWorkers() = 1
[15:31:09.967] plan(): Setting new future strategy stack:
[15:31:09.968] List of future strategies:
[15:31:09.968] 1. sequential:
[15:31:09.968]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:09.968]    - tweaked: FALSE
[15:31:09.968]    - call: plan(strategy)
[15:31:09.969] plan(): nbrOfWorkers() = 1
[15:31:09.969] SequentialFuture started (and completed)
[15:31:09.970] - Launch lazy future ... done
[15:31:09.970] run() for 'SequentialFuture' ... done
[15:31:09.970] Created future:
[15:31:09.971] SequentialFuture:
[15:31:09.971] Label: 'future_by-1'
[15:31:09.971] Expression:
[15:31:09.971] {
[15:31:09.971]     do.call(function(...) {
[15:31:09.971]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:09.971]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:09.971]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:09.971]             on.exit(options(oopts), add = TRUE)
[15:31:09.971]         }
[15:31:09.971]         {
[15:31:09.971]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:09.971]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:09.971]                 ...future.FUN(...future.X_jj, ...)
[15:31:09.971]             })
[15:31:09.971]         }
[15:31:09.971]     }, args = future.call.arguments)
[15:31:09.971] }
[15:31:09.971] Lazy evaluation: FALSE
[15:31:09.971] Asynchronous evaluation: FALSE
[15:31:09.971] Local evaluation: TRUE
[15:31:09.971] Environment: R_GlobalEnv
[15:31:09.971] Capture standard output: TRUE
[15:31:09.971] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:09.971] Globals: 5 objects totaling 10.06 KiB (function '...future.FUN' of 5.20 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:09.971] Packages: 1 packages ('stats')
[15:31:09.971] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:09.971] Resolved: TRUE
[15:31:09.971] Value: 26.06 KiB of class 'list'
[15:31:09.971] Early signaling: FALSE
[15:31:09.971] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:09.971] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:09.979] Chunk #1 of 1 ... DONE
[15:31:09.979] Launching 1 futures (chunks) ... DONE
[15:31:09.979] Resolving 1 futures (chunks) ...
[15:31:09.980] resolve() on list ...
[15:31:09.980]  recursive: 0
[15:31:09.980]  length: 1
[15:31:09.981] 
[15:31:09.981] resolved() for 'SequentialFuture' ...
[15:31:09.981] - state: 'finished'
[15:31:09.981] - run: TRUE
[15:31:09.982] - result: 'FutureResult'
[15:31:09.982] resolved() for 'SequentialFuture' ... done
[15:31:09.982] Future #1
[15:31:09.983] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:09.983] - nx: 1
[15:31:09.983] - relay: TRUE
[15:31:09.983] - stdout: TRUE
[15:31:09.984] - signal: TRUE
[15:31:09.984] - resignal: FALSE
[15:31:09.984] - force: TRUE
[15:31:09.984] - relayed: [n=1] FALSE
[15:31:09.985] - queued futures: [n=1] FALSE
[15:31:09.985]  - until=1
[15:31:09.985]  - relaying element #1
[15:31:09.986] - relayed: [n=1] TRUE
[15:31:09.986] - queued futures: [n=1] TRUE
[15:31:09.986] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:09.987]  length: 0 (resolved future 1)
[15:31:09.987] Relaying remaining futures
[15:31:09.987] signalConditionsASAP(NULL, pos=0) ...
[15:31:09.987] - nx: 1
[15:31:09.988] - relay: TRUE
[15:31:09.988] - stdout: TRUE
[15:31:09.988] - signal: TRUE
[15:31:09.988] - resignal: FALSE
[15:31:09.989] - force: TRUE
[15:31:09.989] - relayed: [n=1] TRUE
[15:31:09.989] - queued futures: [n=1] TRUE
 - flush all
[15:31:09.989] - relayed: [n=1] TRUE
[15:31:09.990] - queued futures: [n=1] TRUE
[15:31:09.990] signalConditionsASAP(NULL, pos=0) ... done
[15:31:09.990] resolve() on list ... DONE
[15:31:09.991]  - Number of value chunks collected: 1
[15:31:09.991] Resolving 1 futures (chunks) ... DONE
[15:31:09.991] Reducing values from 1 chunks ...
[15:31:09.991]  - Number of values collected after concatenation: 3
[15:31:09.992]  - Number of values expected: 3
[15:31:09.992] Reducing values from 1 chunks ... DONE
[15:31:09.992] future_lapply() ... DONE
[15:31:09.993] future_by_internal() ... DONE
[15:31:10.001] future_by_internal() ...
[15:31:10.002] future_lapply() ...
[15:31:10.004] Number of chunks: 1
[15:31:10.004] getGlobalsAndPackagesXApply() ...
[15:31:10.005]  - future.globals: TRUE
[15:31:10.005] getGlobalsAndPackages() ...
[15:31:10.005] Searching for globals...
[15:31:10.009] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:10.009] Searching for globals ... DONE
[15:31:10.010] Resolving globals: FALSE
[15:31:10.015] The total size of the 3 globals is 2.27 KiB (2320 bytes)
[15:31:10.016] The total size of the 3 globals exported for future expression ('FUN()') is 2.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.04 KiB of class 'function'), 'wool' (776 bytes of class 'numeric') and 'breaks' (480 bytes of class 'numeric')
[15:31:10.017] - globals: [3] 'FUN', 'breaks', 'wool'
[15:31:10.017] - packages: [1] 'stats'
[15:31:10.018] getGlobalsAndPackages() ... DONE
[15:31:10.018]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[15:31:10.018]  - needed namespaces: [n=1] 'stats'
[15:31:10.018] Finding globals ... DONE
[15:31:10.019]  - use_args: TRUE
[15:31:10.019]  - Getting '...' globals ...
[15:31:10.020] resolve() on list ...
[15:31:10.020]  recursive: 0
[15:31:10.020]  length: 1
[15:31:10.021]  elements: '...'
[15:31:10.021]  length: 0 (resolved future 1)
[15:31:10.021] resolve() on list ... DONE
[15:31:10.022]    - '...' content: [n=0] 
[15:31:10.022] List of 1
[15:31:10.022]  $ ...: list()
[15:31:10.022]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.022]  - attr(*, "where")=List of 1
[15:31:10.022]   ..$ ...:<environment: 0x0000019c7fb95808> 
[15:31:10.022]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.022]  - attr(*, "resolved")= logi TRUE
[15:31:10.022]  - attr(*, "total_size")= num NA
[15:31:10.027]  - Getting '...' globals ... DONE
[15:31:10.028] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[15:31:10.028] List of 4
[15:31:10.028]  $ ...future.FUN:function (x)  
[15:31:10.028]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:10.028]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.028]  $ ...          : list()
[15:31:10.028]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.028]  - attr(*, "where")=List of 4
[15:31:10.028]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.028]   ..$ breaks       :<environment: R_EmptyEnv> 
[15:31:10.028]   ..$ wool         :<environment: R_EmptyEnv> 
[15:31:10.028]   ..$ ...          :<environment: 0x0000019c7fb95808> 
[15:31:10.028]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.028]  - attr(*, "resolved")= logi FALSE
[15:31:10.028]  - attr(*, "total_size")= num 2320
[15:31:10.036] Packages to be attached in all futures: [n=1] 'stats'
[15:31:10.037] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.037] Number of futures (= number of chunks): 1
[15:31:10.038] Launching 1 futures (chunks) ...
[15:31:10.038] Chunk #1 of 1 ...
[15:31:10.038]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.039] getGlobalsAndPackages() ...
[15:31:10.039] Searching for globals...
[15:31:10.040] 
[15:31:10.040] Searching for globals ... DONE
[15:31:10.041] - globals: [0] <none>
[15:31:10.041] getGlobalsAndPackages() ... DONE
[15:31:10.041]    + additional globals found: [n=0] 
[15:31:10.042]    + additional namespaces needed: [n=0] 
[15:31:10.042]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.042]  - seeds: <none>
[15:31:10.042]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.043] getGlobalsAndPackages() ...
[15:31:10.043] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.043] Resolving globals: FALSE
[15:31:10.044] Tweak future expression to call with '...' arguments ...
[15:31:10.044] {
[15:31:10.044]     do.call(function(...) {
[15:31:10.044]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.044]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.044]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.044]             on.exit(options(oopts), add = TRUE)
[15:31:10.044]         }
[15:31:10.044]         {
[15:31:10.044]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.044]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.044]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.044]             })
[15:31:10.044]         }
[15:31:10.044]     }, args = future.call.arguments)
[15:31:10.044] }
[15:31:10.045] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.046] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.046] 
[15:31:10.046] getGlobalsAndPackages() ... DONE
[15:31:10.047] run() for 'Future' ...
[15:31:10.047] - state: 'created'
[15:31:10.048] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:10.049] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.049] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.049]   - Field: 'label'
[15:31:10.050]   - Field: 'local'
[15:31:10.050]   - Field: 'owner'
[15:31:10.050]   - Field: 'envir'
[15:31:10.050]   - Field: 'packages'
[15:31:10.051]   - Field: 'gc'
[15:31:10.051]   - Field: 'conditions'
[15:31:10.051]   - Field: 'expr'
[15:31:10.052]   - Field: 'uuid'
[15:31:10.052]   - Field: 'seed'
[15:31:10.052]   - Field: 'version'
[15:31:10.053]   - Field: 'result'
[15:31:10.053]   - Field: 'asynchronous'
[15:31:10.053]   - Field: 'calls'
[15:31:10.054]   - Field: 'globals'
[15:31:10.054]   - Field: 'stdout'
[15:31:10.054]   - Field: 'earlySignal'
[15:31:10.054]   - Field: 'lazy'
[15:31:10.055]   - Field: 'state'
[15:31:10.055] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.059] - Launch lazy future ...
[15:31:10.059] Packages needed by the future expression (n = 1): 'stats'
[15:31:10.060] Packages needed by future strategies (n = 0): <none>
[15:31:10.061] {
[15:31:10.061]     {
[15:31:10.061]         {
[15:31:10.061]             ...future.startTime <- base::Sys.time()
[15:31:10.061]             {
[15:31:10.061]                 {
[15:31:10.061]                   {
[15:31:10.061]                     {
[15:31:10.061]                       base::local({
[15:31:10.061]                         has_future <- base::requireNamespace("future", 
[15:31:10.061]                           quietly = TRUE)
[15:31:10.061]                         if (has_future) {
[15:31:10.061]                           ns <- base::getNamespace("future")
[15:31:10.061]                           version <- ns[[".package"]][["version"]]
[15:31:10.061]                           if (is.null(version)) 
[15:31:10.061]                             version <- utils::packageVersion("future")
[15:31:10.061]                         }
[15:31:10.061]                         else {
[15:31:10.061]                           version <- NULL
[15:31:10.061]                         }
[15:31:10.061]                         if (!has_future || version < "1.8.0") {
[15:31:10.061]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.061]                             "", base::R.version$version.string), 
[15:31:10.061]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:10.061]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.061]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.061]                               "release", "version")], collapse = " "), 
[15:31:10.061]                             hostname = base::Sys.info()[["nodename"]])
[15:31:10.061]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.061]                             info)
[15:31:10.061]                           info <- base::paste(info, collapse = "; ")
[15:31:10.061]                           if (!has_future) {
[15:31:10.061]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.061]                               info)
[15:31:10.061]                           }
[15:31:10.061]                           else {
[15:31:10.061]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.061]                               info, version)
[15:31:10.061]                           }
[15:31:10.061]                           base::stop(msg)
[15:31:10.061]                         }
[15:31:10.061]                       })
[15:31:10.061]                     }
[15:31:10.061]                     base::local({
[15:31:10.061]                       for (pkg in "stats") {
[15:31:10.061]                         base::loadNamespace(pkg)
[15:31:10.061]                         base::library(pkg, character.only = TRUE)
[15:31:10.061]                       }
[15:31:10.061]                     })
[15:31:10.061]                   }
[15:31:10.061]                   ...future.strategy.old <- future::plan("list")
[15:31:10.061]                   options(future.plan = NULL)
[15:31:10.061]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.061]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.061]                 }
[15:31:10.061]                 ...future.workdir <- getwd()
[15:31:10.061]             }
[15:31:10.061]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.061]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.061]         }
[15:31:10.061]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.061]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.061]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.061]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.061]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.061]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.061]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.061]             base::names(...future.oldOptions))
[15:31:10.061]     }
[15:31:10.061]     if (FALSE) {
[15:31:10.061]     }
[15:31:10.061]     else {
[15:31:10.061]         if (TRUE) {
[15:31:10.061]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.061]                 open = "w")
[15:31:10.061]         }
[15:31:10.061]         else {
[15:31:10.061]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.061]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.061]         }
[15:31:10.061]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.061]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.061]             base::sink(type = "output", split = FALSE)
[15:31:10.061]             base::close(...future.stdout)
[15:31:10.061]         }, add = TRUE)
[15:31:10.061]     }
[15:31:10.061]     ...future.frame <- base::sys.nframe()
[15:31:10.061]     ...future.conditions <- base::list()
[15:31:10.061]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.061]     if (FALSE) {
[15:31:10.061]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.061]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.061]     }
[15:31:10.061]     ...future.result <- base::tryCatch({
[15:31:10.061]         base::withCallingHandlers({
[15:31:10.061]             ...future.value <- base::withVisible(base::local({
[15:31:10.061]                 do.call(function(...) {
[15:31:10.061]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.061]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.061]                     ...future.globals.maxSize)) {
[15:31:10.061]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.061]                     on.exit(options(oopts), add = TRUE)
[15:31:10.061]                   }
[15:31:10.061]                   {
[15:31:10.061]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.061]                       FUN = function(jj) {
[15:31:10.061]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.061]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.061]                       })
[15:31:10.061]                   }
[15:31:10.061]                 }, args = future.call.arguments)
[15:31:10.061]             }))
[15:31:10.061]             future::FutureResult(value = ...future.value$value, 
[15:31:10.061]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.061]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.061]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.061]                     ...future.globalenv.names))
[15:31:10.061]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.061]         }, condition = base::local({
[15:31:10.061]             c <- base::c
[15:31:10.061]             inherits <- base::inherits
[15:31:10.061]             invokeRestart <- base::invokeRestart
[15:31:10.061]             length <- base::length
[15:31:10.061]             list <- base::list
[15:31:10.061]             seq.int <- base::seq.int
[15:31:10.061]             signalCondition <- base::signalCondition
[15:31:10.061]             sys.calls <- base::sys.calls
[15:31:10.061]             `[[` <- base::`[[`
[15:31:10.061]             `+` <- base::`+`
[15:31:10.061]             `<<-` <- base::`<<-`
[15:31:10.061]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.061]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.061]                   3L)]
[15:31:10.061]             }
[15:31:10.061]             function(cond) {
[15:31:10.061]                 is_error <- inherits(cond, "error")
[15:31:10.061]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.061]                   NULL)
[15:31:10.061]                 if (is_error) {
[15:31:10.061]                   sessionInformation <- function() {
[15:31:10.061]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.061]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.061]                       search = base::search(), system = base::Sys.info())
[15:31:10.061]                   }
[15:31:10.061]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.061]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.061]                     cond$call), session = sessionInformation(), 
[15:31:10.061]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.061]                   signalCondition(cond)
[15:31:10.061]                 }
[15:31:10.061]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.061]                 "immediateCondition"))) {
[15:31:10.061]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.061]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.061]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.061]                   if (TRUE && !signal) {
[15:31:10.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.061]                     {
[15:31:10.061]                       inherits <- base::inherits
[15:31:10.061]                       invokeRestart <- base::invokeRestart
[15:31:10.061]                       is.null <- base::is.null
[15:31:10.061]                       muffled <- FALSE
[15:31:10.061]                       if (inherits(cond, "message")) {
[15:31:10.061]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.061]                         if (muffled) 
[15:31:10.061]                           invokeRestart("muffleMessage")
[15:31:10.061]                       }
[15:31:10.061]                       else if (inherits(cond, "warning")) {
[15:31:10.061]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.061]                         if (muffled) 
[15:31:10.061]                           invokeRestart("muffleWarning")
[15:31:10.061]                       }
[15:31:10.061]                       else if (inherits(cond, "condition")) {
[15:31:10.061]                         if (!is.null(pattern)) {
[15:31:10.061]                           computeRestarts <- base::computeRestarts
[15:31:10.061]                           grepl <- base::grepl
[15:31:10.061]                           restarts <- computeRestarts(cond)
[15:31:10.061]                           for (restart in restarts) {
[15:31:10.061]                             name <- restart$name
[15:31:10.061]                             if (is.null(name)) 
[15:31:10.061]                               next
[15:31:10.061]                             if (!grepl(pattern, name)) 
[15:31:10.061]                               next
[15:31:10.061]                             invokeRestart(restart)
[15:31:10.061]                             muffled <- TRUE
[15:31:10.061]                             break
[15:31:10.061]                           }
[15:31:10.061]                         }
[15:31:10.061]                       }
[15:31:10.061]                       invisible(muffled)
[15:31:10.061]                     }
[15:31:10.061]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.061]                   }
[15:31:10.061]                 }
[15:31:10.061]                 else {
[15:31:10.061]                   if (TRUE) {
[15:31:10.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.061]                     {
[15:31:10.061]                       inherits <- base::inherits
[15:31:10.061]                       invokeRestart <- base::invokeRestart
[15:31:10.061]                       is.null <- base::is.null
[15:31:10.061]                       muffled <- FALSE
[15:31:10.061]                       if (inherits(cond, "message")) {
[15:31:10.061]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.061]                         if (muffled) 
[15:31:10.061]                           invokeRestart("muffleMessage")
[15:31:10.061]                       }
[15:31:10.061]                       else if (inherits(cond, "warning")) {
[15:31:10.061]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.061]                         if (muffled) 
[15:31:10.061]                           invokeRestart("muffleWarning")
[15:31:10.061]                       }
[15:31:10.061]                       else if (inherits(cond, "condition")) {
[15:31:10.061]                         if (!is.null(pattern)) {
[15:31:10.061]                           computeRestarts <- base::computeRestarts
[15:31:10.061]                           grepl <- base::grepl
[15:31:10.061]                           restarts <- computeRestarts(cond)
[15:31:10.061]                           for (restart in restarts) {
[15:31:10.061]                             name <- restart$name
[15:31:10.061]                             if (is.null(name)) 
[15:31:10.061]                               next
[15:31:10.061]                             if (!grepl(pattern, name)) 
[15:31:10.061]                               next
[15:31:10.061]                             invokeRestart(restart)
[15:31:10.061]                             muffled <- TRUE
[15:31:10.061]                             break
[15:31:10.061]                           }
[15:31:10.061]                         }
[15:31:10.061]                       }
[15:31:10.061]                       invisible(muffled)
[15:31:10.061]                     }
[15:31:10.061]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.061]                   }
[15:31:10.061]                 }
[15:31:10.061]             }
[15:31:10.061]         }))
[15:31:10.061]     }, error = function(ex) {
[15:31:10.061]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.061]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.061]                 ...future.rng), started = ...future.startTime, 
[15:31:10.061]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.061]             version = "1.8"), class = "FutureResult")
[15:31:10.061]     }, finally = {
[15:31:10.061]         if (!identical(...future.workdir, getwd())) 
[15:31:10.061]             setwd(...future.workdir)
[15:31:10.061]         {
[15:31:10.061]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.061]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.061]             }
[15:31:10.061]             base::options(...future.oldOptions)
[15:31:10.061]             if (.Platform$OS.type == "windows") {
[15:31:10.061]                 old_names <- names(...future.oldEnvVars)
[15:31:10.061]                 envs <- base::Sys.getenv()
[15:31:10.061]                 names <- names(envs)
[15:31:10.061]                 common <- intersect(names, old_names)
[15:31:10.061]                 added <- setdiff(names, old_names)
[15:31:10.061]                 removed <- setdiff(old_names, names)
[15:31:10.061]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.061]                   envs[common]]
[15:31:10.061]                 NAMES <- toupper(changed)
[15:31:10.061]                 args <- list()
[15:31:10.061]                 for (kk in seq_along(NAMES)) {
[15:31:10.061]                   name <- changed[[kk]]
[15:31:10.061]                   NAME <- NAMES[[kk]]
[15:31:10.061]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.061]                     next
[15:31:10.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.061]                 }
[15:31:10.061]                 NAMES <- toupper(added)
[15:31:10.061]                 for (kk in seq_along(NAMES)) {
[15:31:10.061]                   name <- added[[kk]]
[15:31:10.061]                   NAME <- NAMES[[kk]]
[15:31:10.061]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.061]                     next
[15:31:10.061]                   args[[name]] <- ""
[15:31:10.061]                 }
[15:31:10.061]                 NAMES <- toupper(removed)
[15:31:10.061]                 for (kk in seq_along(NAMES)) {
[15:31:10.061]                   name <- removed[[kk]]
[15:31:10.061]                   NAME <- NAMES[[kk]]
[15:31:10.061]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.061]                     next
[15:31:10.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.061]                 }
[15:31:10.061]                 if (length(args) > 0) 
[15:31:10.061]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.061]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.061]             }
[15:31:10.061]             else {
[15:31:10.061]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.061]             }
[15:31:10.061]             {
[15:31:10.061]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.061]                   0L) {
[15:31:10.061]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.061]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.061]                   base::options(opts)
[15:31:10.061]                 }
[15:31:10.061]                 {
[15:31:10.061]                   {
[15:31:10.061]                     NULL
[15:31:10.061]                     RNGkind("Mersenne-Twister")
[15:31:10.061]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.061]                       inherits = FALSE)
[15:31:10.061]                   }
[15:31:10.061]                   options(future.plan = NULL)
[15:31:10.061]                   if (is.na(NA_character_)) 
[15:31:10.061]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.061]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.061]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.061]                     .init = FALSE)
[15:31:10.061]                 }
[15:31:10.061]             }
[15:31:10.061]         }
[15:31:10.061]     })
[15:31:10.061]     if (TRUE) {
[15:31:10.061]         base::sink(type = "output", split = FALSE)
[15:31:10.061]         if (TRUE) {
[15:31:10.061]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.061]         }
[15:31:10.061]         else {
[15:31:10.061]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.061]         }
[15:31:10.061]         base::close(...future.stdout)
[15:31:10.061]         ...future.stdout <- NULL
[15:31:10.061]     }
[15:31:10.061]     ...future.result$conditions <- ...future.conditions
[15:31:10.061]     ...future.result$finished <- base::Sys.time()
[15:31:10.061]     ...future.result
[15:31:10.061] }
[15:31:10.068] assign_globals() ...
[15:31:10.069] List of 7
[15:31:10.069]  $ ...future.FUN            :function (x)  
[15:31:10.069]  $ breaks                   : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:10.069]  $ wool                     : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.069]  $ future.call.arguments    : list()
[15:31:10.069]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.069]  $ ...future.elements_ii    :List of 3
[15:31:10.069]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.069]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.069]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.069]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.069]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.069]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.069]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.069]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.069]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.069]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.069]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.069]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.069]  $ ...future.seeds_ii       : NULL
[15:31:10.069]  $ ...future.globals.maxSize: NULL
[15:31:10.069]  - attr(*, "where")=List of 7
[15:31:10.069]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.069]   ..$ breaks                   :<environment: R_EmptyEnv> 
[15:31:10.069]   ..$ wool                     :<environment: R_EmptyEnv> 
[15:31:10.069]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.069]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.069]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.069]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.069]  - attr(*, "resolved")= logi FALSE
[15:31:10.069]  - attr(*, "total_size")= num 2320
[15:31:10.069]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.069]  - attr(*, "already-done")= logi TRUE
[15:31:10.090] - reassign environment for '...future.FUN'
[15:31:10.090] - copied '...future.FUN' to environment
[15:31:10.091] - copied 'breaks' to environment
[15:31:10.091] - copied 'wool' to environment
[15:31:10.091] - copied 'future.call.arguments' to environment
[15:31:10.092] - copied '...future.elements_ii' to environment
[15:31:10.092] - copied '...future.seeds_ii' to environment
[15:31:10.092] - copied '...future.globals.maxSize' to environment
[15:31:10.093] assign_globals() ... done
[15:31:10.094] plan(): Setting new future strategy stack:
[15:31:10.094] List of future strategies:
[15:31:10.094] 1. sequential:
[15:31:10.094]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.094]    - tweaked: FALSE
[15:31:10.094]    - call: NULL
[15:31:10.095] plan(): nbrOfWorkers() = 1
[15:31:10.105] plan(): Setting new future strategy stack:
[15:31:10.106] List of future strategies:
[15:31:10.106] 1. sequential:
[15:31:10.106]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.106]    - tweaked: FALSE
[15:31:10.106]    - call: plan(strategy)
[15:31:10.107] plan(): nbrOfWorkers() = 1
[15:31:10.107] SequentialFuture started (and completed)
[15:31:10.107] - Launch lazy future ... done
[15:31:10.108] run() for 'SequentialFuture' ... done
[15:31:10.108] Created future:
[15:31:10.108] SequentialFuture:
[15:31:10.108] Label: 'future_by-1'
[15:31:10.108] Expression:
[15:31:10.108] {
[15:31:10.108]     do.call(function(...) {
[15:31:10.108]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.108]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.108]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.108]             on.exit(options(oopts), add = TRUE)
[15:31:10.108]         }
[15:31:10.108]         {
[15:31:10.108]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.108]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.108]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.108]             })
[15:31:10.108]         }
[15:31:10.108]     }, args = future.call.arguments)
[15:31:10.108] }
[15:31:10.108] Lazy evaluation: FALSE
[15:31:10.108] Asynchronous evaluation: FALSE
[15:31:10.108] Local evaluation: TRUE
[15:31:10.108] Environment: 0x0000019c7fb5c878
[15:31:10.108] Capture standard output: TRUE
[15:31:10.108] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.108] Globals: 7 objects totaling 7.07 KiB (function '...future.FUN' of 1.04 KiB, numeric 'breaks' of 480 bytes, factor 'wool' of 776 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, ...)
[15:31:10.108] Packages: 1 packages ('stats')
[15:31:10.108] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.108] Resolved: TRUE
[15:31:10.108] Value: 25.57 KiB of class 'list'
[15:31:10.108] Early signaling: FALSE
[15:31:10.108] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.108] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.112] Chunk #1 of 1 ... DONE
[15:31:10.112] Launching 1 futures (chunks) ... DONE
[15:31:10.112] Resolving 1 futures (chunks) ...
[15:31:10.112] resolve() on list ...
[15:31:10.113]  recursive: 0
[15:31:10.113]  length: 1
[15:31:10.113] 
[15:31:10.114] resolved() for 'SequentialFuture' ...
[15:31:10.114] - state: 'finished'
[15:31:10.114] - run: TRUE
[15:31:10.115] - result: 'FutureResult'
[15:31:10.115] resolved() for 'SequentialFuture' ... done
[15:31:10.115] Future #1
[15:31:10.115] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.116] - nx: 1
[15:31:10.116] - relay: TRUE
[15:31:10.116] - stdout: TRUE
[15:31:10.116] - signal: TRUE
[15:31:10.117] - resignal: FALSE
[15:31:10.117] - force: TRUE
[15:31:10.117] - relayed: [n=1] FALSE
[15:31:10.117] - queued futures: [n=1] FALSE
[15:31:10.118]  - until=1
[15:31:10.118]  - relaying element #1
[15:31:10.118] - relayed: [n=1] TRUE
[15:31:10.119] - queued futures: [n=1] TRUE
[15:31:10.119] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.119]  length: 0 (resolved future 1)
[15:31:10.120] Relaying remaining futures
[15:31:10.120] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.120] - nx: 1
[15:31:10.120] - relay: TRUE
[15:31:10.121] - stdout: TRUE
[15:31:10.121] - signal: TRUE
[15:31:10.121] - resignal: FALSE
[15:31:10.121] - force: TRUE
[15:31:10.121] - relayed: [n=1] TRUE
[15:31:10.122] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.122] - relayed: [n=1] TRUE
[15:31:10.122] - queued futures: [n=1] TRUE
[15:31:10.123] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.123] resolve() on list ... DONE
[15:31:10.123]  - Number of value chunks collected: 1
[15:31:10.124] Resolving 1 futures (chunks) ... DONE
[15:31:10.124] Reducing values from 1 chunks ...
[15:31:10.124]  - Number of values collected after concatenation: 3
[15:31:10.124]  - Number of values expected: 3
[15:31:10.125] Reducing values from 1 chunks ... DONE
[15:31:10.125] future_lapply() ... DONE
[15:31:10.125] future_by_internal() ... DONE
[15:31:10.126] future_by_internal() ...
[15:31:10.127] future_lapply() ...
[15:31:10.128] Number of chunks: 1
[15:31:10.128] getGlobalsAndPackagesXApply() ...
[15:31:10.128]  - future.globals: TRUE
[15:31:10.129] getGlobalsAndPackages() ...
[15:31:10.129] Searching for globals...
[15:31:10.131] - globals found: [2] 'FUN', 'UseMethod'
[15:31:10.131] Searching for globals ... DONE
[15:31:10.131] Resolving globals: FALSE
[15:31:10.132] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:10.133] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:10.133] - globals: [1] 'FUN'
[15:31:10.133] 
[15:31:10.134] getGlobalsAndPackages() ... DONE
[15:31:10.134]  - globals found/used: [n=1] 'FUN'
[15:31:10.134]  - needed namespaces: [n=0] 
[15:31:10.134] Finding globals ... DONE
[15:31:10.135]  - use_args: TRUE
[15:31:10.135]  - Getting '...' globals ...
[15:31:10.136] resolve() on list ...
[15:31:10.136]  recursive: 0
[15:31:10.136]  length: 1
[15:31:10.136]  elements: '...'
[15:31:10.137]  length: 0 (resolved future 1)
[15:31:10.137] resolve() on list ... DONE
[15:31:10.137]    - '...' content: [n=0] 
[15:31:10.138] List of 1
[15:31:10.138]  $ ...: list()
[15:31:10.138]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.138]  - attr(*, "where")=List of 1
[15:31:10.138]   ..$ ...:<environment: 0x0000019c7f373c00> 
[15:31:10.138]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.138]  - attr(*, "resolved")= logi TRUE
[15:31:10.138]  - attr(*, "total_size")= num NA
[15:31:10.145]  - Getting '...' globals ... DONE
[15:31:10.145] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.145] List of 2
[15:31:10.145]  $ ...future.FUN:function (object, ...)  
[15:31:10.145]  $ ...          : list()
[15:31:10.145]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.145]  - attr(*, "where")=List of 2
[15:31:10.145]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.145]   ..$ ...          :<environment: 0x0000019c7f373c00> 
[15:31:10.145]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.145]  - attr(*, "resolved")= logi FALSE
[15:31:10.145]  - attr(*, "total_size")= num 1240
[15:31:10.151] Packages to be attached in all futures: [n=0] 
[15:31:10.151] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.151] Number of futures (= number of chunks): 1
[15:31:10.152] Launching 1 futures (chunks) ...
[15:31:10.152] Chunk #1 of 1 ...
[15:31:10.152]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.153] getGlobalsAndPackages() ...
[15:31:10.153] Searching for globals...
[15:31:10.154] 
[15:31:10.154] Searching for globals ... DONE
[15:31:10.154] - globals: [0] <none>
[15:31:10.154] getGlobalsAndPackages() ... DONE
[15:31:10.155]    + additional globals found: [n=0] 
[15:31:10.155]    + additional namespaces needed: [n=0] 
[15:31:10.155]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.155]  - seeds: <none>
[15:31:10.156]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.156] getGlobalsAndPackages() ...
[15:31:10.156] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.157] Resolving globals: FALSE
[15:31:10.157] Tweak future expression to call with '...' arguments ...
[15:31:10.157] {
[15:31:10.157]     do.call(function(...) {
[15:31:10.157]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.157]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.157]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.157]             on.exit(options(oopts), add = TRUE)
[15:31:10.157]         }
[15:31:10.157]         {
[15:31:10.157]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.157]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.157]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.157]             })
[15:31:10.157]         }
[15:31:10.157]     }, args = future.call.arguments)
[15:31:10.157] }
[15:31:10.158] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.159] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.159] 
[15:31:10.159] getGlobalsAndPackages() ... DONE
[15:31:10.160] run() for 'Future' ...
[15:31:10.160] - state: 'created'
[15:31:10.161] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:10.161] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.162] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.162]   - Field: 'label'
[15:31:10.162]   - Field: 'local'
[15:31:10.163]   - Field: 'owner'
[15:31:10.163]   - Field: 'envir'
[15:31:10.163]   - Field: 'packages'
[15:31:10.164]   - Field: 'gc'
[15:31:10.164]   - Field: 'conditions'
[15:31:10.164]   - Field: 'expr'
[15:31:10.164]   - Field: 'uuid'
[15:31:10.165]   - Field: 'seed'
[15:31:10.165]   - Field: 'version'
[15:31:10.165]   - Field: 'result'
[15:31:10.166]   - Field: 'asynchronous'
[15:31:10.166]   - Field: 'calls'
[15:31:10.166]   - Field: 'globals'
[15:31:10.167]   - Field: 'stdout'
[15:31:10.167]   - Field: 'earlySignal'
[15:31:10.167]   - Field: 'lazy'
[15:31:10.167]   - Field: 'state'
[15:31:10.168] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.168] - Launch lazy future ...
[15:31:10.169] Packages needed by the future expression (n = 0): <none>
[15:31:10.169] Packages needed by future strategies (n = 0): <none>
[15:31:10.170] {
[15:31:10.170]     {
[15:31:10.170]         {
[15:31:10.170]             ...future.startTime <- base::Sys.time()
[15:31:10.170]             {
[15:31:10.170]                 {
[15:31:10.170]                   {
[15:31:10.170]                     base::local({
[15:31:10.170]                       has_future <- base::requireNamespace("future", 
[15:31:10.170]                         quietly = TRUE)
[15:31:10.170]                       if (has_future) {
[15:31:10.170]                         ns <- base::getNamespace("future")
[15:31:10.170]                         version <- ns[[".package"]][["version"]]
[15:31:10.170]                         if (is.null(version)) 
[15:31:10.170]                           version <- utils::packageVersion("future")
[15:31:10.170]                       }
[15:31:10.170]                       else {
[15:31:10.170]                         version <- NULL
[15:31:10.170]                       }
[15:31:10.170]                       if (!has_future || version < "1.8.0") {
[15:31:10.170]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.170]                           "", base::R.version$version.string), 
[15:31:10.170]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.170]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.170]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.170]                             "release", "version")], collapse = " "), 
[15:31:10.170]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.170]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.170]                           info)
[15:31:10.170]                         info <- base::paste(info, collapse = "; ")
[15:31:10.170]                         if (!has_future) {
[15:31:10.170]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.170]                             info)
[15:31:10.170]                         }
[15:31:10.170]                         else {
[15:31:10.170]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.170]                             info, version)
[15:31:10.170]                         }
[15:31:10.170]                         base::stop(msg)
[15:31:10.170]                       }
[15:31:10.170]                     })
[15:31:10.170]                   }
[15:31:10.170]                   ...future.strategy.old <- future::plan("list")
[15:31:10.170]                   options(future.plan = NULL)
[15:31:10.170]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.170]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.170]                 }
[15:31:10.170]                 ...future.workdir <- getwd()
[15:31:10.170]             }
[15:31:10.170]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.170]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.170]         }
[15:31:10.170]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.170]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.170]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.170]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.170]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.170]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.170]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.170]             base::names(...future.oldOptions))
[15:31:10.170]     }
[15:31:10.170]     if (FALSE) {
[15:31:10.170]     }
[15:31:10.170]     else {
[15:31:10.170]         if (TRUE) {
[15:31:10.170]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.170]                 open = "w")
[15:31:10.170]         }
[15:31:10.170]         else {
[15:31:10.170]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.170]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.170]         }
[15:31:10.170]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.170]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.170]             base::sink(type = "output", split = FALSE)
[15:31:10.170]             base::close(...future.stdout)
[15:31:10.170]         }, add = TRUE)
[15:31:10.170]     }
[15:31:10.170]     ...future.frame <- base::sys.nframe()
[15:31:10.170]     ...future.conditions <- base::list()
[15:31:10.170]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.170]     if (FALSE) {
[15:31:10.170]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.170]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.170]     }
[15:31:10.170]     ...future.result <- base::tryCatch({
[15:31:10.170]         base::withCallingHandlers({
[15:31:10.170]             ...future.value <- base::withVisible(base::local({
[15:31:10.170]                 do.call(function(...) {
[15:31:10.170]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.170]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.170]                     ...future.globals.maxSize)) {
[15:31:10.170]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.170]                     on.exit(options(oopts), add = TRUE)
[15:31:10.170]                   }
[15:31:10.170]                   {
[15:31:10.170]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.170]                       FUN = function(jj) {
[15:31:10.170]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.170]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.170]                       })
[15:31:10.170]                   }
[15:31:10.170]                 }, args = future.call.arguments)
[15:31:10.170]             }))
[15:31:10.170]             future::FutureResult(value = ...future.value$value, 
[15:31:10.170]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.170]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.170]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.170]                     ...future.globalenv.names))
[15:31:10.170]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.170]         }, condition = base::local({
[15:31:10.170]             c <- base::c
[15:31:10.170]             inherits <- base::inherits
[15:31:10.170]             invokeRestart <- base::invokeRestart
[15:31:10.170]             length <- base::length
[15:31:10.170]             list <- base::list
[15:31:10.170]             seq.int <- base::seq.int
[15:31:10.170]             signalCondition <- base::signalCondition
[15:31:10.170]             sys.calls <- base::sys.calls
[15:31:10.170]             `[[` <- base::`[[`
[15:31:10.170]             `+` <- base::`+`
[15:31:10.170]             `<<-` <- base::`<<-`
[15:31:10.170]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.170]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.170]                   3L)]
[15:31:10.170]             }
[15:31:10.170]             function(cond) {
[15:31:10.170]                 is_error <- inherits(cond, "error")
[15:31:10.170]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.170]                   NULL)
[15:31:10.170]                 if (is_error) {
[15:31:10.170]                   sessionInformation <- function() {
[15:31:10.170]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.170]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.170]                       search = base::search(), system = base::Sys.info())
[15:31:10.170]                   }
[15:31:10.170]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.170]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.170]                     cond$call), session = sessionInformation(), 
[15:31:10.170]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.170]                   signalCondition(cond)
[15:31:10.170]                 }
[15:31:10.170]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.170]                 "immediateCondition"))) {
[15:31:10.170]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.170]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.170]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.170]                   if (TRUE && !signal) {
[15:31:10.170]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.170]                     {
[15:31:10.170]                       inherits <- base::inherits
[15:31:10.170]                       invokeRestart <- base::invokeRestart
[15:31:10.170]                       is.null <- base::is.null
[15:31:10.170]                       muffled <- FALSE
[15:31:10.170]                       if (inherits(cond, "message")) {
[15:31:10.170]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.170]                         if (muffled) 
[15:31:10.170]                           invokeRestart("muffleMessage")
[15:31:10.170]                       }
[15:31:10.170]                       else if (inherits(cond, "warning")) {
[15:31:10.170]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.170]                         if (muffled) 
[15:31:10.170]                           invokeRestart("muffleWarning")
[15:31:10.170]                       }
[15:31:10.170]                       else if (inherits(cond, "condition")) {
[15:31:10.170]                         if (!is.null(pattern)) {
[15:31:10.170]                           computeRestarts <- base::computeRestarts
[15:31:10.170]                           grepl <- base::grepl
[15:31:10.170]                           restarts <- computeRestarts(cond)
[15:31:10.170]                           for (restart in restarts) {
[15:31:10.170]                             name <- restart$name
[15:31:10.170]                             if (is.null(name)) 
[15:31:10.170]                               next
[15:31:10.170]                             if (!grepl(pattern, name)) 
[15:31:10.170]                               next
[15:31:10.170]                             invokeRestart(restart)
[15:31:10.170]                             muffled <- TRUE
[15:31:10.170]                             break
[15:31:10.170]                           }
[15:31:10.170]                         }
[15:31:10.170]                       }
[15:31:10.170]                       invisible(muffled)
[15:31:10.170]                     }
[15:31:10.170]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.170]                   }
[15:31:10.170]                 }
[15:31:10.170]                 else {
[15:31:10.170]                   if (TRUE) {
[15:31:10.170]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.170]                     {
[15:31:10.170]                       inherits <- base::inherits
[15:31:10.170]                       invokeRestart <- base::invokeRestart
[15:31:10.170]                       is.null <- base::is.null
[15:31:10.170]                       muffled <- FALSE
[15:31:10.170]                       if (inherits(cond, "message")) {
[15:31:10.170]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.170]                         if (muffled) 
[15:31:10.170]                           invokeRestart("muffleMessage")
[15:31:10.170]                       }
[15:31:10.170]                       else if (inherits(cond, "warning")) {
[15:31:10.170]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.170]                         if (muffled) 
[15:31:10.170]                           invokeRestart("muffleWarning")
[15:31:10.170]                       }
[15:31:10.170]                       else if (inherits(cond, "condition")) {
[15:31:10.170]                         if (!is.null(pattern)) {
[15:31:10.170]                           computeRestarts <- base::computeRestarts
[15:31:10.170]                           grepl <- base::grepl
[15:31:10.170]                           restarts <- computeRestarts(cond)
[15:31:10.170]                           for (restart in restarts) {
[15:31:10.170]                             name <- restart$name
[15:31:10.170]                             if (is.null(name)) 
[15:31:10.170]                               next
[15:31:10.170]                             if (!grepl(pattern, name)) 
[15:31:10.170]                               next
[15:31:10.170]                             invokeRestart(restart)
[15:31:10.170]                             muffled <- TRUE
[15:31:10.170]                             break
[15:31:10.170]                           }
[15:31:10.170]                         }
[15:31:10.170]                       }
[15:31:10.170]                       invisible(muffled)
[15:31:10.170]                     }
[15:31:10.170]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.170]                   }
[15:31:10.170]                 }
[15:31:10.170]             }
[15:31:10.170]         }))
[15:31:10.170]     }, error = function(ex) {
[15:31:10.170]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.170]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.170]                 ...future.rng), started = ...future.startTime, 
[15:31:10.170]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.170]             version = "1.8"), class = "FutureResult")
[15:31:10.170]     }, finally = {
[15:31:10.170]         if (!identical(...future.workdir, getwd())) 
[15:31:10.170]             setwd(...future.workdir)
[15:31:10.170]         {
[15:31:10.170]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.170]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.170]             }
[15:31:10.170]             base::options(...future.oldOptions)
[15:31:10.170]             if (.Platform$OS.type == "windows") {
[15:31:10.170]                 old_names <- names(...future.oldEnvVars)
[15:31:10.170]                 envs <- base::Sys.getenv()
[15:31:10.170]                 names <- names(envs)
[15:31:10.170]                 common <- intersect(names, old_names)
[15:31:10.170]                 added <- setdiff(names, old_names)
[15:31:10.170]                 removed <- setdiff(old_names, names)
[15:31:10.170]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.170]                   envs[common]]
[15:31:10.170]                 NAMES <- toupper(changed)
[15:31:10.170]                 args <- list()
[15:31:10.170]                 for (kk in seq_along(NAMES)) {
[15:31:10.170]                   name <- changed[[kk]]
[15:31:10.170]                   NAME <- NAMES[[kk]]
[15:31:10.170]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.170]                     next
[15:31:10.170]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.170]                 }
[15:31:10.170]                 NAMES <- toupper(added)
[15:31:10.170]                 for (kk in seq_along(NAMES)) {
[15:31:10.170]                   name <- added[[kk]]
[15:31:10.170]                   NAME <- NAMES[[kk]]
[15:31:10.170]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.170]                     next
[15:31:10.170]                   args[[name]] <- ""
[15:31:10.170]                 }
[15:31:10.170]                 NAMES <- toupper(removed)
[15:31:10.170]                 for (kk in seq_along(NAMES)) {
[15:31:10.170]                   name <- removed[[kk]]
[15:31:10.170]                   NAME <- NAMES[[kk]]
[15:31:10.170]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.170]                     next
[15:31:10.170]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.170]                 }
[15:31:10.170]                 if (length(args) > 0) 
[15:31:10.170]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.170]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.170]             }
[15:31:10.170]             else {
[15:31:10.170]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.170]             }
[15:31:10.170]             {
[15:31:10.170]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.170]                   0L) {
[15:31:10.170]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.170]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.170]                   base::options(opts)
[15:31:10.170]                 }
[15:31:10.170]                 {
[15:31:10.170]                   {
[15:31:10.170]                     NULL
[15:31:10.170]                     RNGkind("Mersenne-Twister")
[15:31:10.170]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.170]                       inherits = FALSE)
[15:31:10.170]                   }
[15:31:10.170]                   options(future.plan = NULL)
[15:31:10.170]                   if (is.na(NA_character_)) 
[15:31:10.170]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.170]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.170]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.170]                     .init = FALSE)
[15:31:10.170]                 }
[15:31:10.170]             }
[15:31:10.170]         }
[15:31:10.170]     })
[15:31:10.170]     if (TRUE) {
[15:31:10.170]         base::sink(type = "output", split = FALSE)
[15:31:10.170]         if (TRUE) {
[15:31:10.170]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.170]         }
[15:31:10.170]         else {
[15:31:10.170]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.170]         }
[15:31:10.170]         base::close(...future.stdout)
[15:31:10.170]         ...future.stdout <- NULL
[15:31:10.170]     }
[15:31:10.170]     ...future.result$conditions <- ...future.conditions
[15:31:10.170]     ...future.result$finished <- base::Sys.time()
[15:31:10.170]     ...future.result
[15:31:10.170] }
[15:31:10.176] assign_globals() ...
[15:31:10.176] List of 5
[15:31:10.176]  $ ...future.FUN            :function (object, ...)  
[15:31:10.176]  $ future.call.arguments    : list()
[15:31:10.176]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.176]  $ ...future.elements_ii    :List of 3
[15:31:10.176]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.176]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.176]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.176]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.176]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.176]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.176]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.176]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.176]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.176]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.176]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.176]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.176]  $ ...future.seeds_ii       : NULL
[15:31:10.176]  $ ...future.globals.maxSize: NULL
[15:31:10.176]  - attr(*, "where")=List of 5
[15:31:10.176]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.176]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.176]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.176]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.176]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.176]  - attr(*, "resolved")= logi FALSE
[15:31:10.176]  - attr(*, "total_size")= num 1240
[15:31:10.176]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.176]  - attr(*, "already-done")= logi TRUE
[15:31:10.196] - copied '...future.FUN' to environment
[15:31:10.196] - copied 'future.call.arguments' to environment
[15:31:10.197] - copied '...future.elements_ii' to environment
[15:31:10.197] - copied '...future.seeds_ii' to environment
[15:31:10.197] - copied '...future.globals.maxSize' to environment
[15:31:10.197] assign_globals() ... done
[15:31:10.198] plan(): Setting new future strategy stack:
[15:31:10.198] List of future strategies:
[15:31:10.198] 1. sequential:
[15:31:10.198]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.198]    - tweaked: FALSE
[15:31:10.198]    - call: NULL
[15:31:10.199] plan(): nbrOfWorkers() = 1
[15:31:10.204] plan(): Setting new future strategy stack:
[15:31:10.204] List of future strategies:
[15:31:10.204] 1. sequential:
[15:31:10.204]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.204]    - tweaked: FALSE
[15:31:10.204]    - call: plan(strategy)
[15:31:10.205] plan(): nbrOfWorkers() = 1
[15:31:10.206] SequentialFuture started (and completed)
[15:31:10.206] - Launch lazy future ... done
[15:31:10.206] run() for 'SequentialFuture' ... done
[15:31:10.207] Created future:
[15:31:10.207] SequentialFuture:
[15:31:10.207] Label: 'future_by-1'
[15:31:10.207] Expression:
[15:31:10.207] {
[15:31:10.207]     do.call(function(...) {
[15:31:10.207]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.207]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.207]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.207]             on.exit(options(oopts), add = TRUE)
[15:31:10.207]         }
[15:31:10.207]         {
[15:31:10.207]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.207]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.207]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.207]             })
[15:31:10.207]         }
[15:31:10.207]     }, args = future.call.arguments)
[15:31:10.207] }
[15:31:10.207] Lazy evaluation: FALSE
[15:31:10.207] Asynchronous evaluation: FALSE
[15:31:10.207] Local evaluation: TRUE
[15:31:10.207] Environment: 0x0000019c7f297878
[15:31:10.207] Capture standard output: TRUE
[15:31:10.207] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.207] Globals: 5 objects totaling 6.02 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.207] Packages: <none>
[15:31:10.207] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.207] Resolved: TRUE
[15:31:10.207] Value: 5.37 KiB of class 'list'
[15:31:10.207] Early signaling: FALSE
[15:31:10.207] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.207] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.210] Chunk #1 of 1 ... DONE
[15:31:10.210] Launching 1 futures (chunks) ... DONE
[15:31:10.210] Resolving 1 futures (chunks) ...
[15:31:10.210] resolve() on list ...
[15:31:10.211]  recursive: 0
[15:31:10.211]  length: 1
[15:31:10.211] 
[15:31:10.211] resolved() for 'SequentialFuture' ...
[15:31:10.212] - state: 'finished'
[15:31:10.212] - run: TRUE
[15:31:10.212] - result: 'FutureResult'
[15:31:10.213] resolved() for 'SequentialFuture' ... done
[15:31:10.213] Future #1
[15:31:10.213] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.214] - nx: 1
[15:31:10.214] - relay: TRUE
[15:31:10.214] - stdout: TRUE
[15:31:10.214] - signal: TRUE
[15:31:10.214] - resignal: FALSE
[15:31:10.215] - force: TRUE
[15:31:10.215] - relayed: [n=1] FALSE
[15:31:10.215] - queued futures: [n=1] FALSE
[15:31:10.215]  - until=1
[15:31:10.216]  - relaying element #1
[15:31:10.216] - relayed: [n=1] TRUE
[15:31:10.216] - queued futures: [n=1] TRUE
[15:31:10.217] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.217]  length: 0 (resolved future 1)
[15:31:10.217] Relaying remaining futures
[15:31:10.217] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.218] - nx: 1
[15:31:10.218] - relay: TRUE
[15:31:10.218] - stdout: TRUE
[15:31:10.218] - signal: TRUE
[15:31:10.219] - resignal: FALSE
[15:31:10.219] - force: TRUE
[15:31:10.219] - relayed: [n=1] TRUE
[15:31:10.219] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.220] - relayed: [n=1] TRUE
[15:31:10.220] - queued futures: [n=1] TRUE
[15:31:10.220] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.220] resolve() on list ... DONE
[15:31:10.221]  - Number of value chunks collected: 1
[15:31:10.221] Resolving 1 futures (chunks) ... DONE
[15:31:10.221] Reducing values from 1 chunks ...
[15:31:10.222]  - Number of values collected after concatenation: 3
[15:31:10.222]  - Number of values expected: 3
[15:31:10.222] Reducing values from 1 chunks ... DONE
[15:31:10.222] future_lapply() ... DONE
[15:31:10.223] future_by_internal() ... DONE
[15:31:10.267] 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.
[15:31:10.269] future_lapply() ...
[15:31:10.270] Number of chunks: 1
[15:31:10.270] getGlobalsAndPackagesXApply() ...
[15:31:10.270]  - future.globals: TRUE
[15:31:10.270] getGlobalsAndPackages() ...
[15:31:10.271] Searching for globals...
[15:31:10.272] - globals found: [2] 'FUN', 'UseMethod'
[15:31:10.273] Searching for globals ... DONE
[15:31:10.273] Resolving globals: FALSE
[15:31:10.274] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:10.274] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:10.275] - globals: [1] 'FUN'
[15:31:10.275] 
[15:31:10.275] getGlobalsAndPackages() ... DONE
[15:31:10.275]  - globals found/used: [n=1] 'FUN'
[15:31:10.276]  - needed namespaces: [n=0] 
[15:31:10.276] Finding globals ... DONE
[15:31:10.276]  - use_args: TRUE
[15:31:10.276]  - Getting '...' globals ...
[15:31:10.277] resolve() on list ...
[15:31:10.277]  recursive: 0
[15:31:10.277]  length: 1
[15:31:10.278]  elements: '...'
[15:31:10.278]  length: 0 (resolved future 1)
[15:31:10.278] resolve() on list ... DONE
[15:31:10.278]    - '...' content: [n=0] 
[15:31:10.279] List of 1
[15:31:10.279]  $ ...: list()
[15:31:10.279]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.279]  - attr(*, "where")=List of 1
[15:31:10.279]   ..$ ...:<environment: 0x0000019c8023e180> 
[15:31:10.279]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.279]  - attr(*, "resolved")= logi TRUE
[15:31:10.279]  - attr(*, "total_size")= num NA
[15:31:10.283]  - Getting '...' globals ... DONE
[15:31:10.284] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.284] List of 2
[15:31:10.284]  $ ...future.FUN:function (object, ...)  
[15:31:10.284]  $ ...          : list()
[15:31:10.284]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.284]  - attr(*, "where")=List of 2
[15:31:10.284]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.284]   ..$ ...          :<environment: 0x0000019c8023e180> 
[15:31:10.284]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.284]  - attr(*, "resolved")= logi FALSE
[15:31:10.284]  - attr(*, "total_size")= num 1240
[15:31:10.289] Packages to be attached in all futures: [n=0] 
[15:31:10.289] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.289] Number of futures (= number of chunks): 1
[15:31:10.290] Launching 1 futures (chunks) ...
[15:31:10.290] Chunk #1 of 1 ...
[15:31:10.290]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.290] getGlobalsAndPackages() ...
[15:31:10.291] Searching for globals...
[15:31:10.292] 
[15:31:10.292] Searching for globals ... DONE
[15:31:10.292] - globals: [0] <none>
[15:31:10.292] getGlobalsAndPackages() ... DONE
[15:31:10.292]    + additional globals found: [n=0] 
[15:31:10.293]    + additional namespaces needed: [n=0] 
[15:31:10.293]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.293]  - seeds: <none>
[15:31:10.293]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.294] getGlobalsAndPackages() ...
[15:31:10.294] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.294] Resolving globals: FALSE
[15:31:10.295] Tweak future expression to call with '...' arguments ...
[15:31:10.295] {
[15:31:10.295]     do.call(function(...) {
[15:31:10.295]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.295]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.295]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.295]             on.exit(options(oopts), add = TRUE)
[15:31:10.295]         }
[15:31:10.295]         {
[15:31:10.295]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.295]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.295]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.295]             })
[15:31:10.295]         }
[15:31:10.295]     }, args = future.call.arguments)
[15:31:10.295] }
[15:31:10.296] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.296] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.297] 
[15:31:10.297] getGlobalsAndPackages() ... DONE
[15:31:10.297] run() for 'Future' ...
[15:31:10.298] - state: 'created'
[15:31:10.298] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:10.299] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.299] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.299]   - Field: 'label'
[15:31:10.299]   - Field: 'local'
[15:31:10.300]   - Field: 'owner'
[15:31:10.300]   - Field: 'envir'
[15:31:10.300]   - Field: 'packages'
[15:31:10.300]   - Field: 'gc'
[15:31:10.301]   - Field: 'conditions'
[15:31:10.301]   - Field: 'expr'
[15:31:10.301]   - Field: 'uuid'
[15:31:10.301]   - Field: 'seed'
[15:31:10.302]   - Field: 'version'
[15:31:10.302]   - Field: 'result'
[15:31:10.302]   - Field: 'asynchronous'
[15:31:10.302]   - Field: 'calls'
[15:31:10.303]   - Field: 'globals'
[15:31:10.303]   - Field: 'stdout'
[15:31:10.303]   - Field: 'earlySignal'
[15:31:10.304]   - Field: 'lazy'
[15:31:10.304]   - Field: 'state'
[15:31:10.304] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.304] - Launch lazy future ...
[15:31:10.305] Packages needed by the future expression (n = 0): <none>
[15:31:10.305] Packages needed by future strategies (n = 0): <none>
[15:31:10.306] {
[15:31:10.306]     {
[15:31:10.306]         {
[15:31:10.306]             ...future.startTime <- base::Sys.time()
[15:31:10.306]             {
[15:31:10.306]                 {
[15:31:10.306]                   {
[15:31:10.306]                     base::local({
[15:31:10.306]                       has_future <- base::requireNamespace("future", 
[15:31:10.306]                         quietly = TRUE)
[15:31:10.306]                       if (has_future) {
[15:31:10.306]                         ns <- base::getNamespace("future")
[15:31:10.306]                         version <- ns[[".package"]][["version"]]
[15:31:10.306]                         if (is.null(version)) 
[15:31:10.306]                           version <- utils::packageVersion("future")
[15:31:10.306]                       }
[15:31:10.306]                       else {
[15:31:10.306]                         version <- NULL
[15:31:10.306]                       }
[15:31:10.306]                       if (!has_future || version < "1.8.0") {
[15:31:10.306]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.306]                           "", base::R.version$version.string), 
[15:31:10.306]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.306]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.306]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.306]                             "release", "version")], collapse = " "), 
[15:31:10.306]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.306]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.306]                           info)
[15:31:10.306]                         info <- base::paste(info, collapse = "; ")
[15:31:10.306]                         if (!has_future) {
[15:31:10.306]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.306]                             info)
[15:31:10.306]                         }
[15:31:10.306]                         else {
[15:31:10.306]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.306]                             info, version)
[15:31:10.306]                         }
[15:31:10.306]                         base::stop(msg)
[15:31:10.306]                       }
[15:31:10.306]                     })
[15:31:10.306]                   }
[15:31:10.306]                   ...future.strategy.old <- future::plan("list")
[15:31:10.306]                   options(future.plan = NULL)
[15:31:10.306]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.306]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.306]                 }
[15:31:10.306]                 ...future.workdir <- getwd()
[15:31:10.306]             }
[15:31:10.306]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.306]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.306]         }
[15:31:10.306]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.306]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.306]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.306]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.306]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.306]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.306]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.306]             base::names(...future.oldOptions))
[15:31:10.306]     }
[15:31:10.306]     if (FALSE) {
[15:31:10.306]     }
[15:31:10.306]     else {
[15:31:10.306]         if (TRUE) {
[15:31:10.306]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.306]                 open = "w")
[15:31:10.306]         }
[15:31:10.306]         else {
[15:31:10.306]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.306]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.306]         }
[15:31:10.306]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.306]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.306]             base::sink(type = "output", split = FALSE)
[15:31:10.306]             base::close(...future.stdout)
[15:31:10.306]         }, add = TRUE)
[15:31:10.306]     }
[15:31:10.306]     ...future.frame <- base::sys.nframe()
[15:31:10.306]     ...future.conditions <- base::list()
[15:31:10.306]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.306]     if (FALSE) {
[15:31:10.306]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.306]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.306]     }
[15:31:10.306]     ...future.result <- base::tryCatch({
[15:31:10.306]         base::withCallingHandlers({
[15:31:10.306]             ...future.value <- base::withVisible(base::local({
[15:31:10.306]                 do.call(function(...) {
[15:31:10.306]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.306]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.306]                     ...future.globals.maxSize)) {
[15:31:10.306]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.306]                     on.exit(options(oopts), add = TRUE)
[15:31:10.306]                   }
[15:31:10.306]                   {
[15:31:10.306]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.306]                       FUN = function(jj) {
[15:31:10.306]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.306]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.306]                       })
[15:31:10.306]                   }
[15:31:10.306]                 }, args = future.call.arguments)
[15:31:10.306]             }))
[15:31:10.306]             future::FutureResult(value = ...future.value$value, 
[15:31:10.306]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.306]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.306]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.306]                     ...future.globalenv.names))
[15:31:10.306]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.306]         }, condition = base::local({
[15:31:10.306]             c <- base::c
[15:31:10.306]             inherits <- base::inherits
[15:31:10.306]             invokeRestart <- base::invokeRestart
[15:31:10.306]             length <- base::length
[15:31:10.306]             list <- base::list
[15:31:10.306]             seq.int <- base::seq.int
[15:31:10.306]             signalCondition <- base::signalCondition
[15:31:10.306]             sys.calls <- base::sys.calls
[15:31:10.306]             `[[` <- base::`[[`
[15:31:10.306]             `+` <- base::`+`
[15:31:10.306]             `<<-` <- base::`<<-`
[15:31:10.306]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.306]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.306]                   3L)]
[15:31:10.306]             }
[15:31:10.306]             function(cond) {
[15:31:10.306]                 is_error <- inherits(cond, "error")
[15:31:10.306]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.306]                   NULL)
[15:31:10.306]                 if (is_error) {
[15:31:10.306]                   sessionInformation <- function() {
[15:31:10.306]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.306]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.306]                       search = base::search(), system = base::Sys.info())
[15:31:10.306]                   }
[15:31:10.306]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.306]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.306]                     cond$call), session = sessionInformation(), 
[15:31:10.306]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.306]                   signalCondition(cond)
[15:31:10.306]                 }
[15:31:10.306]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.306]                 "immediateCondition"))) {
[15:31:10.306]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.306]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.306]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.306]                   if (TRUE && !signal) {
[15:31:10.306]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.306]                     {
[15:31:10.306]                       inherits <- base::inherits
[15:31:10.306]                       invokeRestart <- base::invokeRestart
[15:31:10.306]                       is.null <- base::is.null
[15:31:10.306]                       muffled <- FALSE
[15:31:10.306]                       if (inherits(cond, "message")) {
[15:31:10.306]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.306]                         if (muffled) 
[15:31:10.306]                           invokeRestart("muffleMessage")
[15:31:10.306]                       }
[15:31:10.306]                       else if (inherits(cond, "warning")) {
[15:31:10.306]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.306]                         if (muffled) 
[15:31:10.306]                           invokeRestart("muffleWarning")
[15:31:10.306]                       }
[15:31:10.306]                       else if (inherits(cond, "condition")) {
[15:31:10.306]                         if (!is.null(pattern)) {
[15:31:10.306]                           computeRestarts <- base::computeRestarts
[15:31:10.306]                           grepl <- base::grepl
[15:31:10.306]                           restarts <- computeRestarts(cond)
[15:31:10.306]                           for (restart in restarts) {
[15:31:10.306]                             name <- restart$name
[15:31:10.306]                             if (is.null(name)) 
[15:31:10.306]                               next
[15:31:10.306]                             if (!grepl(pattern, name)) 
[15:31:10.306]                               next
[15:31:10.306]                             invokeRestart(restart)
[15:31:10.306]                             muffled <- TRUE
[15:31:10.306]                             break
[15:31:10.306]                           }
[15:31:10.306]                         }
[15:31:10.306]                       }
[15:31:10.306]                       invisible(muffled)
[15:31:10.306]                     }
[15:31:10.306]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.306]                   }
[15:31:10.306]                 }
[15:31:10.306]                 else {
[15:31:10.306]                   if (TRUE) {
[15:31:10.306]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.306]                     {
[15:31:10.306]                       inherits <- base::inherits
[15:31:10.306]                       invokeRestart <- base::invokeRestart
[15:31:10.306]                       is.null <- base::is.null
[15:31:10.306]                       muffled <- FALSE
[15:31:10.306]                       if (inherits(cond, "message")) {
[15:31:10.306]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.306]                         if (muffled) 
[15:31:10.306]                           invokeRestart("muffleMessage")
[15:31:10.306]                       }
[15:31:10.306]                       else if (inherits(cond, "warning")) {
[15:31:10.306]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.306]                         if (muffled) 
[15:31:10.306]                           invokeRestart("muffleWarning")
[15:31:10.306]                       }
[15:31:10.306]                       else if (inherits(cond, "condition")) {
[15:31:10.306]                         if (!is.null(pattern)) {
[15:31:10.306]                           computeRestarts <- base::computeRestarts
[15:31:10.306]                           grepl <- base::grepl
[15:31:10.306]                           restarts <- computeRestarts(cond)
[15:31:10.306]                           for (restart in restarts) {
[15:31:10.306]                             name <- restart$name
[15:31:10.306]                             if (is.null(name)) 
[15:31:10.306]                               next
[15:31:10.306]                             if (!grepl(pattern, name)) 
[15:31:10.306]                               next
[15:31:10.306]                             invokeRestart(restart)
[15:31:10.306]                             muffled <- TRUE
[15:31:10.306]                             break
[15:31:10.306]                           }
[15:31:10.306]                         }
[15:31:10.306]                       }
[15:31:10.306]                       invisible(muffled)
[15:31:10.306]                     }
[15:31:10.306]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.306]                   }
[15:31:10.306]                 }
[15:31:10.306]             }
[15:31:10.306]         }))
[15:31:10.306]     }, error = function(ex) {
[15:31:10.306]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.306]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.306]                 ...future.rng), started = ...future.startTime, 
[15:31:10.306]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.306]             version = "1.8"), class = "FutureResult")
[15:31:10.306]     }, finally = {
[15:31:10.306]         if (!identical(...future.workdir, getwd())) 
[15:31:10.306]             setwd(...future.workdir)
[15:31:10.306]         {
[15:31:10.306]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.306]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.306]             }
[15:31:10.306]             base::options(...future.oldOptions)
[15:31:10.306]             if (.Platform$OS.type == "windows") {
[15:31:10.306]                 old_names <- names(...future.oldEnvVars)
[15:31:10.306]                 envs <- base::Sys.getenv()
[15:31:10.306]                 names <- names(envs)
[15:31:10.306]                 common <- intersect(names, old_names)
[15:31:10.306]                 added <- setdiff(names, old_names)
[15:31:10.306]                 removed <- setdiff(old_names, names)
[15:31:10.306]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.306]                   envs[common]]
[15:31:10.306]                 NAMES <- toupper(changed)
[15:31:10.306]                 args <- list()
[15:31:10.306]                 for (kk in seq_along(NAMES)) {
[15:31:10.306]                   name <- changed[[kk]]
[15:31:10.306]                   NAME <- NAMES[[kk]]
[15:31:10.306]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.306]                     next
[15:31:10.306]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.306]                 }
[15:31:10.306]                 NAMES <- toupper(added)
[15:31:10.306]                 for (kk in seq_along(NAMES)) {
[15:31:10.306]                   name <- added[[kk]]
[15:31:10.306]                   NAME <- NAMES[[kk]]
[15:31:10.306]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.306]                     next
[15:31:10.306]                   args[[name]] <- ""
[15:31:10.306]                 }
[15:31:10.306]                 NAMES <- toupper(removed)
[15:31:10.306]                 for (kk in seq_along(NAMES)) {
[15:31:10.306]                   name <- removed[[kk]]
[15:31:10.306]                   NAME <- NAMES[[kk]]
[15:31:10.306]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.306]                     next
[15:31:10.306]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.306]                 }
[15:31:10.306]                 if (length(args) > 0) 
[15:31:10.306]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.306]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.306]             }
[15:31:10.306]             else {
[15:31:10.306]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.306]             }
[15:31:10.306]             {
[15:31:10.306]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.306]                   0L) {
[15:31:10.306]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.306]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.306]                   base::options(opts)
[15:31:10.306]                 }
[15:31:10.306]                 {
[15:31:10.306]                   {
[15:31:10.306]                     NULL
[15:31:10.306]                     RNGkind("Mersenne-Twister")
[15:31:10.306]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.306]                       inherits = FALSE)
[15:31:10.306]                   }
[15:31:10.306]                   options(future.plan = NULL)
[15:31:10.306]                   if (is.na(NA_character_)) 
[15:31:10.306]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.306]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.306]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.306]                     .init = FALSE)
[15:31:10.306]                 }
[15:31:10.306]             }
[15:31:10.306]         }
[15:31:10.306]     })
[15:31:10.306]     if (TRUE) {
[15:31:10.306]         base::sink(type = "output", split = FALSE)
[15:31:10.306]         if (TRUE) {
[15:31:10.306]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.306]         }
[15:31:10.306]         else {
[15:31:10.306]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.306]         }
[15:31:10.306]         base::close(...future.stdout)
[15:31:10.306]         ...future.stdout <- NULL
[15:31:10.306]     }
[15:31:10.306]     ...future.result$conditions <- ...future.conditions
[15:31:10.306]     ...future.result$finished <- base::Sys.time()
[15:31:10.306]     ...future.result
[15:31:10.306] }
[15:31:10.312] assign_globals() ...
[15:31:10.312] List of 5
[15:31:10.312]  $ ...future.FUN            :function (object, ...)  
[15:31:10.312]  $ future.call.arguments    : list()
[15:31:10.312]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.312]  $ ...future.elements_ii    :List of 3
[15:31:10.312]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.312]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.312]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.312]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.312]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.312]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.312]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.312]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.312]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.312]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.312]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.312]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.312]  $ ...future.seeds_ii       : NULL
[15:31:10.312]  $ ...future.globals.maxSize: NULL
[15:31:10.312]  - attr(*, "where")=List of 5
[15:31:10.312]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.312]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.312]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.312]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.312]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.312]  - attr(*, "resolved")= logi FALSE
[15:31:10.312]  - attr(*, "total_size")= num 1240
[15:31:10.312]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.312]  - attr(*, "already-done")= logi TRUE
[15:31:10.329] - copied '...future.FUN' to environment
[15:31:10.329] - copied 'future.call.arguments' to environment
[15:31:10.329] - copied '...future.elements_ii' to environment
[15:31:10.330] - copied '...future.seeds_ii' to environment
[15:31:10.330] - copied '...future.globals.maxSize' to environment
[15:31:10.330] assign_globals() ... done
[15:31:10.331] plan(): Setting new future strategy stack:
[15:31:10.331] List of future strategies:
[15:31:10.331] 1. sequential:
[15:31:10.331]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.331]    - tweaked: FALSE
[15:31:10.331]    - call: NULL
[15:31:10.332] plan(): nbrOfWorkers() = 1
[15:31:10.337] plan(): Setting new future strategy stack:
[15:31:10.337] List of future strategies:
[15:31:10.337] 1. sequential:
[15:31:10.337]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.337]    - tweaked: FALSE
[15:31:10.337]    - call: plan(strategy)
[15:31:10.338] plan(): nbrOfWorkers() = 1
[15:31:10.338] SequentialFuture started (and completed)
[15:31:10.338] - Launch lazy future ... done
[15:31:10.339] run() for 'SequentialFuture' ... done
[15:31:10.339] Created future:
[15:31:10.339] SequentialFuture:
[15:31:10.339] Label: 'future_by-1'
[15:31:10.339] Expression:
[15:31:10.339] {
[15:31:10.339]     do.call(function(...) {
[15:31:10.339]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.339]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.339]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.339]             on.exit(options(oopts), add = TRUE)
[15:31:10.339]         }
[15:31:10.339]         {
[15:31:10.339]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.339]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.339]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.339]             })
[15:31:10.339]         }
[15:31:10.339]     }, args = future.call.arguments)
[15:31:10.339] }
[15:31:10.339] Lazy evaluation: FALSE
[15:31:10.339] Asynchronous evaluation: FALSE
[15:31:10.339] Local evaluation: TRUE
[15:31:10.339] Environment: 0x0000019c803727b0
[15:31:10.339] Capture standard output: TRUE
[15:31:10.339] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.339] Globals: 5 objects totaling 6.02 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.339] Packages: <none>
[15:31:10.339] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.339] Resolved: TRUE
[15:31:10.339] Value: 5.37 KiB of class 'list'
[15:31:10.339] Early signaling: FALSE
[15:31:10.339] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.339] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.342] Chunk #1 of 1 ... DONE
[15:31:10.342] Launching 1 futures (chunks) ... DONE
[15:31:10.343] Resolving 1 futures (chunks) ...
[15:31:10.343] resolve() on list ...
[15:31:10.343]  recursive: 0
[15:31:10.344]  length: 1
[15:31:10.344] 
[15:31:10.344] resolved() for 'SequentialFuture' ...
[15:31:10.344] - state: 'finished'
[15:31:10.345] - run: TRUE
[15:31:10.345] - result: 'FutureResult'
[15:31:10.345] resolved() for 'SequentialFuture' ... done
[15:31:10.346] Future #1
[15:31:10.346] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.346] - nx: 1
[15:31:10.347] - relay: TRUE
[15:31:10.347] - stdout: TRUE
[15:31:10.347] - signal: TRUE
[15:31:10.347] - resignal: FALSE
[15:31:10.348] - force: TRUE
[15:31:10.348] - relayed: [n=1] FALSE
[15:31:10.348] - queued futures: [n=1] FALSE
[15:31:10.348]  - until=1
[15:31:10.349]  - relaying element #1
[15:31:10.349] - relayed: [n=1] TRUE
[15:31:10.349] - queued futures: [n=1] TRUE
[15:31:10.350] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.350]  length: 0 (resolved future 1)
[15:31:10.350] Relaying remaining futures
[15:31:10.351] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.351] - nx: 1
[15:31:10.351] - relay: TRUE
[15:31:10.351] - stdout: TRUE
[15:31:10.351] - signal: TRUE
[15:31:10.352] - resignal: FALSE
[15:31:10.352] - force: TRUE
[15:31:10.352] - relayed: [n=1] TRUE
[15:31:10.352] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.353] - relayed: [n=1] TRUE
[15:31:10.353] - queued futures: [n=1] TRUE
[15:31:10.353] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.354] resolve() on list ... DONE
[15:31:10.354]  - Number of value chunks collected: 1
[15:31:10.354] Resolving 1 futures (chunks) ... DONE
[15:31:10.354] Reducing values from 1 chunks ...
[15:31:10.355]  - Number of values collected after concatenation: 3
[15:31:10.355]  - Number of values expected: 3
[15:31:10.355] Reducing values from 1 chunks ... DONE
[15:31:10.355] future_lapply() ... DONE
[15:31:10.356] future_by_internal() ... DONE
[15:31:10.357] future_by_internal() ...
- plan('multisession') ...
[15:31:10.359] plan(): Setting new future strategy stack:
[15:31:10.359] List of future strategies:
[15:31:10.359] 1. multisession:
[15:31:10.359]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.359]    - tweaked: FALSE
[15:31:10.359]    - call: plan(strategy)
[15:31:10.360] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:31:10.360] multisession:
[15:31:10.360] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.360] - tweaked: FALSE
[15:31:10.360] - call: plan(strategy)
[15:31:10.364] getGlobalsAndPackages() ...
[15:31:10.365] Not searching for globals
[15:31:10.365] - globals: [0] <none>
[15:31:10.365] getGlobalsAndPackages() ... DONE
[15:31:10.366] Packages needed by the future expression (n = 0): <none>
[15:31:10.366] Packages needed by future strategies (n = 0): <none>
[15:31:10.367] {
[15:31:10.367]     {
[15:31:10.367]         {
[15:31:10.367]             ...future.startTime <- base::Sys.time()
[15:31:10.367]             {
[15:31:10.367]                 {
[15:31:10.367]                   {
[15:31:10.367]                     base::local({
[15:31:10.367]                       has_future <- base::requireNamespace("future", 
[15:31:10.367]                         quietly = TRUE)
[15:31:10.367]                       if (has_future) {
[15:31:10.367]                         ns <- base::getNamespace("future")
[15:31:10.367]                         version <- ns[[".package"]][["version"]]
[15:31:10.367]                         if (is.null(version)) 
[15:31:10.367]                           version <- utils::packageVersion("future")
[15:31:10.367]                       }
[15:31:10.367]                       else {
[15:31:10.367]                         version <- NULL
[15:31:10.367]                       }
[15:31:10.367]                       if (!has_future || version < "1.8.0") {
[15:31:10.367]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.367]                           "", base::R.version$version.string), 
[15:31:10.367]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.367]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.367]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.367]                             "release", "version")], collapse = " "), 
[15:31:10.367]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.367]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.367]                           info)
[15:31:10.367]                         info <- base::paste(info, collapse = "; ")
[15:31:10.367]                         if (!has_future) {
[15:31:10.367]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.367]                             info)
[15:31:10.367]                         }
[15:31:10.367]                         else {
[15:31:10.367]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.367]                             info, version)
[15:31:10.367]                         }
[15:31:10.367]                         base::stop(msg)
[15:31:10.367]                       }
[15:31:10.367]                     })
[15:31:10.367]                   }
[15:31:10.367]                   ...future.strategy.old <- future::plan("list")
[15:31:10.367]                   options(future.plan = NULL)
[15:31:10.367]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.367]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.367]                 }
[15:31:10.367]                 ...future.workdir <- getwd()
[15:31:10.367]             }
[15:31:10.367]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.367]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.367]         }
[15:31:10.367]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.367]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.367]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.367]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.367]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.367]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.367]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.367]             base::names(...future.oldOptions))
[15:31:10.367]     }
[15:31:10.367]     if (FALSE) {
[15:31:10.367]     }
[15:31:10.367]     else {
[15:31:10.367]         if (TRUE) {
[15:31:10.367]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.367]                 open = "w")
[15:31:10.367]         }
[15:31:10.367]         else {
[15:31:10.367]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.367]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.367]         }
[15:31:10.367]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.367]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.367]             base::sink(type = "output", split = FALSE)
[15:31:10.367]             base::close(...future.stdout)
[15:31:10.367]         }, add = TRUE)
[15:31:10.367]     }
[15:31:10.367]     ...future.frame <- base::sys.nframe()
[15:31:10.367]     ...future.conditions <- base::list()
[15:31:10.367]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.367]     if (FALSE) {
[15:31:10.367]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.367]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.367]     }
[15:31:10.367]     ...future.result <- base::tryCatch({
[15:31:10.367]         base::withCallingHandlers({
[15:31:10.367]             ...future.value <- base::withVisible(base::local(NA))
[15:31:10.367]             future::FutureResult(value = ...future.value$value, 
[15:31:10.367]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.367]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.367]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.367]                     ...future.globalenv.names))
[15:31:10.367]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.367]         }, condition = base::local({
[15:31:10.367]             c <- base::c
[15:31:10.367]             inherits <- base::inherits
[15:31:10.367]             invokeRestart <- base::invokeRestart
[15:31:10.367]             length <- base::length
[15:31:10.367]             list <- base::list
[15:31:10.367]             seq.int <- base::seq.int
[15:31:10.367]             signalCondition <- base::signalCondition
[15:31:10.367]             sys.calls <- base::sys.calls
[15:31:10.367]             `[[` <- base::`[[`
[15:31:10.367]             `+` <- base::`+`
[15:31:10.367]             `<<-` <- base::`<<-`
[15:31:10.367]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.367]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.367]                   3L)]
[15:31:10.367]             }
[15:31:10.367]             function(cond) {
[15:31:10.367]                 is_error <- inherits(cond, "error")
[15:31:10.367]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.367]                   NULL)
[15:31:10.367]                 if (is_error) {
[15:31:10.367]                   sessionInformation <- function() {
[15:31:10.367]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.367]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.367]                       search = base::search(), system = base::Sys.info())
[15:31:10.367]                   }
[15:31:10.367]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.367]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.367]                     cond$call), session = sessionInformation(), 
[15:31:10.367]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.367]                   signalCondition(cond)
[15:31:10.367]                 }
[15:31:10.367]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.367]                 "immediateCondition"))) {
[15:31:10.367]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.367]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.367]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.367]                   if (TRUE && !signal) {
[15:31:10.367]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.367]                     {
[15:31:10.367]                       inherits <- base::inherits
[15:31:10.367]                       invokeRestart <- base::invokeRestart
[15:31:10.367]                       is.null <- base::is.null
[15:31:10.367]                       muffled <- FALSE
[15:31:10.367]                       if (inherits(cond, "message")) {
[15:31:10.367]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.367]                         if (muffled) 
[15:31:10.367]                           invokeRestart("muffleMessage")
[15:31:10.367]                       }
[15:31:10.367]                       else if (inherits(cond, "warning")) {
[15:31:10.367]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.367]                         if (muffled) 
[15:31:10.367]                           invokeRestart("muffleWarning")
[15:31:10.367]                       }
[15:31:10.367]                       else if (inherits(cond, "condition")) {
[15:31:10.367]                         if (!is.null(pattern)) {
[15:31:10.367]                           computeRestarts <- base::computeRestarts
[15:31:10.367]                           grepl <- base::grepl
[15:31:10.367]                           restarts <- computeRestarts(cond)
[15:31:10.367]                           for (restart in restarts) {
[15:31:10.367]                             name <- restart$name
[15:31:10.367]                             if (is.null(name)) 
[15:31:10.367]                               next
[15:31:10.367]                             if (!grepl(pattern, name)) 
[15:31:10.367]                               next
[15:31:10.367]                             invokeRestart(restart)
[15:31:10.367]                             muffled <- TRUE
[15:31:10.367]                             break
[15:31:10.367]                           }
[15:31:10.367]                         }
[15:31:10.367]                       }
[15:31:10.367]                       invisible(muffled)
[15:31:10.367]                     }
[15:31:10.367]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.367]                   }
[15:31:10.367]                 }
[15:31:10.367]                 else {
[15:31:10.367]                   if (TRUE) {
[15:31:10.367]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.367]                     {
[15:31:10.367]                       inherits <- base::inherits
[15:31:10.367]                       invokeRestart <- base::invokeRestart
[15:31:10.367]                       is.null <- base::is.null
[15:31:10.367]                       muffled <- FALSE
[15:31:10.367]                       if (inherits(cond, "message")) {
[15:31:10.367]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.367]                         if (muffled) 
[15:31:10.367]                           invokeRestart("muffleMessage")
[15:31:10.367]                       }
[15:31:10.367]                       else if (inherits(cond, "warning")) {
[15:31:10.367]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.367]                         if (muffled) 
[15:31:10.367]                           invokeRestart("muffleWarning")
[15:31:10.367]                       }
[15:31:10.367]                       else if (inherits(cond, "condition")) {
[15:31:10.367]                         if (!is.null(pattern)) {
[15:31:10.367]                           computeRestarts <- base::computeRestarts
[15:31:10.367]                           grepl <- base::grepl
[15:31:10.367]                           restarts <- computeRestarts(cond)
[15:31:10.367]                           for (restart in restarts) {
[15:31:10.367]                             name <- restart$name
[15:31:10.367]                             if (is.null(name)) 
[15:31:10.367]                               next
[15:31:10.367]                             if (!grepl(pattern, name)) 
[15:31:10.367]                               next
[15:31:10.367]                             invokeRestart(restart)
[15:31:10.367]                             muffled <- TRUE
[15:31:10.367]                             break
[15:31:10.367]                           }
[15:31:10.367]                         }
[15:31:10.367]                       }
[15:31:10.367]                       invisible(muffled)
[15:31:10.367]                     }
[15:31:10.367]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.367]                   }
[15:31:10.367]                 }
[15:31:10.367]             }
[15:31:10.367]         }))
[15:31:10.367]     }, error = function(ex) {
[15:31:10.367]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.367]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.367]                 ...future.rng), started = ...future.startTime, 
[15:31:10.367]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.367]             version = "1.8"), class = "FutureResult")
[15:31:10.367]     }, finally = {
[15:31:10.367]         if (!identical(...future.workdir, getwd())) 
[15:31:10.367]             setwd(...future.workdir)
[15:31:10.367]         {
[15:31:10.367]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.367]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.367]             }
[15:31:10.367]             base::options(...future.oldOptions)
[15:31:10.367]             if (.Platform$OS.type == "windows") {
[15:31:10.367]                 old_names <- names(...future.oldEnvVars)
[15:31:10.367]                 envs <- base::Sys.getenv()
[15:31:10.367]                 names <- names(envs)
[15:31:10.367]                 common <- intersect(names, old_names)
[15:31:10.367]                 added <- setdiff(names, old_names)
[15:31:10.367]                 removed <- setdiff(old_names, names)
[15:31:10.367]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.367]                   envs[common]]
[15:31:10.367]                 NAMES <- toupper(changed)
[15:31:10.367]                 args <- list()
[15:31:10.367]                 for (kk in seq_along(NAMES)) {
[15:31:10.367]                   name <- changed[[kk]]
[15:31:10.367]                   NAME <- NAMES[[kk]]
[15:31:10.367]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.367]                     next
[15:31:10.367]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.367]                 }
[15:31:10.367]                 NAMES <- toupper(added)
[15:31:10.367]                 for (kk in seq_along(NAMES)) {
[15:31:10.367]                   name <- added[[kk]]
[15:31:10.367]                   NAME <- NAMES[[kk]]
[15:31:10.367]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.367]                     next
[15:31:10.367]                   args[[name]] <- ""
[15:31:10.367]                 }
[15:31:10.367]                 NAMES <- toupper(removed)
[15:31:10.367]                 for (kk in seq_along(NAMES)) {
[15:31:10.367]                   name <- removed[[kk]]
[15:31:10.367]                   NAME <- NAMES[[kk]]
[15:31:10.367]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.367]                     next
[15:31:10.367]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.367]                 }
[15:31:10.367]                 if (length(args) > 0) 
[15:31:10.367]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.367]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.367]             }
[15:31:10.367]             else {
[15:31:10.367]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.367]             }
[15:31:10.367]             {
[15:31:10.367]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.367]                   0L) {
[15:31:10.367]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.367]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.367]                   base::options(opts)
[15:31:10.367]                 }
[15:31:10.367]                 {
[15:31:10.367]                   {
[15:31:10.367]                     NULL
[15:31:10.367]                     RNGkind("Mersenne-Twister")
[15:31:10.367]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.367]                       inherits = FALSE)
[15:31:10.367]                   }
[15:31:10.367]                   options(future.plan = NULL)
[15:31:10.367]                   if (is.na(NA_character_)) 
[15:31:10.367]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.367]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.367]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.367]                     .init = FALSE)
[15:31:10.367]                 }
[15:31:10.367]             }
[15:31:10.367]         }
[15:31:10.367]     })
[15:31:10.367]     if (TRUE) {
[15:31:10.367]         base::sink(type = "output", split = FALSE)
[15:31:10.367]         if (TRUE) {
[15:31:10.367]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.367]         }
[15:31:10.367]         else {
[15:31:10.367]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.367]         }
[15:31:10.367]         base::close(...future.stdout)
[15:31:10.367]         ...future.stdout <- NULL
[15:31:10.367]     }
[15:31:10.367]     ...future.result$conditions <- ...future.conditions
[15:31:10.367]     ...future.result$finished <- base::Sys.time()
[15:31:10.367]     ...future.result
[15:31:10.367] }
[15:31:10.373] plan(): Setting new future strategy stack:
[15:31:10.373] List of future strategies:
[15:31:10.373] 1. sequential:
[15:31:10.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.373]    - tweaked: FALSE
[15:31:10.373]    - call: NULL
[15:31:10.374] plan(): nbrOfWorkers() = 1
[15:31:10.376] plan(): Setting new future strategy stack:
[15:31:10.376] List of future strategies:
[15:31:10.376] 1. multisession:
[15:31:10.376]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.376]    - tweaked: FALSE
[15:31:10.376]    - call: plan(strategy)
[15:31:10.380] plan(): nbrOfWorkers() = 1
[15:31:10.381] SequentialFuture started (and completed)
[15:31:10.381] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:31:10.385] plan(): nbrOfWorkers() = 1
[15:31:10.385] future_by_internal() ...
[15:31:10.386] future_lapply() ...
[15:31:10.390] Number of chunks: 1
[15:31:10.390] getGlobalsAndPackagesXApply() ...
[15:31:10.391]  - future.globals: TRUE
[15:31:10.391] getGlobalsAndPackages() ...
[15:31:10.391] Searching for globals...
[15:31:10.393] - globals found: [2] 'FUN', 'UseMethod'
[15:31:10.394] Searching for globals ... DONE
[15:31:10.394] Resolving globals: FALSE
[15:31:10.395] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:10.395] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:10.396] - globals: [1] 'FUN'
[15:31:10.396] 
[15:31:10.396] getGlobalsAndPackages() ... DONE
[15:31:10.396]  - globals found/used: [n=1] 'FUN'
[15:31:10.397]  - needed namespaces: [n=0] 
[15:31:10.397] Finding globals ... DONE
[15:31:10.397]  - use_args: TRUE
[15:31:10.397]  - Getting '...' globals ...
[15:31:10.398] resolve() on list ...
[15:31:10.398]  recursive: 0
[15:31:10.399]  length: 1
[15:31:10.399]  elements: '...'
[15:31:10.399]  length: 0 (resolved future 1)
[15:31:10.399] resolve() on list ... DONE
[15:31:10.400]    - '...' content: [n=0] 
[15:31:10.400] List of 1
[15:31:10.400]  $ ...: list()
[15:31:10.400]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.400]  - attr(*, "where")=List of 1
[15:31:10.400]   ..$ ...:<environment: 0x0000019c82a490a0> 
[15:31:10.400]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.400]  - attr(*, "resolved")= logi TRUE
[15:31:10.400]  - attr(*, "total_size")= num NA
[15:31:10.405]  - Getting '...' globals ... DONE
[15:31:10.406] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.406] List of 2
[15:31:10.406]  $ ...future.FUN:function (object, ...)  
[15:31:10.406]  $ ...          : list()
[15:31:10.406]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.406]  - attr(*, "where")=List of 2
[15:31:10.406]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.406]   ..$ ...          :<environment: 0x0000019c82a490a0> 
[15:31:10.406]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.406]  - attr(*, "resolved")= logi FALSE
[15:31:10.406]  - attr(*, "total_size")= num 1240
[15:31:10.411] Packages to be attached in all futures: [n=0] 
[15:31:10.412] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.412] Number of futures (= number of chunks): 1
[15:31:10.412] Launching 1 futures (chunks) ...
[15:31:10.413] Chunk #1 of 1 ...
[15:31:10.413]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.413] getGlobalsAndPackages() ...
[15:31:10.413] Searching for globals...
[15:31:10.414] 
[15:31:10.415] Searching for globals ... DONE
[15:31:10.415] - globals: [0] <none>
[15:31:10.415] getGlobalsAndPackages() ... DONE
[15:31:10.415]    + additional globals found: [n=0] 
[15:31:10.416]    + additional namespaces needed: [n=0] 
[15:31:10.416]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.416]  - seeds: <none>
[15:31:10.416]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.417] getGlobalsAndPackages() ...
[15:31:10.417] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.417] Resolving globals: FALSE
[15:31:10.418] Tweak future expression to call with '...' arguments ...
[15:31:10.418] {
[15:31:10.418]     do.call(function(...) {
[15:31:10.418]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.418]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.418]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.418]             on.exit(options(oopts), add = TRUE)
[15:31:10.418]         }
[15:31:10.418]         {
[15:31:10.418]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.418]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.418]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.418]             })
[15:31:10.418]         }
[15:31:10.418]     }, args = future.call.arguments)
[15:31:10.418] }
[15:31:10.419] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.419] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.420] 
[15:31:10.420] getGlobalsAndPackages() ... DONE
[15:31:10.421] run() for 'Future' ...
[15:31:10.421] - state: 'created'
[15:31:10.421] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:10.425] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.425] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.426]   - Field: 'label'
[15:31:10.426]   - Field: 'local'
[15:31:10.426]   - Field: 'owner'
[15:31:10.427]   - Field: 'envir'
[15:31:10.427]   - Field: 'packages'
[15:31:10.427]   - Field: 'gc'
[15:31:10.427]   - Field: 'conditions'
[15:31:10.428]   - Field: 'expr'
[15:31:10.428]   - Field: 'uuid'
[15:31:10.428]   - Field: 'seed'
[15:31:10.429]   - Field: 'version'
[15:31:10.429]   - Field: 'result'
[15:31:10.429]   - Field: 'asynchronous'
[15:31:10.429]   - Field: 'calls'
[15:31:10.430]   - Field: 'globals'
[15:31:10.430]   - Field: 'stdout'
[15:31:10.430]   - Field: 'earlySignal'
[15:31:10.430]   - Field: 'lazy'
[15:31:10.431]   - Field: 'state'
[15:31:10.431] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.431] - Launch lazy future ...
[15:31:10.432] Packages needed by the future expression (n = 0): <none>
[15:31:10.432] Packages needed by future strategies (n = 0): <none>
[15:31:10.433] {
[15:31:10.433]     {
[15:31:10.433]         {
[15:31:10.433]             ...future.startTime <- base::Sys.time()
[15:31:10.433]             {
[15:31:10.433]                 {
[15:31:10.433]                   {
[15:31:10.433]                     base::local({
[15:31:10.433]                       has_future <- base::requireNamespace("future", 
[15:31:10.433]                         quietly = TRUE)
[15:31:10.433]                       if (has_future) {
[15:31:10.433]                         ns <- base::getNamespace("future")
[15:31:10.433]                         version <- ns[[".package"]][["version"]]
[15:31:10.433]                         if (is.null(version)) 
[15:31:10.433]                           version <- utils::packageVersion("future")
[15:31:10.433]                       }
[15:31:10.433]                       else {
[15:31:10.433]                         version <- NULL
[15:31:10.433]                       }
[15:31:10.433]                       if (!has_future || version < "1.8.0") {
[15:31:10.433]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.433]                           "", base::R.version$version.string), 
[15:31:10.433]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.433]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.433]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.433]                             "release", "version")], collapse = " "), 
[15:31:10.433]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.433]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.433]                           info)
[15:31:10.433]                         info <- base::paste(info, collapse = "; ")
[15:31:10.433]                         if (!has_future) {
[15:31:10.433]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.433]                             info)
[15:31:10.433]                         }
[15:31:10.433]                         else {
[15:31:10.433]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.433]                             info, version)
[15:31:10.433]                         }
[15:31:10.433]                         base::stop(msg)
[15:31:10.433]                       }
[15:31:10.433]                     })
[15:31:10.433]                   }
[15:31:10.433]                   ...future.strategy.old <- future::plan("list")
[15:31:10.433]                   options(future.plan = NULL)
[15:31:10.433]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.433]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.433]                 }
[15:31:10.433]                 ...future.workdir <- getwd()
[15:31:10.433]             }
[15:31:10.433]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.433]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.433]         }
[15:31:10.433]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.433]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.433]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.433]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.433]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.433]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.433]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.433]             base::names(...future.oldOptions))
[15:31:10.433]     }
[15:31:10.433]     if (FALSE) {
[15:31:10.433]     }
[15:31:10.433]     else {
[15:31:10.433]         if (TRUE) {
[15:31:10.433]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.433]                 open = "w")
[15:31:10.433]         }
[15:31:10.433]         else {
[15:31:10.433]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.433]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.433]         }
[15:31:10.433]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.433]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.433]             base::sink(type = "output", split = FALSE)
[15:31:10.433]             base::close(...future.stdout)
[15:31:10.433]         }, add = TRUE)
[15:31:10.433]     }
[15:31:10.433]     ...future.frame <- base::sys.nframe()
[15:31:10.433]     ...future.conditions <- base::list()
[15:31:10.433]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.433]     if (FALSE) {
[15:31:10.433]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.433]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.433]     }
[15:31:10.433]     ...future.result <- base::tryCatch({
[15:31:10.433]         base::withCallingHandlers({
[15:31:10.433]             ...future.value <- base::withVisible(base::local({
[15:31:10.433]                 do.call(function(...) {
[15:31:10.433]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.433]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.433]                     ...future.globals.maxSize)) {
[15:31:10.433]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.433]                     on.exit(options(oopts), add = TRUE)
[15:31:10.433]                   }
[15:31:10.433]                   {
[15:31:10.433]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.433]                       FUN = function(jj) {
[15:31:10.433]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.433]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.433]                       })
[15:31:10.433]                   }
[15:31:10.433]                 }, args = future.call.arguments)
[15:31:10.433]             }))
[15:31:10.433]             future::FutureResult(value = ...future.value$value, 
[15:31:10.433]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.433]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.433]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.433]                     ...future.globalenv.names))
[15:31:10.433]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.433]         }, condition = base::local({
[15:31:10.433]             c <- base::c
[15:31:10.433]             inherits <- base::inherits
[15:31:10.433]             invokeRestart <- base::invokeRestart
[15:31:10.433]             length <- base::length
[15:31:10.433]             list <- base::list
[15:31:10.433]             seq.int <- base::seq.int
[15:31:10.433]             signalCondition <- base::signalCondition
[15:31:10.433]             sys.calls <- base::sys.calls
[15:31:10.433]             `[[` <- base::`[[`
[15:31:10.433]             `+` <- base::`+`
[15:31:10.433]             `<<-` <- base::`<<-`
[15:31:10.433]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.433]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.433]                   3L)]
[15:31:10.433]             }
[15:31:10.433]             function(cond) {
[15:31:10.433]                 is_error <- inherits(cond, "error")
[15:31:10.433]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.433]                   NULL)
[15:31:10.433]                 if (is_error) {
[15:31:10.433]                   sessionInformation <- function() {
[15:31:10.433]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.433]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.433]                       search = base::search(), system = base::Sys.info())
[15:31:10.433]                   }
[15:31:10.433]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.433]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.433]                     cond$call), session = sessionInformation(), 
[15:31:10.433]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.433]                   signalCondition(cond)
[15:31:10.433]                 }
[15:31:10.433]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.433]                 "immediateCondition"))) {
[15:31:10.433]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.433]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.433]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.433]                   if (TRUE && !signal) {
[15:31:10.433]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.433]                     {
[15:31:10.433]                       inherits <- base::inherits
[15:31:10.433]                       invokeRestart <- base::invokeRestart
[15:31:10.433]                       is.null <- base::is.null
[15:31:10.433]                       muffled <- FALSE
[15:31:10.433]                       if (inherits(cond, "message")) {
[15:31:10.433]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.433]                         if (muffled) 
[15:31:10.433]                           invokeRestart("muffleMessage")
[15:31:10.433]                       }
[15:31:10.433]                       else if (inherits(cond, "warning")) {
[15:31:10.433]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.433]                         if (muffled) 
[15:31:10.433]                           invokeRestart("muffleWarning")
[15:31:10.433]                       }
[15:31:10.433]                       else if (inherits(cond, "condition")) {
[15:31:10.433]                         if (!is.null(pattern)) {
[15:31:10.433]                           computeRestarts <- base::computeRestarts
[15:31:10.433]                           grepl <- base::grepl
[15:31:10.433]                           restarts <- computeRestarts(cond)
[15:31:10.433]                           for (restart in restarts) {
[15:31:10.433]                             name <- restart$name
[15:31:10.433]                             if (is.null(name)) 
[15:31:10.433]                               next
[15:31:10.433]                             if (!grepl(pattern, name)) 
[15:31:10.433]                               next
[15:31:10.433]                             invokeRestart(restart)
[15:31:10.433]                             muffled <- TRUE
[15:31:10.433]                             break
[15:31:10.433]                           }
[15:31:10.433]                         }
[15:31:10.433]                       }
[15:31:10.433]                       invisible(muffled)
[15:31:10.433]                     }
[15:31:10.433]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.433]                   }
[15:31:10.433]                 }
[15:31:10.433]                 else {
[15:31:10.433]                   if (TRUE) {
[15:31:10.433]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.433]                     {
[15:31:10.433]                       inherits <- base::inherits
[15:31:10.433]                       invokeRestart <- base::invokeRestart
[15:31:10.433]                       is.null <- base::is.null
[15:31:10.433]                       muffled <- FALSE
[15:31:10.433]                       if (inherits(cond, "message")) {
[15:31:10.433]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.433]                         if (muffled) 
[15:31:10.433]                           invokeRestart("muffleMessage")
[15:31:10.433]                       }
[15:31:10.433]                       else if (inherits(cond, "warning")) {
[15:31:10.433]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.433]                         if (muffled) 
[15:31:10.433]                           invokeRestart("muffleWarning")
[15:31:10.433]                       }
[15:31:10.433]                       else if (inherits(cond, "condition")) {
[15:31:10.433]                         if (!is.null(pattern)) {
[15:31:10.433]                           computeRestarts <- base::computeRestarts
[15:31:10.433]                           grepl <- base::grepl
[15:31:10.433]                           restarts <- computeRestarts(cond)
[15:31:10.433]                           for (restart in restarts) {
[15:31:10.433]                             name <- restart$name
[15:31:10.433]                             if (is.null(name)) 
[15:31:10.433]                               next
[15:31:10.433]                             if (!grepl(pattern, name)) 
[15:31:10.433]                               next
[15:31:10.433]                             invokeRestart(restart)
[15:31:10.433]                             muffled <- TRUE
[15:31:10.433]                             break
[15:31:10.433]                           }
[15:31:10.433]                         }
[15:31:10.433]                       }
[15:31:10.433]                       invisible(muffled)
[15:31:10.433]                     }
[15:31:10.433]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.433]                   }
[15:31:10.433]                 }
[15:31:10.433]             }
[15:31:10.433]         }))
[15:31:10.433]     }, error = function(ex) {
[15:31:10.433]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.433]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.433]                 ...future.rng), started = ...future.startTime, 
[15:31:10.433]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.433]             version = "1.8"), class = "FutureResult")
[15:31:10.433]     }, finally = {
[15:31:10.433]         if (!identical(...future.workdir, getwd())) 
[15:31:10.433]             setwd(...future.workdir)
[15:31:10.433]         {
[15:31:10.433]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.433]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.433]             }
[15:31:10.433]             base::options(...future.oldOptions)
[15:31:10.433]             if (.Platform$OS.type == "windows") {
[15:31:10.433]                 old_names <- names(...future.oldEnvVars)
[15:31:10.433]                 envs <- base::Sys.getenv()
[15:31:10.433]                 names <- names(envs)
[15:31:10.433]                 common <- intersect(names, old_names)
[15:31:10.433]                 added <- setdiff(names, old_names)
[15:31:10.433]                 removed <- setdiff(old_names, names)
[15:31:10.433]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.433]                   envs[common]]
[15:31:10.433]                 NAMES <- toupper(changed)
[15:31:10.433]                 args <- list()
[15:31:10.433]                 for (kk in seq_along(NAMES)) {
[15:31:10.433]                   name <- changed[[kk]]
[15:31:10.433]                   NAME <- NAMES[[kk]]
[15:31:10.433]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.433]                     next
[15:31:10.433]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.433]                 }
[15:31:10.433]                 NAMES <- toupper(added)
[15:31:10.433]                 for (kk in seq_along(NAMES)) {
[15:31:10.433]                   name <- added[[kk]]
[15:31:10.433]                   NAME <- NAMES[[kk]]
[15:31:10.433]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.433]                     next
[15:31:10.433]                   args[[name]] <- ""
[15:31:10.433]                 }
[15:31:10.433]                 NAMES <- toupper(removed)
[15:31:10.433]                 for (kk in seq_along(NAMES)) {
[15:31:10.433]                   name <- removed[[kk]]
[15:31:10.433]                   NAME <- NAMES[[kk]]
[15:31:10.433]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.433]                     next
[15:31:10.433]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.433]                 }
[15:31:10.433]                 if (length(args) > 0) 
[15:31:10.433]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.433]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.433]             }
[15:31:10.433]             else {
[15:31:10.433]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.433]             }
[15:31:10.433]             {
[15:31:10.433]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.433]                   0L) {
[15:31:10.433]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.433]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.433]                   base::options(opts)
[15:31:10.433]                 }
[15:31:10.433]                 {
[15:31:10.433]                   {
[15:31:10.433]                     NULL
[15:31:10.433]                     RNGkind("Mersenne-Twister")
[15:31:10.433]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.433]                       inherits = FALSE)
[15:31:10.433]                   }
[15:31:10.433]                   options(future.plan = NULL)
[15:31:10.433]                   if (is.na(NA_character_)) 
[15:31:10.433]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.433]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.433]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.433]                     .init = FALSE)
[15:31:10.433]                 }
[15:31:10.433]             }
[15:31:10.433]         }
[15:31:10.433]     })
[15:31:10.433]     if (TRUE) {
[15:31:10.433]         base::sink(type = "output", split = FALSE)
[15:31:10.433]         if (TRUE) {
[15:31:10.433]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.433]         }
[15:31:10.433]         else {
[15:31:10.433]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.433]         }
[15:31:10.433]         base::close(...future.stdout)
[15:31:10.433]         ...future.stdout <- NULL
[15:31:10.433]     }
[15:31:10.433]     ...future.result$conditions <- ...future.conditions
[15:31:10.433]     ...future.result$finished <- base::Sys.time()
[15:31:10.433]     ...future.result
[15:31:10.433] }
[15:31:10.439] assign_globals() ...
[15:31:10.439] List of 5
[15:31:10.439]  $ ...future.FUN            :function (object, ...)  
[15:31:10.439]  $ future.call.arguments    : list()
[15:31:10.439]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.439]  $ ...future.elements_ii    :List of 3
[15:31:10.439]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:10.439]   .. ..$ breaks: num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.439]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.439]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:10.439]   .. ..$ breaks: num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.439]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.439]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:10.439]   .. ..$ breaks: num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.439]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.439]  $ ...future.seeds_ii       : NULL
[15:31:10.439]  $ ...future.globals.maxSize: NULL
[15:31:10.439]  - attr(*, "where")=List of 5
[15:31:10.439]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.439]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.439]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.439]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.439]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.439]  - attr(*, "resolved")= logi FALSE
[15:31:10.439]  - attr(*, "total_size")= num 1240
[15:31:10.439]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.439]  - attr(*, "already-done")= logi TRUE
[15:31:10.454] - copied '...future.FUN' to environment
[15:31:10.454] - copied 'future.call.arguments' to environment
[15:31:10.455] - copied '...future.elements_ii' to environment
[15:31:10.457] - copied '...future.seeds_ii' to environment
[15:31:10.458] - copied '...future.globals.maxSize' to environment
[15:31:10.458] assign_globals() ... done
[15:31:10.458] plan(): Setting new future strategy stack:
[15:31:10.459] List of future strategies:
[15:31:10.459] 1. sequential:
[15:31:10.459]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.459]    - tweaked: FALSE
[15:31:10.459]    - call: NULL
[15:31:10.460] plan(): nbrOfWorkers() = 1
[15:31:10.463] plan(): Setting new future strategy stack:
[15:31:10.463] List of future strategies:
[15:31:10.463] 1. multisession:
[15:31:10.463]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.463]    - tweaked: FALSE
[15:31:10.463]    - call: plan(strategy)
[15:31:10.467] plan(): nbrOfWorkers() = 1
[15:31:10.467] SequentialFuture started (and completed)
[15:31:10.467] - Launch lazy future ... done
[15:31:10.467] run() for 'SequentialFuture' ... done
[15:31:10.468] Created future:
[15:31:10.468] SequentialFuture:
[15:31:10.468] Label: 'future_by-1'
[15:31:10.468] Expression:
[15:31:10.468] {
[15:31:10.468]     do.call(function(...) {
[15:31:10.468]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.468]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.468]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.468]             on.exit(options(oopts), add = TRUE)
[15:31:10.468]         }
[15:31:10.468]         {
[15:31:10.468]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.468]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.468]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.468]             })
[15:31:10.468]         }
[15:31:10.468]     }, args = future.call.arguments)
[15:31:10.468] }
[15:31:10.468] Lazy evaluation: FALSE
[15:31:10.468] Asynchronous evaluation: FALSE
[15:31:10.468] Local evaluation: TRUE
[15:31:10.468] Environment: R_GlobalEnv
[15:31:10.468] Capture standard output: TRUE
[15:31:10.468] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.468] Globals: 5 objects totaling 3.79 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 2.58 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.468] Packages: <none>
[15:31:10.468] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.468] Resolved: TRUE
[15:31:10.468] Value: 4.62 KiB of class 'list'
[15:31:10.468] Early signaling: FALSE
[15:31:10.468] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.468] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.470] Chunk #1 of 1 ... DONE
[15:31:10.470] Launching 1 futures (chunks) ... DONE
[15:31:10.471] Resolving 1 futures (chunks) ...
[15:31:10.471] resolve() on list ...
[15:31:10.471]  recursive: 0
[15:31:10.471]  length: 1
[15:31:10.471] 
[15:31:10.472] resolved() for 'SequentialFuture' ...
[15:31:10.472] - state: 'finished'
[15:31:10.472] - run: TRUE
[15:31:10.472] - result: 'FutureResult'
[15:31:10.473] resolved() for 'SequentialFuture' ... done
[15:31:10.473] Future #1
[15:31:10.473] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.474] - nx: 1
[15:31:10.474] - relay: TRUE
[15:31:10.474] - stdout: TRUE
[15:31:10.474] - signal: TRUE
[15:31:10.474] - resignal: FALSE
[15:31:10.475] - force: TRUE
[15:31:10.475] - relayed: [n=1] FALSE
[15:31:10.475] - queued futures: [n=1] FALSE
[15:31:10.475]  - until=1
[15:31:10.475]  - relaying element #1
[15:31:10.476] - relayed: [n=1] TRUE
[15:31:10.476] - queued futures: [n=1] TRUE
[15:31:10.476] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.476]  length: 0 (resolved future 1)
[15:31:10.477] Relaying remaining futures
[15:31:10.477] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.477] - nx: 1
[15:31:10.477] - relay: TRUE
[15:31:10.477] - stdout: TRUE
[15:31:10.478] - signal: TRUE
[15:31:10.478] - resignal: FALSE
[15:31:10.478] - force: TRUE
[15:31:10.478] - relayed: [n=1] TRUE
[15:31:10.479] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.479] - relayed: [n=1] TRUE
[15:31:10.479] - queued futures: [n=1] TRUE
[15:31:10.479] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.480] resolve() on list ... DONE
[15:31:10.480]  - Number of value chunks collected: 1
[15:31:10.480] Resolving 1 futures (chunks) ... DONE
[15:31:10.480] Reducing values from 1 chunks ...
[15:31:10.481]  - Number of values collected after concatenation: 3
[15:31:10.481]  - Number of values expected: 3
[15:31:10.481] Reducing values from 1 chunks ... DONE
[15:31:10.481] future_lapply() ... DONE
[15:31:10.481] future_by_internal() ... DONE
[15:31:10.482] future_by_internal() ...
[15:31:10.483] future_lapply() ...
[15:31:10.486] Number of chunks: 1
[15:31:10.487] getGlobalsAndPackagesXApply() ...
[15:31:10.487]  - future.globals: TRUE
[15:31:10.487] getGlobalsAndPackages() ...
[15:31:10.487] Searching for globals...
[15:31:10.489] - globals found: [2] 'FUN', 'UseMethod'
[15:31:10.489] Searching for globals ... DONE
[15:31:10.490] Resolving globals: FALSE
[15:31:10.490] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:10.491] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:10.491] - globals: [1] 'FUN'
[15:31:10.491] 
[15:31:10.491] getGlobalsAndPackages() ... DONE
[15:31:10.492]  - globals found/used: [n=1] 'FUN'
[15:31:10.492]  - needed namespaces: [n=0] 
[15:31:10.492] Finding globals ... DONE
[15:31:10.492]  - use_args: TRUE
[15:31:10.493]  - Getting '...' globals ...
[15:31:10.493] resolve() on list ...
[15:31:10.493]  recursive: 0
[15:31:10.494]  length: 1
[15:31:10.494]  elements: '...'
[15:31:10.494]  length: 0 (resolved future 1)
[15:31:10.494] resolve() on list ... DONE
[15:31:10.495]    - '...' content: [n=1] 'digits'
[15:31:10.495] List of 1
[15:31:10.495]  $ ...:List of 1
[15:31:10.495]   ..$ digits: int 2
[15:31:10.495]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.495]  - attr(*, "where")=List of 1
[15:31:10.495]   ..$ ...:<environment: 0x0000019c7f6116b8> 
[15:31:10.495]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.495]  - attr(*, "resolved")= logi TRUE
[15:31:10.495]  - attr(*, "total_size")= num NA
[15:31:10.499]  - Getting '...' globals ... DONE
[15:31:10.500] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.500] List of 2
[15:31:10.500]  $ ...future.FUN:function (object, ...)  
[15:31:10.500]  $ ...          :List of 1
[15:31:10.500]   ..$ digits: int 2
[15:31:10.500]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.500]  - attr(*, "where")=List of 2
[15:31:10.500]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.500]   ..$ ...          :<environment: 0x0000019c7f6116b8> 
[15:31:10.500]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.500]  - attr(*, "resolved")= logi FALSE
[15:31:10.500]  - attr(*, "total_size")= num 1296
[15:31:10.504] Packages to be attached in all futures: [n=0] 
[15:31:10.505] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.505] Number of futures (= number of chunks): 1
[15:31:10.505] Launching 1 futures (chunks) ...
[15:31:10.505] Chunk #1 of 1 ...
[15:31:10.506]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.506] getGlobalsAndPackages() ...
[15:31:10.506] Searching for globals...
[15:31:10.506] 
[15:31:10.506] Searching for globals ... DONE
[15:31:10.507] - globals: [0] <none>
[15:31:10.507] getGlobalsAndPackages() ... DONE
[15:31:10.507]    + additional globals found: [n=0] 
[15:31:10.507]    + additional namespaces needed: [n=0] 
[15:31:10.507]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.508]  - seeds: <none>
[15:31:10.508]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.508] getGlobalsAndPackages() ...
[15:31:10.508] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.508] Resolving globals: FALSE
[15:31:10.509] Tweak future expression to call with '...' arguments ...
[15:31:10.509] {
[15:31:10.509]     do.call(function(...) {
[15:31:10.509]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.509]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.509]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.509]             on.exit(options(oopts), add = TRUE)
[15:31:10.509]         }
[15:31:10.509]         {
[15:31:10.509]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.509]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.509]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.509]             })
[15:31:10.509]         }
[15:31:10.509]     }, args = future.call.arguments)
[15:31:10.509] }
[15:31:10.510] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.510] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.510] 
[15:31:10.511] getGlobalsAndPackages() ... DONE
[15:31:10.511] run() for 'Future' ...
[15:31:10.511] - state: 'created'
[15:31:10.512] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:10.514] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.514] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.514]   - Field: 'label'
[15:31:10.515]   - Field: 'local'
[15:31:10.515]   - Field: 'owner'
[15:31:10.515]   - Field: 'envir'
[15:31:10.515]   - Field: 'packages'
[15:31:10.516]   - Field: 'gc'
[15:31:10.516]   - Field: 'conditions'
[15:31:10.516]   - Field: 'expr'
[15:31:10.516]   - Field: 'uuid'
[15:31:10.517]   - Field: 'seed'
[15:31:10.517]   - Field: 'version'
[15:31:10.517]   - Field: 'result'
[15:31:10.517]   - Field: 'asynchronous'
[15:31:10.517]   - Field: 'calls'
[15:31:10.518]   - Field: 'globals'
[15:31:10.518]   - Field: 'stdout'
[15:31:10.518]   - Field: 'earlySignal'
[15:31:10.518]   - Field: 'lazy'
[15:31:10.519]   - Field: 'state'
[15:31:10.519] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.519] - Launch lazy future ...
[15:31:10.519] Packages needed by the future expression (n = 0): <none>
[15:31:10.520] Packages needed by future strategies (n = 0): <none>
[15:31:10.520] {
[15:31:10.520]     {
[15:31:10.520]         {
[15:31:10.520]             ...future.startTime <- base::Sys.time()
[15:31:10.520]             {
[15:31:10.520]                 {
[15:31:10.520]                   {
[15:31:10.520]                     base::local({
[15:31:10.520]                       has_future <- base::requireNamespace("future", 
[15:31:10.520]                         quietly = TRUE)
[15:31:10.520]                       if (has_future) {
[15:31:10.520]                         ns <- base::getNamespace("future")
[15:31:10.520]                         version <- ns[[".package"]][["version"]]
[15:31:10.520]                         if (is.null(version)) 
[15:31:10.520]                           version <- utils::packageVersion("future")
[15:31:10.520]                       }
[15:31:10.520]                       else {
[15:31:10.520]                         version <- NULL
[15:31:10.520]                       }
[15:31:10.520]                       if (!has_future || version < "1.8.0") {
[15:31:10.520]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.520]                           "", base::R.version$version.string), 
[15:31:10.520]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.520]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.520]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.520]                             "release", "version")], collapse = " "), 
[15:31:10.520]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.520]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.520]                           info)
[15:31:10.520]                         info <- base::paste(info, collapse = "; ")
[15:31:10.520]                         if (!has_future) {
[15:31:10.520]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.520]                             info)
[15:31:10.520]                         }
[15:31:10.520]                         else {
[15:31:10.520]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.520]                             info, version)
[15:31:10.520]                         }
[15:31:10.520]                         base::stop(msg)
[15:31:10.520]                       }
[15:31:10.520]                     })
[15:31:10.520]                   }
[15:31:10.520]                   ...future.strategy.old <- future::plan("list")
[15:31:10.520]                   options(future.plan = NULL)
[15:31:10.520]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.520]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.520]                 }
[15:31:10.520]                 ...future.workdir <- getwd()
[15:31:10.520]             }
[15:31:10.520]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.520]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.520]         }
[15:31:10.520]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.520]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.520]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.520]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.520]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.520]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.520]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.520]             base::names(...future.oldOptions))
[15:31:10.520]     }
[15:31:10.520]     if (FALSE) {
[15:31:10.520]     }
[15:31:10.520]     else {
[15:31:10.520]         if (TRUE) {
[15:31:10.520]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.520]                 open = "w")
[15:31:10.520]         }
[15:31:10.520]         else {
[15:31:10.520]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.520]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.520]         }
[15:31:10.520]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.520]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.520]             base::sink(type = "output", split = FALSE)
[15:31:10.520]             base::close(...future.stdout)
[15:31:10.520]         }, add = TRUE)
[15:31:10.520]     }
[15:31:10.520]     ...future.frame <- base::sys.nframe()
[15:31:10.520]     ...future.conditions <- base::list()
[15:31:10.520]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.520]     if (FALSE) {
[15:31:10.520]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.520]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.520]     }
[15:31:10.520]     ...future.result <- base::tryCatch({
[15:31:10.520]         base::withCallingHandlers({
[15:31:10.520]             ...future.value <- base::withVisible(base::local({
[15:31:10.520]                 do.call(function(...) {
[15:31:10.520]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.520]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.520]                     ...future.globals.maxSize)) {
[15:31:10.520]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.520]                     on.exit(options(oopts), add = TRUE)
[15:31:10.520]                   }
[15:31:10.520]                   {
[15:31:10.520]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.520]                       FUN = function(jj) {
[15:31:10.520]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.520]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.520]                       })
[15:31:10.520]                   }
[15:31:10.520]                 }, args = future.call.arguments)
[15:31:10.520]             }))
[15:31:10.520]             future::FutureResult(value = ...future.value$value, 
[15:31:10.520]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.520]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.520]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.520]                     ...future.globalenv.names))
[15:31:10.520]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.520]         }, condition = base::local({
[15:31:10.520]             c <- base::c
[15:31:10.520]             inherits <- base::inherits
[15:31:10.520]             invokeRestart <- base::invokeRestart
[15:31:10.520]             length <- base::length
[15:31:10.520]             list <- base::list
[15:31:10.520]             seq.int <- base::seq.int
[15:31:10.520]             signalCondition <- base::signalCondition
[15:31:10.520]             sys.calls <- base::sys.calls
[15:31:10.520]             `[[` <- base::`[[`
[15:31:10.520]             `+` <- base::`+`
[15:31:10.520]             `<<-` <- base::`<<-`
[15:31:10.520]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.520]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.520]                   3L)]
[15:31:10.520]             }
[15:31:10.520]             function(cond) {
[15:31:10.520]                 is_error <- inherits(cond, "error")
[15:31:10.520]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.520]                   NULL)
[15:31:10.520]                 if (is_error) {
[15:31:10.520]                   sessionInformation <- function() {
[15:31:10.520]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.520]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.520]                       search = base::search(), system = base::Sys.info())
[15:31:10.520]                   }
[15:31:10.520]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.520]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.520]                     cond$call), session = sessionInformation(), 
[15:31:10.520]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.520]                   signalCondition(cond)
[15:31:10.520]                 }
[15:31:10.520]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.520]                 "immediateCondition"))) {
[15:31:10.520]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.520]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.520]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.520]                   if (TRUE && !signal) {
[15:31:10.520]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.520]                     {
[15:31:10.520]                       inherits <- base::inherits
[15:31:10.520]                       invokeRestart <- base::invokeRestart
[15:31:10.520]                       is.null <- base::is.null
[15:31:10.520]                       muffled <- FALSE
[15:31:10.520]                       if (inherits(cond, "message")) {
[15:31:10.520]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.520]                         if (muffled) 
[15:31:10.520]                           invokeRestart("muffleMessage")
[15:31:10.520]                       }
[15:31:10.520]                       else if (inherits(cond, "warning")) {
[15:31:10.520]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.520]                         if (muffled) 
[15:31:10.520]                           invokeRestart("muffleWarning")
[15:31:10.520]                       }
[15:31:10.520]                       else if (inherits(cond, "condition")) {
[15:31:10.520]                         if (!is.null(pattern)) {
[15:31:10.520]                           computeRestarts <- base::computeRestarts
[15:31:10.520]                           grepl <- base::grepl
[15:31:10.520]                           restarts <- computeRestarts(cond)
[15:31:10.520]                           for (restart in restarts) {
[15:31:10.520]                             name <- restart$name
[15:31:10.520]                             if (is.null(name)) 
[15:31:10.520]                               next
[15:31:10.520]                             if (!grepl(pattern, name)) 
[15:31:10.520]                               next
[15:31:10.520]                             invokeRestart(restart)
[15:31:10.520]                             muffled <- TRUE
[15:31:10.520]                             break
[15:31:10.520]                           }
[15:31:10.520]                         }
[15:31:10.520]                       }
[15:31:10.520]                       invisible(muffled)
[15:31:10.520]                     }
[15:31:10.520]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.520]                   }
[15:31:10.520]                 }
[15:31:10.520]                 else {
[15:31:10.520]                   if (TRUE) {
[15:31:10.520]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.520]                     {
[15:31:10.520]                       inherits <- base::inherits
[15:31:10.520]                       invokeRestart <- base::invokeRestart
[15:31:10.520]                       is.null <- base::is.null
[15:31:10.520]                       muffled <- FALSE
[15:31:10.520]                       if (inherits(cond, "message")) {
[15:31:10.520]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.520]                         if (muffled) 
[15:31:10.520]                           invokeRestart("muffleMessage")
[15:31:10.520]                       }
[15:31:10.520]                       else if (inherits(cond, "warning")) {
[15:31:10.520]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.520]                         if (muffled) 
[15:31:10.520]                           invokeRestart("muffleWarning")
[15:31:10.520]                       }
[15:31:10.520]                       else if (inherits(cond, "condition")) {
[15:31:10.520]                         if (!is.null(pattern)) {
[15:31:10.520]                           computeRestarts <- base::computeRestarts
[15:31:10.520]                           grepl <- base::grepl
[15:31:10.520]                           restarts <- computeRestarts(cond)
[15:31:10.520]                           for (restart in restarts) {
[15:31:10.520]                             name <- restart$name
[15:31:10.520]                             if (is.null(name)) 
[15:31:10.520]                               next
[15:31:10.520]                             if (!grepl(pattern, name)) 
[15:31:10.520]                               next
[15:31:10.520]                             invokeRestart(restart)
[15:31:10.520]                             muffled <- TRUE
[15:31:10.520]                             break
[15:31:10.520]                           }
[15:31:10.520]                         }
[15:31:10.520]                       }
[15:31:10.520]                       invisible(muffled)
[15:31:10.520]                     }
[15:31:10.520]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.520]                   }
[15:31:10.520]                 }
[15:31:10.520]             }
[15:31:10.520]         }))
[15:31:10.520]     }, error = function(ex) {
[15:31:10.520]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.520]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.520]                 ...future.rng), started = ...future.startTime, 
[15:31:10.520]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.520]             version = "1.8"), class = "FutureResult")
[15:31:10.520]     }, finally = {
[15:31:10.520]         if (!identical(...future.workdir, getwd())) 
[15:31:10.520]             setwd(...future.workdir)
[15:31:10.520]         {
[15:31:10.520]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.520]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.520]             }
[15:31:10.520]             base::options(...future.oldOptions)
[15:31:10.520]             if (.Platform$OS.type == "windows") {
[15:31:10.520]                 old_names <- names(...future.oldEnvVars)
[15:31:10.520]                 envs <- base::Sys.getenv()
[15:31:10.520]                 names <- names(envs)
[15:31:10.520]                 common <- intersect(names, old_names)
[15:31:10.520]                 added <- setdiff(names, old_names)
[15:31:10.520]                 removed <- setdiff(old_names, names)
[15:31:10.520]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.520]                   envs[common]]
[15:31:10.520]                 NAMES <- toupper(changed)
[15:31:10.520]                 args <- list()
[15:31:10.520]                 for (kk in seq_along(NAMES)) {
[15:31:10.520]                   name <- changed[[kk]]
[15:31:10.520]                   NAME <- NAMES[[kk]]
[15:31:10.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.520]                     next
[15:31:10.520]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.520]                 }
[15:31:10.520]                 NAMES <- toupper(added)
[15:31:10.520]                 for (kk in seq_along(NAMES)) {
[15:31:10.520]                   name <- added[[kk]]
[15:31:10.520]                   NAME <- NAMES[[kk]]
[15:31:10.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.520]                     next
[15:31:10.520]                   args[[name]] <- ""
[15:31:10.520]                 }
[15:31:10.520]                 NAMES <- toupper(removed)
[15:31:10.520]                 for (kk in seq_along(NAMES)) {
[15:31:10.520]                   name <- removed[[kk]]
[15:31:10.520]                   NAME <- NAMES[[kk]]
[15:31:10.520]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.520]                     next
[15:31:10.520]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.520]                 }
[15:31:10.520]                 if (length(args) > 0) 
[15:31:10.520]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.520]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.520]             }
[15:31:10.520]             else {
[15:31:10.520]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.520]             }
[15:31:10.520]             {
[15:31:10.520]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.520]                   0L) {
[15:31:10.520]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.520]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.520]                   base::options(opts)
[15:31:10.520]                 }
[15:31:10.520]                 {
[15:31:10.520]                   {
[15:31:10.520]                     NULL
[15:31:10.520]                     RNGkind("Mersenne-Twister")
[15:31:10.520]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.520]                       inherits = FALSE)
[15:31:10.520]                   }
[15:31:10.520]                   options(future.plan = NULL)
[15:31:10.520]                   if (is.na(NA_character_)) 
[15:31:10.520]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.520]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.520]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.520]                     .init = FALSE)
[15:31:10.520]                 }
[15:31:10.520]             }
[15:31:10.520]         }
[15:31:10.520]     })
[15:31:10.520]     if (TRUE) {
[15:31:10.520]         base::sink(type = "output", split = FALSE)
[15:31:10.520]         if (TRUE) {
[15:31:10.520]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.520]         }
[15:31:10.520]         else {
[15:31:10.520]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.520]         }
[15:31:10.520]         base::close(...future.stdout)
[15:31:10.520]         ...future.stdout <- NULL
[15:31:10.520]     }
[15:31:10.520]     ...future.result$conditions <- ...future.conditions
[15:31:10.520]     ...future.result$finished <- base::Sys.time()
[15:31:10.520]     ...future.result
[15:31:10.520] }
[15:31:10.526] assign_globals() ...
[15:31:10.526] List of 5
[15:31:10.526]  $ ...future.FUN            :function (object, ...)  
[15:31:10.526]  $ future.call.arguments    :List of 1
[15:31:10.526]   ..$ digits: int 2
[15:31:10.526]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.526]  $ ...future.elements_ii    :List of 6
[15:31:10.526]   ..$ : num [1:9] 26 30 54 25 70 52 51 26 67
[15:31:10.526]   ..$ : num [1:9] 27 14 29 19 29 31 41 20 44
[15:31:10.526]   ..$ : num [1:9] 18 21 29 17 12 18 35 30 36
[15:31:10.526]   ..$ : num [1:9] 42 26 19 16 39 28 21 39 29
[15:31:10.526]   ..$ : num [1:9] 36 21 24 18 10 43 28 15 26
[15:31:10.526]   ..$ : num [1:9] 20 21 24 17 13 15 15 16 28
[15:31:10.526]  $ ...future.seeds_ii       : NULL
[15:31:10.526]  $ ...future.globals.maxSize: NULL
[15:31:10.526]  - attr(*, "where")=List of 5
[15:31:10.526]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.526]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.526]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.526]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.526]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.526]  - attr(*, "resolved")= logi FALSE
[15:31:10.526]  - attr(*, "total_size")= num 1296
[15:31:10.526]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.526]  - attr(*, "already-done")= logi TRUE
[15:31:10.538] - copied '...future.FUN' to environment
[15:31:10.538] - copied 'future.call.arguments' to environment
[15:31:10.538] - copied '...future.elements_ii' to environment
[15:31:10.538] - copied '...future.seeds_ii' to environment
[15:31:10.539] - copied '...future.globals.maxSize' to environment
[15:31:10.539] assign_globals() ... done
[15:31:10.539] plan(): Setting new future strategy stack:
[15:31:10.540] List of future strategies:
[15:31:10.540] 1. sequential:
[15:31:10.540]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.540]    - tweaked: FALSE
[15:31:10.540]    - call: NULL
[15:31:10.540] plan(): nbrOfWorkers() = 1
[15:31:10.543] plan(): Setting new future strategy stack:
[15:31:10.543] List of future strategies:
[15:31:10.543] 1. multisession:
[15:31:10.543]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.543]    - tweaked: FALSE
[15:31:10.543]    - call: plan(strategy)
[15:31:10.547] plan(): nbrOfWorkers() = 1
[15:31:10.547] SequentialFuture started (and completed)
[15:31:10.548] - Launch lazy future ... done
[15:31:10.548] run() for 'SequentialFuture' ... done
[15:31:10.548] Created future:
[15:31:10.548] SequentialFuture:
[15:31:10.548] Label: 'future_by-1'
[15:31:10.548] Expression:
[15:31:10.548] {
[15:31:10.548]     do.call(function(...) {
[15:31:10.548]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.548]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.548]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.548]             on.exit(options(oopts), add = TRUE)
[15:31:10.548]         }
[15:31:10.548]         {
[15:31:10.548]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.548]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.548]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.548]             })
[15:31:10.548]         }
[15:31:10.548]     }, args = future.call.arguments)
[15:31:10.548] }
[15:31:10.548] Lazy evaluation: FALSE
[15:31:10.548] Asynchronous evaluation: FALSE
[15:31:10.548] Local evaluation: TRUE
[15:31:10.548] Environment: R_GlobalEnv
[15:31:10.548] Capture standard output: TRUE
[15:31:10.548] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.548] Globals: 5 objects totaling 2.30 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 1.03 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.548] Packages: <none>
[15:31:10.548] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.548] Resolved: TRUE
[15:31:10.548] Value: 5.48 KiB of class 'list'
[15:31:10.548] Early signaling: FALSE
[15:31:10.548] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.548] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.550] Chunk #1 of 1 ... DONE
[15:31:10.551] Launching 1 futures (chunks) ... DONE
[15:31:10.551] Resolving 1 futures (chunks) ...
[15:31:10.551] resolve() on list ...
[15:31:10.551]  recursive: 0
[15:31:10.551]  length: 1
[15:31:10.552] 
[15:31:10.552] resolved() for 'SequentialFuture' ...
[15:31:10.552] - state: 'finished'
[15:31:10.552] - run: TRUE
[15:31:10.553] - result: 'FutureResult'
[15:31:10.553] resolved() for 'SequentialFuture' ... done
[15:31:10.553] Future #1
[15:31:10.553] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.554] - nx: 1
[15:31:10.554] - relay: TRUE
[15:31:10.554] - stdout: TRUE
[15:31:10.554] - signal: TRUE
[15:31:10.555] - resignal: FALSE
[15:31:10.555] - force: TRUE
[15:31:10.555] - relayed: [n=1] FALSE
[15:31:10.555] - queued futures: [n=1] FALSE
[15:31:10.555]  - until=1
[15:31:10.556]  - relaying element #1
[15:31:10.556] - relayed: [n=1] TRUE
[15:31:10.556] - queued futures: [n=1] TRUE
[15:31:10.556] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.557]  length: 0 (resolved future 1)
[15:31:10.557] Relaying remaining futures
[15:31:10.557] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.557] - nx: 1
[15:31:10.558] - relay: TRUE
[15:31:10.558] - stdout: TRUE
[15:31:10.558] - signal: TRUE
[15:31:10.558] - resignal: FALSE
[15:31:10.558] - force: TRUE
[15:31:10.559] - relayed: [n=1] TRUE
[15:31:10.559] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.559] - relayed: [n=1] TRUE
[15:31:10.559] - queued futures: [n=1] TRUE
[15:31:10.560] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.560] resolve() on list ... DONE
[15:31:10.560]  - Number of value chunks collected: 1
[15:31:10.560] Resolving 1 futures (chunks) ... DONE
[15:31:10.561] Reducing values from 1 chunks ...
[15:31:10.561]  - Number of values collected after concatenation: 6
[15:31:10.561]  - Number of values expected: 6
[15:31:10.561] Reducing values from 1 chunks ... DONE
[15:31:10.561] future_lapply() ... DONE
[15:31:10.562] future_by_internal() ... DONE
[15:31:10.564] future_by_internal() ...
[15:31:10.565] future_lapply() ...
[15:31:10.570] Number of chunks: 1
[15:31:10.570] getGlobalsAndPackagesXApply() ...
[15:31:10.570]  - future.globals: TRUE
[15:31:10.571] getGlobalsAndPackages() ...
[15:31:10.571] Searching for globals...
[15:31:10.574] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:10.574] Searching for globals ... DONE
[15:31:10.575] Resolving globals: FALSE
[15:31:10.576] The total size of the 1 globals is 5.20 KiB (5328 bytes)
[15:31:10.577] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 5.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (5.20 KiB of class 'function')
[15:31:10.577] - globals: [1] 'FUN'
[15:31:10.577] - packages: [1] 'stats'
[15:31:10.578] getGlobalsAndPackages() ... DONE
[15:31:10.578]  - globals found/used: [n=1] 'FUN'
[15:31:10.578]  - needed namespaces: [n=1] 'stats'
[15:31:10.578] Finding globals ... DONE
[15:31:10.579]  - use_args: TRUE
[15:31:10.579]  - Getting '...' globals ...
[15:31:10.580] resolve() on list ...
[15:31:10.580]  recursive: 0
[15:31:10.580]  length: 1
[15:31:10.580]  elements: '...'
[15:31:10.581]  length: 0 (resolved future 1)
[15:31:10.581] resolve() on list ... DONE
[15:31:10.581]    - '...' content: [n=1] 'singular.ok'
[15:31:10.582] List of 1
[15:31:10.582]  $ ...:List of 1
[15:31:10.582]   ..$ singular.ok: logi FALSE
[15:31:10.582]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.582]  - attr(*, "where")=List of 1
[15:31:10.582]   ..$ ...:<environment: 0x0000019c82b7c370> 
[15:31:10.582]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.582]  - attr(*, "resolved")= logi TRUE
[15:31:10.582]  - attr(*, "total_size")= num NA
[15:31:10.587]  - Getting '...' globals ... DONE
[15:31:10.588] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.588] List of 2
[15:31:10.588]  $ ...future.FUN:function (x, ...)  
[15:31:10.588]  $ ...          :List of 1
[15:31:10.588]   ..$ singular.ok: logi FALSE
[15:31:10.588]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.588]  - attr(*, "where")=List of 2
[15:31:10.588]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.588]   ..$ ...          :<environment: 0x0000019c82b7c370> 
[15:31:10.588]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.588]  - attr(*, "resolved")= logi FALSE
[15:31:10.588]  - attr(*, "total_size")= num 5384
[15:31:10.594] Packages to be attached in all futures: [n=1] 'stats'
[15:31:10.594] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.595] Number of futures (= number of chunks): 1
[15:31:10.595] Launching 1 futures (chunks) ...
[15:31:10.595] Chunk #1 of 1 ...
[15:31:10.596]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.596] getGlobalsAndPackages() ...
[15:31:10.596] Searching for globals...
[15:31:10.597] 
[15:31:10.597] Searching for globals ... DONE
[15:31:10.597] - globals: [0] <none>
[15:31:10.598] getGlobalsAndPackages() ... DONE
[15:31:10.598]    + additional globals found: [n=0] 
[15:31:10.598]    + additional namespaces needed: [n=0] 
[15:31:10.598]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.599]  - seeds: <none>
[15:31:10.599]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.599] getGlobalsAndPackages() ...
[15:31:10.599] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.600] Resolving globals: FALSE
[15:31:10.600] Tweak future expression to call with '...' arguments ...
[15:31:10.600] {
[15:31:10.600]     do.call(function(...) {
[15:31:10.600]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.600]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.600]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.600]             on.exit(options(oopts), add = TRUE)
[15:31:10.600]         }
[15:31:10.600]         {
[15:31:10.600]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.600]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.600]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.600]             })
[15:31:10.600]         }
[15:31:10.600]     }, args = future.call.arguments)
[15:31:10.600] }
[15:31:10.601] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.601] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.602] 
[15:31:10.602] getGlobalsAndPackages() ... DONE
[15:31:10.603] run() for 'Future' ...
[15:31:10.603] - state: 'created'
[15:31:10.603] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:10.607] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.608] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.608]   - Field: 'label'
[15:31:10.608]   - Field: 'local'
[15:31:10.608]   - Field: 'owner'
[15:31:10.609]   - Field: 'envir'
[15:31:10.609]   - Field: 'packages'
[15:31:10.609]   - Field: 'gc'
[15:31:10.610]   - Field: 'conditions'
[15:31:10.610]   - Field: 'expr'
[15:31:10.610]   - Field: 'uuid'
[15:31:10.610]   - Field: 'seed'
[15:31:10.611]   - Field: 'version'
[15:31:10.611]   - Field: 'result'
[15:31:10.611]   - Field: 'asynchronous'
[15:31:10.612]   - Field: 'calls'
[15:31:10.612]   - Field: 'globals'
[15:31:10.612]   - Field: 'stdout'
[15:31:10.613]   - Field: 'earlySignal'
[15:31:10.613]   - Field: 'lazy'
[15:31:10.613]   - Field: 'state'
[15:31:10.613] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.614] - Launch lazy future ...
[15:31:10.614] Packages needed by the future expression (n = 1): 'stats'
[15:31:10.614] Packages needed by future strategies (n = 0): <none>
[15:31:10.616] {
[15:31:10.616]     {
[15:31:10.616]         {
[15:31:10.616]             ...future.startTime <- base::Sys.time()
[15:31:10.616]             {
[15:31:10.616]                 {
[15:31:10.616]                   {
[15:31:10.616]                     {
[15:31:10.616]                       base::local({
[15:31:10.616]                         has_future <- base::requireNamespace("future", 
[15:31:10.616]                           quietly = TRUE)
[15:31:10.616]                         if (has_future) {
[15:31:10.616]                           ns <- base::getNamespace("future")
[15:31:10.616]                           version <- ns[[".package"]][["version"]]
[15:31:10.616]                           if (is.null(version)) 
[15:31:10.616]                             version <- utils::packageVersion("future")
[15:31:10.616]                         }
[15:31:10.616]                         else {
[15:31:10.616]                           version <- NULL
[15:31:10.616]                         }
[15:31:10.616]                         if (!has_future || version < "1.8.0") {
[15:31:10.616]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.616]                             "", base::R.version$version.string), 
[15:31:10.616]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:10.616]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.616]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.616]                               "release", "version")], collapse = " "), 
[15:31:10.616]                             hostname = base::Sys.info()[["nodename"]])
[15:31:10.616]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.616]                             info)
[15:31:10.616]                           info <- base::paste(info, collapse = "; ")
[15:31:10.616]                           if (!has_future) {
[15:31:10.616]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.616]                               info)
[15:31:10.616]                           }
[15:31:10.616]                           else {
[15:31:10.616]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.616]                               info, version)
[15:31:10.616]                           }
[15:31:10.616]                           base::stop(msg)
[15:31:10.616]                         }
[15:31:10.616]                       })
[15:31:10.616]                     }
[15:31:10.616]                     base::local({
[15:31:10.616]                       for (pkg in "stats") {
[15:31:10.616]                         base::loadNamespace(pkg)
[15:31:10.616]                         base::library(pkg, character.only = TRUE)
[15:31:10.616]                       }
[15:31:10.616]                     })
[15:31:10.616]                   }
[15:31:10.616]                   ...future.strategy.old <- future::plan("list")
[15:31:10.616]                   options(future.plan = NULL)
[15:31:10.616]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.616]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.616]                 }
[15:31:10.616]                 ...future.workdir <- getwd()
[15:31:10.616]             }
[15:31:10.616]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.616]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.616]         }
[15:31:10.616]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.616]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.616]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.616]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.616]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.616]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.616]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.616]             base::names(...future.oldOptions))
[15:31:10.616]     }
[15:31:10.616]     if (FALSE) {
[15:31:10.616]     }
[15:31:10.616]     else {
[15:31:10.616]         if (TRUE) {
[15:31:10.616]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.616]                 open = "w")
[15:31:10.616]         }
[15:31:10.616]         else {
[15:31:10.616]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.616]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.616]         }
[15:31:10.616]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.616]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.616]             base::sink(type = "output", split = FALSE)
[15:31:10.616]             base::close(...future.stdout)
[15:31:10.616]         }, add = TRUE)
[15:31:10.616]     }
[15:31:10.616]     ...future.frame <- base::sys.nframe()
[15:31:10.616]     ...future.conditions <- base::list()
[15:31:10.616]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.616]     if (FALSE) {
[15:31:10.616]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.616]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.616]     }
[15:31:10.616]     ...future.result <- base::tryCatch({
[15:31:10.616]         base::withCallingHandlers({
[15:31:10.616]             ...future.value <- base::withVisible(base::local({
[15:31:10.616]                 do.call(function(...) {
[15:31:10.616]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.616]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.616]                     ...future.globals.maxSize)) {
[15:31:10.616]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.616]                     on.exit(options(oopts), add = TRUE)
[15:31:10.616]                   }
[15:31:10.616]                   {
[15:31:10.616]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.616]                       FUN = function(jj) {
[15:31:10.616]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.616]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.616]                       })
[15:31:10.616]                   }
[15:31:10.616]                 }, args = future.call.arguments)
[15:31:10.616]             }))
[15:31:10.616]             future::FutureResult(value = ...future.value$value, 
[15:31:10.616]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.616]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.616]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.616]                     ...future.globalenv.names))
[15:31:10.616]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.616]         }, condition = base::local({
[15:31:10.616]             c <- base::c
[15:31:10.616]             inherits <- base::inherits
[15:31:10.616]             invokeRestart <- base::invokeRestart
[15:31:10.616]             length <- base::length
[15:31:10.616]             list <- base::list
[15:31:10.616]             seq.int <- base::seq.int
[15:31:10.616]             signalCondition <- base::signalCondition
[15:31:10.616]             sys.calls <- base::sys.calls
[15:31:10.616]             `[[` <- base::`[[`
[15:31:10.616]             `+` <- base::`+`
[15:31:10.616]             `<<-` <- base::`<<-`
[15:31:10.616]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.616]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.616]                   3L)]
[15:31:10.616]             }
[15:31:10.616]             function(cond) {
[15:31:10.616]                 is_error <- inherits(cond, "error")
[15:31:10.616]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.616]                   NULL)
[15:31:10.616]                 if (is_error) {
[15:31:10.616]                   sessionInformation <- function() {
[15:31:10.616]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.616]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.616]                       search = base::search(), system = base::Sys.info())
[15:31:10.616]                   }
[15:31:10.616]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.616]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.616]                     cond$call), session = sessionInformation(), 
[15:31:10.616]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.616]                   signalCondition(cond)
[15:31:10.616]                 }
[15:31:10.616]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.616]                 "immediateCondition"))) {
[15:31:10.616]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.616]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.616]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.616]                   if (TRUE && !signal) {
[15:31:10.616]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.616]                     {
[15:31:10.616]                       inherits <- base::inherits
[15:31:10.616]                       invokeRestart <- base::invokeRestart
[15:31:10.616]                       is.null <- base::is.null
[15:31:10.616]                       muffled <- FALSE
[15:31:10.616]                       if (inherits(cond, "message")) {
[15:31:10.616]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.616]                         if (muffled) 
[15:31:10.616]                           invokeRestart("muffleMessage")
[15:31:10.616]                       }
[15:31:10.616]                       else if (inherits(cond, "warning")) {
[15:31:10.616]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.616]                         if (muffled) 
[15:31:10.616]                           invokeRestart("muffleWarning")
[15:31:10.616]                       }
[15:31:10.616]                       else if (inherits(cond, "condition")) {
[15:31:10.616]                         if (!is.null(pattern)) {
[15:31:10.616]                           computeRestarts <- base::computeRestarts
[15:31:10.616]                           grepl <- base::grepl
[15:31:10.616]                           restarts <- computeRestarts(cond)
[15:31:10.616]                           for (restart in restarts) {
[15:31:10.616]                             name <- restart$name
[15:31:10.616]                             if (is.null(name)) 
[15:31:10.616]                               next
[15:31:10.616]                             if (!grepl(pattern, name)) 
[15:31:10.616]                               next
[15:31:10.616]                             invokeRestart(restart)
[15:31:10.616]                             muffled <- TRUE
[15:31:10.616]                             break
[15:31:10.616]                           }
[15:31:10.616]                         }
[15:31:10.616]                       }
[15:31:10.616]                       invisible(muffled)
[15:31:10.616]                     }
[15:31:10.616]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.616]                   }
[15:31:10.616]                 }
[15:31:10.616]                 else {
[15:31:10.616]                   if (TRUE) {
[15:31:10.616]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.616]                     {
[15:31:10.616]                       inherits <- base::inherits
[15:31:10.616]                       invokeRestart <- base::invokeRestart
[15:31:10.616]                       is.null <- base::is.null
[15:31:10.616]                       muffled <- FALSE
[15:31:10.616]                       if (inherits(cond, "message")) {
[15:31:10.616]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.616]                         if (muffled) 
[15:31:10.616]                           invokeRestart("muffleMessage")
[15:31:10.616]                       }
[15:31:10.616]                       else if (inherits(cond, "warning")) {
[15:31:10.616]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.616]                         if (muffled) 
[15:31:10.616]                           invokeRestart("muffleWarning")
[15:31:10.616]                       }
[15:31:10.616]                       else if (inherits(cond, "condition")) {
[15:31:10.616]                         if (!is.null(pattern)) {
[15:31:10.616]                           computeRestarts <- base::computeRestarts
[15:31:10.616]                           grepl <- base::grepl
[15:31:10.616]                           restarts <- computeRestarts(cond)
[15:31:10.616]                           for (restart in restarts) {
[15:31:10.616]                             name <- restart$name
[15:31:10.616]                             if (is.null(name)) 
[15:31:10.616]                               next
[15:31:10.616]                             if (!grepl(pattern, name)) 
[15:31:10.616]                               next
[15:31:10.616]                             invokeRestart(restart)
[15:31:10.616]                             muffled <- TRUE
[15:31:10.616]                             break
[15:31:10.616]                           }
[15:31:10.616]                         }
[15:31:10.616]                       }
[15:31:10.616]                       invisible(muffled)
[15:31:10.616]                     }
[15:31:10.616]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.616]                   }
[15:31:10.616]                 }
[15:31:10.616]             }
[15:31:10.616]         }))
[15:31:10.616]     }, error = function(ex) {
[15:31:10.616]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.616]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.616]                 ...future.rng), started = ...future.startTime, 
[15:31:10.616]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.616]             version = "1.8"), class = "FutureResult")
[15:31:10.616]     }, finally = {
[15:31:10.616]         if (!identical(...future.workdir, getwd())) 
[15:31:10.616]             setwd(...future.workdir)
[15:31:10.616]         {
[15:31:10.616]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.616]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.616]             }
[15:31:10.616]             base::options(...future.oldOptions)
[15:31:10.616]             if (.Platform$OS.type == "windows") {
[15:31:10.616]                 old_names <- names(...future.oldEnvVars)
[15:31:10.616]                 envs <- base::Sys.getenv()
[15:31:10.616]                 names <- names(envs)
[15:31:10.616]                 common <- intersect(names, old_names)
[15:31:10.616]                 added <- setdiff(names, old_names)
[15:31:10.616]                 removed <- setdiff(old_names, names)
[15:31:10.616]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.616]                   envs[common]]
[15:31:10.616]                 NAMES <- toupper(changed)
[15:31:10.616]                 args <- list()
[15:31:10.616]                 for (kk in seq_along(NAMES)) {
[15:31:10.616]                   name <- changed[[kk]]
[15:31:10.616]                   NAME <- NAMES[[kk]]
[15:31:10.616]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.616]                     next
[15:31:10.616]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.616]                 }
[15:31:10.616]                 NAMES <- toupper(added)
[15:31:10.616]                 for (kk in seq_along(NAMES)) {
[15:31:10.616]                   name <- added[[kk]]
[15:31:10.616]                   NAME <- NAMES[[kk]]
[15:31:10.616]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.616]                     next
[15:31:10.616]                   args[[name]] <- ""
[15:31:10.616]                 }
[15:31:10.616]                 NAMES <- toupper(removed)
[15:31:10.616]                 for (kk in seq_along(NAMES)) {
[15:31:10.616]                   name <- removed[[kk]]
[15:31:10.616]                   NAME <- NAMES[[kk]]
[15:31:10.616]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.616]                     next
[15:31:10.616]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.616]                 }
[15:31:10.616]                 if (length(args) > 0) 
[15:31:10.616]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.616]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.616]             }
[15:31:10.616]             else {
[15:31:10.616]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.616]             }
[15:31:10.616]             {
[15:31:10.616]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.616]                   0L) {
[15:31:10.616]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.616]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.616]                   base::options(opts)
[15:31:10.616]                 }
[15:31:10.616]                 {
[15:31:10.616]                   {
[15:31:10.616]                     NULL
[15:31:10.616]                     RNGkind("Mersenne-Twister")
[15:31:10.616]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.616]                       inherits = FALSE)
[15:31:10.616]                   }
[15:31:10.616]                   options(future.plan = NULL)
[15:31:10.616]                   if (is.na(NA_character_)) 
[15:31:10.616]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.616]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.616]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.616]                     .init = FALSE)
[15:31:10.616]                 }
[15:31:10.616]             }
[15:31:10.616]         }
[15:31:10.616]     })
[15:31:10.616]     if (TRUE) {
[15:31:10.616]         base::sink(type = "output", split = FALSE)
[15:31:10.616]         if (TRUE) {
[15:31:10.616]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.616]         }
[15:31:10.616]         else {
[15:31:10.616]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.616]         }
[15:31:10.616]         base::close(...future.stdout)
[15:31:10.616]         ...future.stdout <- NULL
[15:31:10.616]     }
[15:31:10.616]     ...future.result$conditions <- ...future.conditions
[15:31:10.616]     ...future.result$finished <- base::Sys.time()
[15:31:10.616]     ...future.result
[15:31:10.616] }
[15:31:10.623] assign_globals() ...
[15:31:10.623] List of 5
[15:31:10.623]  $ ...future.FUN            :function (x, ...)  
[15:31:10.623]  $ future.call.arguments    :List of 1
[15:31:10.623]   ..$ singular.ok: logi FALSE
[15:31:10.623]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.623]  $ ...future.elements_ii    :List of 3
[15:31:10.623]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.623]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.623]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.623]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.623]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.623]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.623]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.623]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.623]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.623]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.623]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.623]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.623]  $ ...future.seeds_ii       : NULL
[15:31:10.623]  $ ...future.globals.maxSize: NULL
[15:31:10.623]  - attr(*, "where")=List of 5
[15:31:10.623]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.623]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.623]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.623]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.623]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.623]  - attr(*, "resolved")= logi FALSE
[15:31:10.623]  - attr(*, "total_size")= num 5384
[15:31:10.623]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.623]  - attr(*, "already-done")= logi TRUE
[15:31:10.643] - reassign environment for '...future.FUN'
[15:31:10.644] - copied '...future.FUN' to environment
[15:31:10.644] - copied 'future.call.arguments' to environment
[15:31:10.644] - copied '...future.elements_ii' to environment
[15:31:10.645] - copied '...future.seeds_ii' to environment
[15:31:10.645] - copied '...future.globals.maxSize' to environment
[15:31:10.645] assign_globals() ... done
[15:31:10.646] plan(): Setting new future strategy stack:
[15:31:10.646] List of future strategies:
[15:31:10.646] 1. sequential:
[15:31:10.646]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.646]    - tweaked: FALSE
[15:31:10.646]    - call: NULL
[15:31:10.647] plan(): nbrOfWorkers() = 1
[15:31:10.653] plan(): Setting new future strategy stack:
[15:31:10.654] List of future strategies:
[15:31:10.654] 1. multisession:
[15:31:10.654]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.654]    - tweaked: FALSE
[15:31:10.654]    - call: plan(strategy)
[15:31:10.658] plan(): nbrOfWorkers() = 1
[15:31:10.658] SequentialFuture started (and completed)
[15:31:10.658] - Launch lazy future ... done
[15:31:10.659] run() for 'SequentialFuture' ... done
[15:31:10.659] Created future:
[15:31:10.659] SequentialFuture:
[15:31:10.659] Label: 'future_by-1'
[15:31:10.659] Expression:
[15:31:10.659] {
[15:31:10.659]     do.call(function(...) {
[15:31:10.659]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.659]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.659]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.659]             on.exit(options(oopts), add = TRUE)
[15:31:10.659]         }
[15:31:10.659]         {
[15:31:10.659]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.659]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.659]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.659]             })
[15:31:10.659]         }
[15:31:10.659]     }, args = future.call.arguments)
[15:31:10.659] }
[15:31:10.659] Lazy evaluation: FALSE
[15:31:10.659] Asynchronous evaluation: FALSE
[15:31:10.659] Local evaluation: TRUE
[15:31:10.659] Environment: R_GlobalEnv
[15:31:10.659] Capture standard output: TRUE
[15:31:10.659] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.659] Globals: 5 objects totaling 10.06 KiB (function '...future.FUN' of 5.20 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.659] Packages: 1 packages ('stats')
[15:31:10.659] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.659] Resolved: TRUE
[15:31:10.659] Value: 26.06 KiB of class 'list'
[15:31:10.659] Early signaling: FALSE
[15:31:10.659] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.659] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.662] Chunk #1 of 1 ... DONE
[15:31:10.662] Launching 1 futures (chunks) ... DONE
[15:31:10.663] Resolving 1 futures (chunks) ...
[15:31:10.663] resolve() on list ...
[15:31:10.663]  recursive: 0
[15:31:10.664]  length: 1
[15:31:10.664] 
[15:31:10.664] resolved() for 'SequentialFuture' ...
[15:31:10.664] - state: 'finished'
[15:31:10.665] - run: TRUE
[15:31:10.665] - result: 'FutureResult'
[15:31:10.665] resolved() for 'SequentialFuture' ... done
[15:31:10.666] Future #1
[15:31:10.666] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.666] - nx: 1
[15:31:10.666] - relay: TRUE
[15:31:10.667] - stdout: TRUE
[15:31:10.667] - signal: TRUE
[15:31:10.667] - resignal: FALSE
[15:31:10.667] - force: TRUE
[15:31:10.668] - relayed: [n=1] FALSE
[15:31:10.668] - queued futures: [n=1] FALSE
[15:31:10.668]  - until=1
[15:31:10.668]  - relaying element #1
[15:31:10.669] - relayed: [n=1] TRUE
[15:31:10.669] - queued futures: [n=1] TRUE
[15:31:10.669] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.670]  length: 0 (resolved future 1)
[15:31:10.670] Relaying remaining futures
[15:31:10.670] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.670] - nx: 1
[15:31:10.671] - relay: TRUE
[15:31:10.671] - stdout: TRUE
[15:31:10.671] - signal: TRUE
[15:31:10.671] - resignal: FALSE
[15:31:10.672] - force: TRUE
[15:31:10.672] - relayed: [n=1] TRUE
[15:31:10.672] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.673] - relayed: [n=1] TRUE
[15:31:10.673] - queued futures: [n=1] TRUE
[15:31:10.673] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.673] resolve() on list ... DONE
[15:31:10.674]  - Number of value chunks collected: 1
[15:31:10.674] Resolving 1 futures (chunks) ... DONE
[15:31:10.674] Reducing values from 1 chunks ...
[15:31:10.675]  - Number of values collected after concatenation: 3
[15:31:10.675]  - Number of values expected: 3
[15:31:10.675] Reducing values from 1 chunks ... DONE
[15:31:10.675] future_lapply() ... DONE
[15:31:10.676] future_by_internal() ... DONE
[15:31:10.684] future_by_internal() ...
[15:31:10.685] future_lapply() ...
[15:31:10.690] Number of chunks: 1
[15:31:10.690] getGlobalsAndPackagesXApply() ...
[15:31:10.690]  - future.globals: TRUE
[15:31:10.691] getGlobalsAndPackages() ...
[15:31:10.691] Searching for globals...
[15:31:10.694] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:10.695] Searching for globals ... DONE
[15:31:10.695] Resolving globals: FALSE
[15:31:10.696] The total size of the 3 globals is 2.27 KiB (2320 bytes)
[15:31:10.697] The total size of the 3 globals exported for future expression ('FUN()') is 2.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.04 KiB of class 'function'), 'wool' (776 bytes of class 'numeric') and 'breaks' (480 bytes of class 'numeric')
[15:31:10.697] - globals: [3] 'FUN', 'breaks', 'wool'
[15:31:10.697] - packages: [1] 'stats'
[15:31:10.698] getGlobalsAndPackages() ... DONE
[15:31:10.698]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[15:31:10.698]  - needed namespaces: [n=1] 'stats'
[15:31:10.698] Finding globals ... DONE
[15:31:10.699]  - use_args: TRUE
[15:31:10.699]  - Getting '...' globals ...
[15:31:10.700] resolve() on list ...
[15:31:10.700]  recursive: 0
[15:31:10.700]  length: 1
[15:31:10.700]  elements: '...'
[15:31:10.700]  length: 0 (resolved future 1)
[15:31:10.701] resolve() on list ... DONE
[15:31:10.701]    - '...' content: [n=0] 
[15:31:10.701] List of 1
[15:31:10.701]  $ ...: list()
[15:31:10.701]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.701]  - attr(*, "where")=List of 1
[15:31:10.701]   ..$ ...:<environment: 0x0000019c80b763e0> 
[15:31:10.701]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.701]  - attr(*, "resolved")= logi TRUE
[15:31:10.701]  - attr(*, "total_size")= num NA
[15:31:10.706]  - Getting '...' globals ... DONE
[15:31:10.707] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[15:31:10.707] List of 4
[15:31:10.707]  $ ...future.FUN:function (x)  
[15:31:10.707]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:10.707]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.707]  $ ...          : list()
[15:31:10.707]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.707]  - attr(*, "where")=List of 4
[15:31:10.707]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.707]   ..$ breaks       :<environment: R_EmptyEnv> 
[15:31:10.707]   ..$ wool         :<environment: R_EmptyEnv> 
[15:31:10.707]   ..$ ...          :<environment: 0x0000019c80b763e0> 
[15:31:10.707]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.707]  - attr(*, "resolved")= logi FALSE
[15:31:10.707]  - attr(*, "total_size")= num 2320
[15:31:10.714] Packages to be attached in all futures: [n=1] 'stats'
[15:31:10.714] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.714] Number of futures (= number of chunks): 1
[15:31:10.714] Launching 1 futures (chunks) ...
[15:31:10.715] Chunk #1 of 1 ...
[15:31:10.715]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.715] getGlobalsAndPackages() ...
[15:31:10.715] Searching for globals...
[15:31:10.716] 
[15:31:10.716] Searching for globals ... DONE
[15:31:10.716] - globals: [0] <none>
[15:31:10.716] getGlobalsAndPackages() ... DONE
[15:31:10.716]    + additional globals found: [n=0] 
[15:31:10.717]    + additional namespaces needed: [n=0] 
[15:31:10.717]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.717]  - seeds: <none>
[15:31:10.717]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.717] getGlobalsAndPackages() ...
[15:31:10.718] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.718] Resolving globals: FALSE
[15:31:10.718] Tweak future expression to call with '...' arguments ...
[15:31:10.718] {
[15:31:10.718]     do.call(function(...) {
[15:31:10.718]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.718]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.718]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.718]             on.exit(options(oopts), add = TRUE)
[15:31:10.718]         }
[15:31:10.718]         {
[15:31:10.718]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.718]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.718]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.718]             })
[15:31:10.718]         }
[15:31:10.718]     }, args = future.call.arguments)
[15:31:10.718] }
[15:31:10.719] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.720] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.720] 
[15:31:10.721] getGlobalsAndPackages() ... DONE
[15:31:10.721] run() for 'Future' ...
[15:31:10.722] - state: 'created'
[15:31:10.722] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:10.726] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.727] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.727]   - Field: 'label'
[15:31:10.727]   - Field: 'local'
[15:31:10.728]   - Field: 'owner'
[15:31:10.728]   - Field: 'envir'
[15:31:10.728]   - Field: 'packages'
[15:31:10.729]   - Field: 'gc'
[15:31:10.729]   - Field: 'conditions'
[15:31:10.729]   - Field: 'expr'
[15:31:10.729]   - Field: 'uuid'
[15:31:10.730]   - Field: 'seed'
[15:31:10.730]   - Field: 'version'
[15:31:10.730]   - Field: 'result'
[15:31:10.731]   - Field: 'asynchronous'
[15:31:10.731]   - Field: 'calls'
[15:31:10.731]   - Field: 'globals'
[15:31:10.732]   - Field: 'stdout'
[15:31:10.732]   - Field: 'earlySignal'
[15:31:10.732]   - Field: 'lazy'
[15:31:10.733]   - Field: 'state'
[15:31:10.733] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.733] - Launch lazy future ...
[15:31:10.734] Packages needed by the future expression (n = 1): 'stats'
[15:31:10.734] Packages needed by future strategies (n = 0): <none>
[15:31:10.735] {
[15:31:10.735]     {
[15:31:10.735]         {
[15:31:10.735]             ...future.startTime <- base::Sys.time()
[15:31:10.735]             {
[15:31:10.735]                 {
[15:31:10.735]                   {
[15:31:10.735]                     {
[15:31:10.735]                       base::local({
[15:31:10.735]                         has_future <- base::requireNamespace("future", 
[15:31:10.735]                           quietly = TRUE)
[15:31:10.735]                         if (has_future) {
[15:31:10.735]                           ns <- base::getNamespace("future")
[15:31:10.735]                           version <- ns[[".package"]][["version"]]
[15:31:10.735]                           if (is.null(version)) 
[15:31:10.735]                             version <- utils::packageVersion("future")
[15:31:10.735]                         }
[15:31:10.735]                         else {
[15:31:10.735]                           version <- NULL
[15:31:10.735]                         }
[15:31:10.735]                         if (!has_future || version < "1.8.0") {
[15:31:10.735]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.735]                             "", base::R.version$version.string), 
[15:31:10.735]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:10.735]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.735]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.735]                               "release", "version")], collapse = " "), 
[15:31:10.735]                             hostname = base::Sys.info()[["nodename"]])
[15:31:10.735]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.735]                             info)
[15:31:10.735]                           info <- base::paste(info, collapse = "; ")
[15:31:10.735]                           if (!has_future) {
[15:31:10.735]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.735]                               info)
[15:31:10.735]                           }
[15:31:10.735]                           else {
[15:31:10.735]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.735]                               info, version)
[15:31:10.735]                           }
[15:31:10.735]                           base::stop(msg)
[15:31:10.735]                         }
[15:31:10.735]                       })
[15:31:10.735]                     }
[15:31:10.735]                     base::local({
[15:31:10.735]                       for (pkg in "stats") {
[15:31:10.735]                         base::loadNamespace(pkg)
[15:31:10.735]                         base::library(pkg, character.only = TRUE)
[15:31:10.735]                       }
[15:31:10.735]                     })
[15:31:10.735]                   }
[15:31:10.735]                   ...future.strategy.old <- future::plan("list")
[15:31:10.735]                   options(future.plan = NULL)
[15:31:10.735]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.735]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.735]                 }
[15:31:10.735]                 ...future.workdir <- getwd()
[15:31:10.735]             }
[15:31:10.735]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.735]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.735]         }
[15:31:10.735]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.735]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.735]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.735]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.735]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.735]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.735]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.735]             base::names(...future.oldOptions))
[15:31:10.735]     }
[15:31:10.735]     if (FALSE) {
[15:31:10.735]     }
[15:31:10.735]     else {
[15:31:10.735]         if (TRUE) {
[15:31:10.735]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.735]                 open = "w")
[15:31:10.735]         }
[15:31:10.735]         else {
[15:31:10.735]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.735]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.735]         }
[15:31:10.735]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.735]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.735]             base::sink(type = "output", split = FALSE)
[15:31:10.735]             base::close(...future.stdout)
[15:31:10.735]         }, add = TRUE)
[15:31:10.735]     }
[15:31:10.735]     ...future.frame <- base::sys.nframe()
[15:31:10.735]     ...future.conditions <- base::list()
[15:31:10.735]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.735]     if (FALSE) {
[15:31:10.735]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.735]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.735]     }
[15:31:10.735]     ...future.result <- base::tryCatch({
[15:31:10.735]         base::withCallingHandlers({
[15:31:10.735]             ...future.value <- base::withVisible(base::local({
[15:31:10.735]                 do.call(function(...) {
[15:31:10.735]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.735]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.735]                     ...future.globals.maxSize)) {
[15:31:10.735]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.735]                     on.exit(options(oopts), add = TRUE)
[15:31:10.735]                   }
[15:31:10.735]                   {
[15:31:10.735]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.735]                       FUN = function(jj) {
[15:31:10.735]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.735]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.735]                       })
[15:31:10.735]                   }
[15:31:10.735]                 }, args = future.call.arguments)
[15:31:10.735]             }))
[15:31:10.735]             future::FutureResult(value = ...future.value$value, 
[15:31:10.735]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.735]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.735]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.735]                     ...future.globalenv.names))
[15:31:10.735]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.735]         }, condition = base::local({
[15:31:10.735]             c <- base::c
[15:31:10.735]             inherits <- base::inherits
[15:31:10.735]             invokeRestart <- base::invokeRestart
[15:31:10.735]             length <- base::length
[15:31:10.735]             list <- base::list
[15:31:10.735]             seq.int <- base::seq.int
[15:31:10.735]             signalCondition <- base::signalCondition
[15:31:10.735]             sys.calls <- base::sys.calls
[15:31:10.735]             `[[` <- base::`[[`
[15:31:10.735]             `+` <- base::`+`
[15:31:10.735]             `<<-` <- base::`<<-`
[15:31:10.735]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.735]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.735]                   3L)]
[15:31:10.735]             }
[15:31:10.735]             function(cond) {
[15:31:10.735]                 is_error <- inherits(cond, "error")
[15:31:10.735]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.735]                   NULL)
[15:31:10.735]                 if (is_error) {
[15:31:10.735]                   sessionInformation <- function() {
[15:31:10.735]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.735]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.735]                       search = base::search(), system = base::Sys.info())
[15:31:10.735]                   }
[15:31:10.735]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.735]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.735]                     cond$call), session = sessionInformation(), 
[15:31:10.735]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.735]                   signalCondition(cond)
[15:31:10.735]                 }
[15:31:10.735]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.735]                 "immediateCondition"))) {
[15:31:10.735]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.735]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.735]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.735]                   if (TRUE && !signal) {
[15:31:10.735]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.735]                     {
[15:31:10.735]                       inherits <- base::inherits
[15:31:10.735]                       invokeRestart <- base::invokeRestart
[15:31:10.735]                       is.null <- base::is.null
[15:31:10.735]                       muffled <- FALSE
[15:31:10.735]                       if (inherits(cond, "message")) {
[15:31:10.735]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.735]                         if (muffled) 
[15:31:10.735]                           invokeRestart("muffleMessage")
[15:31:10.735]                       }
[15:31:10.735]                       else if (inherits(cond, "warning")) {
[15:31:10.735]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.735]                         if (muffled) 
[15:31:10.735]                           invokeRestart("muffleWarning")
[15:31:10.735]                       }
[15:31:10.735]                       else if (inherits(cond, "condition")) {
[15:31:10.735]                         if (!is.null(pattern)) {
[15:31:10.735]                           computeRestarts <- base::computeRestarts
[15:31:10.735]                           grepl <- base::grepl
[15:31:10.735]                           restarts <- computeRestarts(cond)
[15:31:10.735]                           for (restart in restarts) {
[15:31:10.735]                             name <- restart$name
[15:31:10.735]                             if (is.null(name)) 
[15:31:10.735]                               next
[15:31:10.735]                             if (!grepl(pattern, name)) 
[15:31:10.735]                               next
[15:31:10.735]                             invokeRestart(restart)
[15:31:10.735]                             muffled <- TRUE
[15:31:10.735]                             break
[15:31:10.735]                           }
[15:31:10.735]                         }
[15:31:10.735]                       }
[15:31:10.735]                       invisible(muffled)
[15:31:10.735]                     }
[15:31:10.735]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.735]                   }
[15:31:10.735]                 }
[15:31:10.735]                 else {
[15:31:10.735]                   if (TRUE) {
[15:31:10.735]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.735]                     {
[15:31:10.735]                       inherits <- base::inherits
[15:31:10.735]                       invokeRestart <- base::invokeRestart
[15:31:10.735]                       is.null <- base::is.null
[15:31:10.735]                       muffled <- FALSE
[15:31:10.735]                       if (inherits(cond, "message")) {
[15:31:10.735]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.735]                         if (muffled) 
[15:31:10.735]                           invokeRestart("muffleMessage")
[15:31:10.735]                       }
[15:31:10.735]                       else if (inherits(cond, "warning")) {
[15:31:10.735]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.735]                         if (muffled) 
[15:31:10.735]                           invokeRestart("muffleWarning")
[15:31:10.735]                       }
[15:31:10.735]                       else if (inherits(cond, "condition")) {
[15:31:10.735]                         if (!is.null(pattern)) {
[15:31:10.735]                           computeRestarts <- base::computeRestarts
[15:31:10.735]                           grepl <- base::grepl
[15:31:10.735]                           restarts <- computeRestarts(cond)
[15:31:10.735]                           for (restart in restarts) {
[15:31:10.735]                             name <- restart$name
[15:31:10.735]                             if (is.null(name)) 
[15:31:10.735]                               next
[15:31:10.735]                             if (!grepl(pattern, name)) 
[15:31:10.735]                               next
[15:31:10.735]                             invokeRestart(restart)
[15:31:10.735]                             muffled <- TRUE
[15:31:10.735]                             break
[15:31:10.735]                           }
[15:31:10.735]                         }
[15:31:10.735]                       }
[15:31:10.735]                       invisible(muffled)
[15:31:10.735]                     }
[15:31:10.735]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.735]                   }
[15:31:10.735]                 }
[15:31:10.735]             }
[15:31:10.735]         }))
[15:31:10.735]     }, error = function(ex) {
[15:31:10.735]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.735]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.735]                 ...future.rng), started = ...future.startTime, 
[15:31:10.735]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.735]             version = "1.8"), class = "FutureResult")
[15:31:10.735]     }, finally = {
[15:31:10.735]         if (!identical(...future.workdir, getwd())) 
[15:31:10.735]             setwd(...future.workdir)
[15:31:10.735]         {
[15:31:10.735]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.735]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.735]             }
[15:31:10.735]             base::options(...future.oldOptions)
[15:31:10.735]             if (.Platform$OS.type == "windows") {
[15:31:10.735]                 old_names <- names(...future.oldEnvVars)
[15:31:10.735]                 envs <- base::Sys.getenv()
[15:31:10.735]                 names <- names(envs)
[15:31:10.735]                 common <- intersect(names, old_names)
[15:31:10.735]                 added <- setdiff(names, old_names)
[15:31:10.735]                 removed <- setdiff(old_names, names)
[15:31:10.735]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.735]                   envs[common]]
[15:31:10.735]                 NAMES <- toupper(changed)
[15:31:10.735]                 args <- list()
[15:31:10.735]                 for (kk in seq_along(NAMES)) {
[15:31:10.735]                   name <- changed[[kk]]
[15:31:10.735]                   NAME <- NAMES[[kk]]
[15:31:10.735]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.735]                     next
[15:31:10.735]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.735]                 }
[15:31:10.735]                 NAMES <- toupper(added)
[15:31:10.735]                 for (kk in seq_along(NAMES)) {
[15:31:10.735]                   name <- added[[kk]]
[15:31:10.735]                   NAME <- NAMES[[kk]]
[15:31:10.735]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.735]                     next
[15:31:10.735]                   args[[name]] <- ""
[15:31:10.735]                 }
[15:31:10.735]                 NAMES <- toupper(removed)
[15:31:10.735]                 for (kk in seq_along(NAMES)) {
[15:31:10.735]                   name <- removed[[kk]]
[15:31:10.735]                   NAME <- NAMES[[kk]]
[15:31:10.735]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.735]                     next
[15:31:10.735]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.735]                 }
[15:31:10.735]                 if (length(args) > 0) 
[15:31:10.735]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.735]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.735]             }
[15:31:10.735]             else {
[15:31:10.735]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.735]             }
[15:31:10.735]             {
[15:31:10.735]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.735]                   0L) {
[15:31:10.735]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.735]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.735]                   base::options(opts)
[15:31:10.735]                 }
[15:31:10.735]                 {
[15:31:10.735]                   {
[15:31:10.735]                     NULL
[15:31:10.735]                     RNGkind("Mersenne-Twister")
[15:31:10.735]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.735]                       inherits = FALSE)
[15:31:10.735]                   }
[15:31:10.735]                   options(future.plan = NULL)
[15:31:10.735]                   if (is.na(NA_character_)) 
[15:31:10.735]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.735]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.735]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.735]                     .init = FALSE)
[15:31:10.735]                 }
[15:31:10.735]             }
[15:31:10.735]         }
[15:31:10.735]     })
[15:31:10.735]     if (TRUE) {
[15:31:10.735]         base::sink(type = "output", split = FALSE)
[15:31:10.735]         if (TRUE) {
[15:31:10.735]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.735]         }
[15:31:10.735]         else {
[15:31:10.735]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.735]         }
[15:31:10.735]         base::close(...future.stdout)
[15:31:10.735]         ...future.stdout <- NULL
[15:31:10.735]     }
[15:31:10.735]     ...future.result$conditions <- ...future.conditions
[15:31:10.735]     ...future.result$finished <- base::Sys.time()
[15:31:10.735]     ...future.result
[15:31:10.735] }
[15:31:10.742] assign_globals() ...
[15:31:10.743] List of 7
[15:31:10.743]  $ ...future.FUN            :function (x)  
[15:31:10.743]  $ breaks                   : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:10.743]  $ wool                     : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.743]  $ future.call.arguments    : list()
[15:31:10.743]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.743]  $ ...future.elements_ii    :List of 3
[15:31:10.743]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.743]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.743]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.743]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.743]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.743]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.743]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.743]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.743]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.743]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.743]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.743]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.743]  $ ...future.seeds_ii       : NULL
[15:31:10.743]  $ ...future.globals.maxSize: NULL
[15:31:10.743]  - attr(*, "where")=List of 7
[15:31:10.743]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.743]   ..$ breaks                   :<environment: R_EmptyEnv> 
[15:31:10.743]   ..$ wool                     :<environment: R_EmptyEnv> 
[15:31:10.743]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.743]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.743]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.743]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.743]  - attr(*, "resolved")= logi FALSE
[15:31:10.743]  - attr(*, "total_size")= num 2320
[15:31:10.743]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.743]  - attr(*, "already-done")= logi TRUE
[15:31:10.763] - reassign environment for '...future.FUN'
[15:31:10.763] - copied '...future.FUN' to environment
[15:31:10.763] - copied 'breaks' to environment
[15:31:10.763] - copied 'wool' to environment
[15:31:10.764] - copied 'future.call.arguments' to environment
[15:31:10.764] - copied '...future.elements_ii' to environment
[15:31:10.764] - copied '...future.seeds_ii' to environment
[15:31:10.765] - copied '...future.globals.maxSize' to environment
[15:31:10.765] assign_globals() ... done
[15:31:10.766] plan(): Setting new future strategy stack:
[15:31:10.766] List of future strategies:
[15:31:10.766] 1. sequential:
[15:31:10.766]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.766]    - tweaked: FALSE
[15:31:10.766]    - call: NULL
[15:31:10.767] plan(): nbrOfWorkers() = 1
[15:31:10.773] plan(): Setting new future strategy stack:
[15:31:10.773] List of future strategies:
[15:31:10.773] 1. multisession:
[15:31:10.773]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.773]    - tweaked: FALSE
[15:31:10.773]    - call: plan(strategy)
[15:31:10.777] plan(): nbrOfWorkers() = 1
[15:31:10.778] SequentialFuture started (and completed)
[15:31:10.778] - Launch lazy future ... done
[15:31:10.778] run() for 'SequentialFuture' ... done
[15:31:10.779] Created future:
[15:31:10.779] SequentialFuture:
[15:31:10.779] Label: 'future_by-1'
[15:31:10.779] Expression:
[15:31:10.779] {
[15:31:10.779]     do.call(function(...) {
[15:31:10.779]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.779]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.779]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.779]             on.exit(options(oopts), add = TRUE)
[15:31:10.779]         }
[15:31:10.779]         {
[15:31:10.779]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.779]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.779]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.779]             })
[15:31:10.779]         }
[15:31:10.779]     }, args = future.call.arguments)
[15:31:10.779] }
[15:31:10.779] Lazy evaluation: FALSE
[15:31:10.779] Asynchronous evaluation: FALSE
[15:31:10.779] Local evaluation: TRUE
[15:31:10.779] Environment: 0x0000019c80b47d88
[15:31:10.779] Capture standard output: TRUE
[15:31:10.779] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.779] Globals: 7 objects totaling 7.07 KiB (function '...future.FUN' of 1.04 KiB, numeric 'breaks' of 480 bytes, factor 'wool' of 776 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, ...)
[15:31:10.779] Packages: 1 packages ('stats')
[15:31:10.779] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.779] Resolved: TRUE
[15:31:10.779] Value: 25.57 KiB of class 'list'
[15:31:10.779] Early signaling: FALSE
[15:31:10.779] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.779] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.783] Chunk #1 of 1 ... DONE
[15:31:10.783] Launching 1 futures (chunks) ... DONE
[15:31:10.783] Resolving 1 futures (chunks) ...
[15:31:10.784] resolve() on list ...
[15:31:10.784]  recursive: 0
[15:31:10.784]  length: 1
[15:31:10.785] 
[15:31:10.785] resolved() for 'SequentialFuture' ...
[15:31:10.785] - state: 'finished'
[15:31:10.786] - run: TRUE
[15:31:10.786] - result: 'FutureResult'
[15:31:10.786] resolved() for 'SequentialFuture' ... done
[15:31:10.787] Future #1
[15:31:10.787] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.787] - nx: 1
[15:31:10.788] - relay: TRUE
[15:31:10.788] - stdout: TRUE
[15:31:10.788] - signal: TRUE
[15:31:10.789] - resignal: FALSE
[15:31:10.789] - force: TRUE
[15:31:10.789] - relayed: [n=1] FALSE
[15:31:10.789] - queued futures: [n=1] FALSE
[15:31:10.790]  - until=1
[15:31:10.790]  - relaying element #1
[15:31:10.791] - relayed: [n=1] TRUE
[15:31:10.791] - queued futures: [n=1] TRUE
[15:31:10.791] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.792]  length: 0 (resolved future 1)
[15:31:10.792] Relaying remaining futures
[15:31:10.792] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.792] - nx: 1
[15:31:10.793] - relay: TRUE
[15:31:10.793] - stdout: TRUE
[15:31:10.793] - signal: TRUE
[15:31:10.793] - resignal: FALSE
[15:31:10.794] - force: TRUE
[15:31:10.794] - relayed: [n=1] TRUE
[15:31:10.794] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.795] - relayed: [n=1] TRUE
[15:31:10.795] - queued futures: [n=1] TRUE
[15:31:10.796] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.796] resolve() on list ... DONE
[15:31:10.796]  - Number of value chunks collected: 1
[15:31:10.797] Resolving 1 futures (chunks) ... DONE
[15:31:10.797] Reducing values from 1 chunks ...
[15:31:10.797]  - Number of values collected after concatenation: 3
[15:31:10.797]  - Number of values expected: 3
[15:31:10.798] Reducing values from 1 chunks ... DONE
[15:31:10.798] future_lapply() ... DONE
[15:31:10.798] future_by_internal() ... DONE
[15:31:10.799] future_by_internal() ...
[15:31:10.800] future_lapply() ...
[15:31:10.805] Number of chunks: 1
[15:31:10.805] getGlobalsAndPackagesXApply() ...
[15:31:10.805]  - future.globals: TRUE
[15:31:10.806] getGlobalsAndPackages() ...
[15:31:10.806] Searching for globals...
[15:31:10.808] - globals found: [2] 'FUN', 'UseMethod'
[15:31:10.808] Searching for globals ... DONE
[15:31:10.809] Resolving globals: FALSE
[15:31:10.809] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:10.810] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:10.811] - globals: [1] 'FUN'
[15:31:10.811] 
[15:31:10.811] getGlobalsAndPackages() ... DONE
[15:31:10.814]  - globals found/used: [n=1] 'FUN'
[15:31:10.815]  - needed namespaces: [n=0] 
[15:31:10.815] Finding globals ... DONE
[15:31:10.815]  - use_args: TRUE
[15:31:10.816]  - Getting '...' globals ...
[15:31:10.816] resolve() on list ...
[15:31:10.817]  recursive: 0
[15:31:10.817]  length: 1
[15:31:10.817]  elements: '...'
[15:31:10.818]  length: 0 (resolved future 1)
[15:31:10.818] resolve() on list ... DONE
[15:31:10.818]    - '...' content: [n=0] 
[15:31:10.818] List of 1
[15:31:10.818]  $ ...: list()
[15:31:10.818]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.818]  - attr(*, "where")=List of 1
[15:31:10.818]   ..$ ...:<environment: 0x0000019c83905e60> 
[15:31:10.818]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.818]  - attr(*, "resolved")= logi TRUE
[15:31:10.818]  - attr(*, "total_size")= num NA
[15:31:10.823]  - Getting '...' globals ... DONE
[15:31:10.824] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.824] List of 2
[15:31:10.824]  $ ...future.FUN:function (object, ...)  
[15:31:10.824]  $ ...          : list()
[15:31:10.824]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.824]  - attr(*, "where")=List of 2
[15:31:10.824]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.824]   ..$ ...          :<environment: 0x0000019c83905e60> 
[15:31:10.824]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.824]  - attr(*, "resolved")= logi FALSE
[15:31:10.824]  - attr(*, "total_size")= num 1240
[15:31:10.829] Packages to be attached in all futures: [n=0] 
[15:31:10.830] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.830] Number of futures (= number of chunks): 1
[15:31:10.830] Launching 1 futures (chunks) ...
[15:31:10.831] Chunk #1 of 1 ...
[15:31:10.831]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.831] getGlobalsAndPackages() ...
[15:31:10.831] Searching for globals...
[15:31:10.832] 
[15:31:10.833] Searching for globals ... DONE
[15:31:10.833] - globals: [0] <none>
[15:31:10.833] getGlobalsAndPackages() ... DONE
[15:31:10.834]    + additional globals found: [n=0] 
[15:31:10.834]    + additional namespaces needed: [n=0] 
[15:31:10.834]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.834]  - seeds: <none>
[15:31:10.835]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.835] getGlobalsAndPackages() ...
[15:31:10.835] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.836] Resolving globals: FALSE
[15:31:10.836] Tweak future expression to call with '...' arguments ...
[15:31:10.836] {
[15:31:10.836]     do.call(function(...) {
[15:31:10.836]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.836]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.836]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.836]             on.exit(options(oopts), add = TRUE)
[15:31:10.836]         }
[15:31:10.836]         {
[15:31:10.836]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.836]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.836]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.836]             })
[15:31:10.836]         }
[15:31:10.836]     }, args = future.call.arguments)
[15:31:10.836] }
[15:31:10.837] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.838] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.838] 
[15:31:10.838] getGlobalsAndPackages() ... DONE
[15:31:10.839] run() for 'Future' ...
[15:31:10.839] - state: 'created'
[15:31:10.840] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:10.844] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.844] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.845]   - Field: 'label'
[15:31:10.845]   - Field: 'local'
[15:31:10.845]   - Field: 'owner'
[15:31:10.846]   - Field: 'envir'
[15:31:10.846]   - Field: 'packages'
[15:31:10.846]   - Field: 'gc'
[15:31:10.846]   - Field: 'conditions'
[15:31:10.847]   - Field: 'expr'
[15:31:10.847]   - Field: 'uuid'
[15:31:10.847]   - Field: 'seed'
[15:31:10.848]   - Field: 'version'
[15:31:10.848]   - Field: 'result'
[15:31:10.848]   - Field: 'asynchronous'
[15:31:10.848]   - Field: 'calls'
[15:31:10.849]   - Field: 'globals'
[15:31:10.849]   - Field: 'stdout'
[15:31:10.849]   - Field: 'earlySignal'
[15:31:10.850]   - Field: 'lazy'
[15:31:10.850]   - Field: 'state'
[15:31:10.850] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.851] - Launch lazy future ...
[15:31:10.851] Packages needed by the future expression (n = 0): <none>
[15:31:10.851] Packages needed by future strategies (n = 0): <none>
[15:31:10.852] {
[15:31:10.852]     {
[15:31:10.852]         {
[15:31:10.852]             ...future.startTime <- base::Sys.time()
[15:31:10.852]             {
[15:31:10.852]                 {
[15:31:10.852]                   {
[15:31:10.852]                     base::local({
[15:31:10.852]                       has_future <- base::requireNamespace("future", 
[15:31:10.852]                         quietly = TRUE)
[15:31:10.852]                       if (has_future) {
[15:31:10.852]                         ns <- base::getNamespace("future")
[15:31:10.852]                         version <- ns[[".package"]][["version"]]
[15:31:10.852]                         if (is.null(version)) 
[15:31:10.852]                           version <- utils::packageVersion("future")
[15:31:10.852]                       }
[15:31:10.852]                       else {
[15:31:10.852]                         version <- NULL
[15:31:10.852]                       }
[15:31:10.852]                       if (!has_future || version < "1.8.0") {
[15:31:10.852]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.852]                           "", base::R.version$version.string), 
[15:31:10.852]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.852]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.852]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.852]                             "release", "version")], collapse = " "), 
[15:31:10.852]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.852]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.852]                           info)
[15:31:10.852]                         info <- base::paste(info, collapse = "; ")
[15:31:10.852]                         if (!has_future) {
[15:31:10.852]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.852]                             info)
[15:31:10.852]                         }
[15:31:10.852]                         else {
[15:31:10.852]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.852]                             info, version)
[15:31:10.852]                         }
[15:31:10.852]                         base::stop(msg)
[15:31:10.852]                       }
[15:31:10.852]                     })
[15:31:10.852]                   }
[15:31:10.852]                   ...future.strategy.old <- future::plan("list")
[15:31:10.852]                   options(future.plan = NULL)
[15:31:10.852]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.852]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.852]                 }
[15:31:10.852]                 ...future.workdir <- getwd()
[15:31:10.852]             }
[15:31:10.852]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.852]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.852]         }
[15:31:10.852]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.852]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.852]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.852]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.852]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.852]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.852]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.852]             base::names(...future.oldOptions))
[15:31:10.852]     }
[15:31:10.852]     if (FALSE) {
[15:31:10.852]     }
[15:31:10.852]     else {
[15:31:10.852]         if (TRUE) {
[15:31:10.852]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.852]                 open = "w")
[15:31:10.852]         }
[15:31:10.852]         else {
[15:31:10.852]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.852]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.852]         }
[15:31:10.852]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.852]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.852]             base::sink(type = "output", split = FALSE)
[15:31:10.852]             base::close(...future.stdout)
[15:31:10.852]         }, add = TRUE)
[15:31:10.852]     }
[15:31:10.852]     ...future.frame <- base::sys.nframe()
[15:31:10.852]     ...future.conditions <- base::list()
[15:31:10.852]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.852]     if (FALSE) {
[15:31:10.852]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.852]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.852]     }
[15:31:10.852]     ...future.result <- base::tryCatch({
[15:31:10.852]         base::withCallingHandlers({
[15:31:10.852]             ...future.value <- base::withVisible(base::local({
[15:31:10.852]                 do.call(function(...) {
[15:31:10.852]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.852]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.852]                     ...future.globals.maxSize)) {
[15:31:10.852]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.852]                     on.exit(options(oopts), add = TRUE)
[15:31:10.852]                   }
[15:31:10.852]                   {
[15:31:10.852]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.852]                       FUN = function(jj) {
[15:31:10.852]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.852]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.852]                       })
[15:31:10.852]                   }
[15:31:10.852]                 }, args = future.call.arguments)
[15:31:10.852]             }))
[15:31:10.852]             future::FutureResult(value = ...future.value$value, 
[15:31:10.852]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.852]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.852]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.852]                     ...future.globalenv.names))
[15:31:10.852]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.852]         }, condition = base::local({
[15:31:10.852]             c <- base::c
[15:31:10.852]             inherits <- base::inherits
[15:31:10.852]             invokeRestart <- base::invokeRestart
[15:31:10.852]             length <- base::length
[15:31:10.852]             list <- base::list
[15:31:10.852]             seq.int <- base::seq.int
[15:31:10.852]             signalCondition <- base::signalCondition
[15:31:10.852]             sys.calls <- base::sys.calls
[15:31:10.852]             `[[` <- base::`[[`
[15:31:10.852]             `+` <- base::`+`
[15:31:10.852]             `<<-` <- base::`<<-`
[15:31:10.852]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.852]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.852]                   3L)]
[15:31:10.852]             }
[15:31:10.852]             function(cond) {
[15:31:10.852]                 is_error <- inherits(cond, "error")
[15:31:10.852]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.852]                   NULL)
[15:31:10.852]                 if (is_error) {
[15:31:10.852]                   sessionInformation <- function() {
[15:31:10.852]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.852]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.852]                       search = base::search(), system = base::Sys.info())
[15:31:10.852]                   }
[15:31:10.852]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.852]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.852]                     cond$call), session = sessionInformation(), 
[15:31:10.852]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.852]                   signalCondition(cond)
[15:31:10.852]                 }
[15:31:10.852]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.852]                 "immediateCondition"))) {
[15:31:10.852]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.852]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.852]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.852]                   if (TRUE && !signal) {
[15:31:10.852]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.852]                     {
[15:31:10.852]                       inherits <- base::inherits
[15:31:10.852]                       invokeRestart <- base::invokeRestart
[15:31:10.852]                       is.null <- base::is.null
[15:31:10.852]                       muffled <- FALSE
[15:31:10.852]                       if (inherits(cond, "message")) {
[15:31:10.852]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.852]                         if (muffled) 
[15:31:10.852]                           invokeRestart("muffleMessage")
[15:31:10.852]                       }
[15:31:10.852]                       else if (inherits(cond, "warning")) {
[15:31:10.852]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.852]                         if (muffled) 
[15:31:10.852]                           invokeRestart("muffleWarning")
[15:31:10.852]                       }
[15:31:10.852]                       else if (inherits(cond, "condition")) {
[15:31:10.852]                         if (!is.null(pattern)) {
[15:31:10.852]                           computeRestarts <- base::computeRestarts
[15:31:10.852]                           grepl <- base::grepl
[15:31:10.852]                           restarts <- computeRestarts(cond)
[15:31:10.852]                           for (restart in restarts) {
[15:31:10.852]                             name <- restart$name
[15:31:10.852]                             if (is.null(name)) 
[15:31:10.852]                               next
[15:31:10.852]                             if (!grepl(pattern, name)) 
[15:31:10.852]                               next
[15:31:10.852]                             invokeRestart(restart)
[15:31:10.852]                             muffled <- TRUE
[15:31:10.852]                             break
[15:31:10.852]                           }
[15:31:10.852]                         }
[15:31:10.852]                       }
[15:31:10.852]                       invisible(muffled)
[15:31:10.852]                     }
[15:31:10.852]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.852]                   }
[15:31:10.852]                 }
[15:31:10.852]                 else {
[15:31:10.852]                   if (TRUE) {
[15:31:10.852]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.852]                     {
[15:31:10.852]                       inherits <- base::inherits
[15:31:10.852]                       invokeRestart <- base::invokeRestart
[15:31:10.852]                       is.null <- base::is.null
[15:31:10.852]                       muffled <- FALSE
[15:31:10.852]                       if (inherits(cond, "message")) {
[15:31:10.852]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.852]                         if (muffled) 
[15:31:10.852]                           invokeRestart("muffleMessage")
[15:31:10.852]                       }
[15:31:10.852]                       else if (inherits(cond, "warning")) {
[15:31:10.852]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.852]                         if (muffled) 
[15:31:10.852]                           invokeRestart("muffleWarning")
[15:31:10.852]                       }
[15:31:10.852]                       else if (inherits(cond, "condition")) {
[15:31:10.852]                         if (!is.null(pattern)) {
[15:31:10.852]                           computeRestarts <- base::computeRestarts
[15:31:10.852]                           grepl <- base::grepl
[15:31:10.852]                           restarts <- computeRestarts(cond)
[15:31:10.852]                           for (restart in restarts) {
[15:31:10.852]                             name <- restart$name
[15:31:10.852]                             if (is.null(name)) 
[15:31:10.852]                               next
[15:31:10.852]                             if (!grepl(pattern, name)) 
[15:31:10.852]                               next
[15:31:10.852]                             invokeRestart(restart)
[15:31:10.852]                             muffled <- TRUE
[15:31:10.852]                             break
[15:31:10.852]                           }
[15:31:10.852]                         }
[15:31:10.852]                       }
[15:31:10.852]                       invisible(muffled)
[15:31:10.852]                     }
[15:31:10.852]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.852]                   }
[15:31:10.852]                 }
[15:31:10.852]             }
[15:31:10.852]         }))
[15:31:10.852]     }, error = function(ex) {
[15:31:10.852]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.852]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.852]                 ...future.rng), started = ...future.startTime, 
[15:31:10.852]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.852]             version = "1.8"), class = "FutureResult")
[15:31:10.852]     }, finally = {
[15:31:10.852]         if (!identical(...future.workdir, getwd())) 
[15:31:10.852]             setwd(...future.workdir)
[15:31:10.852]         {
[15:31:10.852]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.852]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.852]             }
[15:31:10.852]             base::options(...future.oldOptions)
[15:31:10.852]             if (.Platform$OS.type == "windows") {
[15:31:10.852]                 old_names <- names(...future.oldEnvVars)
[15:31:10.852]                 envs <- base::Sys.getenv()
[15:31:10.852]                 names <- names(envs)
[15:31:10.852]                 common <- intersect(names, old_names)
[15:31:10.852]                 added <- setdiff(names, old_names)
[15:31:10.852]                 removed <- setdiff(old_names, names)
[15:31:10.852]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.852]                   envs[common]]
[15:31:10.852]                 NAMES <- toupper(changed)
[15:31:10.852]                 args <- list()
[15:31:10.852]                 for (kk in seq_along(NAMES)) {
[15:31:10.852]                   name <- changed[[kk]]
[15:31:10.852]                   NAME <- NAMES[[kk]]
[15:31:10.852]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.852]                     next
[15:31:10.852]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.852]                 }
[15:31:10.852]                 NAMES <- toupper(added)
[15:31:10.852]                 for (kk in seq_along(NAMES)) {
[15:31:10.852]                   name <- added[[kk]]
[15:31:10.852]                   NAME <- NAMES[[kk]]
[15:31:10.852]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.852]                     next
[15:31:10.852]                   args[[name]] <- ""
[15:31:10.852]                 }
[15:31:10.852]                 NAMES <- toupper(removed)
[15:31:10.852]                 for (kk in seq_along(NAMES)) {
[15:31:10.852]                   name <- removed[[kk]]
[15:31:10.852]                   NAME <- NAMES[[kk]]
[15:31:10.852]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.852]                     next
[15:31:10.852]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.852]                 }
[15:31:10.852]                 if (length(args) > 0) 
[15:31:10.852]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.852]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.852]             }
[15:31:10.852]             else {
[15:31:10.852]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.852]             }
[15:31:10.852]             {
[15:31:10.852]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.852]                   0L) {
[15:31:10.852]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.852]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.852]                   base::options(opts)
[15:31:10.852]                 }
[15:31:10.852]                 {
[15:31:10.852]                   {
[15:31:10.852]                     NULL
[15:31:10.852]                     RNGkind("Mersenne-Twister")
[15:31:10.852]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.852]                       inherits = FALSE)
[15:31:10.852]                   }
[15:31:10.852]                   options(future.plan = NULL)
[15:31:10.852]                   if (is.na(NA_character_)) 
[15:31:10.852]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.852]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.852]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.852]                     .init = FALSE)
[15:31:10.852]                 }
[15:31:10.852]             }
[15:31:10.852]         }
[15:31:10.852]     })
[15:31:10.852]     if (TRUE) {
[15:31:10.852]         base::sink(type = "output", split = FALSE)
[15:31:10.852]         if (TRUE) {
[15:31:10.852]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.852]         }
[15:31:10.852]         else {
[15:31:10.852]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.852]         }
[15:31:10.852]         base::close(...future.stdout)
[15:31:10.852]         ...future.stdout <- NULL
[15:31:10.852]     }
[15:31:10.852]     ...future.result$conditions <- ...future.conditions
[15:31:10.852]     ...future.result$finished <- base::Sys.time()
[15:31:10.852]     ...future.result
[15:31:10.852] }
[15:31:10.859] assign_globals() ...
[15:31:10.859] List of 5
[15:31:10.859]  $ ...future.FUN            :function (object, ...)  
[15:31:10.859]  $ future.call.arguments    : list()
[15:31:10.859]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.859]  $ ...future.elements_ii    :List of 3
[15:31:10.859]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.859]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.859]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.859]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.859]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.859]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.859]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.859]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.859]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.859]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.859]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.859]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.859]  $ ...future.seeds_ii       : NULL
[15:31:10.859]  $ ...future.globals.maxSize: NULL
[15:31:10.859]  - attr(*, "where")=List of 5
[15:31:10.859]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.859]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.859]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.859]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.859]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.859]  - attr(*, "resolved")= logi FALSE
[15:31:10.859]  - attr(*, "total_size")= num 1240
[15:31:10.859]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.859]  - attr(*, "already-done")= logi TRUE
[15:31:10.876] - copied '...future.FUN' to environment
[15:31:10.877] - copied 'future.call.arguments' to environment
[15:31:10.877] - copied '...future.elements_ii' to environment
[15:31:10.877] - copied '...future.seeds_ii' to environment
[15:31:10.878] - copied '...future.globals.maxSize' to environment
[15:31:10.878] assign_globals() ... done
[15:31:10.879] plan(): Setting new future strategy stack:
[15:31:10.879] List of future strategies:
[15:31:10.879] 1. sequential:
[15:31:10.879]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.879]    - tweaked: FALSE
[15:31:10.879]    - call: NULL
[15:31:10.880] plan(): nbrOfWorkers() = 1
[15:31:10.885] plan(): Setting new future strategy stack:
[15:31:10.885] List of future strategies:
[15:31:10.885] 1. multisession:
[15:31:10.885]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.885]    - tweaked: FALSE
[15:31:10.885]    - call: plan(strategy)
[15:31:10.889] plan(): nbrOfWorkers() = 1
[15:31:10.890] SequentialFuture started (and completed)
[15:31:10.890] - Launch lazy future ... done
[15:31:10.890] run() for 'SequentialFuture' ... done
[15:31:10.891] Created future:
[15:31:10.891] SequentialFuture:
[15:31:10.891] Label: 'future_by-1'
[15:31:10.891] Expression:
[15:31:10.891] {
[15:31:10.891]     do.call(function(...) {
[15:31:10.891]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.891]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.891]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.891]             on.exit(options(oopts), add = TRUE)
[15:31:10.891]         }
[15:31:10.891]         {
[15:31:10.891]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.891]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.891]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.891]             })
[15:31:10.891]         }
[15:31:10.891]     }, args = future.call.arguments)
[15:31:10.891] }
[15:31:10.891] Lazy evaluation: FALSE
[15:31:10.891] Asynchronous evaluation: FALSE
[15:31:10.891] Local evaluation: TRUE
[15:31:10.891] Environment: 0x0000019c8389b2c8
[15:31:10.891] Capture standard output: TRUE
[15:31:10.891] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.891] Globals: 5 objects totaling 6.02 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.891] Packages: <none>
[15:31:10.891] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.891] Resolved: TRUE
[15:31:10.891] Value: 5.37 KiB of class 'list'
[15:31:10.891] Early signaling: FALSE
[15:31:10.891] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.891] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.894] Chunk #1 of 1 ... DONE
[15:31:10.894] Launching 1 futures (chunks) ... DONE
[15:31:10.894] Resolving 1 futures (chunks) ...
[15:31:10.895] resolve() on list ...
[15:31:10.895]  recursive: 0
[15:31:10.895]  length: 1
[15:31:10.896] 
[15:31:10.896] resolved() for 'SequentialFuture' ...
[15:31:10.896] - state: 'finished'
[15:31:10.897] - run: TRUE
[15:31:10.897] - result: 'FutureResult'
[15:31:10.897] resolved() for 'SequentialFuture' ... done
[15:31:10.898] Future #1
[15:31:10.898] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:10.898] - nx: 1
[15:31:10.898] - relay: TRUE
[15:31:10.899] - stdout: TRUE
[15:31:10.899] - signal: TRUE
[15:31:10.899] - resignal: FALSE
[15:31:10.900] - force: TRUE
[15:31:10.900] - relayed: [n=1] FALSE
[15:31:10.900] - queued futures: [n=1] FALSE
[15:31:10.900]  - until=1
[15:31:10.901]  - relaying element #1
[15:31:10.901] - relayed: [n=1] TRUE
[15:31:10.901] - queued futures: [n=1] TRUE
[15:31:10.902] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:10.902]  length: 0 (resolved future 1)
[15:31:10.902] Relaying remaining futures
[15:31:10.903] signalConditionsASAP(NULL, pos=0) ...
[15:31:10.903] - nx: 1
[15:31:10.903] - relay: TRUE
[15:31:10.903] - stdout: TRUE
[15:31:10.904] - signal: TRUE
[15:31:10.904] - resignal: FALSE
[15:31:10.904] - force: TRUE
[15:31:10.904] - relayed: [n=1] TRUE
[15:31:10.905] - queued futures: [n=1] TRUE
 - flush all
[15:31:10.905] - relayed: [n=1] TRUE
[15:31:10.905] - queued futures: [n=1] TRUE
[15:31:10.906] signalConditionsASAP(NULL, pos=0) ... done
[15:31:10.906] resolve() on list ... DONE
[15:31:10.906]  - Number of value chunks collected: 1
[15:31:10.906] Resolving 1 futures (chunks) ... DONE
[15:31:10.907] Reducing values from 1 chunks ...
[15:31:10.907]  - Number of values collected after concatenation: 3
[15:31:10.907]  - Number of values expected: 3
[15:31:10.907] Reducing values from 1 chunks ... DONE
[15:31:10.908] future_lapply() ... DONE
[15:31:10.908] future_by_internal() ... DONE
[15:31:10.910] 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.
[15:31:10.911] future_lapply() ...
[15:31:10.915] Number of chunks: 1
[15:31:10.916] getGlobalsAndPackagesXApply() ...
[15:31:10.916]  - future.globals: TRUE
[15:31:10.916] getGlobalsAndPackages() ...
[15:31:10.917] Searching for globals...
[15:31:10.919] - globals found: [2] 'FUN', 'UseMethod'
[15:31:10.919] Searching for globals ... DONE
[15:31:10.919] Resolving globals: FALSE
[15:31:10.920] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:10.921] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:10.921] - globals: [1] 'FUN'
[15:31:10.921] 
[15:31:10.922] getGlobalsAndPackages() ... DONE
[15:31:10.922]  - globals found/used: [n=1] 'FUN'
[15:31:10.922]  - needed namespaces: [n=0] 
[15:31:10.922] Finding globals ... DONE
[15:31:10.923]  - use_args: TRUE
[15:31:10.923]  - Getting '...' globals ...
[15:31:10.924] resolve() on list ...
[15:31:10.924]  recursive: 0
[15:31:10.924]  length: 1
[15:31:10.924]  elements: '...'
[15:31:10.925]  length: 0 (resolved future 1)
[15:31:10.925] resolve() on list ... DONE
[15:31:10.925]    - '...' content: [n=0] 
[15:31:10.926] List of 1
[15:31:10.926]  $ ...: list()
[15:31:10.926]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.926]  - attr(*, "where")=List of 1
[15:31:10.926]   ..$ ...:<environment: 0x0000019c8235c920> 
[15:31:10.926]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.926]  - attr(*, "resolved")= logi TRUE
[15:31:10.926]  - attr(*, "total_size")= num NA
[15:31:10.931]  - Getting '...' globals ... DONE
[15:31:10.931] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:10.932] List of 2
[15:31:10.932]  $ ...future.FUN:function (object, ...)  
[15:31:10.932]  $ ...          : list()
[15:31:10.932]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.932]  - attr(*, "where")=List of 2
[15:31:10.932]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:10.932]   ..$ ...          :<environment: 0x0000019c8235c920> 
[15:31:10.932]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.932]  - attr(*, "resolved")= logi FALSE
[15:31:10.932]  - attr(*, "total_size")= num 1240
[15:31:10.937] Packages to be attached in all futures: [n=0] 
[15:31:10.937] getGlobalsAndPackagesXApply() ... DONE
[15:31:10.938] Number of futures (= number of chunks): 1
[15:31:10.938] Launching 1 futures (chunks) ...
[15:31:10.938] Chunk #1 of 1 ...
[15:31:10.939]  - Finding globals in 'X' for chunk #1 ...
[15:31:10.939] getGlobalsAndPackages() ...
[15:31:10.939] Searching for globals...
[15:31:10.940] 
[15:31:10.941] Searching for globals ... DONE
[15:31:10.941] - globals: [0] <none>
[15:31:10.941] getGlobalsAndPackages() ... DONE
[15:31:10.941]    + additional globals found: [n=0] 
[15:31:10.942]    + additional namespaces needed: [n=0] 
[15:31:10.942]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:10.942]  - seeds: <none>
[15:31:10.942]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.943] getGlobalsAndPackages() ...
[15:31:10.943] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.943] Resolving globals: FALSE
[15:31:10.944] Tweak future expression to call with '...' arguments ...
[15:31:10.944] {
[15:31:10.944]     do.call(function(...) {
[15:31:10.944]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.944]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.944]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.944]             on.exit(options(oopts), add = TRUE)
[15:31:10.944]         }
[15:31:10.944]         {
[15:31:10.944]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.944]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.944]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.944]             })
[15:31:10.944]         }
[15:31:10.944]     }, args = future.call.arguments)
[15:31:10.944] }
[15:31:10.945] Tweak future expression to call with '...' arguments ... DONE
[15:31:10.946] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:10.946] 
[15:31:10.946] getGlobalsAndPackages() ... DONE
[15:31:10.947] run() for 'Future' ...
[15:31:10.947] - state: 'created'
[15:31:10.948] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:10.952] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.952] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:10.953]   - Field: 'label'
[15:31:10.953]   - Field: 'local'
[15:31:10.953]   - Field: 'owner'
[15:31:10.954]   - Field: 'envir'
[15:31:10.954]   - Field: 'packages'
[15:31:10.954]   - Field: 'gc'
[15:31:10.955]   - Field: 'conditions'
[15:31:10.955]   - Field: 'expr'
[15:31:10.955]   - Field: 'uuid'
[15:31:10.955]   - Field: 'seed'
[15:31:10.956]   - Field: 'version'
[15:31:10.956]   - Field: 'result'
[15:31:10.956]   - Field: 'asynchronous'
[15:31:10.957]   - Field: 'calls'
[15:31:10.957]   - Field: 'globals'
[15:31:10.957]   - Field: 'stdout'
[15:31:10.958]   - Field: 'earlySignal'
[15:31:10.958]   - Field: 'lazy'
[15:31:10.958]   - Field: 'state'
[15:31:10.959] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:10.959] - Launch lazy future ...
[15:31:10.959] Packages needed by the future expression (n = 0): <none>
[15:31:10.960] Packages needed by future strategies (n = 0): <none>
[15:31:10.961] {
[15:31:10.961]     {
[15:31:10.961]         {
[15:31:10.961]             ...future.startTime <- base::Sys.time()
[15:31:10.961]             {
[15:31:10.961]                 {
[15:31:10.961]                   {
[15:31:10.961]                     base::local({
[15:31:10.961]                       has_future <- base::requireNamespace("future", 
[15:31:10.961]                         quietly = TRUE)
[15:31:10.961]                       if (has_future) {
[15:31:10.961]                         ns <- base::getNamespace("future")
[15:31:10.961]                         version <- ns[[".package"]][["version"]]
[15:31:10.961]                         if (is.null(version)) 
[15:31:10.961]                           version <- utils::packageVersion("future")
[15:31:10.961]                       }
[15:31:10.961]                       else {
[15:31:10.961]                         version <- NULL
[15:31:10.961]                       }
[15:31:10.961]                       if (!has_future || version < "1.8.0") {
[15:31:10.961]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:10.961]                           "", base::R.version$version.string), 
[15:31:10.961]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:10.961]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:10.961]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:10.961]                             "release", "version")], collapse = " "), 
[15:31:10.961]                           hostname = base::Sys.info()[["nodename"]])
[15:31:10.961]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:10.961]                           info)
[15:31:10.961]                         info <- base::paste(info, collapse = "; ")
[15:31:10.961]                         if (!has_future) {
[15:31:10.961]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:10.961]                             info)
[15:31:10.961]                         }
[15:31:10.961]                         else {
[15:31:10.961]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:10.961]                             info, version)
[15:31:10.961]                         }
[15:31:10.961]                         base::stop(msg)
[15:31:10.961]                       }
[15:31:10.961]                     })
[15:31:10.961]                   }
[15:31:10.961]                   ...future.strategy.old <- future::plan("list")
[15:31:10.961]                   options(future.plan = NULL)
[15:31:10.961]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.961]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:10.961]                 }
[15:31:10.961]                 ...future.workdir <- getwd()
[15:31:10.961]             }
[15:31:10.961]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:10.961]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:10.961]         }
[15:31:10.961]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:10.961]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:10.961]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:10.961]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:10.961]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:10.961]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:10.961]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:10.961]             base::names(...future.oldOptions))
[15:31:10.961]     }
[15:31:10.961]     if (FALSE) {
[15:31:10.961]     }
[15:31:10.961]     else {
[15:31:10.961]         if (TRUE) {
[15:31:10.961]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:10.961]                 open = "w")
[15:31:10.961]         }
[15:31:10.961]         else {
[15:31:10.961]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:10.961]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:10.961]         }
[15:31:10.961]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:10.961]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:10.961]             base::sink(type = "output", split = FALSE)
[15:31:10.961]             base::close(...future.stdout)
[15:31:10.961]         }, add = TRUE)
[15:31:10.961]     }
[15:31:10.961]     ...future.frame <- base::sys.nframe()
[15:31:10.961]     ...future.conditions <- base::list()
[15:31:10.961]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:10.961]     if (FALSE) {
[15:31:10.961]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:10.961]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:10.961]     }
[15:31:10.961]     ...future.result <- base::tryCatch({
[15:31:10.961]         base::withCallingHandlers({
[15:31:10.961]             ...future.value <- base::withVisible(base::local({
[15:31:10.961]                 do.call(function(...) {
[15:31:10.961]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.961]                   if (!identical(...future.globals.maxSize.org, 
[15:31:10.961]                     ...future.globals.maxSize)) {
[15:31:10.961]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.961]                     on.exit(options(oopts), add = TRUE)
[15:31:10.961]                   }
[15:31:10.961]                   {
[15:31:10.961]                     lapply(seq_along(...future.elements_ii), 
[15:31:10.961]                       FUN = function(jj) {
[15:31:10.961]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.961]                         ...future.FUN(...future.X_jj, ...)
[15:31:10.961]                       })
[15:31:10.961]                   }
[15:31:10.961]                 }, args = future.call.arguments)
[15:31:10.961]             }))
[15:31:10.961]             future::FutureResult(value = ...future.value$value, 
[15:31:10.961]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.961]                   ...future.rng), globalenv = if (FALSE) 
[15:31:10.961]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:10.961]                     ...future.globalenv.names))
[15:31:10.961]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:10.961]         }, condition = base::local({
[15:31:10.961]             c <- base::c
[15:31:10.961]             inherits <- base::inherits
[15:31:10.961]             invokeRestart <- base::invokeRestart
[15:31:10.961]             length <- base::length
[15:31:10.961]             list <- base::list
[15:31:10.961]             seq.int <- base::seq.int
[15:31:10.961]             signalCondition <- base::signalCondition
[15:31:10.961]             sys.calls <- base::sys.calls
[15:31:10.961]             `[[` <- base::`[[`
[15:31:10.961]             `+` <- base::`+`
[15:31:10.961]             `<<-` <- base::`<<-`
[15:31:10.961]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:10.961]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:10.961]                   3L)]
[15:31:10.961]             }
[15:31:10.961]             function(cond) {
[15:31:10.961]                 is_error <- inherits(cond, "error")
[15:31:10.961]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:10.961]                   NULL)
[15:31:10.961]                 if (is_error) {
[15:31:10.961]                   sessionInformation <- function() {
[15:31:10.961]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:10.961]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:10.961]                       search = base::search(), system = base::Sys.info())
[15:31:10.961]                   }
[15:31:10.961]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.961]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:10.961]                     cond$call), session = sessionInformation(), 
[15:31:10.961]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:10.961]                   signalCondition(cond)
[15:31:10.961]                 }
[15:31:10.961]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:10.961]                 "immediateCondition"))) {
[15:31:10.961]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:10.961]                   ...future.conditions[[length(...future.conditions) + 
[15:31:10.961]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:10.961]                   if (TRUE && !signal) {
[15:31:10.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.961]                     {
[15:31:10.961]                       inherits <- base::inherits
[15:31:10.961]                       invokeRestart <- base::invokeRestart
[15:31:10.961]                       is.null <- base::is.null
[15:31:10.961]                       muffled <- FALSE
[15:31:10.961]                       if (inherits(cond, "message")) {
[15:31:10.961]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.961]                         if (muffled) 
[15:31:10.961]                           invokeRestart("muffleMessage")
[15:31:10.961]                       }
[15:31:10.961]                       else if (inherits(cond, "warning")) {
[15:31:10.961]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.961]                         if (muffled) 
[15:31:10.961]                           invokeRestart("muffleWarning")
[15:31:10.961]                       }
[15:31:10.961]                       else if (inherits(cond, "condition")) {
[15:31:10.961]                         if (!is.null(pattern)) {
[15:31:10.961]                           computeRestarts <- base::computeRestarts
[15:31:10.961]                           grepl <- base::grepl
[15:31:10.961]                           restarts <- computeRestarts(cond)
[15:31:10.961]                           for (restart in restarts) {
[15:31:10.961]                             name <- restart$name
[15:31:10.961]                             if (is.null(name)) 
[15:31:10.961]                               next
[15:31:10.961]                             if (!grepl(pattern, name)) 
[15:31:10.961]                               next
[15:31:10.961]                             invokeRestart(restart)
[15:31:10.961]                             muffled <- TRUE
[15:31:10.961]                             break
[15:31:10.961]                           }
[15:31:10.961]                         }
[15:31:10.961]                       }
[15:31:10.961]                       invisible(muffled)
[15:31:10.961]                     }
[15:31:10.961]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.961]                   }
[15:31:10.961]                 }
[15:31:10.961]                 else {
[15:31:10.961]                   if (TRUE) {
[15:31:10.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:10.961]                     {
[15:31:10.961]                       inherits <- base::inherits
[15:31:10.961]                       invokeRestart <- base::invokeRestart
[15:31:10.961]                       is.null <- base::is.null
[15:31:10.961]                       muffled <- FALSE
[15:31:10.961]                       if (inherits(cond, "message")) {
[15:31:10.961]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:10.961]                         if (muffled) 
[15:31:10.961]                           invokeRestart("muffleMessage")
[15:31:10.961]                       }
[15:31:10.961]                       else if (inherits(cond, "warning")) {
[15:31:10.961]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:10.961]                         if (muffled) 
[15:31:10.961]                           invokeRestart("muffleWarning")
[15:31:10.961]                       }
[15:31:10.961]                       else if (inherits(cond, "condition")) {
[15:31:10.961]                         if (!is.null(pattern)) {
[15:31:10.961]                           computeRestarts <- base::computeRestarts
[15:31:10.961]                           grepl <- base::grepl
[15:31:10.961]                           restarts <- computeRestarts(cond)
[15:31:10.961]                           for (restart in restarts) {
[15:31:10.961]                             name <- restart$name
[15:31:10.961]                             if (is.null(name)) 
[15:31:10.961]                               next
[15:31:10.961]                             if (!grepl(pattern, name)) 
[15:31:10.961]                               next
[15:31:10.961]                             invokeRestart(restart)
[15:31:10.961]                             muffled <- TRUE
[15:31:10.961]                             break
[15:31:10.961]                           }
[15:31:10.961]                         }
[15:31:10.961]                       }
[15:31:10.961]                       invisible(muffled)
[15:31:10.961]                     }
[15:31:10.961]                     muffleCondition(cond, pattern = "^muffle")
[15:31:10.961]                   }
[15:31:10.961]                 }
[15:31:10.961]             }
[15:31:10.961]         }))
[15:31:10.961]     }, error = function(ex) {
[15:31:10.961]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:10.961]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:10.961]                 ...future.rng), started = ...future.startTime, 
[15:31:10.961]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:10.961]             version = "1.8"), class = "FutureResult")
[15:31:10.961]     }, finally = {
[15:31:10.961]         if (!identical(...future.workdir, getwd())) 
[15:31:10.961]             setwd(...future.workdir)
[15:31:10.961]         {
[15:31:10.961]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:10.961]                 ...future.oldOptions$nwarnings <- NULL
[15:31:10.961]             }
[15:31:10.961]             base::options(...future.oldOptions)
[15:31:10.961]             if (.Platform$OS.type == "windows") {
[15:31:10.961]                 old_names <- names(...future.oldEnvVars)
[15:31:10.961]                 envs <- base::Sys.getenv()
[15:31:10.961]                 names <- names(envs)
[15:31:10.961]                 common <- intersect(names, old_names)
[15:31:10.961]                 added <- setdiff(names, old_names)
[15:31:10.961]                 removed <- setdiff(old_names, names)
[15:31:10.961]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:10.961]                   envs[common]]
[15:31:10.961]                 NAMES <- toupper(changed)
[15:31:10.961]                 args <- list()
[15:31:10.961]                 for (kk in seq_along(NAMES)) {
[15:31:10.961]                   name <- changed[[kk]]
[15:31:10.961]                   NAME <- NAMES[[kk]]
[15:31:10.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.961]                     next
[15:31:10.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.961]                 }
[15:31:10.961]                 NAMES <- toupper(added)
[15:31:10.961]                 for (kk in seq_along(NAMES)) {
[15:31:10.961]                   name <- added[[kk]]
[15:31:10.961]                   NAME <- NAMES[[kk]]
[15:31:10.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.961]                     next
[15:31:10.961]                   args[[name]] <- ""
[15:31:10.961]                 }
[15:31:10.961]                 NAMES <- toupper(removed)
[15:31:10.961]                 for (kk in seq_along(NAMES)) {
[15:31:10.961]                   name <- removed[[kk]]
[15:31:10.961]                   NAME <- NAMES[[kk]]
[15:31:10.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:10.961]                     next
[15:31:10.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:10.961]                 }
[15:31:10.961]                 if (length(args) > 0) 
[15:31:10.961]                   base::do.call(base::Sys.setenv, args = args)
[15:31:10.961]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:10.961]             }
[15:31:10.961]             else {
[15:31:10.961]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:10.961]             }
[15:31:10.961]             {
[15:31:10.961]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:10.961]                   0L) {
[15:31:10.961]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:10.961]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:10.961]                   base::options(opts)
[15:31:10.961]                 }
[15:31:10.961]                 {
[15:31:10.961]                   {
[15:31:10.961]                     NULL
[15:31:10.961]                     RNGkind("Mersenne-Twister")
[15:31:10.961]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:10.961]                       inherits = FALSE)
[15:31:10.961]                   }
[15:31:10.961]                   options(future.plan = NULL)
[15:31:10.961]                   if (is.na(NA_character_)) 
[15:31:10.961]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:10.961]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:10.961]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:10.961]                     .init = FALSE)
[15:31:10.961]                 }
[15:31:10.961]             }
[15:31:10.961]         }
[15:31:10.961]     })
[15:31:10.961]     if (TRUE) {
[15:31:10.961]         base::sink(type = "output", split = FALSE)
[15:31:10.961]         if (TRUE) {
[15:31:10.961]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:10.961]         }
[15:31:10.961]         else {
[15:31:10.961]             ...future.result["stdout"] <- base::list(NULL)
[15:31:10.961]         }
[15:31:10.961]         base::close(...future.stdout)
[15:31:10.961]         ...future.stdout <- NULL
[15:31:10.961]     }
[15:31:10.961]     ...future.result$conditions <- ...future.conditions
[15:31:10.961]     ...future.result$finished <- base::Sys.time()
[15:31:10.961]     ...future.result
[15:31:10.961] }
[15:31:10.968] assign_globals() ...
[15:31:10.968] List of 5
[15:31:10.968]  $ ...future.FUN            :function (object, ...)  
[15:31:10.968]  $ future.call.arguments    : list()
[15:31:10.968]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:10.968]  $ ...future.elements_ii    :List of 3
[15:31:10.968]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.968]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:10.968]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.968]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:10.968]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.968]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:10.968]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.968]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:10.968]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:10.968]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:10.968]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:10.968]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:10.968]  $ ...future.seeds_ii       : NULL
[15:31:10.968]  $ ...future.globals.maxSize: NULL
[15:31:10.968]  - attr(*, "where")=List of 5
[15:31:10.968]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:10.968]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:10.968]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:10.968]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:10.968]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:10.968]  - attr(*, "resolved")= logi FALSE
[15:31:10.968]  - attr(*, "total_size")= num 1240
[15:31:10.968]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:10.968]  - attr(*, "already-done")= logi TRUE
[15:31:10.984] - copied '...future.FUN' to environment
[15:31:10.984] - copied 'future.call.arguments' to environment
[15:31:10.985] - copied '...future.elements_ii' to environment
[15:31:10.985] - copied '...future.seeds_ii' to environment
[15:31:10.985] - copied '...future.globals.maxSize' to environment
[15:31:10.986] assign_globals() ... done
[15:31:10.987] plan(): Setting new future strategy stack:
[15:31:10.987] List of future strategies:
[15:31:10.987] 1. sequential:
[15:31:10.987]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:10.987]    - tweaked: FALSE
[15:31:10.987]    - call: NULL
[15:31:10.988] plan(): nbrOfWorkers() = 1
[15:31:10.993] plan(): Setting new future strategy stack:
[15:31:10.993] List of future strategies:
[15:31:10.993] 1. multisession:
[15:31:10.993]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:10.993]    - tweaked: FALSE
[15:31:10.993]    - call: plan(strategy)
[15:31:10.996] plan(): nbrOfWorkers() = 1
[15:31:10.996] SequentialFuture started (and completed)
[15:31:10.997] - Launch lazy future ... done
[15:31:10.997] run() for 'SequentialFuture' ... done
[15:31:10.997] Created future:
[15:31:10.997] SequentialFuture:
[15:31:10.997] Label: 'future_by-1'
[15:31:10.997] Expression:
[15:31:10.997] {
[15:31:10.997]     do.call(function(...) {
[15:31:10.997]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:10.997]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:10.997]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:10.997]             on.exit(options(oopts), add = TRUE)
[15:31:10.997]         }
[15:31:10.997]         {
[15:31:10.997]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:10.997]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:10.997]                 ...future.FUN(...future.X_jj, ...)
[15:31:10.997]             })
[15:31:10.997]         }
[15:31:10.997]     }, args = future.call.arguments)
[15:31:10.997] }
[15:31:10.997] Lazy evaluation: FALSE
[15:31:10.997] Asynchronous evaluation: FALSE
[15:31:10.997] Local evaluation: TRUE
[15:31:10.997] Environment: 0x0000019c82329aa8
[15:31:10.997] Capture standard output: TRUE
[15:31:10.997] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:10.997] Globals: 5 objects totaling 6.02 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:10.997] Packages: <none>
[15:31:10.997] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:10.997] Resolved: TRUE
[15:31:10.997] Value: 5.37 KiB of class 'list'
[15:31:10.997] Early signaling: FALSE
[15:31:10.997] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:10.997] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:10.999] Chunk #1 of 1 ... DONE
[15:31:11.000] Launching 1 futures (chunks) ... DONE
[15:31:11.000] Resolving 1 futures (chunks) ...
[15:31:11.000] resolve() on list ...
[15:31:11.000]  recursive: 0
[15:31:11.000]  length: 1
[15:31:11.001] 
[15:31:11.001] resolved() for 'SequentialFuture' ...
[15:31:11.001] - state: 'finished'
[15:31:11.001] - run: TRUE
[15:31:11.002] - result: 'FutureResult'
[15:31:11.002] resolved() for 'SequentialFuture' ... done
[15:31:11.002] Future #1
[15:31:11.002] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.003] - nx: 1
[15:31:11.003] - relay: TRUE
[15:31:11.003] - stdout: TRUE
[15:31:11.003] - signal: TRUE
[15:31:11.003] - resignal: FALSE
[15:31:11.003] - force: TRUE
[15:31:11.004] - relayed: [n=1] FALSE
[15:31:11.004] - queued futures: [n=1] FALSE
[15:31:11.004]  - until=1
[15:31:11.004]  - relaying element #1
[15:31:11.004] - relayed: [n=1] TRUE
[15:31:11.007] - queued futures: [n=1] TRUE
[15:31:11.007] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.007]  length: 0 (resolved future 1)
[15:31:11.007] Relaying remaining futures
[15:31:11.007] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.007] - nx: 1
[15:31:11.008] - relay: TRUE
[15:31:11.008] - stdout: TRUE
[15:31:11.008] - signal: TRUE
[15:31:11.008] - resignal: FALSE
[15:31:11.008] - force: TRUE
[15:31:11.008] - relayed: [n=1] TRUE
[15:31:11.009] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.009] - relayed: [n=1] TRUE
[15:31:11.009] - queued futures: [n=1] TRUE
[15:31:11.009] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.009] resolve() on list ... DONE
[15:31:11.010]  - Number of value chunks collected: 1
[15:31:11.010] Resolving 1 futures (chunks) ... DONE
[15:31:11.010] Reducing values from 1 chunks ...
[15:31:11.010]  - Number of values collected after concatenation: 3
[15:31:11.010]  - Number of values expected: 3
[15:31:11.010] Reducing values from 1 chunks ... DONE
[15:31:11.011] future_lapply() ... DONE
[15:31:11.011] future_by_internal() ... DONE
[15:31:11.012] future_by_internal() ...
Testing with 1 cores ... DONE
Testing with 2 cores ...
- plan('sequential') ...
[15:31:11.013] plan(): Setting new future strategy stack:
[15:31:11.013] List of future strategies:
[15:31:11.013] 1. sequential:
[15:31:11.013]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.013]    - tweaked: FALSE
[15:31:11.013]    - call: plan(strategy)
[15:31:11.014] plan(): nbrOfWorkers() = 1
[15:31:11.014] future_by_internal() ...
[15:31:11.015] future_lapply() ...
[15:31:11.016] Number of chunks: 1
[15:31:11.016] getGlobalsAndPackagesXApply() ...
[15:31:11.017]  - future.globals: TRUE
[15:31:11.017] getGlobalsAndPackages() ...
[15:31:11.017] Searching for globals...
[15:31:11.018] - globals found: [2] 'FUN', 'UseMethod'
[15:31:11.019] Searching for globals ... DONE
[15:31:11.019] Resolving globals: FALSE
[15:31:11.019] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:11.020] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:11.020] - globals: [1] 'FUN'
[15:31:11.020] 
[15:31:11.021] getGlobalsAndPackages() ... DONE
[15:31:11.021]  - globals found/used: [n=1] 'FUN'
[15:31:11.021]  - needed namespaces: [n=0] 
[15:31:11.021] Finding globals ... DONE
[15:31:11.022]  - use_args: TRUE
[15:31:11.022]  - Getting '...' globals ...
[15:31:11.023] resolve() on list ...
[15:31:11.023]  recursive: 0
[15:31:11.023]  length: 1
[15:31:11.023]  elements: '...'
[15:31:11.024]  length: 0 (resolved future 1)
[15:31:11.024] resolve() on list ... DONE
[15:31:11.024]    - '...' content: [n=0] 
[15:31:11.025] List of 1
[15:31:11.025]  $ ...: list()
[15:31:11.025]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.025]  - attr(*, "where")=List of 1
[15:31:11.025]   ..$ ...:<environment: 0x0000019c7ff86848> 
[15:31:11.025]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.025]  - attr(*, "resolved")= logi TRUE
[15:31:11.025]  - attr(*, "total_size")= num NA
[15:31:11.029]  - Getting '...' globals ... DONE
[15:31:11.030] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:11.030] List of 2
[15:31:11.030]  $ ...future.FUN:function (object, ...)  
[15:31:11.030]  $ ...          : list()
[15:31:11.030]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.030]  - attr(*, "where")=List of 2
[15:31:11.030]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:11.030]   ..$ ...          :<environment: 0x0000019c7ff86848> 
[15:31:11.030]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.030]  - attr(*, "resolved")= logi FALSE
[15:31:11.030]  - attr(*, "total_size")= num 1240
[15:31:11.035] Packages to be attached in all futures: [n=0] 
[15:31:11.036] getGlobalsAndPackagesXApply() ... DONE
[15:31:11.036] Number of futures (= number of chunks): 1
[15:31:11.036] Launching 1 futures (chunks) ...
[15:31:11.037] Chunk #1 of 1 ...
[15:31:11.037]  - Finding globals in 'X' for chunk #1 ...
[15:31:11.037] getGlobalsAndPackages() ...
[15:31:11.038] Searching for globals...
[15:31:11.039] 
[15:31:11.039] Searching for globals ... DONE
[15:31:11.039] - globals: [0] <none>
[15:31:11.039] getGlobalsAndPackages() ... DONE
[15:31:11.040]    + additional globals found: [n=0] 
[15:31:11.040]    + additional namespaces needed: [n=0] 
[15:31:11.040]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:11.041]  - seeds: <none>
[15:31:11.041]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.041] getGlobalsAndPackages() ...
[15:31:11.041] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.042] Resolving globals: FALSE
[15:31:11.042] Tweak future expression to call with '...' arguments ...
[15:31:11.042] {
[15:31:11.042]     do.call(function(...) {
[15:31:11.042]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.042]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.042]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.042]             on.exit(options(oopts), add = TRUE)
[15:31:11.042]         }
[15:31:11.042]         {
[15:31:11.042]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.042]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.042]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.042]             })
[15:31:11.042]         }
[15:31:11.042]     }, args = future.call.arguments)
[15:31:11.042] }
[15:31:11.043] Tweak future expression to call with '...' arguments ... DONE
[15:31:11.044] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.044] 
[15:31:11.044] getGlobalsAndPackages() ... DONE
[15:31:11.045] run() for 'Future' ...
[15:31:11.045] - state: 'created'
[15:31:11.046] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:11.046] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.046] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:11.047]   - Field: 'label'
[15:31:11.047]   - Field: 'local'
[15:31:11.047]   - Field: 'owner'
[15:31:11.047]   - Field: 'envir'
[15:31:11.048]   - Field: 'packages'
[15:31:11.048]   - Field: 'gc'
[15:31:11.048]   - Field: 'conditions'
[15:31:11.049]   - Field: 'expr'
[15:31:11.049]   - Field: 'uuid'
[15:31:11.049]   - Field: 'seed'
[15:31:11.050]   - Field: 'version'
[15:31:11.050]   - Field: 'result'
[15:31:11.050]   - Field: 'asynchronous'
[15:31:11.051]   - Field: 'calls'
[15:31:11.051]   - Field: 'globals'
[15:31:11.051]   - Field: 'stdout'
[15:31:11.051]   - Field: 'earlySignal'
[15:31:11.052]   - Field: 'lazy'
[15:31:11.052]   - Field: 'state'
[15:31:11.052] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:11.053] - Launch lazy future ...
[15:31:11.053] Packages needed by the future expression (n = 0): <none>
[15:31:11.053] Packages needed by future strategies (n = 0): <none>
[15:31:11.054] {
[15:31:11.054]     {
[15:31:11.054]         {
[15:31:11.054]             ...future.startTime <- base::Sys.time()
[15:31:11.054]             {
[15:31:11.054]                 {
[15:31:11.054]                   {
[15:31:11.054]                     base::local({
[15:31:11.054]                       has_future <- base::requireNamespace("future", 
[15:31:11.054]                         quietly = TRUE)
[15:31:11.054]                       if (has_future) {
[15:31:11.054]                         ns <- base::getNamespace("future")
[15:31:11.054]                         version <- ns[[".package"]][["version"]]
[15:31:11.054]                         if (is.null(version)) 
[15:31:11.054]                           version <- utils::packageVersion("future")
[15:31:11.054]                       }
[15:31:11.054]                       else {
[15:31:11.054]                         version <- NULL
[15:31:11.054]                       }
[15:31:11.054]                       if (!has_future || version < "1.8.0") {
[15:31:11.054]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:11.054]                           "", base::R.version$version.string), 
[15:31:11.054]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:11.054]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:11.054]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:11.054]                             "release", "version")], collapse = " "), 
[15:31:11.054]                           hostname = base::Sys.info()[["nodename"]])
[15:31:11.054]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:11.054]                           info)
[15:31:11.054]                         info <- base::paste(info, collapse = "; ")
[15:31:11.054]                         if (!has_future) {
[15:31:11.054]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:11.054]                             info)
[15:31:11.054]                         }
[15:31:11.054]                         else {
[15:31:11.054]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:11.054]                             info, version)
[15:31:11.054]                         }
[15:31:11.054]                         base::stop(msg)
[15:31:11.054]                       }
[15:31:11.054]                     })
[15:31:11.054]                   }
[15:31:11.054]                   ...future.strategy.old <- future::plan("list")
[15:31:11.054]                   options(future.plan = NULL)
[15:31:11.054]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.054]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:11.054]                 }
[15:31:11.054]                 ...future.workdir <- getwd()
[15:31:11.054]             }
[15:31:11.054]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:11.054]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:11.054]         }
[15:31:11.054]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:11.054]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:11.054]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:11.054]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:11.054]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:11.054]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:11.054]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:11.054]             base::names(...future.oldOptions))
[15:31:11.054]     }
[15:31:11.054]     if (FALSE) {
[15:31:11.054]     }
[15:31:11.054]     else {
[15:31:11.054]         if (TRUE) {
[15:31:11.054]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:11.054]                 open = "w")
[15:31:11.054]         }
[15:31:11.054]         else {
[15:31:11.054]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:11.054]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:11.054]         }
[15:31:11.054]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:11.054]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:11.054]             base::sink(type = "output", split = FALSE)
[15:31:11.054]             base::close(...future.stdout)
[15:31:11.054]         }, add = TRUE)
[15:31:11.054]     }
[15:31:11.054]     ...future.frame <- base::sys.nframe()
[15:31:11.054]     ...future.conditions <- base::list()
[15:31:11.054]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:11.054]     if (FALSE) {
[15:31:11.054]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:11.054]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:11.054]     }
[15:31:11.054]     ...future.result <- base::tryCatch({
[15:31:11.054]         base::withCallingHandlers({
[15:31:11.054]             ...future.value <- base::withVisible(base::local({
[15:31:11.054]                 do.call(function(...) {
[15:31:11.054]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.054]                   if (!identical(...future.globals.maxSize.org, 
[15:31:11.054]                     ...future.globals.maxSize)) {
[15:31:11.054]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.054]                     on.exit(options(oopts), add = TRUE)
[15:31:11.054]                   }
[15:31:11.054]                   {
[15:31:11.054]                     lapply(seq_along(...future.elements_ii), 
[15:31:11.054]                       FUN = function(jj) {
[15:31:11.054]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.054]                         ...future.FUN(...future.X_jj, ...)
[15:31:11.054]                       })
[15:31:11.054]                   }
[15:31:11.054]                 }, args = future.call.arguments)
[15:31:11.054]             }))
[15:31:11.054]             future::FutureResult(value = ...future.value$value, 
[15:31:11.054]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.054]                   ...future.rng), globalenv = if (FALSE) 
[15:31:11.054]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:11.054]                     ...future.globalenv.names))
[15:31:11.054]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:11.054]         }, condition = base::local({
[15:31:11.054]             c <- base::c
[15:31:11.054]             inherits <- base::inherits
[15:31:11.054]             invokeRestart <- base::invokeRestart
[15:31:11.054]             length <- base::length
[15:31:11.054]             list <- base::list
[15:31:11.054]             seq.int <- base::seq.int
[15:31:11.054]             signalCondition <- base::signalCondition
[15:31:11.054]             sys.calls <- base::sys.calls
[15:31:11.054]             `[[` <- base::`[[`
[15:31:11.054]             `+` <- base::`+`
[15:31:11.054]             `<<-` <- base::`<<-`
[15:31:11.054]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:11.054]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:11.054]                   3L)]
[15:31:11.054]             }
[15:31:11.054]             function(cond) {
[15:31:11.054]                 is_error <- inherits(cond, "error")
[15:31:11.054]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:11.054]                   NULL)
[15:31:11.054]                 if (is_error) {
[15:31:11.054]                   sessionInformation <- function() {
[15:31:11.054]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:11.054]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:11.054]                       search = base::search(), system = base::Sys.info())
[15:31:11.054]                   }
[15:31:11.054]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.054]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:11.054]                     cond$call), session = sessionInformation(), 
[15:31:11.054]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:11.054]                   signalCondition(cond)
[15:31:11.054]                 }
[15:31:11.054]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:11.054]                 "immediateCondition"))) {
[15:31:11.054]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:11.054]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.054]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:11.054]                   if (TRUE && !signal) {
[15:31:11.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.054]                     {
[15:31:11.054]                       inherits <- base::inherits
[15:31:11.054]                       invokeRestart <- base::invokeRestart
[15:31:11.054]                       is.null <- base::is.null
[15:31:11.054]                       muffled <- FALSE
[15:31:11.054]                       if (inherits(cond, "message")) {
[15:31:11.054]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.054]                         if (muffled) 
[15:31:11.054]                           invokeRestart("muffleMessage")
[15:31:11.054]                       }
[15:31:11.054]                       else if (inherits(cond, "warning")) {
[15:31:11.054]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.054]                         if (muffled) 
[15:31:11.054]                           invokeRestart("muffleWarning")
[15:31:11.054]                       }
[15:31:11.054]                       else if (inherits(cond, "condition")) {
[15:31:11.054]                         if (!is.null(pattern)) {
[15:31:11.054]                           computeRestarts <- base::computeRestarts
[15:31:11.054]                           grepl <- base::grepl
[15:31:11.054]                           restarts <- computeRestarts(cond)
[15:31:11.054]                           for (restart in restarts) {
[15:31:11.054]                             name <- restart$name
[15:31:11.054]                             if (is.null(name)) 
[15:31:11.054]                               next
[15:31:11.054]                             if (!grepl(pattern, name)) 
[15:31:11.054]                               next
[15:31:11.054]                             invokeRestart(restart)
[15:31:11.054]                             muffled <- TRUE
[15:31:11.054]                             break
[15:31:11.054]                           }
[15:31:11.054]                         }
[15:31:11.054]                       }
[15:31:11.054]                       invisible(muffled)
[15:31:11.054]                     }
[15:31:11.054]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.054]                   }
[15:31:11.054]                 }
[15:31:11.054]                 else {
[15:31:11.054]                   if (TRUE) {
[15:31:11.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.054]                     {
[15:31:11.054]                       inherits <- base::inherits
[15:31:11.054]                       invokeRestart <- base::invokeRestart
[15:31:11.054]                       is.null <- base::is.null
[15:31:11.054]                       muffled <- FALSE
[15:31:11.054]                       if (inherits(cond, "message")) {
[15:31:11.054]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.054]                         if (muffled) 
[15:31:11.054]                           invokeRestart("muffleMessage")
[15:31:11.054]                       }
[15:31:11.054]                       else if (inherits(cond, "warning")) {
[15:31:11.054]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.054]                         if (muffled) 
[15:31:11.054]                           invokeRestart("muffleWarning")
[15:31:11.054]                       }
[15:31:11.054]                       else if (inherits(cond, "condition")) {
[15:31:11.054]                         if (!is.null(pattern)) {
[15:31:11.054]                           computeRestarts <- base::computeRestarts
[15:31:11.054]                           grepl <- base::grepl
[15:31:11.054]                           restarts <- computeRestarts(cond)
[15:31:11.054]                           for (restart in restarts) {
[15:31:11.054]                             name <- restart$name
[15:31:11.054]                             if (is.null(name)) 
[15:31:11.054]                               next
[15:31:11.054]                             if (!grepl(pattern, name)) 
[15:31:11.054]                               next
[15:31:11.054]                             invokeRestart(restart)
[15:31:11.054]                             muffled <- TRUE
[15:31:11.054]                             break
[15:31:11.054]                           }
[15:31:11.054]                         }
[15:31:11.054]                       }
[15:31:11.054]                       invisible(muffled)
[15:31:11.054]                     }
[15:31:11.054]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.054]                   }
[15:31:11.054]                 }
[15:31:11.054]             }
[15:31:11.054]         }))
[15:31:11.054]     }, error = function(ex) {
[15:31:11.054]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:11.054]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.054]                 ...future.rng), started = ...future.startTime, 
[15:31:11.054]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:11.054]             version = "1.8"), class = "FutureResult")
[15:31:11.054]     }, finally = {
[15:31:11.054]         if (!identical(...future.workdir, getwd())) 
[15:31:11.054]             setwd(...future.workdir)
[15:31:11.054]         {
[15:31:11.054]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:11.054]                 ...future.oldOptions$nwarnings <- NULL
[15:31:11.054]             }
[15:31:11.054]             base::options(...future.oldOptions)
[15:31:11.054]             if (.Platform$OS.type == "windows") {
[15:31:11.054]                 old_names <- names(...future.oldEnvVars)
[15:31:11.054]                 envs <- base::Sys.getenv()
[15:31:11.054]                 names <- names(envs)
[15:31:11.054]                 common <- intersect(names, old_names)
[15:31:11.054]                 added <- setdiff(names, old_names)
[15:31:11.054]                 removed <- setdiff(old_names, names)
[15:31:11.054]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:11.054]                   envs[common]]
[15:31:11.054]                 NAMES <- toupper(changed)
[15:31:11.054]                 args <- list()
[15:31:11.054]                 for (kk in seq_along(NAMES)) {
[15:31:11.054]                   name <- changed[[kk]]
[15:31:11.054]                   NAME <- NAMES[[kk]]
[15:31:11.054]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.054]                     next
[15:31:11.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.054]                 }
[15:31:11.054]                 NAMES <- toupper(added)
[15:31:11.054]                 for (kk in seq_along(NAMES)) {
[15:31:11.054]                   name <- added[[kk]]
[15:31:11.054]                   NAME <- NAMES[[kk]]
[15:31:11.054]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.054]                     next
[15:31:11.054]                   args[[name]] <- ""
[15:31:11.054]                 }
[15:31:11.054]                 NAMES <- toupper(removed)
[15:31:11.054]                 for (kk in seq_along(NAMES)) {
[15:31:11.054]                   name <- removed[[kk]]
[15:31:11.054]                   NAME <- NAMES[[kk]]
[15:31:11.054]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.054]                     next
[15:31:11.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.054]                 }
[15:31:11.054]                 if (length(args) > 0) 
[15:31:11.054]                   base::do.call(base::Sys.setenv, args = args)
[15:31:11.054]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:11.054]             }
[15:31:11.054]             else {
[15:31:11.054]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:11.054]             }
[15:31:11.054]             {
[15:31:11.054]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:11.054]                   0L) {
[15:31:11.054]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:11.054]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:11.054]                   base::options(opts)
[15:31:11.054]                 }
[15:31:11.054]                 {
[15:31:11.054]                   {
[15:31:11.054]                     NULL
[15:31:11.054]                     RNGkind("Mersenne-Twister")
[15:31:11.054]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:11.054]                       inherits = FALSE)
[15:31:11.054]                   }
[15:31:11.054]                   options(future.plan = NULL)
[15:31:11.054]                   if (is.na(NA_character_)) 
[15:31:11.054]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.054]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:11.054]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:11.054]                     .init = FALSE)
[15:31:11.054]                 }
[15:31:11.054]             }
[15:31:11.054]         }
[15:31:11.054]     })
[15:31:11.054]     if (TRUE) {
[15:31:11.054]         base::sink(type = "output", split = FALSE)
[15:31:11.054]         if (TRUE) {
[15:31:11.054]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:11.054]         }
[15:31:11.054]         else {
[15:31:11.054]             ...future.result["stdout"] <- base::list(NULL)
[15:31:11.054]         }
[15:31:11.054]         base::close(...future.stdout)
[15:31:11.054]         ...future.stdout <- NULL
[15:31:11.054]     }
[15:31:11.054]     ...future.result$conditions <- ...future.conditions
[15:31:11.054]     ...future.result$finished <- base::Sys.time()
[15:31:11.054]     ...future.result
[15:31:11.054] }
[15:31:11.061] assign_globals() ...
[15:31:11.062] List of 5
[15:31:11.062]  $ ...future.FUN            :function (object, ...)  
[15:31:11.062]  $ future.call.arguments    : list()
[15:31:11.062]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.062]  $ ...future.elements_ii    :List of 3
[15:31:11.062]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:11.062]   .. ..$ breaks: num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:11.062]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.062]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:11.062]   .. ..$ breaks: num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:11.062]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.062]   ..$ :'data.frame':	18 obs. of  2 variables:
[15:31:11.062]   .. ..$ breaks: num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:11.062]   .. ..$ wool  : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.062]  $ ...future.seeds_ii       : NULL
[15:31:11.062]  $ ...future.globals.maxSize: NULL
[15:31:11.062]  - attr(*, "where")=List of 5
[15:31:11.062]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:11.062]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:11.062]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:11.062]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:11.062]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:11.062]  - attr(*, "resolved")= logi FALSE
[15:31:11.062]  - attr(*, "total_size")= num 1240
[15:31:11.062]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.062]  - attr(*, "already-done")= logi TRUE
[15:31:11.075] - copied '...future.FUN' to environment
[15:31:11.075] - copied 'future.call.arguments' to environment
[15:31:11.075] - copied '...future.elements_ii' to environment
[15:31:11.075] - copied '...future.seeds_ii' to environment
[15:31:11.076] - copied '...future.globals.maxSize' to environment
[15:31:11.076] assign_globals() ... done
[15:31:11.077] plan(): Setting new future strategy stack:
[15:31:11.077] List of future strategies:
[15:31:11.077] 1. sequential:
[15:31:11.077]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.077]    - tweaked: FALSE
[15:31:11.077]    - call: NULL
[15:31:11.078] plan(): nbrOfWorkers() = 1
[15:31:11.083] plan(): Setting new future strategy stack:
[15:31:11.083] List of future strategies:
[15:31:11.083] 1. sequential:
[15:31:11.083]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.083]    - tweaked: FALSE
[15:31:11.083]    - call: plan(strategy)
[15:31:11.084] plan(): nbrOfWorkers() = 1
[15:31:11.085] SequentialFuture started (and completed)
[15:31:11.085] - Launch lazy future ... done
[15:31:11.085] run() for 'SequentialFuture' ... done
[15:31:11.086] Created future:
[15:31:11.086] SequentialFuture:
[15:31:11.086] Label: 'future_by-1'
[15:31:11.086] Expression:
[15:31:11.086] {
[15:31:11.086]     do.call(function(...) {
[15:31:11.086]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.086]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.086]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.086]             on.exit(options(oopts), add = TRUE)
[15:31:11.086]         }
[15:31:11.086]         {
[15:31:11.086]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.086]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.086]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.086]             })
[15:31:11.086]         }
[15:31:11.086]     }, args = future.call.arguments)
[15:31:11.086] }
[15:31:11.086] Lazy evaluation: FALSE
[15:31:11.086] Asynchronous evaluation: FALSE
[15:31:11.086] Local evaluation: TRUE
[15:31:11.086] Environment: R_GlobalEnv
[15:31:11.086] Capture standard output: TRUE
[15:31:11.086] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:11.086] Globals: 5 objects totaling 3.79 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 2.58 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:11.086] Packages: <none>
[15:31:11.086] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:11.086] Resolved: TRUE
[15:31:11.086] Value: 4.62 KiB of class 'list'
[15:31:11.086] Early signaling: FALSE
[15:31:11.086] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:11.086] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.089] Chunk #1 of 1 ... DONE
[15:31:11.089] Launching 1 futures (chunks) ... DONE
[15:31:11.089] Resolving 1 futures (chunks) ...
[15:31:11.090] resolve() on list ...
[15:31:11.090]  recursive: 0
[15:31:11.090]  length: 1
[15:31:11.090] 
[15:31:11.091] resolved() for 'SequentialFuture' ...
[15:31:11.091] - state: 'finished'
[15:31:11.091] - run: TRUE
[15:31:11.092] - result: 'FutureResult'
[15:31:11.092] resolved() for 'SequentialFuture' ... done
[15:31:11.092] Future #1
[15:31:11.093] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.093] - nx: 1
[15:31:11.093] - relay: TRUE
[15:31:11.094] - stdout: TRUE
[15:31:11.094] - signal: TRUE
[15:31:11.094] - resignal: FALSE
[15:31:11.095] - force: TRUE
[15:31:11.095] - relayed: [n=1] FALSE
[15:31:11.095] - queued futures: [n=1] FALSE
[15:31:11.095]  - until=1
[15:31:11.096]  - relaying element #1
[15:31:11.096] - relayed: [n=1] TRUE
[15:31:11.097] - queued futures: [n=1] TRUE
[15:31:11.097] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.097]  length: 0 (resolved future 1)
[15:31:11.097] Relaying remaining futures
[15:31:11.098] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.098] - nx: 1
[15:31:11.098] - relay: TRUE
[15:31:11.099] - stdout: TRUE
[15:31:11.099] - signal: TRUE
[15:31:11.099] - resignal: FALSE
[15:31:11.099] - force: TRUE
[15:31:11.100] - relayed: [n=1] TRUE
[15:31:11.100] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.100] - relayed: [n=1] TRUE
[15:31:11.101] - queued futures: [n=1] TRUE
[15:31:11.101] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.101] resolve() on list ... DONE
[15:31:11.102]  - Number of value chunks collected: 1
[15:31:11.102] Resolving 1 futures (chunks) ... DONE
[15:31:11.102] Reducing values from 1 chunks ...
[15:31:11.103]  - Number of values collected after concatenation: 3
[15:31:11.103]  - Number of values expected: 3
[15:31:11.103] Reducing values from 1 chunks ... DONE
[15:31:11.103] future_lapply() ... DONE
[15:31:11.104] future_by_internal() ... DONE
[15:31:11.104] future_by_internal() ...
[15:31:11.105] future_lapply() ...
[15:31:11.106] Number of chunks: 1
[15:31:11.107] getGlobalsAndPackagesXApply() ...
[15:31:11.107]  - future.globals: TRUE
[15:31:11.107] getGlobalsAndPackages() ...
[15:31:11.108] Searching for globals...
[15:31:11.110] - globals found: [2] 'FUN', 'UseMethod'
[15:31:11.110] Searching for globals ... DONE
[15:31:11.110] Resolving globals: FALSE
[15:31:11.111] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:11.112] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:11.112] - globals: [1] 'FUN'
[15:31:11.113] 
[15:31:11.113] getGlobalsAndPackages() ... DONE
[15:31:11.113]  - globals found/used: [n=1] 'FUN'
[15:31:11.114]  - needed namespaces: [n=0] 
[15:31:11.114] Finding globals ... DONE
[15:31:11.114]  - use_args: TRUE
[15:31:11.114]  - Getting '...' globals ...
[15:31:11.115] resolve() on list ...
[15:31:11.115]  recursive: 0
[15:31:11.116]  length: 1
[15:31:11.116]  elements: '...'
[15:31:11.116]  length: 0 (resolved future 1)
[15:31:11.117] resolve() on list ... DONE
[15:31:11.117]    - '...' content: [n=1] 'digits'
[15:31:11.117] List of 1
[15:31:11.117]  $ ...:List of 1
[15:31:11.117]   ..$ digits: int 2
[15:31:11.117]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.117]  - attr(*, "where")=List of 1
[15:31:11.117]   ..$ ...:<environment: 0x0000019c825bf9e0> 
[15:31:11.117]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.117]  - attr(*, "resolved")= logi TRUE
[15:31:11.117]  - attr(*, "total_size")= num NA
[15:31:11.124]  - Getting '...' globals ... DONE
[15:31:11.124] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:11.124] List of 2
[15:31:11.124]  $ ...future.FUN:function (object, ...)  
[15:31:11.124]  $ ...          :List of 1
[15:31:11.124]   ..$ digits: int 2
[15:31:11.124]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.124]  - attr(*, "where")=List of 2
[15:31:11.124]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:11.124]   ..$ ...          :<environment: 0x0000019c825bf9e0> 
[15:31:11.124]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.124]  - attr(*, "resolved")= logi FALSE
[15:31:11.124]  - attr(*, "total_size")= num 1296
[15:31:11.131] Packages to be attached in all futures: [n=0] 
[15:31:11.131] getGlobalsAndPackagesXApply() ... DONE
[15:31:11.132] Number of futures (= number of chunks): 1
[15:31:11.132] Launching 1 futures (chunks) ...
[15:31:11.132] Chunk #1 of 1 ...
[15:31:11.133]  - Finding globals in 'X' for chunk #1 ...
[15:31:11.133] getGlobalsAndPackages() ...
[15:31:11.133] Searching for globals...
[15:31:11.134] 
[15:31:11.134] Searching for globals ... DONE
[15:31:11.134] - globals: [0] <none>
[15:31:11.135] getGlobalsAndPackages() ... DONE
[15:31:11.135]    + additional globals found: [n=0] 
[15:31:11.135]    + additional namespaces needed: [n=0] 
[15:31:11.136]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:11.136]  - seeds: <none>
[15:31:11.136]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.137] getGlobalsAndPackages() ...
[15:31:11.137] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.137] Resolving globals: FALSE
[15:31:11.138] Tweak future expression to call with '...' arguments ...
[15:31:11.138] {
[15:31:11.138]     do.call(function(...) {
[15:31:11.138]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.138]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.138]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.138]             on.exit(options(oopts), add = TRUE)
[15:31:11.138]         }
[15:31:11.138]         {
[15:31:11.138]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.138]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.138]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.138]             })
[15:31:11.138]         }
[15:31:11.138]     }, args = future.call.arguments)
[15:31:11.138] }
[15:31:11.139] Tweak future expression to call with '...' arguments ... DONE
[15:31:11.140] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.140] 
[15:31:11.140] getGlobalsAndPackages() ... DONE
[15:31:11.141] run() for 'Future' ...
[15:31:11.141] - state: 'created'
[15:31:11.142] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:11.142] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.143] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:11.143]   - Field: 'label'
[15:31:11.143]   - Field: 'local'
[15:31:11.144]   - Field: 'owner'
[15:31:11.144]   - Field: 'envir'
[15:31:11.144]   - Field: 'packages'
[15:31:11.145]   - Field: 'gc'
[15:31:11.145]   - Field: 'conditions'
[15:31:11.145]   - Field: 'expr'
[15:31:11.146]   - Field: 'uuid'
[15:31:11.146]   - Field: 'seed'
[15:31:11.146]   - Field: 'version'
[15:31:11.146]   - Field: 'result'
[15:31:11.147]   - Field: 'asynchronous'
[15:31:11.147]   - Field: 'calls'
[15:31:11.147]   - Field: 'globals'
[15:31:11.148]   - Field: 'stdout'
[15:31:11.148]   - Field: 'earlySignal'
[15:31:11.148]   - Field: 'lazy'
[15:31:11.149]   - Field: 'state'
[15:31:11.149] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:11.149] - Launch lazy future ...
[15:31:11.150] Packages needed by the future expression (n = 0): <none>
[15:31:11.150] Packages needed by future strategies (n = 0): <none>
[15:31:11.151] {
[15:31:11.151]     {
[15:31:11.151]         {
[15:31:11.151]             ...future.startTime <- base::Sys.time()
[15:31:11.151]             {
[15:31:11.151]                 {
[15:31:11.151]                   {
[15:31:11.151]                     base::local({
[15:31:11.151]                       has_future <- base::requireNamespace("future", 
[15:31:11.151]                         quietly = TRUE)
[15:31:11.151]                       if (has_future) {
[15:31:11.151]                         ns <- base::getNamespace("future")
[15:31:11.151]                         version <- ns[[".package"]][["version"]]
[15:31:11.151]                         if (is.null(version)) 
[15:31:11.151]                           version <- utils::packageVersion("future")
[15:31:11.151]                       }
[15:31:11.151]                       else {
[15:31:11.151]                         version <- NULL
[15:31:11.151]                       }
[15:31:11.151]                       if (!has_future || version < "1.8.0") {
[15:31:11.151]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:11.151]                           "", base::R.version$version.string), 
[15:31:11.151]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:11.151]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:11.151]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:11.151]                             "release", "version")], collapse = " "), 
[15:31:11.151]                           hostname = base::Sys.info()[["nodename"]])
[15:31:11.151]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:11.151]                           info)
[15:31:11.151]                         info <- base::paste(info, collapse = "; ")
[15:31:11.151]                         if (!has_future) {
[15:31:11.151]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:11.151]                             info)
[15:31:11.151]                         }
[15:31:11.151]                         else {
[15:31:11.151]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:11.151]                             info, version)
[15:31:11.151]                         }
[15:31:11.151]                         base::stop(msg)
[15:31:11.151]                       }
[15:31:11.151]                     })
[15:31:11.151]                   }
[15:31:11.151]                   ...future.strategy.old <- future::plan("list")
[15:31:11.151]                   options(future.plan = NULL)
[15:31:11.151]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.151]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:11.151]                 }
[15:31:11.151]                 ...future.workdir <- getwd()
[15:31:11.151]             }
[15:31:11.151]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:11.151]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:11.151]         }
[15:31:11.151]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:11.151]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:11.151]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:11.151]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:11.151]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:11.151]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:11.151]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:11.151]             base::names(...future.oldOptions))
[15:31:11.151]     }
[15:31:11.151]     if (FALSE) {
[15:31:11.151]     }
[15:31:11.151]     else {
[15:31:11.151]         if (TRUE) {
[15:31:11.151]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:11.151]                 open = "w")
[15:31:11.151]         }
[15:31:11.151]         else {
[15:31:11.151]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:11.151]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:11.151]         }
[15:31:11.151]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:11.151]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:11.151]             base::sink(type = "output", split = FALSE)
[15:31:11.151]             base::close(...future.stdout)
[15:31:11.151]         }, add = TRUE)
[15:31:11.151]     }
[15:31:11.151]     ...future.frame <- base::sys.nframe()
[15:31:11.151]     ...future.conditions <- base::list()
[15:31:11.151]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:11.151]     if (FALSE) {
[15:31:11.151]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:11.151]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:11.151]     }
[15:31:11.151]     ...future.result <- base::tryCatch({
[15:31:11.151]         base::withCallingHandlers({
[15:31:11.151]             ...future.value <- base::withVisible(base::local({
[15:31:11.151]                 do.call(function(...) {
[15:31:11.151]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.151]                   if (!identical(...future.globals.maxSize.org, 
[15:31:11.151]                     ...future.globals.maxSize)) {
[15:31:11.151]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.151]                     on.exit(options(oopts), add = TRUE)
[15:31:11.151]                   }
[15:31:11.151]                   {
[15:31:11.151]                     lapply(seq_along(...future.elements_ii), 
[15:31:11.151]                       FUN = function(jj) {
[15:31:11.151]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.151]                         ...future.FUN(...future.X_jj, ...)
[15:31:11.151]                       })
[15:31:11.151]                   }
[15:31:11.151]                 }, args = future.call.arguments)
[15:31:11.151]             }))
[15:31:11.151]             future::FutureResult(value = ...future.value$value, 
[15:31:11.151]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.151]                   ...future.rng), globalenv = if (FALSE) 
[15:31:11.151]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:11.151]                     ...future.globalenv.names))
[15:31:11.151]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:11.151]         }, condition = base::local({
[15:31:11.151]             c <- base::c
[15:31:11.151]             inherits <- base::inherits
[15:31:11.151]             invokeRestart <- base::invokeRestart
[15:31:11.151]             length <- base::length
[15:31:11.151]             list <- base::list
[15:31:11.151]             seq.int <- base::seq.int
[15:31:11.151]             signalCondition <- base::signalCondition
[15:31:11.151]             sys.calls <- base::sys.calls
[15:31:11.151]             `[[` <- base::`[[`
[15:31:11.151]             `+` <- base::`+`
[15:31:11.151]             `<<-` <- base::`<<-`
[15:31:11.151]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:11.151]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:11.151]                   3L)]
[15:31:11.151]             }
[15:31:11.151]             function(cond) {
[15:31:11.151]                 is_error <- inherits(cond, "error")
[15:31:11.151]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:11.151]                   NULL)
[15:31:11.151]                 if (is_error) {
[15:31:11.151]                   sessionInformation <- function() {
[15:31:11.151]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:11.151]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:11.151]                       search = base::search(), system = base::Sys.info())
[15:31:11.151]                   }
[15:31:11.151]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.151]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:11.151]                     cond$call), session = sessionInformation(), 
[15:31:11.151]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:11.151]                   signalCondition(cond)
[15:31:11.151]                 }
[15:31:11.151]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:11.151]                 "immediateCondition"))) {
[15:31:11.151]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:11.151]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.151]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:11.151]                   if (TRUE && !signal) {
[15:31:11.151]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.151]                     {
[15:31:11.151]                       inherits <- base::inherits
[15:31:11.151]                       invokeRestart <- base::invokeRestart
[15:31:11.151]                       is.null <- base::is.null
[15:31:11.151]                       muffled <- FALSE
[15:31:11.151]                       if (inherits(cond, "message")) {
[15:31:11.151]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.151]                         if (muffled) 
[15:31:11.151]                           invokeRestart("muffleMessage")
[15:31:11.151]                       }
[15:31:11.151]                       else if (inherits(cond, "warning")) {
[15:31:11.151]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.151]                         if (muffled) 
[15:31:11.151]                           invokeRestart("muffleWarning")
[15:31:11.151]                       }
[15:31:11.151]                       else if (inherits(cond, "condition")) {
[15:31:11.151]                         if (!is.null(pattern)) {
[15:31:11.151]                           computeRestarts <- base::computeRestarts
[15:31:11.151]                           grepl <- base::grepl
[15:31:11.151]                           restarts <- computeRestarts(cond)
[15:31:11.151]                           for (restart in restarts) {
[15:31:11.151]                             name <- restart$name
[15:31:11.151]                             if (is.null(name)) 
[15:31:11.151]                               next
[15:31:11.151]                             if (!grepl(pattern, name)) 
[15:31:11.151]                               next
[15:31:11.151]                             invokeRestart(restart)
[15:31:11.151]                             muffled <- TRUE
[15:31:11.151]                             break
[15:31:11.151]                           }
[15:31:11.151]                         }
[15:31:11.151]                       }
[15:31:11.151]                       invisible(muffled)
[15:31:11.151]                     }
[15:31:11.151]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.151]                   }
[15:31:11.151]                 }
[15:31:11.151]                 else {
[15:31:11.151]                   if (TRUE) {
[15:31:11.151]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.151]                     {
[15:31:11.151]                       inherits <- base::inherits
[15:31:11.151]                       invokeRestart <- base::invokeRestart
[15:31:11.151]                       is.null <- base::is.null
[15:31:11.151]                       muffled <- FALSE
[15:31:11.151]                       if (inherits(cond, "message")) {
[15:31:11.151]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.151]                         if (muffled) 
[15:31:11.151]                           invokeRestart("muffleMessage")
[15:31:11.151]                       }
[15:31:11.151]                       else if (inherits(cond, "warning")) {
[15:31:11.151]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.151]                         if (muffled) 
[15:31:11.151]                           invokeRestart("muffleWarning")
[15:31:11.151]                       }
[15:31:11.151]                       else if (inherits(cond, "condition")) {
[15:31:11.151]                         if (!is.null(pattern)) {
[15:31:11.151]                           computeRestarts <- base::computeRestarts
[15:31:11.151]                           grepl <- base::grepl
[15:31:11.151]                           restarts <- computeRestarts(cond)
[15:31:11.151]                           for (restart in restarts) {
[15:31:11.151]                             name <- restart$name
[15:31:11.151]                             if (is.null(name)) 
[15:31:11.151]                               next
[15:31:11.151]                             if (!grepl(pattern, name)) 
[15:31:11.151]                               next
[15:31:11.151]                             invokeRestart(restart)
[15:31:11.151]                             muffled <- TRUE
[15:31:11.151]                             break
[15:31:11.151]                           }
[15:31:11.151]                         }
[15:31:11.151]                       }
[15:31:11.151]                       invisible(muffled)
[15:31:11.151]                     }
[15:31:11.151]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.151]                   }
[15:31:11.151]                 }
[15:31:11.151]             }
[15:31:11.151]         }))
[15:31:11.151]     }, error = function(ex) {
[15:31:11.151]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:11.151]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.151]                 ...future.rng), started = ...future.startTime, 
[15:31:11.151]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:11.151]             version = "1.8"), class = "FutureResult")
[15:31:11.151]     }, finally = {
[15:31:11.151]         if (!identical(...future.workdir, getwd())) 
[15:31:11.151]             setwd(...future.workdir)
[15:31:11.151]         {
[15:31:11.151]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:11.151]                 ...future.oldOptions$nwarnings <- NULL
[15:31:11.151]             }
[15:31:11.151]             base::options(...future.oldOptions)
[15:31:11.151]             if (.Platform$OS.type == "windows") {
[15:31:11.151]                 old_names <- names(...future.oldEnvVars)
[15:31:11.151]                 envs <- base::Sys.getenv()
[15:31:11.151]                 names <- names(envs)
[15:31:11.151]                 common <- intersect(names, old_names)
[15:31:11.151]                 added <- setdiff(names, old_names)
[15:31:11.151]                 removed <- setdiff(old_names, names)
[15:31:11.151]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:11.151]                   envs[common]]
[15:31:11.151]                 NAMES <- toupper(changed)
[15:31:11.151]                 args <- list()
[15:31:11.151]                 for (kk in seq_along(NAMES)) {
[15:31:11.151]                   name <- changed[[kk]]
[15:31:11.151]                   NAME <- NAMES[[kk]]
[15:31:11.151]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.151]                     next
[15:31:11.151]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.151]                 }
[15:31:11.151]                 NAMES <- toupper(added)
[15:31:11.151]                 for (kk in seq_along(NAMES)) {
[15:31:11.151]                   name <- added[[kk]]
[15:31:11.151]                   NAME <- NAMES[[kk]]
[15:31:11.151]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.151]                     next
[15:31:11.151]                   args[[name]] <- ""
[15:31:11.151]                 }
[15:31:11.151]                 NAMES <- toupper(removed)
[15:31:11.151]                 for (kk in seq_along(NAMES)) {
[15:31:11.151]                   name <- removed[[kk]]
[15:31:11.151]                   NAME <- NAMES[[kk]]
[15:31:11.151]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.151]                     next
[15:31:11.151]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.151]                 }
[15:31:11.151]                 if (length(args) > 0) 
[15:31:11.151]                   base::do.call(base::Sys.setenv, args = args)
[15:31:11.151]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:11.151]             }
[15:31:11.151]             else {
[15:31:11.151]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:11.151]             }
[15:31:11.151]             {
[15:31:11.151]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:11.151]                   0L) {
[15:31:11.151]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:11.151]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:11.151]                   base::options(opts)
[15:31:11.151]                 }
[15:31:11.151]                 {
[15:31:11.151]                   {
[15:31:11.151]                     NULL
[15:31:11.151]                     RNGkind("Mersenne-Twister")
[15:31:11.151]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:11.151]                       inherits = FALSE)
[15:31:11.151]                   }
[15:31:11.151]                   options(future.plan = NULL)
[15:31:11.151]                   if (is.na(NA_character_)) 
[15:31:11.151]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.151]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:11.151]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:11.151]                     .init = FALSE)
[15:31:11.151]                 }
[15:31:11.151]             }
[15:31:11.151]         }
[15:31:11.151]     })
[15:31:11.151]     if (TRUE) {
[15:31:11.151]         base::sink(type = "output", split = FALSE)
[15:31:11.151]         if (TRUE) {
[15:31:11.151]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:11.151]         }
[15:31:11.151]         else {
[15:31:11.151]             ...future.result["stdout"] <- base::list(NULL)
[15:31:11.151]         }
[15:31:11.151]         base::close(...future.stdout)
[15:31:11.151]         ...future.stdout <- NULL
[15:31:11.151]     }
[15:31:11.151]     ...future.result$conditions <- ...future.conditions
[15:31:11.151]     ...future.result$finished <- base::Sys.time()
[15:31:11.151]     ...future.result
[15:31:11.151] }
[15:31:11.158] assign_globals() ...
[15:31:11.158] List of 5
[15:31:11.158]  $ ...future.FUN            :function (object, ...)  
[15:31:11.158]  $ future.call.arguments    :List of 1
[15:31:11.158]   ..$ digits: int 2
[15:31:11.158]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.158]  $ ...future.elements_ii    :List of 6
[15:31:11.158]   ..$ : num [1:9] 26 30 54 25 70 52 51 26 67
[15:31:11.158]   ..$ : num [1:9] 27 14 29 19 29 31 41 20 44
[15:31:11.158]   ..$ : num [1:9] 18 21 29 17 12 18 35 30 36
[15:31:11.158]   ..$ : num [1:9] 42 26 19 16 39 28 21 39 29
[15:31:11.158]   ..$ : num [1:9] 36 21 24 18 10 43 28 15 26
[15:31:11.158]   ..$ : num [1:9] 20 21 24 17 13 15 15 16 28
[15:31:11.158]  $ ...future.seeds_ii       : NULL
[15:31:11.158]  $ ...future.globals.maxSize: NULL
[15:31:11.158]  - attr(*, "where")=List of 5
[15:31:11.158]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:11.158]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:11.158]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:11.158]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:11.158]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:11.158]  - attr(*, "resolved")= logi FALSE
[15:31:11.158]  - attr(*, "total_size")= num 1296
[15:31:11.158]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.158]  - attr(*, "already-done")= logi TRUE
[15:31:11.172] - copied '...future.FUN' to environment
[15:31:11.172] - copied 'future.call.arguments' to environment
[15:31:11.172] - copied '...future.elements_ii' to environment
[15:31:11.173] - copied '...future.seeds_ii' to environment
[15:31:11.173] - copied '...future.globals.maxSize' to environment
[15:31:11.173] assign_globals() ... done
[15:31:11.174] plan(): Setting new future strategy stack:
[15:31:11.174] List of future strategies:
[15:31:11.174] 1. sequential:
[15:31:11.174]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.174]    - tweaked: FALSE
[15:31:11.174]    - call: NULL
[15:31:11.175] plan(): nbrOfWorkers() = 1
[15:31:11.179] plan(): Setting new future strategy stack:
[15:31:11.179] List of future strategies:
[15:31:11.179] 1. sequential:
[15:31:11.179]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.179]    - tweaked: FALSE
[15:31:11.179]    - call: plan(strategy)
[15:31:11.180] plan(): nbrOfWorkers() = 1
[15:31:11.180] SequentialFuture started (and completed)
[15:31:11.181] - Launch lazy future ... done
[15:31:11.181] run() for 'SequentialFuture' ... done
[15:31:11.181] Created future:
[15:31:11.182] SequentialFuture:
[15:31:11.182] Label: 'future_by-1'
[15:31:11.182] Expression:
[15:31:11.182] {
[15:31:11.182]     do.call(function(...) {
[15:31:11.182]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.182]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.182]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.182]             on.exit(options(oopts), add = TRUE)
[15:31:11.182]         }
[15:31:11.182]         {
[15:31:11.182]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.182]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.182]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.182]             })
[15:31:11.182]         }
[15:31:11.182]     }, args = future.call.arguments)
[15:31:11.182] }
[15:31:11.182] Lazy evaluation: FALSE
[15:31:11.182] Asynchronous evaluation: FALSE
[15:31:11.182] Local evaluation: TRUE
[15:31:11.182] Environment: R_GlobalEnv
[15:31:11.182] Capture standard output: TRUE
[15:31:11.182] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:11.182] Globals: 5 objects totaling 2.30 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 1.03 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:11.182] Packages: <none>
[15:31:11.182] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:11.182] Resolved: TRUE
[15:31:11.182] Value: 5.48 KiB of class 'list'
[15:31:11.182] Early signaling: FALSE
[15:31:11.182] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:11.182] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.184] Chunk #1 of 1 ... DONE
[15:31:11.184] Launching 1 futures (chunks) ... DONE
[15:31:11.184] Resolving 1 futures (chunks) ...
[15:31:11.185] resolve() on list ...
[15:31:11.185]  recursive: 0
[15:31:11.185]  length: 1
[15:31:11.185] 
[15:31:11.186] resolved() for 'SequentialFuture' ...
[15:31:11.187] - state: 'finished'
[15:31:11.187] - run: TRUE
[15:31:11.187] - result: 'FutureResult'
[15:31:11.188] resolved() for 'SequentialFuture' ... done
[15:31:11.188] Future #1
[15:31:11.188] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.189] - nx: 1
[15:31:11.189] - relay: TRUE
[15:31:11.189] - stdout: TRUE
[15:31:11.189] - signal: TRUE
[15:31:11.190] - resignal: FALSE
[15:31:11.190] - force: TRUE
[15:31:11.190] - relayed: [n=1] FALSE
[15:31:11.191] - queued futures: [n=1] FALSE
[15:31:11.191]  - until=1
[15:31:11.191]  - relaying element #1
[15:31:11.192] - relayed: [n=1] TRUE
[15:31:11.192] - queued futures: [n=1] TRUE
[15:31:11.192] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.193]  length: 0 (resolved future 1)
[15:31:11.193] Relaying remaining futures
[15:31:11.193] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.194] - nx: 1
[15:31:11.194] - relay: TRUE
[15:31:11.194] - stdout: TRUE
[15:31:11.194] - signal: TRUE
[15:31:11.198] - resignal: FALSE
[15:31:11.198] - force: TRUE
[15:31:11.198] - relayed: [n=1] TRUE
[15:31:11.198] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.199] - relayed: [n=1] TRUE
[15:31:11.199] - queued futures: [n=1] TRUE
[15:31:11.199] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.200] resolve() on list ... DONE
[15:31:11.200]  - Number of value chunks collected: 1
[15:31:11.200] Resolving 1 futures (chunks) ... DONE
[15:31:11.201] Reducing values from 1 chunks ...
[15:31:11.201]  - Number of values collected after concatenation: 6
[15:31:11.201]  - Number of values expected: 6
[15:31:11.202] Reducing values from 1 chunks ... DONE
[15:31:11.202] future_lapply() ... DONE
[15:31:11.202] future_by_internal() ... DONE
[15:31:11.204] future_by_internal() ...
[15:31:11.205] future_lapply() ...
[15:31:11.207] Number of chunks: 1
[15:31:11.207] getGlobalsAndPackagesXApply() ...
[15:31:11.207]  - future.globals: TRUE
[15:31:11.208] getGlobalsAndPackages() ...
[15:31:11.208] Searching for globals...
[15:31:11.211] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:11.211] Searching for globals ... DONE
[15:31:11.212] Resolving globals: FALSE
[15:31:11.213] The total size of the 1 globals is 5.20 KiB (5328 bytes)
[15:31:11.213] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 5.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (5.20 KiB of class 'function')
[15:31:11.214] - globals: [1] 'FUN'
[15:31:11.214] - packages: [1] 'stats'
[15:31:11.214] getGlobalsAndPackages() ... DONE
[15:31:11.215]  - globals found/used: [n=1] 'FUN'
[15:31:11.215]  - needed namespaces: [n=1] 'stats'
[15:31:11.215] Finding globals ... DONE
[15:31:11.215]  - use_args: TRUE
[15:31:11.216]  - Getting '...' globals ...
[15:31:11.216] resolve() on list ...
[15:31:11.217]  recursive: 0
[15:31:11.217]  length: 1
[15:31:11.217]  elements: '...'
[15:31:11.217]  length: 0 (resolved future 1)
[15:31:11.217] resolve() on list ... DONE
[15:31:11.218]    - '...' content: [n=1] 'singular.ok'
[15:31:11.218] List of 1
[15:31:11.218]  $ ...:List of 1
[15:31:11.218]   ..$ singular.ok: logi FALSE
[15:31:11.218]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.218]  - attr(*, "where")=List of 1
[15:31:11.218]   ..$ ...:<environment: 0x0000019c80160a00> 
[15:31:11.218]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.218]  - attr(*, "resolved")= logi TRUE
[15:31:11.218]  - attr(*, "total_size")= num NA
[15:31:11.221]  - Getting '...' globals ... DONE
[15:31:11.222] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:11.222] List of 2
[15:31:11.222]  $ ...future.FUN:function (x, ...)  
[15:31:11.222]  $ ...          :List of 1
[15:31:11.222]   ..$ singular.ok: logi FALSE
[15:31:11.222]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.222]  - attr(*, "where")=List of 2
[15:31:11.222]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:11.222]   ..$ ...          :<environment: 0x0000019c80160a00> 
[15:31:11.222]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.222]  - attr(*, "resolved")= logi FALSE
[15:31:11.222]  - attr(*, "total_size")= num 5384
[15:31:11.226] Packages to be attached in all futures: [n=1] 'stats'
[15:31:11.226] getGlobalsAndPackagesXApply() ... DONE
[15:31:11.226] Number of futures (= number of chunks): 1
[15:31:11.226] Launching 1 futures (chunks) ...
[15:31:11.227] Chunk #1 of 1 ...
[15:31:11.227]  - Finding globals in 'X' for chunk #1 ...
[15:31:11.227] getGlobalsAndPackages() ...
[15:31:11.227] Searching for globals...
[15:31:11.228] 
[15:31:11.228] Searching for globals ... DONE
[15:31:11.228] - globals: [0] <none>
[15:31:11.228] getGlobalsAndPackages() ... DONE
[15:31:11.228]    + additional globals found: [n=0] 
[15:31:11.229]    + additional namespaces needed: [n=0] 
[15:31:11.229]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:11.229]  - seeds: <none>
[15:31:11.229]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.229] getGlobalsAndPackages() ...
[15:31:11.229] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.230] Resolving globals: FALSE
[15:31:11.230] Tweak future expression to call with '...' arguments ...
[15:31:11.230] {
[15:31:11.230]     do.call(function(...) {
[15:31:11.230]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.230]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.230]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.230]             on.exit(options(oopts), add = TRUE)
[15:31:11.230]         }
[15:31:11.230]         {
[15:31:11.230]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.230]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.230]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.230]             })
[15:31:11.230]         }
[15:31:11.230]     }, args = future.call.arguments)
[15:31:11.230] }
[15:31:11.230] Tweak future expression to call with '...' arguments ... DONE
[15:31:11.231] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.231] 
[15:31:11.231] getGlobalsAndPackages() ... DONE
[15:31:11.232] run() for 'Future' ...
[15:31:11.232] - state: 'created'
[15:31:11.232] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:11.232] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.233] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:11.233]   - Field: 'label'
[15:31:11.234]   - Field: 'local'
[15:31:11.235]   - Field: 'owner'
[15:31:11.235]   - Field: 'envir'
[15:31:11.235]   - Field: 'packages'
[15:31:11.236]   - Field: 'gc'
[15:31:11.236]   - Field: 'conditions'
[15:31:11.236]   - Field: 'expr'
[15:31:11.237]   - Field: 'uuid'
[15:31:11.237]   - Field: 'seed'
[15:31:11.237]   - Field: 'version'
[15:31:11.238]   - Field: 'result'
[15:31:11.238]   - Field: 'asynchronous'
[15:31:11.238]   - Field: 'calls'
[15:31:11.239]   - Field: 'globals'
[15:31:11.239]   - Field: 'stdout'
[15:31:11.239]   - Field: 'earlySignal'
[15:31:11.240]   - Field: 'lazy'
[15:31:11.240]   - Field: 'state'
[15:31:11.240] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:11.240] - Launch lazy future ...
[15:31:11.241] Packages needed by the future expression (n = 1): 'stats'
[15:31:11.241] Packages needed by future strategies (n = 0): <none>
[15:31:11.242] {
[15:31:11.242]     {
[15:31:11.242]         {
[15:31:11.242]             ...future.startTime <- base::Sys.time()
[15:31:11.242]             {
[15:31:11.242]                 {
[15:31:11.242]                   {
[15:31:11.242]                     {
[15:31:11.242]                       base::local({
[15:31:11.242]                         has_future <- base::requireNamespace("future", 
[15:31:11.242]                           quietly = TRUE)
[15:31:11.242]                         if (has_future) {
[15:31:11.242]                           ns <- base::getNamespace("future")
[15:31:11.242]                           version <- ns[[".package"]][["version"]]
[15:31:11.242]                           if (is.null(version)) 
[15:31:11.242]                             version <- utils::packageVersion("future")
[15:31:11.242]                         }
[15:31:11.242]                         else {
[15:31:11.242]                           version <- NULL
[15:31:11.242]                         }
[15:31:11.242]                         if (!has_future || version < "1.8.0") {
[15:31:11.242]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:11.242]                             "", base::R.version$version.string), 
[15:31:11.242]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:11.242]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:11.242]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:11.242]                               "release", "version")], collapse = " "), 
[15:31:11.242]                             hostname = base::Sys.info()[["nodename"]])
[15:31:11.242]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:11.242]                             info)
[15:31:11.242]                           info <- base::paste(info, collapse = "; ")
[15:31:11.242]                           if (!has_future) {
[15:31:11.242]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:11.242]                               info)
[15:31:11.242]                           }
[15:31:11.242]                           else {
[15:31:11.242]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:11.242]                               info, version)
[15:31:11.242]                           }
[15:31:11.242]                           base::stop(msg)
[15:31:11.242]                         }
[15:31:11.242]                       })
[15:31:11.242]                     }
[15:31:11.242]                     base::local({
[15:31:11.242]                       for (pkg in "stats") {
[15:31:11.242]                         base::loadNamespace(pkg)
[15:31:11.242]                         base::library(pkg, character.only = TRUE)
[15:31:11.242]                       }
[15:31:11.242]                     })
[15:31:11.242]                   }
[15:31:11.242]                   ...future.strategy.old <- future::plan("list")
[15:31:11.242]                   options(future.plan = NULL)
[15:31:11.242]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.242]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:11.242]                 }
[15:31:11.242]                 ...future.workdir <- getwd()
[15:31:11.242]             }
[15:31:11.242]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:11.242]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:11.242]         }
[15:31:11.242]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:11.242]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:11.242]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:11.242]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:11.242]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:11.242]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:11.242]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:11.242]             base::names(...future.oldOptions))
[15:31:11.242]     }
[15:31:11.242]     if (FALSE) {
[15:31:11.242]     }
[15:31:11.242]     else {
[15:31:11.242]         if (TRUE) {
[15:31:11.242]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:11.242]                 open = "w")
[15:31:11.242]         }
[15:31:11.242]         else {
[15:31:11.242]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:11.242]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:11.242]         }
[15:31:11.242]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:11.242]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:11.242]             base::sink(type = "output", split = FALSE)
[15:31:11.242]             base::close(...future.stdout)
[15:31:11.242]         }, add = TRUE)
[15:31:11.242]     }
[15:31:11.242]     ...future.frame <- base::sys.nframe()
[15:31:11.242]     ...future.conditions <- base::list()
[15:31:11.242]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:11.242]     if (FALSE) {
[15:31:11.242]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:11.242]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:11.242]     }
[15:31:11.242]     ...future.result <- base::tryCatch({
[15:31:11.242]         base::withCallingHandlers({
[15:31:11.242]             ...future.value <- base::withVisible(base::local({
[15:31:11.242]                 do.call(function(...) {
[15:31:11.242]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.242]                   if (!identical(...future.globals.maxSize.org, 
[15:31:11.242]                     ...future.globals.maxSize)) {
[15:31:11.242]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.242]                     on.exit(options(oopts), add = TRUE)
[15:31:11.242]                   }
[15:31:11.242]                   {
[15:31:11.242]                     lapply(seq_along(...future.elements_ii), 
[15:31:11.242]                       FUN = function(jj) {
[15:31:11.242]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.242]                         ...future.FUN(...future.X_jj, ...)
[15:31:11.242]                       })
[15:31:11.242]                   }
[15:31:11.242]                 }, args = future.call.arguments)
[15:31:11.242]             }))
[15:31:11.242]             future::FutureResult(value = ...future.value$value, 
[15:31:11.242]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.242]                   ...future.rng), globalenv = if (FALSE) 
[15:31:11.242]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:11.242]                     ...future.globalenv.names))
[15:31:11.242]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:11.242]         }, condition = base::local({
[15:31:11.242]             c <- base::c
[15:31:11.242]             inherits <- base::inherits
[15:31:11.242]             invokeRestart <- base::invokeRestart
[15:31:11.242]             length <- base::length
[15:31:11.242]             list <- base::list
[15:31:11.242]             seq.int <- base::seq.int
[15:31:11.242]             signalCondition <- base::signalCondition
[15:31:11.242]             sys.calls <- base::sys.calls
[15:31:11.242]             `[[` <- base::`[[`
[15:31:11.242]             `+` <- base::`+`
[15:31:11.242]             `<<-` <- base::`<<-`
[15:31:11.242]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:11.242]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:11.242]                   3L)]
[15:31:11.242]             }
[15:31:11.242]             function(cond) {
[15:31:11.242]                 is_error <- inherits(cond, "error")
[15:31:11.242]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:11.242]                   NULL)
[15:31:11.242]                 if (is_error) {
[15:31:11.242]                   sessionInformation <- function() {
[15:31:11.242]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:11.242]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:11.242]                       search = base::search(), system = base::Sys.info())
[15:31:11.242]                   }
[15:31:11.242]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.242]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:11.242]                     cond$call), session = sessionInformation(), 
[15:31:11.242]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:11.242]                   signalCondition(cond)
[15:31:11.242]                 }
[15:31:11.242]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:11.242]                 "immediateCondition"))) {
[15:31:11.242]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:11.242]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.242]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:11.242]                   if (TRUE && !signal) {
[15:31:11.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.242]                     {
[15:31:11.242]                       inherits <- base::inherits
[15:31:11.242]                       invokeRestart <- base::invokeRestart
[15:31:11.242]                       is.null <- base::is.null
[15:31:11.242]                       muffled <- FALSE
[15:31:11.242]                       if (inherits(cond, "message")) {
[15:31:11.242]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.242]                         if (muffled) 
[15:31:11.242]                           invokeRestart("muffleMessage")
[15:31:11.242]                       }
[15:31:11.242]                       else if (inherits(cond, "warning")) {
[15:31:11.242]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.242]                         if (muffled) 
[15:31:11.242]                           invokeRestart("muffleWarning")
[15:31:11.242]                       }
[15:31:11.242]                       else if (inherits(cond, "condition")) {
[15:31:11.242]                         if (!is.null(pattern)) {
[15:31:11.242]                           computeRestarts <- base::computeRestarts
[15:31:11.242]                           grepl <- base::grepl
[15:31:11.242]                           restarts <- computeRestarts(cond)
[15:31:11.242]                           for (restart in restarts) {
[15:31:11.242]                             name <- restart$name
[15:31:11.242]                             if (is.null(name)) 
[15:31:11.242]                               next
[15:31:11.242]                             if (!grepl(pattern, name)) 
[15:31:11.242]                               next
[15:31:11.242]                             invokeRestart(restart)
[15:31:11.242]                             muffled <- TRUE
[15:31:11.242]                             break
[15:31:11.242]                           }
[15:31:11.242]                         }
[15:31:11.242]                       }
[15:31:11.242]                       invisible(muffled)
[15:31:11.242]                     }
[15:31:11.242]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.242]                   }
[15:31:11.242]                 }
[15:31:11.242]                 else {
[15:31:11.242]                   if (TRUE) {
[15:31:11.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.242]                     {
[15:31:11.242]                       inherits <- base::inherits
[15:31:11.242]                       invokeRestart <- base::invokeRestart
[15:31:11.242]                       is.null <- base::is.null
[15:31:11.242]                       muffled <- FALSE
[15:31:11.242]                       if (inherits(cond, "message")) {
[15:31:11.242]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.242]                         if (muffled) 
[15:31:11.242]                           invokeRestart("muffleMessage")
[15:31:11.242]                       }
[15:31:11.242]                       else if (inherits(cond, "warning")) {
[15:31:11.242]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.242]                         if (muffled) 
[15:31:11.242]                           invokeRestart("muffleWarning")
[15:31:11.242]                       }
[15:31:11.242]                       else if (inherits(cond, "condition")) {
[15:31:11.242]                         if (!is.null(pattern)) {
[15:31:11.242]                           computeRestarts <- base::computeRestarts
[15:31:11.242]                           grepl <- base::grepl
[15:31:11.242]                           restarts <- computeRestarts(cond)
[15:31:11.242]                           for (restart in restarts) {
[15:31:11.242]                             name <- restart$name
[15:31:11.242]                             if (is.null(name)) 
[15:31:11.242]                               next
[15:31:11.242]                             if (!grepl(pattern, name)) 
[15:31:11.242]                               next
[15:31:11.242]                             invokeRestart(restart)
[15:31:11.242]                             muffled <- TRUE
[15:31:11.242]                             break
[15:31:11.242]                           }
[15:31:11.242]                         }
[15:31:11.242]                       }
[15:31:11.242]                       invisible(muffled)
[15:31:11.242]                     }
[15:31:11.242]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.242]                   }
[15:31:11.242]                 }
[15:31:11.242]             }
[15:31:11.242]         }))
[15:31:11.242]     }, error = function(ex) {
[15:31:11.242]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:11.242]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.242]                 ...future.rng), started = ...future.startTime, 
[15:31:11.242]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:11.242]             version = "1.8"), class = "FutureResult")
[15:31:11.242]     }, finally = {
[15:31:11.242]         if (!identical(...future.workdir, getwd())) 
[15:31:11.242]             setwd(...future.workdir)
[15:31:11.242]         {
[15:31:11.242]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:11.242]                 ...future.oldOptions$nwarnings <- NULL
[15:31:11.242]             }
[15:31:11.242]             base::options(...future.oldOptions)
[15:31:11.242]             if (.Platform$OS.type == "windows") {
[15:31:11.242]                 old_names <- names(...future.oldEnvVars)
[15:31:11.242]                 envs <- base::Sys.getenv()
[15:31:11.242]                 names <- names(envs)
[15:31:11.242]                 common <- intersect(names, old_names)
[15:31:11.242]                 added <- setdiff(names, old_names)
[15:31:11.242]                 removed <- setdiff(old_names, names)
[15:31:11.242]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:11.242]                   envs[common]]
[15:31:11.242]                 NAMES <- toupper(changed)
[15:31:11.242]                 args <- list()
[15:31:11.242]                 for (kk in seq_along(NAMES)) {
[15:31:11.242]                   name <- changed[[kk]]
[15:31:11.242]                   NAME <- NAMES[[kk]]
[15:31:11.242]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.242]                     next
[15:31:11.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.242]                 }
[15:31:11.242]                 NAMES <- toupper(added)
[15:31:11.242]                 for (kk in seq_along(NAMES)) {
[15:31:11.242]                   name <- added[[kk]]
[15:31:11.242]                   NAME <- NAMES[[kk]]
[15:31:11.242]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.242]                     next
[15:31:11.242]                   args[[name]] <- ""
[15:31:11.242]                 }
[15:31:11.242]                 NAMES <- toupper(removed)
[15:31:11.242]                 for (kk in seq_along(NAMES)) {
[15:31:11.242]                   name <- removed[[kk]]
[15:31:11.242]                   NAME <- NAMES[[kk]]
[15:31:11.242]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.242]                     next
[15:31:11.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.242]                 }
[15:31:11.242]                 if (length(args) > 0) 
[15:31:11.242]                   base::do.call(base::Sys.setenv, args = args)
[15:31:11.242]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:11.242]             }
[15:31:11.242]             else {
[15:31:11.242]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:11.242]             }
[15:31:11.242]             {
[15:31:11.242]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:11.242]                   0L) {
[15:31:11.242]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:11.242]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:11.242]                   base::options(opts)
[15:31:11.242]                 }
[15:31:11.242]                 {
[15:31:11.242]                   {
[15:31:11.242]                     NULL
[15:31:11.242]                     RNGkind("Mersenne-Twister")
[15:31:11.242]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:11.242]                       inherits = FALSE)
[15:31:11.242]                   }
[15:31:11.242]                   options(future.plan = NULL)
[15:31:11.242]                   if (is.na(NA_character_)) 
[15:31:11.242]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.242]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:11.242]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:11.242]                     .init = FALSE)
[15:31:11.242]                 }
[15:31:11.242]             }
[15:31:11.242]         }
[15:31:11.242]     })
[15:31:11.242]     if (TRUE) {
[15:31:11.242]         base::sink(type = "output", split = FALSE)
[15:31:11.242]         if (TRUE) {
[15:31:11.242]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:11.242]         }
[15:31:11.242]         else {
[15:31:11.242]             ...future.result["stdout"] <- base::list(NULL)
[15:31:11.242]         }
[15:31:11.242]         base::close(...future.stdout)
[15:31:11.242]         ...future.stdout <- NULL
[15:31:11.242]     }
[15:31:11.242]     ...future.result$conditions <- ...future.conditions
[15:31:11.242]     ...future.result$finished <- base::Sys.time()
[15:31:11.242]     ...future.result
[15:31:11.242] }
[15:31:11.246] assign_globals() ...
[15:31:11.247] List of 5
[15:31:11.247]  $ ...future.FUN            :function (x, ...)  
[15:31:11.247]  $ future.call.arguments    :List of 1
[15:31:11.247]   ..$ singular.ok: logi FALSE
[15:31:11.247]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.247]  $ ...future.elements_ii    :List of 3
[15:31:11.247]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.247]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:11.247]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.247]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:11.247]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.247]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:11.247]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.247]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:11.247]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.247]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:11.247]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.247]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:11.247]  $ ...future.seeds_ii       : NULL
[15:31:11.247]  $ ...future.globals.maxSize: NULL
[15:31:11.247]  - attr(*, "where")=List of 5
[15:31:11.247]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:11.247]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:11.247]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:11.247]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:11.247]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:11.247]  - attr(*, "resolved")= logi FALSE
[15:31:11.247]  - attr(*, "total_size")= num 5384
[15:31:11.247]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.247]  - attr(*, "already-done")= logi TRUE
[15:31:11.261] - reassign environment for '...future.FUN'
[15:31:11.262] - copied '...future.FUN' to environment
[15:31:11.262] - copied 'future.call.arguments' to environment
[15:31:11.262] - copied '...future.elements_ii' to environment
[15:31:11.262] - copied '...future.seeds_ii' to environment
[15:31:11.263] - copied '...future.globals.maxSize' to environment
[15:31:11.263] assign_globals() ... done
[15:31:11.264] plan(): Setting new future strategy stack:
[15:31:11.264] List of future strategies:
[15:31:11.264] 1. sequential:
[15:31:11.264]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.264]    - tweaked: FALSE
[15:31:11.264]    - call: NULL
[15:31:11.266] plan(): nbrOfWorkers() = 1
[15:31:11.272] plan(): Setting new future strategy stack:
[15:31:11.272] List of future strategies:
[15:31:11.272] 1. sequential:
[15:31:11.272]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.272]    - tweaked: FALSE
[15:31:11.272]    - call: plan(strategy)
[15:31:11.273] plan(): nbrOfWorkers() = 1
[15:31:11.274] SequentialFuture started (and completed)
[15:31:11.274] - Launch lazy future ... done
[15:31:11.274] run() for 'SequentialFuture' ... done
[15:31:11.275] Created future:
[15:31:11.275] SequentialFuture:
[15:31:11.275] Label: 'future_by-1'
[15:31:11.275] Expression:
[15:31:11.275] {
[15:31:11.275]     do.call(function(...) {
[15:31:11.275]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.275]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.275]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.275]             on.exit(options(oopts), add = TRUE)
[15:31:11.275]         }
[15:31:11.275]         {
[15:31:11.275]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.275]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.275]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.275]             })
[15:31:11.275]         }
[15:31:11.275]     }, args = future.call.arguments)
[15:31:11.275] }
[15:31:11.275] Lazy evaluation: FALSE
[15:31:11.275] Asynchronous evaluation: FALSE
[15:31:11.275] Local evaluation: TRUE
[15:31:11.275] Environment: R_GlobalEnv
[15:31:11.275] Capture standard output: TRUE
[15:31:11.275] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:11.275] Globals: 5 objects totaling 10.06 KiB (function '...future.FUN' of 5.20 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:11.275] Packages: 1 packages ('stats')
[15:31:11.275] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:11.275] Resolved: TRUE
[15:31:11.275] Value: 26.06 KiB of class 'list'
[15:31:11.275] Early signaling: FALSE
[15:31:11.275] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:11.275] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.278] Chunk #1 of 1 ... DONE
[15:31:11.278] Launching 1 futures (chunks) ... DONE
[15:31:11.279] Resolving 1 futures (chunks) ...
[15:31:11.279] resolve() on list ...
[15:31:11.279]  recursive: 0
[15:31:11.280]  length: 1
[15:31:11.280] 
[15:31:11.280] resolved() for 'SequentialFuture' ...
[15:31:11.280] - state: 'finished'
[15:31:11.281] - run: TRUE
[15:31:11.281] - result: 'FutureResult'
[15:31:11.281] resolved() for 'SequentialFuture' ... done
[15:31:11.282] Future #1
[15:31:11.282] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.282] - nx: 1
[15:31:11.283] - relay: TRUE
[15:31:11.283] - stdout: TRUE
[15:31:11.283] - signal: TRUE
[15:31:11.283] - resignal: FALSE
[15:31:11.284] - force: TRUE
[15:31:11.284] - relayed: [n=1] FALSE
[15:31:11.284] - queued futures: [n=1] FALSE
[15:31:11.285]  - until=1
[15:31:11.285]  - relaying element #1
[15:31:11.285] - relayed: [n=1] TRUE
[15:31:11.286] - queued futures: [n=1] TRUE
[15:31:11.286] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.286]  length: 0 (resolved future 1)
[15:31:11.286] Relaying remaining futures
[15:31:11.287] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.287] - nx: 1
[15:31:11.287] - relay: TRUE
[15:31:11.288] - stdout: TRUE
[15:31:11.288] - signal: TRUE
[15:31:11.288] - resignal: FALSE
[15:31:11.288] - force: TRUE
[15:31:11.289] - relayed: [n=1] TRUE
[15:31:11.289] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.289] - relayed: [n=1] TRUE
[15:31:11.290] - queued futures: [n=1] TRUE
[15:31:11.290] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.290] resolve() on list ... DONE
[15:31:11.291]  - Number of value chunks collected: 1
[15:31:11.291] Resolving 1 futures (chunks) ... DONE
[15:31:11.291] Reducing values from 1 chunks ...
[15:31:11.291]  - Number of values collected after concatenation: 3
[15:31:11.292]  - Number of values expected: 3
[15:31:11.292] Reducing values from 1 chunks ... DONE
[15:31:11.292] future_lapply() ... DONE
[15:31:11.293] future_by_internal() ... DONE
[15:31:11.301] future_by_internal() ...
[15:31:11.302] future_lapply() ...
[15:31:11.304] Number of chunks: 1
[15:31:11.304] getGlobalsAndPackagesXApply() ...
[15:31:11.304]  - future.globals: TRUE
[15:31:11.304] getGlobalsAndPackages() ...
[15:31:11.305] Searching for globals...
[15:31:11.308] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:11.309] Searching for globals ... DONE
[15:31:11.309] Resolving globals: FALSE
[15:31:11.310] The total size of the 3 globals is 2.27 KiB (2320 bytes)
[15:31:11.311] The total size of the 3 globals exported for future expression ('FUN()') is 2.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.04 KiB of class 'function'), 'wool' (776 bytes of class 'numeric') and 'breaks' (480 bytes of class 'numeric')
[15:31:11.311] - globals: [3] 'FUN', 'breaks', 'wool'
[15:31:11.312] - packages: [1] 'stats'
[15:31:11.312] getGlobalsAndPackages() ... DONE
[15:31:11.312]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[15:31:11.313]  - needed namespaces: [n=1] 'stats'
[15:31:11.313] Finding globals ... DONE
[15:31:11.313]  - use_args: TRUE
[15:31:11.313]  - Getting '...' globals ...
[15:31:11.314] resolve() on list ...
[15:31:11.314]  recursive: 0
[15:31:11.315]  length: 1
[15:31:11.315]  elements: '...'
[15:31:11.315]  length: 0 (resolved future 1)
[15:31:11.316] resolve() on list ... DONE
[15:31:11.316]    - '...' content: [n=0] 
[15:31:11.316] List of 1
[15:31:11.316]  $ ...: list()
[15:31:11.316]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.316]  - attr(*, "where")=List of 1
[15:31:11.316]   ..$ ...:<environment: 0x0000019c82c44ca0> 
[15:31:11.316]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.316]  - attr(*, "resolved")= logi TRUE
[15:31:11.316]  - attr(*, "total_size")= num NA
[15:31:11.320]  - Getting '...' globals ... DONE
[15:31:11.320] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[15:31:11.320] List of 4
[15:31:11.320]  $ ...future.FUN:function (x)  
[15:31:11.320]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:11.320]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:11.320]  $ ...          : list()
[15:31:11.320]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.320]  - attr(*, "where")=List of 4
[15:31:11.320]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:11.320]   ..$ breaks       :<environment: R_EmptyEnv> 
[15:31:11.320]   ..$ wool         :<environment: R_EmptyEnv> 
[15:31:11.320]   ..$ ...          :<environment: 0x0000019c82c44ca0> 
[15:31:11.320]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.320]  - attr(*, "resolved")= logi FALSE
[15:31:11.320]  - attr(*, "total_size")= num 2320
[15:31:11.326] Packages to be attached in all futures: [n=1] 'stats'
[15:31:11.326] getGlobalsAndPackagesXApply() ... DONE
[15:31:11.326] Number of futures (= number of chunks): 1
[15:31:11.327] Launching 1 futures (chunks) ...
[15:31:11.327] Chunk #1 of 1 ...
[15:31:11.327]  - Finding globals in 'X' for chunk #1 ...
[15:31:11.328] getGlobalsAndPackages() ...
[15:31:11.328] Searching for globals...
[15:31:11.329] 
[15:31:11.329] Searching for globals ... DONE
[15:31:11.329] - globals: [0] <none>
[15:31:11.329] getGlobalsAndPackages() ... DONE
[15:31:11.329]    + additional globals found: [n=0] 
[15:31:11.330]    + additional namespaces needed: [n=0] 
[15:31:11.330]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:11.330]  - seeds: <none>
[15:31:11.330]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.330] getGlobalsAndPackages() ...
[15:31:11.330] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.331] Resolving globals: FALSE
[15:31:11.331] Tweak future expression to call with '...' arguments ...
[15:31:11.331] {
[15:31:11.331]     do.call(function(...) {
[15:31:11.331]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.331]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.331]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.331]             on.exit(options(oopts), add = TRUE)
[15:31:11.331]         }
[15:31:11.331]         {
[15:31:11.331]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.331]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.331]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.331]             })
[15:31:11.331]         }
[15:31:11.331]     }, args = future.call.arguments)
[15:31:11.331] }
[15:31:11.332] Tweak future expression to call with '...' arguments ... DONE
[15:31:11.332] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.333] 
[15:31:11.333] getGlobalsAndPackages() ... DONE
[15:31:11.333] run() for 'Future' ...
[15:31:11.334] - state: 'created'
[15:31:11.334] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:11.335] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.335] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:11.335]   - Field: 'label'
[15:31:11.336]   - Field: 'local'
[15:31:11.336]   - Field: 'owner'
[15:31:11.336]   - Field: 'envir'
[15:31:11.337]   - Field: 'packages'
[15:31:11.337]   - Field: 'gc'
[15:31:11.337]   - Field: 'conditions'
[15:31:11.338]   - Field: 'expr'
[15:31:11.338]   - Field: 'uuid'
[15:31:11.338]   - Field: 'seed'
[15:31:11.339]   - Field: 'version'
[15:31:11.339]   - Field: 'result'
[15:31:11.339]   - Field: 'asynchronous'
[15:31:11.340]   - Field: 'calls'
[15:31:11.340]   - Field: 'globals'
[15:31:11.340]   - Field: 'stdout'
[15:31:11.341]   - Field: 'earlySignal'
[15:31:11.341]   - Field: 'lazy'
[15:31:11.341]   - Field: 'state'
[15:31:11.341] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:11.342] - Launch lazy future ...
[15:31:11.342] Packages needed by the future expression (n = 1): 'stats'
[15:31:11.343] Packages needed by future strategies (n = 0): <none>
[15:31:11.344] {
[15:31:11.344]     {
[15:31:11.344]         {
[15:31:11.344]             ...future.startTime <- base::Sys.time()
[15:31:11.344]             {
[15:31:11.344]                 {
[15:31:11.344]                   {
[15:31:11.344]                     {
[15:31:11.344]                       base::local({
[15:31:11.344]                         has_future <- base::requireNamespace("future", 
[15:31:11.344]                           quietly = TRUE)
[15:31:11.344]                         if (has_future) {
[15:31:11.344]                           ns <- base::getNamespace("future")
[15:31:11.344]                           version <- ns[[".package"]][["version"]]
[15:31:11.344]                           if (is.null(version)) 
[15:31:11.344]                             version <- utils::packageVersion("future")
[15:31:11.344]                         }
[15:31:11.344]                         else {
[15:31:11.344]                           version <- NULL
[15:31:11.344]                         }
[15:31:11.344]                         if (!has_future || version < "1.8.0") {
[15:31:11.344]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:11.344]                             "", base::R.version$version.string), 
[15:31:11.344]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:11.344]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:11.344]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:11.344]                               "release", "version")], collapse = " "), 
[15:31:11.344]                             hostname = base::Sys.info()[["nodename"]])
[15:31:11.344]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:11.344]                             info)
[15:31:11.344]                           info <- base::paste(info, collapse = "; ")
[15:31:11.344]                           if (!has_future) {
[15:31:11.344]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:11.344]                               info)
[15:31:11.344]                           }
[15:31:11.344]                           else {
[15:31:11.344]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:11.344]                               info, version)
[15:31:11.344]                           }
[15:31:11.344]                           base::stop(msg)
[15:31:11.344]                         }
[15:31:11.344]                       })
[15:31:11.344]                     }
[15:31:11.344]                     base::local({
[15:31:11.344]                       for (pkg in "stats") {
[15:31:11.344]                         base::loadNamespace(pkg)
[15:31:11.344]                         base::library(pkg, character.only = TRUE)
[15:31:11.344]                       }
[15:31:11.344]                     })
[15:31:11.344]                   }
[15:31:11.344]                   ...future.strategy.old <- future::plan("list")
[15:31:11.344]                   options(future.plan = NULL)
[15:31:11.344]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.344]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:11.344]                 }
[15:31:11.344]                 ...future.workdir <- getwd()
[15:31:11.344]             }
[15:31:11.344]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:11.344]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:11.344]         }
[15:31:11.344]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:11.344]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:11.344]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:11.344]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:11.344]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:11.344]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:11.344]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:11.344]             base::names(...future.oldOptions))
[15:31:11.344]     }
[15:31:11.344]     if (FALSE) {
[15:31:11.344]     }
[15:31:11.344]     else {
[15:31:11.344]         if (TRUE) {
[15:31:11.344]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:11.344]                 open = "w")
[15:31:11.344]         }
[15:31:11.344]         else {
[15:31:11.344]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:11.344]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:11.344]         }
[15:31:11.344]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:11.344]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:11.344]             base::sink(type = "output", split = FALSE)
[15:31:11.344]             base::close(...future.stdout)
[15:31:11.344]         }, add = TRUE)
[15:31:11.344]     }
[15:31:11.344]     ...future.frame <- base::sys.nframe()
[15:31:11.344]     ...future.conditions <- base::list()
[15:31:11.344]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:11.344]     if (FALSE) {
[15:31:11.344]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:11.344]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:11.344]     }
[15:31:11.344]     ...future.result <- base::tryCatch({
[15:31:11.344]         base::withCallingHandlers({
[15:31:11.344]             ...future.value <- base::withVisible(base::local({
[15:31:11.344]                 do.call(function(...) {
[15:31:11.344]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.344]                   if (!identical(...future.globals.maxSize.org, 
[15:31:11.344]                     ...future.globals.maxSize)) {
[15:31:11.344]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.344]                     on.exit(options(oopts), add = TRUE)
[15:31:11.344]                   }
[15:31:11.344]                   {
[15:31:11.344]                     lapply(seq_along(...future.elements_ii), 
[15:31:11.344]                       FUN = function(jj) {
[15:31:11.344]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.344]                         ...future.FUN(...future.X_jj, ...)
[15:31:11.344]                       })
[15:31:11.344]                   }
[15:31:11.344]                 }, args = future.call.arguments)
[15:31:11.344]             }))
[15:31:11.344]             future::FutureResult(value = ...future.value$value, 
[15:31:11.344]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.344]                   ...future.rng), globalenv = if (FALSE) 
[15:31:11.344]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:11.344]                     ...future.globalenv.names))
[15:31:11.344]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:11.344]         }, condition = base::local({
[15:31:11.344]             c <- base::c
[15:31:11.344]             inherits <- base::inherits
[15:31:11.344]             invokeRestart <- base::invokeRestart
[15:31:11.344]             length <- base::length
[15:31:11.344]             list <- base::list
[15:31:11.344]             seq.int <- base::seq.int
[15:31:11.344]             signalCondition <- base::signalCondition
[15:31:11.344]             sys.calls <- base::sys.calls
[15:31:11.344]             `[[` <- base::`[[`
[15:31:11.344]             `+` <- base::`+`
[15:31:11.344]             `<<-` <- base::`<<-`
[15:31:11.344]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:11.344]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:11.344]                   3L)]
[15:31:11.344]             }
[15:31:11.344]             function(cond) {
[15:31:11.344]                 is_error <- inherits(cond, "error")
[15:31:11.344]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:11.344]                   NULL)
[15:31:11.344]                 if (is_error) {
[15:31:11.344]                   sessionInformation <- function() {
[15:31:11.344]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:11.344]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:11.344]                       search = base::search(), system = base::Sys.info())
[15:31:11.344]                   }
[15:31:11.344]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.344]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:11.344]                     cond$call), session = sessionInformation(), 
[15:31:11.344]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:11.344]                   signalCondition(cond)
[15:31:11.344]                 }
[15:31:11.344]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:11.344]                 "immediateCondition"))) {
[15:31:11.344]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:11.344]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.344]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:11.344]                   if (TRUE && !signal) {
[15:31:11.344]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.344]                     {
[15:31:11.344]                       inherits <- base::inherits
[15:31:11.344]                       invokeRestart <- base::invokeRestart
[15:31:11.344]                       is.null <- base::is.null
[15:31:11.344]                       muffled <- FALSE
[15:31:11.344]                       if (inherits(cond, "message")) {
[15:31:11.344]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.344]                         if (muffled) 
[15:31:11.344]                           invokeRestart("muffleMessage")
[15:31:11.344]                       }
[15:31:11.344]                       else if (inherits(cond, "warning")) {
[15:31:11.344]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.344]                         if (muffled) 
[15:31:11.344]                           invokeRestart("muffleWarning")
[15:31:11.344]                       }
[15:31:11.344]                       else if (inherits(cond, "condition")) {
[15:31:11.344]                         if (!is.null(pattern)) {
[15:31:11.344]                           computeRestarts <- base::computeRestarts
[15:31:11.344]                           grepl <- base::grepl
[15:31:11.344]                           restarts <- computeRestarts(cond)
[15:31:11.344]                           for (restart in restarts) {
[15:31:11.344]                             name <- restart$name
[15:31:11.344]                             if (is.null(name)) 
[15:31:11.344]                               next
[15:31:11.344]                             if (!grepl(pattern, name)) 
[15:31:11.344]                               next
[15:31:11.344]                             invokeRestart(restart)
[15:31:11.344]                             muffled <- TRUE
[15:31:11.344]                             break
[15:31:11.344]                           }
[15:31:11.344]                         }
[15:31:11.344]                       }
[15:31:11.344]                       invisible(muffled)
[15:31:11.344]                     }
[15:31:11.344]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.344]                   }
[15:31:11.344]                 }
[15:31:11.344]                 else {
[15:31:11.344]                   if (TRUE) {
[15:31:11.344]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.344]                     {
[15:31:11.344]                       inherits <- base::inherits
[15:31:11.344]                       invokeRestart <- base::invokeRestart
[15:31:11.344]                       is.null <- base::is.null
[15:31:11.344]                       muffled <- FALSE
[15:31:11.344]                       if (inherits(cond, "message")) {
[15:31:11.344]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.344]                         if (muffled) 
[15:31:11.344]                           invokeRestart("muffleMessage")
[15:31:11.344]                       }
[15:31:11.344]                       else if (inherits(cond, "warning")) {
[15:31:11.344]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.344]                         if (muffled) 
[15:31:11.344]                           invokeRestart("muffleWarning")
[15:31:11.344]                       }
[15:31:11.344]                       else if (inherits(cond, "condition")) {
[15:31:11.344]                         if (!is.null(pattern)) {
[15:31:11.344]                           computeRestarts <- base::computeRestarts
[15:31:11.344]                           grepl <- base::grepl
[15:31:11.344]                           restarts <- computeRestarts(cond)
[15:31:11.344]                           for (restart in restarts) {
[15:31:11.344]                             name <- restart$name
[15:31:11.344]                             if (is.null(name)) 
[15:31:11.344]                               next
[15:31:11.344]                             if (!grepl(pattern, name)) 
[15:31:11.344]                               next
[15:31:11.344]                             invokeRestart(restart)
[15:31:11.344]                             muffled <- TRUE
[15:31:11.344]                             break
[15:31:11.344]                           }
[15:31:11.344]                         }
[15:31:11.344]                       }
[15:31:11.344]                       invisible(muffled)
[15:31:11.344]                     }
[15:31:11.344]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.344]                   }
[15:31:11.344]                 }
[15:31:11.344]             }
[15:31:11.344]         }))
[15:31:11.344]     }, error = function(ex) {
[15:31:11.344]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:11.344]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.344]                 ...future.rng), started = ...future.startTime, 
[15:31:11.344]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:11.344]             version = "1.8"), class = "FutureResult")
[15:31:11.344]     }, finally = {
[15:31:11.344]         if (!identical(...future.workdir, getwd())) 
[15:31:11.344]             setwd(...future.workdir)
[15:31:11.344]         {
[15:31:11.344]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:11.344]                 ...future.oldOptions$nwarnings <- NULL
[15:31:11.344]             }
[15:31:11.344]             base::options(...future.oldOptions)
[15:31:11.344]             if (.Platform$OS.type == "windows") {
[15:31:11.344]                 old_names <- names(...future.oldEnvVars)
[15:31:11.344]                 envs <- base::Sys.getenv()
[15:31:11.344]                 names <- names(envs)
[15:31:11.344]                 common <- intersect(names, old_names)
[15:31:11.344]                 added <- setdiff(names, old_names)
[15:31:11.344]                 removed <- setdiff(old_names, names)
[15:31:11.344]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:11.344]                   envs[common]]
[15:31:11.344]                 NAMES <- toupper(changed)
[15:31:11.344]                 args <- list()
[15:31:11.344]                 for (kk in seq_along(NAMES)) {
[15:31:11.344]                   name <- changed[[kk]]
[15:31:11.344]                   NAME <- NAMES[[kk]]
[15:31:11.344]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.344]                     next
[15:31:11.344]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.344]                 }
[15:31:11.344]                 NAMES <- toupper(added)
[15:31:11.344]                 for (kk in seq_along(NAMES)) {
[15:31:11.344]                   name <- added[[kk]]
[15:31:11.344]                   NAME <- NAMES[[kk]]
[15:31:11.344]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.344]                     next
[15:31:11.344]                   args[[name]] <- ""
[15:31:11.344]                 }
[15:31:11.344]                 NAMES <- toupper(removed)
[15:31:11.344]                 for (kk in seq_along(NAMES)) {
[15:31:11.344]                   name <- removed[[kk]]
[15:31:11.344]                   NAME <- NAMES[[kk]]
[15:31:11.344]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.344]                     next
[15:31:11.344]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.344]                 }
[15:31:11.344]                 if (length(args) > 0) 
[15:31:11.344]                   base::do.call(base::Sys.setenv, args = args)
[15:31:11.344]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:11.344]             }
[15:31:11.344]             else {
[15:31:11.344]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:11.344]             }
[15:31:11.344]             {
[15:31:11.344]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:11.344]                   0L) {
[15:31:11.344]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:11.344]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:11.344]                   base::options(opts)
[15:31:11.344]                 }
[15:31:11.344]                 {
[15:31:11.344]                   {
[15:31:11.344]                     NULL
[15:31:11.344]                     RNGkind("Mersenne-Twister")
[15:31:11.344]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:11.344]                       inherits = FALSE)
[15:31:11.344]                   }
[15:31:11.344]                   options(future.plan = NULL)
[15:31:11.344]                   if (is.na(NA_character_)) 
[15:31:11.344]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.344]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:11.344]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:11.344]                     .init = FALSE)
[15:31:11.344]                 }
[15:31:11.344]             }
[15:31:11.344]         }
[15:31:11.344]     })
[15:31:11.344]     if (TRUE) {
[15:31:11.344]         base::sink(type = "output", split = FALSE)
[15:31:11.344]         if (TRUE) {
[15:31:11.344]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:11.344]         }
[15:31:11.344]         else {
[15:31:11.344]             ...future.result["stdout"] <- base::list(NULL)
[15:31:11.344]         }
[15:31:11.344]         base::close(...future.stdout)
[15:31:11.344]         ...future.stdout <- NULL
[15:31:11.344]     }
[15:31:11.344]     ...future.result$conditions <- ...future.conditions
[15:31:11.344]     ...future.result$finished <- base::Sys.time()
[15:31:11.344]     ...future.result
[15:31:11.344] }
[15:31:11.351] assign_globals() ...
[15:31:11.351] List of 7
[15:31:11.351]  $ ...future.FUN            :function (x)  
[15:31:11.351]  $ breaks                   : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:11.351]  $ wool                     : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:11.351]  $ future.call.arguments    : list()
[15:31:11.351]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.351]  $ ...future.elements_ii    :List of 3
[15:31:11.351]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.351]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:11.351]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.351]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:11.351]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.351]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:11.351]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.351]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:11.351]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.351]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:11.351]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.351]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:11.351]  $ ...future.seeds_ii       : NULL
[15:31:11.351]  $ ...future.globals.maxSize: NULL
[15:31:11.351]  - attr(*, "where")=List of 7
[15:31:11.351]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:11.351]   ..$ breaks                   :<environment: R_EmptyEnv> 
[15:31:11.351]   ..$ wool                     :<environment: R_EmptyEnv> 
[15:31:11.351]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:11.351]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:11.351]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:11.351]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:11.351]  - attr(*, "resolved")= logi FALSE
[15:31:11.351]  - attr(*, "total_size")= num 2320
[15:31:11.351]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.351]  - attr(*, "already-done")= logi TRUE
[15:31:11.367] - reassign environment for '...future.FUN'
[15:31:11.367] - copied '...future.FUN' to environment
[15:31:11.367] - copied 'breaks' to environment
[15:31:11.367] - copied 'wool' to environment
[15:31:11.368] - copied 'future.call.arguments' to environment
[15:31:11.368] - copied '...future.elements_ii' to environment
[15:31:11.368] - copied '...future.seeds_ii' to environment
[15:31:11.368] - copied '...future.globals.maxSize' to environment
[15:31:11.368] assign_globals() ... done
[15:31:11.369] plan(): Setting new future strategy stack:
[15:31:11.369] List of future strategies:
[15:31:11.369] 1. sequential:
[15:31:11.369]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.369]    - tweaked: FALSE
[15:31:11.369]    - call: NULL
[15:31:11.370] plan(): nbrOfWorkers() = 1
[15:31:11.375] plan(): Setting new future strategy stack:
[15:31:11.376] List of future strategies:
[15:31:11.376] 1. sequential:
[15:31:11.376]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.376]    - tweaked: FALSE
[15:31:11.376]    - call: plan(strategy)
[15:31:11.376] plan(): nbrOfWorkers() = 1
[15:31:11.377] SequentialFuture started (and completed)
[15:31:11.377] - Launch lazy future ... done
[15:31:11.377] run() for 'SequentialFuture' ... done
[15:31:11.378] Created future:
[15:31:11.378] SequentialFuture:
[15:31:11.378] Label: 'future_by-1'
[15:31:11.378] Expression:
[15:31:11.378] {
[15:31:11.378]     do.call(function(...) {
[15:31:11.378]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.378]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.378]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.378]             on.exit(options(oopts), add = TRUE)
[15:31:11.378]         }
[15:31:11.378]         {
[15:31:11.378]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.378]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.378]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.378]             })
[15:31:11.378]         }
[15:31:11.378]     }, args = future.call.arguments)
[15:31:11.378] }
[15:31:11.378] Lazy evaluation: FALSE
[15:31:11.378] Asynchronous evaluation: FALSE
[15:31:11.378] Local evaluation: TRUE
[15:31:11.378] Environment: 0x0000019c82c10880
[15:31:11.378] Capture standard output: TRUE
[15:31:11.378] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:11.378] Globals: 7 objects totaling 7.07 KiB (function '...future.FUN' of 1.04 KiB, numeric 'breaks' of 480 bytes, factor 'wool' of 776 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, ...)
[15:31:11.378] Packages: 1 packages ('stats')
[15:31:11.378] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:11.378] Resolved: TRUE
[15:31:11.378] Value: 25.57 KiB of class 'list'
[15:31:11.378] Early signaling: FALSE
[15:31:11.378] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:11.378] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.380] Chunk #1 of 1 ... DONE
[15:31:11.380] Launching 1 futures (chunks) ... DONE
[15:31:11.380] Resolving 1 futures (chunks) ...
[15:31:11.381] resolve() on list ...
[15:31:11.381]  recursive: 0
[15:31:11.381]  length: 1
[15:31:11.381] 
[15:31:11.382] resolved() for 'SequentialFuture' ...
[15:31:11.382] - state: 'finished'
[15:31:11.382] - run: TRUE
[15:31:11.382] - result: 'FutureResult'
[15:31:11.383] resolved() for 'SequentialFuture' ... done
[15:31:11.383] Future #1
[15:31:11.383] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.383] - nx: 1
[15:31:11.383] - relay: TRUE
[15:31:11.384] - stdout: TRUE
[15:31:11.384] - signal: TRUE
[15:31:11.384] - resignal: FALSE
[15:31:11.384] - force: TRUE
[15:31:11.384] - relayed: [n=1] FALSE
[15:31:11.384] - queued futures: [n=1] FALSE
[15:31:11.385]  - until=1
[15:31:11.385]  - relaying element #1
[15:31:11.385] - relayed: [n=1] TRUE
[15:31:11.386] - queued futures: [n=1] TRUE
[15:31:11.386] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.386]  length: 0 (resolved future 1)
[15:31:11.386] Relaying remaining futures
[15:31:11.387] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.387] - nx: 1
[15:31:11.387] - relay: TRUE
[15:31:11.387] - stdout: TRUE
[15:31:11.387] - signal: TRUE
[15:31:11.388] - resignal: FALSE
[15:31:11.388] - force: TRUE
[15:31:11.388] - relayed: [n=1] TRUE
[15:31:11.388] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.389] - relayed: [n=1] TRUE
[15:31:11.390] - queued futures: [n=1] TRUE
[15:31:11.390] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.390] resolve() on list ... DONE
[15:31:11.391]  - Number of value chunks collected: 1
[15:31:11.391] Resolving 1 futures (chunks) ... DONE
[15:31:11.392] Reducing values from 1 chunks ...
[15:31:11.392]  - Number of values collected after concatenation: 3
[15:31:11.392]  - Number of values expected: 3
[15:31:11.392] Reducing values from 1 chunks ... DONE
[15:31:11.393] future_lapply() ... DONE
[15:31:11.393] future_by_internal() ... DONE
[15:31:11.394] future_by_internal() ...
[15:31:11.395] future_lapply() ...
[15:31:11.396] Number of chunks: 1
[15:31:11.396] getGlobalsAndPackagesXApply() ...
[15:31:11.396]  - future.globals: TRUE
[15:31:11.397] getGlobalsAndPackages() ...
[15:31:11.397] Searching for globals...
[15:31:11.399] - globals found: [2] 'FUN', 'UseMethod'
[15:31:11.399] Searching for globals ... DONE
[15:31:11.400] Resolving globals: FALSE
[15:31:11.400] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:11.401] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:11.401] - globals: [1] 'FUN'
[15:31:11.402] 
[15:31:11.402] getGlobalsAndPackages() ... DONE
[15:31:11.402]  - globals found/used: [n=1] 'FUN'
[15:31:11.402]  - needed namespaces: [n=0] 
[15:31:11.403] Finding globals ... DONE
[15:31:11.403]  - use_args: TRUE
[15:31:11.403]  - Getting '...' globals ...
[15:31:11.404] resolve() on list ...
[15:31:11.405]  recursive: 0
[15:31:11.405]  length: 1
[15:31:11.405]  elements: '...'
[15:31:11.406]  length: 0 (resolved future 1)
[15:31:11.406] resolve() on list ... DONE
[15:31:11.406]    - '...' content: [n=0] 
[15:31:11.406] List of 1
[15:31:11.406]  $ ...: list()
[15:31:11.406]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.406]  - attr(*, "where")=List of 1
[15:31:11.406]   ..$ ...:<environment: 0x0000019c80944a38> 
[15:31:11.406]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.406]  - attr(*, "resolved")= logi TRUE
[15:31:11.406]  - attr(*, "total_size")= num NA
[15:31:11.411]  - Getting '...' globals ... DONE
[15:31:11.411] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:11.411] List of 2
[15:31:11.411]  $ ...future.FUN:function (object, ...)  
[15:31:11.411]  $ ...          : list()
[15:31:11.411]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.411]  - attr(*, "where")=List of 2
[15:31:11.411]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:11.411]   ..$ ...          :<environment: 0x0000019c80944a38> 
[15:31:11.411]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.411]  - attr(*, "resolved")= logi FALSE
[15:31:11.411]  - attr(*, "total_size")= num 1240
[15:31:11.416] Packages to be attached in all futures: [n=0] 
[15:31:11.416] getGlobalsAndPackagesXApply() ... DONE
[15:31:11.417] Number of futures (= number of chunks): 1
[15:31:11.417] Launching 1 futures (chunks) ...
[15:31:11.417] Chunk #1 of 1 ...
[15:31:11.418]  - Finding globals in 'X' for chunk #1 ...
[15:31:11.418] getGlobalsAndPackages() ...
[15:31:11.418] Searching for globals...
[15:31:11.419] 
[15:31:11.419] Searching for globals ... DONE
[15:31:11.420] - globals: [0] <none>
[15:31:11.420] getGlobalsAndPackages() ... DONE
[15:31:11.420]    + additional globals found: [n=0] 
[15:31:11.421]    + additional namespaces needed: [n=0] 
[15:31:11.421]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:11.421]  - seeds: <none>
[15:31:11.421]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.422] getGlobalsAndPackages() ...
[15:31:11.422] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.422] Resolving globals: FALSE
[15:31:11.423] Tweak future expression to call with '...' arguments ...
[15:31:11.423] {
[15:31:11.423]     do.call(function(...) {
[15:31:11.423]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.423]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.423]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.423]             on.exit(options(oopts), add = TRUE)
[15:31:11.423]         }
[15:31:11.423]         {
[15:31:11.423]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.423]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.423]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.423]             })
[15:31:11.423]         }
[15:31:11.423]     }, args = future.call.arguments)
[15:31:11.423] }
[15:31:11.424] Tweak future expression to call with '...' arguments ... DONE
[15:31:11.425] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.425] 
[15:31:11.425] getGlobalsAndPackages() ... DONE
[15:31:11.426] run() for 'Future' ...
[15:31:11.426] - state: 'created'
[15:31:11.427] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:11.427] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.428] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:11.428]   - Field: 'label'
[15:31:11.428]   - Field: 'local'
[15:31:11.429]   - Field: 'owner'
[15:31:11.429]   - Field: 'envir'
[15:31:11.429]   - Field: 'packages'
[15:31:11.430]   - Field: 'gc'
[15:31:11.430]   - Field: 'conditions'
[15:31:11.430]   - Field: 'expr'
[15:31:11.431]   - Field: 'uuid'
[15:31:11.431]   - Field: 'seed'
[15:31:11.431]   - Field: 'version'
[15:31:11.432]   - Field: 'result'
[15:31:11.432]   - Field: 'asynchronous'
[15:31:11.432]   - Field: 'calls'
[15:31:11.432]   - Field: 'globals'
[15:31:11.433]   - Field: 'stdout'
[15:31:11.433]   - Field: 'earlySignal'
[15:31:11.433]   - Field: 'lazy'
[15:31:11.434]   - Field: 'state'
[15:31:11.434] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:11.434] - Launch lazy future ...
[15:31:11.435] Packages needed by the future expression (n = 0): <none>
[15:31:11.435] Packages needed by future strategies (n = 0): <none>
[15:31:11.436] {
[15:31:11.436]     {
[15:31:11.436]         {
[15:31:11.436]             ...future.startTime <- base::Sys.time()
[15:31:11.436]             {
[15:31:11.436]                 {
[15:31:11.436]                   {
[15:31:11.436]                     base::local({
[15:31:11.436]                       has_future <- base::requireNamespace("future", 
[15:31:11.436]                         quietly = TRUE)
[15:31:11.436]                       if (has_future) {
[15:31:11.436]                         ns <- base::getNamespace("future")
[15:31:11.436]                         version <- ns[[".package"]][["version"]]
[15:31:11.436]                         if (is.null(version)) 
[15:31:11.436]                           version <- utils::packageVersion("future")
[15:31:11.436]                       }
[15:31:11.436]                       else {
[15:31:11.436]                         version <- NULL
[15:31:11.436]                       }
[15:31:11.436]                       if (!has_future || version < "1.8.0") {
[15:31:11.436]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:11.436]                           "", base::R.version$version.string), 
[15:31:11.436]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:11.436]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:11.436]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:11.436]                             "release", "version")], collapse = " "), 
[15:31:11.436]                           hostname = base::Sys.info()[["nodename"]])
[15:31:11.436]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:11.436]                           info)
[15:31:11.436]                         info <- base::paste(info, collapse = "; ")
[15:31:11.436]                         if (!has_future) {
[15:31:11.436]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:11.436]                             info)
[15:31:11.436]                         }
[15:31:11.436]                         else {
[15:31:11.436]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:11.436]                             info, version)
[15:31:11.436]                         }
[15:31:11.436]                         base::stop(msg)
[15:31:11.436]                       }
[15:31:11.436]                     })
[15:31:11.436]                   }
[15:31:11.436]                   ...future.strategy.old <- future::plan("list")
[15:31:11.436]                   options(future.plan = NULL)
[15:31:11.436]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.436]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:11.436]                 }
[15:31:11.436]                 ...future.workdir <- getwd()
[15:31:11.436]             }
[15:31:11.436]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:11.436]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:11.436]         }
[15:31:11.436]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:11.436]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:11.436]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:11.436]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:11.436]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:11.436]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:11.436]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:11.436]             base::names(...future.oldOptions))
[15:31:11.436]     }
[15:31:11.436]     if (FALSE) {
[15:31:11.436]     }
[15:31:11.436]     else {
[15:31:11.436]         if (TRUE) {
[15:31:11.436]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:11.436]                 open = "w")
[15:31:11.436]         }
[15:31:11.436]         else {
[15:31:11.436]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:11.436]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:11.436]         }
[15:31:11.436]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:11.436]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:11.436]             base::sink(type = "output", split = FALSE)
[15:31:11.436]             base::close(...future.stdout)
[15:31:11.436]         }, add = TRUE)
[15:31:11.436]     }
[15:31:11.436]     ...future.frame <- base::sys.nframe()
[15:31:11.436]     ...future.conditions <- base::list()
[15:31:11.436]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:11.436]     if (FALSE) {
[15:31:11.436]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:11.436]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:11.436]     }
[15:31:11.436]     ...future.result <- base::tryCatch({
[15:31:11.436]         base::withCallingHandlers({
[15:31:11.436]             ...future.value <- base::withVisible(base::local({
[15:31:11.436]                 do.call(function(...) {
[15:31:11.436]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.436]                   if (!identical(...future.globals.maxSize.org, 
[15:31:11.436]                     ...future.globals.maxSize)) {
[15:31:11.436]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.436]                     on.exit(options(oopts), add = TRUE)
[15:31:11.436]                   }
[15:31:11.436]                   {
[15:31:11.436]                     lapply(seq_along(...future.elements_ii), 
[15:31:11.436]                       FUN = function(jj) {
[15:31:11.436]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.436]                         ...future.FUN(...future.X_jj, ...)
[15:31:11.436]                       })
[15:31:11.436]                   }
[15:31:11.436]                 }, args = future.call.arguments)
[15:31:11.436]             }))
[15:31:11.436]             future::FutureResult(value = ...future.value$value, 
[15:31:11.436]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.436]                   ...future.rng), globalenv = if (FALSE) 
[15:31:11.436]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:11.436]                     ...future.globalenv.names))
[15:31:11.436]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:11.436]         }, condition = base::local({
[15:31:11.436]             c <- base::c
[15:31:11.436]             inherits <- base::inherits
[15:31:11.436]             invokeRestart <- base::invokeRestart
[15:31:11.436]             length <- base::length
[15:31:11.436]             list <- base::list
[15:31:11.436]             seq.int <- base::seq.int
[15:31:11.436]             signalCondition <- base::signalCondition
[15:31:11.436]             sys.calls <- base::sys.calls
[15:31:11.436]             `[[` <- base::`[[`
[15:31:11.436]             `+` <- base::`+`
[15:31:11.436]             `<<-` <- base::`<<-`
[15:31:11.436]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:11.436]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:11.436]                   3L)]
[15:31:11.436]             }
[15:31:11.436]             function(cond) {
[15:31:11.436]                 is_error <- inherits(cond, "error")
[15:31:11.436]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:11.436]                   NULL)
[15:31:11.436]                 if (is_error) {
[15:31:11.436]                   sessionInformation <- function() {
[15:31:11.436]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:11.436]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:11.436]                       search = base::search(), system = base::Sys.info())
[15:31:11.436]                   }
[15:31:11.436]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.436]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:11.436]                     cond$call), session = sessionInformation(), 
[15:31:11.436]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:11.436]                   signalCondition(cond)
[15:31:11.436]                 }
[15:31:11.436]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:11.436]                 "immediateCondition"))) {
[15:31:11.436]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:11.436]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.436]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:11.436]                   if (TRUE && !signal) {
[15:31:11.436]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.436]                     {
[15:31:11.436]                       inherits <- base::inherits
[15:31:11.436]                       invokeRestart <- base::invokeRestart
[15:31:11.436]                       is.null <- base::is.null
[15:31:11.436]                       muffled <- FALSE
[15:31:11.436]                       if (inherits(cond, "message")) {
[15:31:11.436]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.436]                         if (muffled) 
[15:31:11.436]                           invokeRestart("muffleMessage")
[15:31:11.436]                       }
[15:31:11.436]                       else if (inherits(cond, "warning")) {
[15:31:11.436]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.436]                         if (muffled) 
[15:31:11.436]                           invokeRestart("muffleWarning")
[15:31:11.436]                       }
[15:31:11.436]                       else if (inherits(cond, "condition")) {
[15:31:11.436]                         if (!is.null(pattern)) {
[15:31:11.436]                           computeRestarts <- base::computeRestarts
[15:31:11.436]                           grepl <- base::grepl
[15:31:11.436]                           restarts <- computeRestarts(cond)
[15:31:11.436]                           for (restart in restarts) {
[15:31:11.436]                             name <- restart$name
[15:31:11.436]                             if (is.null(name)) 
[15:31:11.436]                               next
[15:31:11.436]                             if (!grepl(pattern, name)) 
[15:31:11.436]                               next
[15:31:11.436]                             invokeRestart(restart)
[15:31:11.436]                             muffled <- TRUE
[15:31:11.436]                             break
[15:31:11.436]                           }
[15:31:11.436]                         }
[15:31:11.436]                       }
[15:31:11.436]                       invisible(muffled)
[15:31:11.436]                     }
[15:31:11.436]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.436]                   }
[15:31:11.436]                 }
[15:31:11.436]                 else {
[15:31:11.436]                   if (TRUE) {
[15:31:11.436]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.436]                     {
[15:31:11.436]                       inherits <- base::inherits
[15:31:11.436]                       invokeRestart <- base::invokeRestart
[15:31:11.436]                       is.null <- base::is.null
[15:31:11.436]                       muffled <- FALSE
[15:31:11.436]                       if (inherits(cond, "message")) {
[15:31:11.436]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.436]                         if (muffled) 
[15:31:11.436]                           invokeRestart("muffleMessage")
[15:31:11.436]                       }
[15:31:11.436]                       else if (inherits(cond, "warning")) {
[15:31:11.436]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.436]                         if (muffled) 
[15:31:11.436]                           invokeRestart("muffleWarning")
[15:31:11.436]                       }
[15:31:11.436]                       else if (inherits(cond, "condition")) {
[15:31:11.436]                         if (!is.null(pattern)) {
[15:31:11.436]                           computeRestarts <- base::computeRestarts
[15:31:11.436]                           grepl <- base::grepl
[15:31:11.436]                           restarts <- computeRestarts(cond)
[15:31:11.436]                           for (restart in restarts) {
[15:31:11.436]                             name <- restart$name
[15:31:11.436]                             if (is.null(name)) 
[15:31:11.436]                               next
[15:31:11.436]                             if (!grepl(pattern, name)) 
[15:31:11.436]                               next
[15:31:11.436]                             invokeRestart(restart)
[15:31:11.436]                             muffled <- TRUE
[15:31:11.436]                             break
[15:31:11.436]                           }
[15:31:11.436]                         }
[15:31:11.436]                       }
[15:31:11.436]                       invisible(muffled)
[15:31:11.436]                     }
[15:31:11.436]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.436]                   }
[15:31:11.436]                 }
[15:31:11.436]             }
[15:31:11.436]         }))
[15:31:11.436]     }, error = function(ex) {
[15:31:11.436]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:11.436]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.436]                 ...future.rng), started = ...future.startTime, 
[15:31:11.436]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:11.436]             version = "1.8"), class = "FutureResult")
[15:31:11.436]     }, finally = {
[15:31:11.436]         if (!identical(...future.workdir, getwd())) 
[15:31:11.436]             setwd(...future.workdir)
[15:31:11.436]         {
[15:31:11.436]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:11.436]                 ...future.oldOptions$nwarnings <- NULL
[15:31:11.436]             }
[15:31:11.436]             base::options(...future.oldOptions)
[15:31:11.436]             if (.Platform$OS.type == "windows") {
[15:31:11.436]                 old_names <- names(...future.oldEnvVars)
[15:31:11.436]                 envs <- base::Sys.getenv()
[15:31:11.436]                 names <- names(envs)
[15:31:11.436]                 common <- intersect(names, old_names)
[15:31:11.436]                 added <- setdiff(names, old_names)
[15:31:11.436]                 removed <- setdiff(old_names, names)
[15:31:11.436]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:11.436]                   envs[common]]
[15:31:11.436]                 NAMES <- toupper(changed)
[15:31:11.436]                 args <- list()
[15:31:11.436]                 for (kk in seq_along(NAMES)) {
[15:31:11.436]                   name <- changed[[kk]]
[15:31:11.436]                   NAME <- NAMES[[kk]]
[15:31:11.436]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.436]                     next
[15:31:11.436]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.436]                 }
[15:31:11.436]                 NAMES <- toupper(added)
[15:31:11.436]                 for (kk in seq_along(NAMES)) {
[15:31:11.436]                   name <- added[[kk]]
[15:31:11.436]                   NAME <- NAMES[[kk]]
[15:31:11.436]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.436]                     next
[15:31:11.436]                   args[[name]] <- ""
[15:31:11.436]                 }
[15:31:11.436]                 NAMES <- toupper(removed)
[15:31:11.436]                 for (kk in seq_along(NAMES)) {
[15:31:11.436]                   name <- removed[[kk]]
[15:31:11.436]                   NAME <- NAMES[[kk]]
[15:31:11.436]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.436]                     next
[15:31:11.436]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.436]                 }
[15:31:11.436]                 if (length(args) > 0) 
[15:31:11.436]                   base::do.call(base::Sys.setenv, args = args)
[15:31:11.436]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:11.436]             }
[15:31:11.436]             else {
[15:31:11.436]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:11.436]             }
[15:31:11.436]             {
[15:31:11.436]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:11.436]                   0L) {
[15:31:11.436]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:11.436]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:11.436]                   base::options(opts)
[15:31:11.436]                 }
[15:31:11.436]                 {
[15:31:11.436]                   {
[15:31:11.436]                     NULL
[15:31:11.436]                     RNGkind("Mersenne-Twister")
[15:31:11.436]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:11.436]                       inherits = FALSE)
[15:31:11.436]                   }
[15:31:11.436]                   options(future.plan = NULL)
[15:31:11.436]                   if (is.na(NA_character_)) 
[15:31:11.436]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.436]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:11.436]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:11.436]                     .init = FALSE)
[15:31:11.436]                 }
[15:31:11.436]             }
[15:31:11.436]         }
[15:31:11.436]     })
[15:31:11.436]     if (TRUE) {
[15:31:11.436]         base::sink(type = "output", split = FALSE)
[15:31:11.436]         if (TRUE) {
[15:31:11.436]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:11.436]         }
[15:31:11.436]         else {
[15:31:11.436]             ...future.result["stdout"] <- base::list(NULL)
[15:31:11.436]         }
[15:31:11.436]         base::close(...future.stdout)
[15:31:11.436]         ...future.stdout <- NULL
[15:31:11.436]     }
[15:31:11.436]     ...future.result$conditions <- ...future.conditions
[15:31:11.436]     ...future.result$finished <- base::Sys.time()
[15:31:11.436]     ...future.result
[15:31:11.436] }
[15:31:11.441] assign_globals() ...
[15:31:11.441] List of 5
[15:31:11.441]  $ ...future.FUN            :function (object, ...)  
[15:31:11.441]  $ future.call.arguments    : list()
[15:31:11.441]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.441]  $ ...future.elements_ii    :List of 3
[15:31:11.441]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.441]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:11.441]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.441]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:11.441]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.441]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:11.441]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.441]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:11.441]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.441]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:11.441]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.441]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:11.441]  $ ...future.seeds_ii       : NULL
[15:31:11.441]  $ ...future.globals.maxSize: NULL
[15:31:11.441]  - attr(*, "where")=List of 5
[15:31:11.441]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:11.441]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:11.441]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:11.441]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:11.441]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:11.441]  - attr(*, "resolved")= logi FALSE
[15:31:11.441]  - attr(*, "total_size")= num 1240
[15:31:11.441]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.441]  - attr(*, "already-done")= logi TRUE
[15:31:11.456] - copied '...future.FUN' to environment
[15:31:11.456] - copied 'future.call.arguments' to environment
[15:31:11.456] - copied '...future.elements_ii' to environment
[15:31:11.457] - copied '...future.seeds_ii' to environment
[15:31:11.457] - copied '...future.globals.maxSize' to environment
[15:31:11.457] assign_globals() ... done
[15:31:11.458] plan(): Setting new future strategy stack:
[15:31:11.458] List of future strategies:
[15:31:11.458] 1. sequential:
[15:31:11.458]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.458]    - tweaked: FALSE
[15:31:11.458]    - call: NULL
[15:31:11.459] plan(): nbrOfWorkers() = 1
[15:31:11.464] plan(): Setting new future strategy stack:
[15:31:11.465] List of future strategies:
[15:31:11.465] 1. sequential:
[15:31:11.465]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.465]    - tweaked: FALSE
[15:31:11.465]    - call: plan(strategy)
[15:31:11.466] plan(): nbrOfWorkers() = 1
[15:31:11.466] SequentialFuture started (and completed)
[15:31:11.466] - Launch lazy future ... done
[15:31:11.467] run() for 'SequentialFuture' ... done
[15:31:11.467] Created future:
[15:31:11.468] SequentialFuture:
[15:31:11.468] Label: 'future_by-1'
[15:31:11.468] Expression:
[15:31:11.468] {
[15:31:11.468]     do.call(function(...) {
[15:31:11.468]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.468]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.468]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.468]             on.exit(options(oopts), add = TRUE)
[15:31:11.468]         }
[15:31:11.468]         {
[15:31:11.468]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.468]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.468]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.468]             })
[15:31:11.468]         }
[15:31:11.468]     }, args = future.call.arguments)
[15:31:11.468] }
[15:31:11.468] Lazy evaluation: FALSE
[15:31:11.468] Asynchronous evaluation: FALSE
[15:31:11.468] Local evaluation: TRUE
[15:31:11.468] Environment: 0x0000019c7d1198e8
[15:31:11.468] Capture standard output: TRUE
[15:31:11.468] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:11.468] Globals: 5 objects totaling 6.02 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:11.468] Packages: <none>
[15:31:11.468] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:11.468] Resolved: TRUE
[15:31:11.468] Value: 5.37 KiB of class 'list'
[15:31:11.468] Early signaling: FALSE
[15:31:11.468] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:11.468] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.470] Chunk #1 of 1 ... DONE
[15:31:11.470] Launching 1 futures (chunks) ... DONE
[15:31:11.470] Resolving 1 futures (chunks) ...
[15:31:11.470] resolve() on list ...
[15:31:11.471]  recursive: 0
[15:31:11.471]  length: 1
[15:31:11.471] 
[15:31:11.471] resolved() for 'SequentialFuture' ...
[15:31:11.472] - state: 'finished'
[15:31:11.472] - run: TRUE
[15:31:11.472] - result: 'FutureResult'
[15:31:11.473] resolved() for 'SequentialFuture' ... done
[15:31:11.473] Future #1
[15:31:11.473] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.474] - nx: 1
[15:31:11.474] - relay: TRUE
[15:31:11.474] - stdout: TRUE
[15:31:11.475] - signal: TRUE
[15:31:11.475] - resignal: FALSE
[15:31:11.475] - force: TRUE
[15:31:11.475] - relayed: [n=1] FALSE
[15:31:11.476] - queued futures: [n=1] FALSE
[15:31:11.476]  - until=1
[15:31:11.476]  - relaying element #1
[15:31:11.477] - relayed: [n=1] TRUE
[15:31:11.477] - queued futures: [n=1] TRUE
[15:31:11.477] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.478]  length: 0 (resolved future 1)
[15:31:11.478] Relaying remaining futures
[15:31:11.478] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.478] - nx: 1
[15:31:11.479] - relay: TRUE
[15:31:11.479] - stdout: TRUE
[15:31:11.479] - signal: TRUE
[15:31:11.479] - resignal: FALSE
[15:31:11.479] - force: TRUE
[15:31:11.480] - relayed: [n=1] TRUE
[15:31:11.480] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.480] - relayed: [n=1] TRUE
[15:31:11.481] - queued futures: [n=1] TRUE
[15:31:11.481] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.481] resolve() on list ... DONE
[15:31:11.482]  - Number of value chunks collected: 1
[15:31:11.482] Resolving 1 futures (chunks) ... DONE
[15:31:11.482] Reducing values from 1 chunks ...
[15:31:11.482]  - Number of values collected after concatenation: 3
[15:31:11.483]  - Number of values expected: 3
[15:31:11.483] Reducing values from 1 chunks ... DONE
[15:31:11.483] future_lapply() ... DONE
[15:31:11.483] future_by_internal() ... DONE
[15:31:11.485] 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.
[15:31:11.486] future_lapply() ...
[15:31:11.487] Number of chunks: 1
[15:31:11.488] getGlobalsAndPackagesXApply() ...
[15:31:11.488]  - future.globals: TRUE
[15:31:11.488] getGlobalsAndPackages() ...
[15:31:11.489] Searching for globals...
[15:31:11.491] - globals found: [2] 'FUN', 'UseMethod'
[15:31:11.491] Searching for globals ... DONE
[15:31:11.491] Resolving globals: FALSE
[15:31:11.492] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:11.493] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:11.493] - globals: [1] 'FUN'
[15:31:11.493] 
[15:31:11.494] getGlobalsAndPackages() ... DONE
[15:31:11.494]  - globals found/used: [n=1] 'FUN'
[15:31:11.494]  - needed namespaces: [n=0] 
[15:31:11.494] Finding globals ... DONE
[15:31:11.495]  - use_args: TRUE
[15:31:11.495]  - Getting '...' globals ...
[15:31:11.496] resolve() on list ...
[15:31:11.496]  recursive: 0
[15:31:11.496]  length: 1
[15:31:11.496]  elements: '...'
[15:31:11.497]  length: 0 (resolved future 1)
[15:31:11.497] resolve() on list ... DONE
[15:31:11.497]    - '...' content: [n=0] 
[15:31:11.497] List of 1
[15:31:11.497]  $ ...: list()
[15:31:11.497]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.497]  - attr(*, "where")=List of 1
[15:31:11.497]   ..$ ...:<environment: 0x0000019c83193f40> 
[15:31:11.497]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.497]  - attr(*, "resolved")= logi TRUE
[15:31:11.497]  - attr(*, "total_size")= num NA
[15:31:11.504]  - Getting '...' globals ... DONE
[15:31:11.505] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:11.505] List of 2
[15:31:11.505]  $ ...future.FUN:function (object, ...)  
[15:31:11.505]  $ ...          : list()
[15:31:11.505]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.505]  - attr(*, "where")=List of 2
[15:31:11.505]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:11.505]   ..$ ...          :<environment: 0x0000019c83193f40> 
[15:31:11.505]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.505]  - attr(*, "resolved")= logi FALSE
[15:31:11.505]  - attr(*, "total_size")= num 1240
[15:31:11.511] Packages to be attached in all futures: [n=0] 
[15:31:11.511] getGlobalsAndPackagesXApply() ... DONE
[15:31:11.511] Number of futures (= number of chunks): 1
[15:31:11.512] Launching 1 futures (chunks) ...
[15:31:11.512] Chunk #1 of 1 ...
[15:31:11.512]  - Finding globals in 'X' for chunk #1 ...
[15:31:11.513] getGlobalsAndPackages() ...
[15:31:11.513] Searching for globals...
[15:31:11.514] 
[15:31:11.514] Searching for globals ... DONE
[15:31:11.515] - globals: [0] <none>
[15:31:11.515] getGlobalsAndPackages() ... DONE
[15:31:11.515]    + additional globals found: [n=0] 
[15:31:11.516]    + additional namespaces needed: [n=0] 
[15:31:11.516]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:11.516]  - seeds: <none>
[15:31:11.517]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.517] getGlobalsAndPackages() ...
[15:31:11.517] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.518] Resolving globals: FALSE
[15:31:11.518] Tweak future expression to call with '...' arguments ...
[15:31:11.518] {
[15:31:11.518]     do.call(function(...) {
[15:31:11.518]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.518]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.518]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.518]             on.exit(options(oopts), add = TRUE)
[15:31:11.518]         }
[15:31:11.518]         {
[15:31:11.518]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.518]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.518]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.518]             })
[15:31:11.518]         }
[15:31:11.518]     }, args = future.call.arguments)
[15:31:11.518] }
[15:31:11.519] Tweak future expression to call with '...' arguments ... DONE
[15:31:11.520] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:11.520] 
[15:31:11.521] getGlobalsAndPackages() ... DONE
[15:31:11.521] run() for 'Future' ...
[15:31:11.522] - state: 'created'
[15:31:11.522] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:11.523] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.532] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:11.532]   - Field: 'label'
[15:31:11.533]   - Field: 'local'
[15:31:11.533]   - Field: 'owner'
[15:31:11.533]   - Field: 'envir'
[15:31:11.534]   - Field: 'packages'
[15:31:11.534]   - Field: 'gc'
[15:31:11.535]   - Field: 'conditions'
[15:31:11.535]   - Field: 'expr'
[15:31:11.535]   - Field: 'uuid'
[15:31:11.536]   - Field: 'seed'
[15:31:11.536]   - Field: 'version'
[15:31:11.536]   - Field: 'result'
[15:31:11.537]   - Field: 'asynchronous'
[15:31:11.537]   - Field: 'calls'
[15:31:11.537]   - Field: 'globals'
[15:31:11.538]   - Field: 'stdout'
[15:31:11.538]   - Field: 'earlySignal'
[15:31:11.538]   - Field: 'lazy'
[15:31:11.539]   - Field: 'state'
[15:31:11.539] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:11.539] - Launch lazy future ...
[15:31:11.540] Packages needed by the future expression (n = 0): <none>
[15:31:11.540] Packages needed by future strategies (n = 0): <none>
[15:31:11.541] {
[15:31:11.541]     {
[15:31:11.541]         {
[15:31:11.541]             ...future.startTime <- base::Sys.time()
[15:31:11.541]             {
[15:31:11.541]                 {
[15:31:11.541]                   {
[15:31:11.541]                     base::local({
[15:31:11.541]                       has_future <- base::requireNamespace("future", 
[15:31:11.541]                         quietly = TRUE)
[15:31:11.541]                       if (has_future) {
[15:31:11.541]                         ns <- base::getNamespace("future")
[15:31:11.541]                         version <- ns[[".package"]][["version"]]
[15:31:11.541]                         if (is.null(version)) 
[15:31:11.541]                           version <- utils::packageVersion("future")
[15:31:11.541]                       }
[15:31:11.541]                       else {
[15:31:11.541]                         version <- NULL
[15:31:11.541]                       }
[15:31:11.541]                       if (!has_future || version < "1.8.0") {
[15:31:11.541]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:11.541]                           "", base::R.version$version.string), 
[15:31:11.541]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:11.541]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:11.541]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:11.541]                             "release", "version")], collapse = " "), 
[15:31:11.541]                           hostname = base::Sys.info()[["nodename"]])
[15:31:11.541]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:11.541]                           info)
[15:31:11.541]                         info <- base::paste(info, collapse = "; ")
[15:31:11.541]                         if (!has_future) {
[15:31:11.541]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:11.541]                             info)
[15:31:11.541]                         }
[15:31:11.541]                         else {
[15:31:11.541]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:11.541]                             info, version)
[15:31:11.541]                         }
[15:31:11.541]                         base::stop(msg)
[15:31:11.541]                       }
[15:31:11.541]                     })
[15:31:11.541]                   }
[15:31:11.541]                   ...future.strategy.old <- future::plan("list")
[15:31:11.541]                   options(future.plan = NULL)
[15:31:11.541]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.541]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:11.541]                 }
[15:31:11.541]                 ...future.workdir <- getwd()
[15:31:11.541]             }
[15:31:11.541]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:11.541]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:11.541]         }
[15:31:11.541]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:11.541]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:11.541]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:11.541]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:11.541]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:11.541]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:11.541]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:11.541]             base::names(...future.oldOptions))
[15:31:11.541]     }
[15:31:11.541]     if (FALSE) {
[15:31:11.541]     }
[15:31:11.541]     else {
[15:31:11.541]         if (TRUE) {
[15:31:11.541]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:11.541]                 open = "w")
[15:31:11.541]         }
[15:31:11.541]         else {
[15:31:11.541]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:11.541]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:11.541]         }
[15:31:11.541]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:11.541]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:11.541]             base::sink(type = "output", split = FALSE)
[15:31:11.541]             base::close(...future.stdout)
[15:31:11.541]         }, add = TRUE)
[15:31:11.541]     }
[15:31:11.541]     ...future.frame <- base::sys.nframe()
[15:31:11.541]     ...future.conditions <- base::list()
[15:31:11.541]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:11.541]     if (FALSE) {
[15:31:11.541]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:11.541]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:11.541]     }
[15:31:11.541]     ...future.result <- base::tryCatch({
[15:31:11.541]         base::withCallingHandlers({
[15:31:11.541]             ...future.value <- base::withVisible(base::local({
[15:31:11.541]                 do.call(function(...) {
[15:31:11.541]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.541]                   if (!identical(...future.globals.maxSize.org, 
[15:31:11.541]                     ...future.globals.maxSize)) {
[15:31:11.541]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.541]                     on.exit(options(oopts), add = TRUE)
[15:31:11.541]                   }
[15:31:11.541]                   {
[15:31:11.541]                     lapply(seq_along(...future.elements_ii), 
[15:31:11.541]                       FUN = function(jj) {
[15:31:11.541]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.541]                         ...future.FUN(...future.X_jj, ...)
[15:31:11.541]                       })
[15:31:11.541]                   }
[15:31:11.541]                 }, args = future.call.arguments)
[15:31:11.541]             }))
[15:31:11.541]             future::FutureResult(value = ...future.value$value, 
[15:31:11.541]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.541]                   ...future.rng), globalenv = if (FALSE) 
[15:31:11.541]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:11.541]                     ...future.globalenv.names))
[15:31:11.541]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:11.541]         }, condition = base::local({
[15:31:11.541]             c <- base::c
[15:31:11.541]             inherits <- base::inherits
[15:31:11.541]             invokeRestart <- base::invokeRestart
[15:31:11.541]             length <- base::length
[15:31:11.541]             list <- base::list
[15:31:11.541]             seq.int <- base::seq.int
[15:31:11.541]             signalCondition <- base::signalCondition
[15:31:11.541]             sys.calls <- base::sys.calls
[15:31:11.541]             `[[` <- base::`[[`
[15:31:11.541]             `+` <- base::`+`
[15:31:11.541]             `<<-` <- base::`<<-`
[15:31:11.541]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:11.541]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:11.541]                   3L)]
[15:31:11.541]             }
[15:31:11.541]             function(cond) {
[15:31:11.541]                 is_error <- inherits(cond, "error")
[15:31:11.541]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:11.541]                   NULL)
[15:31:11.541]                 if (is_error) {
[15:31:11.541]                   sessionInformation <- function() {
[15:31:11.541]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:11.541]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:11.541]                       search = base::search(), system = base::Sys.info())
[15:31:11.541]                   }
[15:31:11.541]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.541]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:11.541]                     cond$call), session = sessionInformation(), 
[15:31:11.541]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:11.541]                   signalCondition(cond)
[15:31:11.541]                 }
[15:31:11.541]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:11.541]                 "immediateCondition"))) {
[15:31:11.541]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:11.541]                   ...future.conditions[[length(...future.conditions) + 
[15:31:11.541]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:11.541]                   if (TRUE && !signal) {
[15:31:11.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.541]                     {
[15:31:11.541]                       inherits <- base::inherits
[15:31:11.541]                       invokeRestart <- base::invokeRestart
[15:31:11.541]                       is.null <- base::is.null
[15:31:11.541]                       muffled <- FALSE
[15:31:11.541]                       if (inherits(cond, "message")) {
[15:31:11.541]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.541]                         if (muffled) 
[15:31:11.541]                           invokeRestart("muffleMessage")
[15:31:11.541]                       }
[15:31:11.541]                       else if (inherits(cond, "warning")) {
[15:31:11.541]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.541]                         if (muffled) 
[15:31:11.541]                           invokeRestart("muffleWarning")
[15:31:11.541]                       }
[15:31:11.541]                       else if (inherits(cond, "condition")) {
[15:31:11.541]                         if (!is.null(pattern)) {
[15:31:11.541]                           computeRestarts <- base::computeRestarts
[15:31:11.541]                           grepl <- base::grepl
[15:31:11.541]                           restarts <- computeRestarts(cond)
[15:31:11.541]                           for (restart in restarts) {
[15:31:11.541]                             name <- restart$name
[15:31:11.541]                             if (is.null(name)) 
[15:31:11.541]                               next
[15:31:11.541]                             if (!grepl(pattern, name)) 
[15:31:11.541]                               next
[15:31:11.541]                             invokeRestart(restart)
[15:31:11.541]                             muffled <- TRUE
[15:31:11.541]                             break
[15:31:11.541]                           }
[15:31:11.541]                         }
[15:31:11.541]                       }
[15:31:11.541]                       invisible(muffled)
[15:31:11.541]                     }
[15:31:11.541]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.541]                   }
[15:31:11.541]                 }
[15:31:11.541]                 else {
[15:31:11.541]                   if (TRUE) {
[15:31:11.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:11.541]                     {
[15:31:11.541]                       inherits <- base::inherits
[15:31:11.541]                       invokeRestart <- base::invokeRestart
[15:31:11.541]                       is.null <- base::is.null
[15:31:11.541]                       muffled <- FALSE
[15:31:11.541]                       if (inherits(cond, "message")) {
[15:31:11.541]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:11.541]                         if (muffled) 
[15:31:11.541]                           invokeRestart("muffleMessage")
[15:31:11.541]                       }
[15:31:11.541]                       else if (inherits(cond, "warning")) {
[15:31:11.541]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:11.541]                         if (muffled) 
[15:31:11.541]                           invokeRestart("muffleWarning")
[15:31:11.541]                       }
[15:31:11.541]                       else if (inherits(cond, "condition")) {
[15:31:11.541]                         if (!is.null(pattern)) {
[15:31:11.541]                           computeRestarts <- base::computeRestarts
[15:31:11.541]                           grepl <- base::grepl
[15:31:11.541]                           restarts <- computeRestarts(cond)
[15:31:11.541]                           for (restart in restarts) {
[15:31:11.541]                             name <- restart$name
[15:31:11.541]                             if (is.null(name)) 
[15:31:11.541]                               next
[15:31:11.541]                             if (!grepl(pattern, name)) 
[15:31:11.541]                               next
[15:31:11.541]                             invokeRestart(restart)
[15:31:11.541]                             muffled <- TRUE
[15:31:11.541]                             break
[15:31:11.541]                           }
[15:31:11.541]                         }
[15:31:11.541]                       }
[15:31:11.541]                       invisible(muffled)
[15:31:11.541]                     }
[15:31:11.541]                     muffleCondition(cond, pattern = "^muffle")
[15:31:11.541]                   }
[15:31:11.541]                 }
[15:31:11.541]             }
[15:31:11.541]         }))
[15:31:11.541]     }, error = function(ex) {
[15:31:11.541]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:11.541]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:11.541]                 ...future.rng), started = ...future.startTime, 
[15:31:11.541]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:11.541]             version = "1.8"), class = "FutureResult")
[15:31:11.541]     }, finally = {
[15:31:11.541]         if (!identical(...future.workdir, getwd())) 
[15:31:11.541]             setwd(...future.workdir)
[15:31:11.541]         {
[15:31:11.541]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:11.541]                 ...future.oldOptions$nwarnings <- NULL
[15:31:11.541]             }
[15:31:11.541]             base::options(...future.oldOptions)
[15:31:11.541]             if (.Platform$OS.type == "windows") {
[15:31:11.541]                 old_names <- names(...future.oldEnvVars)
[15:31:11.541]                 envs <- base::Sys.getenv()
[15:31:11.541]                 names <- names(envs)
[15:31:11.541]                 common <- intersect(names, old_names)
[15:31:11.541]                 added <- setdiff(names, old_names)
[15:31:11.541]                 removed <- setdiff(old_names, names)
[15:31:11.541]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:11.541]                   envs[common]]
[15:31:11.541]                 NAMES <- toupper(changed)
[15:31:11.541]                 args <- list()
[15:31:11.541]                 for (kk in seq_along(NAMES)) {
[15:31:11.541]                   name <- changed[[kk]]
[15:31:11.541]                   NAME <- NAMES[[kk]]
[15:31:11.541]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.541]                     next
[15:31:11.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.541]                 }
[15:31:11.541]                 NAMES <- toupper(added)
[15:31:11.541]                 for (kk in seq_along(NAMES)) {
[15:31:11.541]                   name <- added[[kk]]
[15:31:11.541]                   NAME <- NAMES[[kk]]
[15:31:11.541]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.541]                     next
[15:31:11.541]                   args[[name]] <- ""
[15:31:11.541]                 }
[15:31:11.541]                 NAMES <- toupper(removed)
[15:31:11.541]                 for (kk in seq_along(NAMES)) {
[15:31:11.541]                   name <- removed[[kk]]
[15:31:11.541]                   NAME <- NAMES[[kk]]
[15:31:11.541]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:11.541]                     next
[15:31:11.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:11.541]                 }
[15:31:11.541]                 if (length(args) > 0) 
[15:31:11.541]                   base::do.call(base::Sys.setenv, args = args)
[15:31:11.541]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:11.541]             }
[15:31:11.541]             else {
[15:31:11.541]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:11.541]             }
[15:31:11.541]             {
[15:31:11.541]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:11.541]                   0L) {
[15:31:11.541]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:11.541]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:11.541]                   base::options(opts)
[15:31:11.541]                 }
[15:31:11.541]                 {
[15:31:11.541]                   {
[15:31:11.541]                     NULL
[15:31:11.541]                     RNGkind("Mersenne-Twister")
[15:31:11.541]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:11.541]                       inherits = FALSE)
[15:31:11.541]                   }
[15:31:11.541]                   options(future.plan = NULL)
[15:31:11.541]                   if (is.na(NA_character_)) 
[15:31:11.541]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:11.541]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:11.541]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:11.541]                     .init = FALSE)
[15:31:11.541]                 }
[15:31:11.541]             }
[15:31:11.541]         }
[15:31:11.541]     })
[15:31:11.541]     if (TRUE) {
[15:31:11.541]         base::sink(type = "output", split = FALSE)
[15:31:11.541]         if (TRUE) {
[15:31:11.541]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:11.541]         }
[15:31:11.541]         else {
[15:31:11.541]             ...future.result["stdout"] <- base::list(NULL)
[15:31:11.541]         }
[15:31:11.541]         base::close(...future.stdout)
[15:31:11.541]         ...future.stdout <- NULL
[15:31:11.541]     }
[15:31:11.541]     ...future.result$conditions <- ...future.conditions
[15:31:11.541]     ...future.result$finished <- base::Sys.time()
[15:31:11.541]     ...future.result
[15:31:11.541] }
[15:31:11.548] assign_globals() ...
[15:31:11.549] List of 5
[15:31:11.549]  $ ...future.FUN            :function (object, ...)  
[15:31:11.549]  $ future.call.arguments    : list()
[15:31:11.549]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:11.549]  $ ...future.elements_ii    :List of 3
[15:31:11.549]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.549]   .. ..$ breaks : num [1:18] 26 30 54 25 70 52 51 26 67 27 ...
[15:31:11.549]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.549]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:11.549]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.549]   .. ..$ breaks : num [1:18] 18 21 29 17 12 18 35 30 36 42 ...
[15:31:11.549]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.549]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 2 2 2 2 2 2 2 2 2 2 ...
[15:31:11.549]   ..$ :'data.frame':	18 obs. of  3 variables:
[15:31:11.549]   .. ..$ breaks : num [1:18] 36 21 24 18 10 43 28 15 26 20 ...
[15:31:11.549]   .. ..$ wool   : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 2 ...
[15:31:11.549]   .. ..$ tension: Factor w/ 3 levels "L","M","H": 3 3 3 3 3 3 3 3 3 3 ...
[15:31:11.549]  $ ...future.seeds_ii       : NULL
[15:31:11.549]  $ ...future.globals.maxSize: NULL
[15:31:11.549]  - attr(*, "where")=List of 5
[15:31:11.549]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:11.549]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:11.549]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:11.549]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:11.549]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:11.549]  - attr(*, "resolved")= logi FALSE
[15:31:11.549]  - attr(*, "total_size")= num 1240
[15:31:11.549]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:11.549]  - attr(*, "already-done")= logi TRUE
[15:31:11.566] - copied '...future.FUN' to environment
[15:31:11.567] - copied 'future.call.arguments' to environment
[15:31:11.567] - copied '...future.elements_ii' to environment
[15:31:11.567] - copied '...future.seeds_ii' to environment
[15:31:11.567] - copied '...future.globals.maxSize' to environment
[15:31:11.568] assign_globals() ... done
[15:31:11.568] plan(): Setting new future strategy stack:
[15:31:11.569] List of future strategies:
[15:31:11.569] 1. sequential:
[15:31:11.569]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.569]    - tweaked: FALSE
[15:31:11.569]    - call: NULL
[15:31:11.570] plan(): nbrOfWorkers() = 1
[15:31:11.576] plan(): Setting new future strategy stack:
[15:31:11.576] List of future strategies:
[15:31:11.576] 1. sequential:
[15:31:11.576]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:11.576]    - tweaked: FALSE
[15:31:11.576]    - call: plan(strategy)
[15:31:11.577] plan(): nbrOfWorkers() = 1
[15:31:11.577] SequentialFuture started (and completed)
[15:31:11.578] - Launch lazy future ... done
[15:31:11.578] run() for 'SequentialFuture' ... done
[15:31:11.578] Created future:
[15:31:11.578] SequentialFuture:
[15:31:11.578] Label: 'future_by-1'
[15:31:11.578] Expression:
[15:31:11.578] {
[15:31:11.578]     do.call(function(...) {
[15:31:11.578]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:11.578]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:11.578]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:11.578]             on.exit(options(oopts), add = TRUE)
[15:31:11.578]         }
[15:31:11.578]         {
[15:31:11.578]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:11.578]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:11.578]                 ...future.FUN(...future.X_jj, ...)
[15:31:11.578]             })
[15:31:11.578]         }
[15:31:11.578]     }, args = future.call.arguments)
[15:31:11.578] }
[15:31:11.578] Lazy evaluation: FALSE
[15:31:11.578] Asynchronous evaluation: FALSE
[15:31:11.578] Local evaluation: TRUE
[15:31:11.578] Environment: 0x0000019c83153ca8
[15:31:11.578] Capture standard output: TRUE
[15:31:11.578] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:11.578] Globals: 5 objects totaling 6.02 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 4.80 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:11.578] Packages: <none>
[15:31:11.578] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:11.578] Resolved: TRUE
[15:31:11.578] Value: 5.37 KiB of class 'list'
[15:31:11.578] Early signaling: FALSE
[15:31:11.578] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:11.578] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:11.580] Chunk #1 of 1 ... DONE
[15:31:11.581] Launching 1 futures (chunks) ... DONE
[15:31:11.581] Resolving 1 futures (chunks) ...
[15:31:11.581] resolve() on list ...
[15:31:11.581]  recursive: 0
[15:31:11.582]  length: 1
[15:31:11.582] 
[15:31:11.582] resolved() for 'SequentialFuture' ...
[15:31:11.582] - state: 'finished'
[15:31:11.583] - run: TRUE
[15:31:11.583] - result: 'FutureResult'
[15:31:11.583] resolved() for 'SequentialFuture' ... done
[15:31:11.583] Future #1
[15:31:11.583] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:11.584] - nx: 1
[15:31:11.584] - relay: TRUE
[15:31:11.584] - stdout: TRUE
[15:31:11.584] - signal: TRUE
[15:31:11.584] - resignal: FALSE
[15:31:11.584] - force: TRUE
[15:31:11.585] - relayed: [n=1] FALSE
[15:31:11.585] - queued futures: [n=1] FALSE
[15:31:11.586]  - until=1
[15:31:11.586]  - relaying element #1
[15:31:11.586] - relayed: [n=1] TRUE
[15:31:11.587] - queued futures: [n=1] TRUE
[15:31:11.587] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:11.587]  length: 0 (resolved future 1)
[15:31:11.587] Relaying remaining futures
[15:31:11.588] signalConditionsASAP(NULL, pos=0) ...
[15:31:11.588] - nx: 1
[15:31:11.588] - relay: TRUE
[15:31:11.588] - stdout: TRUE
[15:31:11.588] - signal: TRUE
[15:31:11.589] - resignal: FALSE
[15:31:11.589] - force: TRUE
[15:31:11.589] - relayed: [n=1] TRUE
[15:31:11.589] - queued futures: [n=1] TRUE
 - flush all
[15:31:11.590] - relayed: [n=1] TRUE
[15:31:11.590] - queued futures: [n=1] TRUE
[15:31:11.590] signalConditionsASAP(NULL, pos=0) ... done
[15:31:11.590] resolve() on list ... DONE
[15:31:11.591]  - Number of value chunks collected: 1
[15:31:11.591] Resolving 1 futures (chunks) ... DONE
[15:31:11.591] Reducing values from 1 chunks ...
[15:31:11.592]  - Number of values collected after concatenation: 3
[15:31:11.592]  - Number of values expected: 3
[15:31:11.592] Reducing values from 1 chunks ... DONE
[15:31:11.593] future_lapply() ... DONE
[15:31:11.593] future_by_internal() ... DONE
[15:31:11.595] future_by_internal() ...
- plan('multisession') ...
[15:31:11.596] plan(): Setting new future strategy stack:
[15:31:11.596] List of future strategies:
[15:31:11.596] 1. multisession:
[15:31:11.596]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:11.596]    - tweaked: FALSE
[15:31:11.596]    - call: plan(strategy)
[15:31:11.597] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:31:11.597] multisession:
[15:31:11.597] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:11.597] - tweaked: FALSE
[15:31:11.597] - call: plan(strategy)
[15:31:11.605] getGlobalsAndPackages() ...
[15:31:11.606] Not searching for globals
[15:31:11.606] - globals: [0] <none>
[15:31:11.606] getGlobalsAndPackages() ... DONE
[15:31:11.607] [local output] makeClusterPSOCK() ...
[15:31:11.668] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:31:11.675] [local output] Base port: 34473
[15:31:11.675] [local output] Getting setup options for 2 cluster nodes ...
[15:31:11.675] [local output]  - Node 1 of 2 ...
[15:31:11.676] [local output] localMachine=TRUE => revtunnel=FALSE

[15:31:11.677] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpSSl6iR/worker.rank=1.parallelly.parent=63696.f8d0565d67eb.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpSSl6iR/worker.rank=1.parallelly.parent=63696.f8d0565d67eb.pid\")"'
[15:31:12.233] - Possible to infer worker's PID: TRUE
[15:31:12.234] [local output] Rscript port: 34473

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

[15:31:12.237] [local output] Rscript port: 34473

[15:31:12.237] [local output] Getting setup options for 2 cluster nodes ... done
[15:31:12.238] [local output]  - Parallel setup requested for some PSOCK nodes
[15:31:12.239] [local output] Setting up PSOCK nodes in parallel
[15:31:12.239] List of 36
[15:31:12.239]  $ worker          : chr "localhost"
[15:31:12.239]   ..- attr(*, "localhost")= logi TRUE
[15:31:12.239]  $ master          : chr "localhost"
[15:31:12.239]  $ port            : int 34473
[15:31:12.239]  $ connectTimeout  : num 120
[15:31:12.239]  $ timeout         : num 120
[15:31:12.239]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:31:12.239]  $ homogeneous     : logi TRUE
[15:31:12.239]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_by.R:63696:CRANWIN3:CRAN\"| __truncated__
[15:31:12.239]  $ rscript_envs    : NULL
[15:31:12.239]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:31:12.239]  $ rscript_startup : NULL
[15:31:12.239]  $ rscript_sh      : chr "cmd"
[15:31:12.239]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:31:12.239]  $ methods         : logi TRUE
[15:31:12.239]  $ socketOptions   : chr "no-delay"
[15:31:12.239]  $ useXDR          : logi FALSE
[15:31:12.239]  $ outfile         : chr "/dev/null"
[15:31:12.239]  $ renice          : int NA
[15:31:12.239]  $ rshcmd          : NULL
[15:31:12.239]  $ user            : chr(0) 
[15:31:12.239]  $ revtunnel       : logi FALSE
[15:31:12.239]  $ rshlogfile      : NULL
[15:31:12.239]  $ rshopts         : chr(0) 
[15:31:12.239]  $ rank            : int 1
[15:31:12.239]  $ manual          : logi FALSE
[15:31:12.239]  $ dryrun          : logi FALSE
[15:31:12.239]  $ quiet           : logi FALSE
[15:31:12.239]  $ setup_strategy  : chr "parallel"
[15:31:12.239]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:31:12.239]  $ pidfile         : chr "D:/temp/RtmpSSl6iR/worker.rank=1.parallelly.parent=63696.f8d0565d67eb.pid"
[15:31:12.239]  $ rshcmd_label    : NULL
[15:31:12.239]  $ rsh_call        : NULL
[15:31:12.239]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:31:12.239]  $ localMachine    : logi TRUE
[15:31:12.239]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:31:12.239]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:31:12.239]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:31:12.239]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:31:12.239]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:31:12.239]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:31:12.239]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:31:12.239]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:31:12.239]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:31:12.239]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:31:12.239]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:31:12.239]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:31:12.239]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:31:12.239]  $ arguments       :List of 28
[15:31:12.239]   ..$ worker          : chr "localhost"
[15:31:12.239]   ..$ master          : NULL
[15:31:12.239]   ..$ port            : int 34473
[15:31:12.239]   ..$ connectTimeout  : num 120
[15:31:12.239]   ..$ timeout         : num 120
[15:31:12.239]   ..$ rscript         : NULL
[15:31:12.239]   ..$ homogeneous     : NULL
[15:31:12.239]   ..$ rscript_args    : NULL
[15:31:12.239]   ..$ rscript_envs    : NULL
[15:31:12.239]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:31:12.239]   ..$ rscript_startup : NULL
[15:31:12.239]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:31:12.239]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:31:12.239]   ..$ methods         : logi TRUE
[15:31:12.239]   ..$ socketOptions   : chr "no-delay"
[15:31:12.239]   ..$ useXDR          : logi FALSE
[15:31:12.239]   ..$ outfile         : chr "/dev/null"
[15:31:12.239]   ..$ renice          : int NA
[15:31:12.239]   ..$ rshcmd          : NULL
[15:31:12.239]   ..$ user            : NULL
[15:31:12.239]   ..$ revtunnel       : logi NA
[15:31:12.239]   ..$ rshlogfile      : NULL
[15:31:12.239]   ..$ rshopts         : NULL
[15:31:12.239]   ..$ rank            : int 1
[15:31:12.239]   ..$ manual          : logi FALSE
[15:31:12.239]   ..$ dryrun          : logi FALSE
[15:31:12.239]   ..$ quiet           : logi FALSE
[15:31:12.239]   ..$ setup_strategy  : chr "parallel"
[15:31:12.239]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:31:12.267] [local output] System call to launch all workers:
[15:31:12.268] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_by.R:63696:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpSSl6iR/worker.rank=1.parallelly.parent=63696.f8d0565d67eb.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=34473 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:31:12.268] [local output] Starting PSOCK main server
[15:31:12.277] [local output] Workers launched
[15:31:12.278] [local output] Waiting for workers to connect back
[15:31:12.278]  - [local output] 0 workers out of 2 ready
[15:31:12.520]  - [local output] 0 workers out of 2 ready
[15:31:12.521]  - [local output] 1 workers out of 2 ready
[15:31:12.546]  - [local output] 1 workers out of 2 ready
[15:31:12.546]  - [local output] 2 workers out of 2 ready
[15:31:12.547] [local output] Launching of workers completed
[15:31:12.547] [local output] Collecting session information from workers
[15:31:12.548] [local output]  - Worker #1 of 2
[15:31:12.550] [local output]  - Worker #2 of 2
[15:31:12.550] [local output] makeClusterPSOCK() ... done
[15:31:12.566] Packages needed by the future expression (n = 0): <none>
[15:31:12.566] Packages needed by future strategies (n = 0): <none>
[15:31:12.567] {
[15:31:12.567]     {
[15:31:12.567]         {
[15:31:12.567]             ...future.startTime <- base::Sys.time()
[15:31:12.567]             {
[15:31:12.567]                 {
[15:31:12.567]                   {
[15:31:12.567]                     {
[15:31:12.567]                       base::local({
[15:31:12.567]                         has_future <- base::requireNamespace("future", 
[15:31:12.567]                           quietly = TRUE)
[15:31:12.567]                         if (has_future) {
[15:31:12.567]                           ns <- base::getNamespace("future")
[15:31:12.567]                           version <- ns[[".package"]][["version"]]
[15:31:12.567]                           if (is.null(version)) 
[15:31:12.567]                             version <- utils::packageVersion("future")
[15:31:12.567]                         }
[15:31:12.567]                         else {
[15:31:12.567]                           version <- NULL
[15:31:12.567]                         }
[15:31:12.567]                         if (!has_future || version < "1.8.0") {
[15:31:12.567]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:12.567]                             "", base::R.version$version.string), 
[15:31:12.567]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:12.567]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:12.567]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:12.567]                               "release", "version")], collapse = " "), 
[15:31:12.567]                             hostname = base::Sys.info()[["nodename"]])
[15:31:12.567]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:12.567]                             info)
[15:31:12.567]                           info <- base::paste(info, collapse = "; ")
[15:31:12.567]                           if (!has_future) {
[15:31:12.567]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:12.567]                               info)
[15:31:12.567]                           }
[15:31:12.567]                           else {
[15:31:12.567]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:12.567]                               info, version)
[15:31:12.567]                           }
[15:31:12.567]                           base::stop(msg)
[15:31:12.567]                         }
[15:31:12.567]                       })
[15:31:12.567]                     }
[15:31:12.567]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:12.567]                     base::options(mc.cores = 1L)
[15:31:12.567]                   }
[15:31:12.567]                   ...future.strategy.old <- future::plan("list")
[15:31:12.567]                   options(future.plan = NULL)
[15:31:12.567]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:12.567]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:12.567]                 }
[15:31:12.567]                 ...future.workdir <- getwd()
[15:31:12.567]             }
[15:31:12.567]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:12.567]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:12.567]         }
[15:31:12.567]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:12.567]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:12.567]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:12.567]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:12.567]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:12.567]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:12.567]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:12.567]             base::names(...future.oldOptions))
[15:31:12.567]     }
[15:31:12.567]     if (FALSE) {
[15:31:12.567]     }
[15:31:12.567]     else {
[15:31:12.567]         if (TRUE) {
[15:31:12.567]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:12.567]                 open = "w")
[15:31:12.567]         }
[15:31:12.567]         else {
[15:31:12.567]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:12.567]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:12.567]         }
[15:31:12.567]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:12.567]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:12.567]             base::sink(type = "output", split = FALSE)
[15:31:12.567]             base::close(...future.stdout)
[15:31:12.567]         }, add = TRUE)
[15:31:12.567]     }
[15:31:12.567]     ...future.frame <- base::sys.nframe()
[15:31:12.567]     ...future.conditions <- base::list()
[15:31:12.567]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:12.567]     if (FALSE) {
[15:31:12.567]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:12.567]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:12.567]     }
[15:31:12.567]     ...future.result <- base::tryCatch({
[15:31:12.567]         base::withCallingHandlers({
[15:31:12.567]             ...future.value <- base::withVisible(base::local({
[15:31:12.567]                 ...future.makeSendCondition <- base::local({
[15:31:12.567]                   sendCondition <- NULL
[15:31:12.567]                   function(frame = 1L) {
[15:31:12.567]                     if (is.function(sendCondition)) 
[15:31:12.567]                       return(sendCondition)
[15:31:12.567]                     ns <- getNamespace("parallel")
[15:31:12.567]                     if (exists("sendData", mode = "function", 
[15:31:12.567]                       envir = ns)) {
[15:31:12.567]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:12.567]                         envir = ns)
[15:31:12.567]                       envir <- sys.frame(frame)
[15:31:12.567]                       master <- NULL
[15:31:12.567]                       while (!identical(envir, .GlobalEnv) && 
[15:31:12.567]                         !identical(envir, emptyenv())) {
[15:31:12.567]                         if (exists("master", mode = "list", envir = envir, 
[15:31:12.567]                           inherits = FALSE)) {
[15:31:12.567]                           master <- get("master", mode = "list", 
[15:31:12.567]                             envir = envir, inherits = FALSE)
[15:31:12.567]                           if (inherits(master, c("SOCKnode", 
[15:31:12.567]                             "SOCK0node"))) {
[15:31:12.567]                             sendCondition <<- function(cond) {
[15:31:12.567]                               data <- list(type = "VALUE", value = cond, 
[15:31:12.567]                                 success = TRUE)
[15:31:12.567]                               parallel_sendData(master, data)
[15:31:12.567]                             }
[15:31:12.567]                             return(sendCondition)
[15:31:12.567]                           }
[15:31:12.567]                         }
[15:31:12.567]                         frame <- frame + 1L
[15:31:12.567]                         envir <- sys.frame(frame)
[15:31:12.567]                       }
[15:31:12.567]                     }
[15:31:12.567]                     sendCondition <<- function(cond) NULL
[15:31:12.567]                   }
[15:31:12.567]                 })
[15:31:12.567]                 withCallingHandlers({
[15:31:12.567]                   NA
[15:31:12.567]                 }, immediateCondition = function(cond) {
[15:31:12.567]                   sendCondition <- ...future.makeSendCondition()
[15:31:12.567]                   sendCondition(cond)
[15:31:12.567]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.567]                   {
[15:31:12.567]                     inherits <- base::inherits
[15:31:12.567]                     invokeRestart <- base::invokeRestart
[15:31:12.567]                     is.null <- base::is.null
[15:31:12.567]                     muffled <- FALSE
[15:31:12.567]                     if (inherits(cond, "message")) {
[15:31:12.567]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:12.567]                       if (muffled) 
[15:31:12.567]                         invokeRestart("muffleMessage")
[15:31:12.567]                     }
[15:31:12.567]                     else if (inherits(cond, "warning")) {
[15:31:12.567]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:12.567]                       if (muffled) 
[15:31:12.567]                         invokeRestart("muffleWarning")
[15:31:12.567]                     }
[15:31:12.567]                     else if (inherits(cond, "condition")) {
[15:31:12.567]                       if (!is.null(pattern)) {
[15:31:12.567]                         computeRestarts <- base::computeRestarts
[15:31:12.567]                         grepl <- base::grepl
[15:31:12.567]                         restarts <- computeRestarts(cond)
[15:31:12.567]                         for (restart in restarts) {
[15:31:12.567]                           name <- restart$name
[15:31:12.567]                           if (is.null(name)) 
[15:31:12.567]                             next
[15:31:12.567]                           if (!grepl(pattern, name)) 
[15:31:12.567]                             next
[15:31:12.567]                           invokeRestart(restart)
[15:31:12.567]                           muffled <- TRUE
[15:31:12.567]                           break
[15:31:12.567]                         }
[15:31:12.567]                       }
[15:31:12.567]                     }
[15:31:12.567]                     invisible(muffled)
[15:31:12.567]                   }
[15:31:12.567]                   muffleCondition(cond)
[15:31:12.567]                 })
[15:31:12.567]             }))
[15:31:12.567]             future::FutureResult(value = ...future.value$value, 
[15:31:12.567]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:12.567]                   ...future.rng), globalenv = if (FALSE) 
[15:31:12.567]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:12.567]                     ...future.globalenv.names))
[15:31:12.567]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:12.567]         }, condition = base::local({
[15:31:12.567]             c <- base::c
[15:31:12.567]             inherits <- base::inherits
[15:31:12.567]             invokeRestart <- base::invokeRestart
[15:31:12.567]             length <- base::length
[15:31:12.567]             list <- base::list
[15:31:12.567]             seq.int <- base::seq.int
[15:31:12.567]             signalCondition <- base::signalCondition
[15:31:12.567]             sys.calls <- base::sys.calls
[15:31:12.567]             `[[` <- base::`[[`
[15:31:12.567]             `+` <- base::`+`
[15:31:12.567]             `<<-` <- base::`<<-`
[15:31:12.567]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:12.567]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:12.567]                   3L)]
[15:31:12.567]             }
[15:31:12.567]             function(cond) {
[15:31:12.567]                 is_error <- inherits(cond, "error")
[15:31:12.567]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:12.567]                   NULL)
[15:31:12.567]                 if (is_error) {
[15:31:12.567]                   sessionInformation <- function() {
[15:31:12.567]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:12.567]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:12.567]                       search = base::search(), system = base::Sys.info())
[15:31:12.567]                   }
[15:31:12.567]                   ...future.conditions[[length(...future.conditions) + 
[15:31:12.567]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:12.567]                     cond$call), session = sessionInformation(), 
[15:31:12.567]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:12.567]                   signalCondition(cond)
[15:31:12.567]                 }
[15:31:12.567]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:12.567]                 "immediateCondition"))) {
[15:31:12.567]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:12.567]                   ...future.conditions[[length(...future.conditions) + 
[15:31:12.567]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:12.567]                   if (TRUE && !signal) {
[15:31:12.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.567]                     {
[15:31:12.567]                       inherits <- base::inherits
[15:31:12.567]                       invokeRestart <- base::invokeRestart
[15:31:12.567]                       is.null <- base::is.null
[15:31:12.567]                       muffled <- FALSE
[15:31:12.567]                       if (inherits(cond, "message")) {
[15:31:12.567]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:12.567]                         if (muffled) 
[15:31:12.567]                           invokeRestart("muffleMessage")
[15:31:12.567]                       }
[15:31:12.567]                       else if (inherits(cond, "warning")) {
[15:31:12.567]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:12.567]                         if (muffled) 
[15:31:12.567]                           invokeRestart("muffleWarning")
[15:31:12.567]                       }
[15:31:12.567]                       else if (inherits(cond, "condition")) {
[15:31:12.567]                         if (!is.null(pattern)) {
[15:31:12.567]                           computeRestarts <- base::computeRestarts
[15:31:12.567]                           grepl <- base::grepl
[15:31:12.567]                           restarts <- computeRestarts(cond)
[15:31:12.567]                           for (restart in restarts) {
[15:31:12.567]                             name <- restart$name
[15:31:12.567]                             if (is.null(name)) 
[15:31:12.567]                               next
[15:31:12.567]                             if (!grepl(pattern, name)) 
[15:31:12.567]                               next
[15:31:12.567]                             invokeRestart(restart)
[15:31:12.567]                             muffled <- TRUE
[15:31:12.567]                             break
[15:31:12.567]                           }
[15:31:12.567]                         }
[15:31:12.567]                       }
[15:31:12.567]                       invisible(muffled)
[15:31:12.567]                     }
[15:31:12.567]                     muffleCondition(cond, pattern = "^muffle")
[15:31:12.567]                   }
[15:31:12.567]                 }
[15:31:12.567]                 else {
[15:31:12.567]                   if (TRUE) {
[15:31:12.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.567]                     {
[15:31:12.567]                       inherits <- base::inherits
[15:31:12.567]                       invokeRestart <- base::invokeRestart
[15:31:12.567]                       is.null <- base::is.null
[15:31:12.567]                       muffled <- FALSE
[15:31:12.567]                       if (inherits(cond, "message")) {
[15:31:12.567]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:12.567]                         if (muffled) 
[15:31:12.567]                           invokeRestart("muffleMessage")
[15:31:12.567]                       }
[15:31:12.567]                       else if (inherits(cond, "warning")) {
[15:31:12.567]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:12.567]                         if (muffled) 
[15:31:12.567]                           invokeRestart("muffleWarning")
[15:31:12.567]                       }
[15:31:12.567]                       else if (inherits(cond, "condition")) {
[15:31:12.567]                         if (!is.null(pattern)) {
[15:31:12.567]                           computeRestarts <- base::computeRestarts
[15:31:12.567]                           grepl <- base::grepl
[15:31:12.567]                           restarts <- computeRestarts(cond)
[15:31:12.567]                           for (restart in restarts) {
[15:31:12.567]                             name <- restart$name
[15:31:12.567]                             if (is.null(name)) 
[15:31:12.567]                               next
[15:31:12.567]                             if (!grepl(pattern, name)) 
[15:31:12.567]                               next
[15:31:12.567]                             invokeRestart(restart)
[15:31:12.567]                             muffled <- TRUE
[15:31:12.567]                             break
[15:31:12.567]                           }
[15:31:12.567]                         }
[15:31:12.567]                       }
[15:31:12.567]                       invisible(muffled)
[15:31:12.567]                     }
[15:31:12.567]                     muffleCondition(cond, pattern = "^muffle")
[15:31:12.567]                   }
[15:31:12.567]                 }
[15:31:12.567]             }
[15:31:12.567]         }))
[15:31:12.567]     }, error = function(ex) {
[15:31:12.567]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:12.567]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:12.567]                 ...future.rng), started = ...future.startTime, 
[15:31:12.567]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:12.567]             version = "1.8"), class = "FutureResult")
[15:31:12.567]     }, finally = {
[15:31:12.567]         if (!identical(...future.workdir, getwd())) 
[15:31:12.567]             setwd(...future.workdir)
[15:31:12.567]         {
[15:31:12.567]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:12.567]                 ...future.oldOptions$nwarnings <- NULL
[15:31:12.567]             }
[15:31:12.567]             base::options(...future.oldOptions)
[15:31:12.567]             if (.Platform$OS.type == "windows") {
[15:31:12.567]                 old_names <- names(...future.oldEnvVars)
[15:31:12.567]                 envs <- base::Sys.getenv()
[15:31:12.567]                 names <- names(envs)
[15:31:12.567]                 common <- intersect(names, old_names)
[15:31:12.567]                 added <- setdiff(names, old_names)
[15:31:12.567]                 removed <- setdiff(old_names, names)
[15:31:12.567]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:12.567]                   envs[common]]
[15:31:12.567]                 NAMES <- toupper(changed)
[15:31:12.567]                 args <- list()
[15:31:12.567]                 for (kk in seq_along(NAMES)) {
[15:31:12.567]                   name <- changed[[kk]]
[15:31:12.567]                   NAME <- NAMES[[kk]]
[15:31:12.567]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.567]                     next
[15:31:12.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:12.567]                 }
[15:31:12.567]                 NAMES <- toupper(added)
[15:31:12.567]                 for (kk in seq_along(NAMES)) {
[15:31:12.567]                   name <- added[[kk]]
[15:31:12.567]                   NAME <- NAMES[[kk]]
[15:31:12.567]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.567]                     next
[15:31:12.567]                   args[[name]] <- ""
[15:31:12.567]                 }
[15:31:12.567]                 NAMES <- toupper(removed)
[15:31:12.567]                 for (kk in seq_along(NAMES)) {
[15:31:12.567]                   name <- removed[[kk]]
[15:31:12.567]                   NAME <- NAMES[[kk]]
[15:31:12.567]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.567]                     next
[15:31:12.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:12.567]                 }
[15:31:12.567]                 if (length(args) > 0) 
[15:31:12.567]                   base::do.call(base::Sys.setenv, args = args)
[15:31:12.567]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:12.567]             }
[15:31:12.567]             else {
[15:31:12.567]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:12.567]             }
[15:31:12.567]             {
[15:31:12.567]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:12.567]                   0L) {
[15:31:12.567]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:12.567]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:12.567]                   base::options(opts)
[15:31:12.567]                 }
[15:31:12.567]                 {
[15:31:12.567]                   {
[15:31:12.567]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:12.567]                     NULL
[15:31:12.567]                   }
[15:31:12.567]                   options(future.plan = NULL)
[15:31:12.567]                   if (is.na(NA_character_)) 
[15:31:12.567]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:12.567]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:12.567]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:12.567]                     .init = FALSE)
[15:31:12.567]                 }
[15:31:12.567]             }
[15:31:12.567]         }
[15:31:12.567]     })
[15:31:12.567]     if (TRUE) {
[15:31:12.567]         base::sink(type = "output", split = FALSE)
[15:31:12.567]         if (TRUE) {
[15:31:12.567]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:12.567]         }
[15:31:12.567]         else {
[15:31:12.567]             ...future.result["stdout"] <- base::list(NULL)
[15:31:12.567]         }
[15:31:12.567]         base::close(...future.stdout)
[15:31:12.567]         ...future.stdout <- NULL
[15:31:12.567]     }
[15:31:12.567]     ...future.result$conditions <- ...future.conditions
[15:31:12.567]     ...future.result$finished <- base::Sys.time()
[15:31:12.567]     ...future.result
[15:31:12.567] }
[15:31:12.711] MultisessionFuture started
[15:31:12.712] result() for ClusterFuture ...
[15:31:12.712] receiveMessageFromWorker() for ClusterFuture ...
[15:31:12.713] - Validating connection of MultisessionFuture
[15:31:12.787] - received message: FutureResult
[15:31:12.788] - Received FutureResult
[15:31:12.793] - Erased future from FutureRegistry
[15:31:12.793] result() for ClusterFuture ...
[15:31:12.793] - result already collected: FutureResult
[15:31:12.793] result() for ClusterFuture ... done
[15:31:12.794] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:12.794] result() for ClusterFuture ... done
[15:31:12.794] result() for ClusterFuture ...
[15:31:12.794] - result already collected: FutureResult
[15:31:12.795] result() for ClusterFuture ... done
[15:31:12.795] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:31:12.799] plan(): nbrOfWorkers() = 2
[15:31:12.799] future_by_internal() ...
[15:31:12.800] future_lapply() ...
[15:31:12.805] Number of chunks: 2
[15:31:12.805] getGlobalsAndPackagesXApply() ...
[15:31:12.806]  - future.globals: TRUE
[15:31:12.806] getGlobalsAndPackages() ...
[15:31:12.806] Searching for globals...
[15:31:12.808] - globals found: [2] 'FUN', 'UseMethod'
[15:31:12.809] Searching for globals ... DONE
[15:31:12.809] Resolving globals: FALSE
[15:31:12.810] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:12.810] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:12.811] - globals: [1] 'FUN'
[15:31:12.811] 
[15:31:12.811] getGlobalsAndPackages() ... DONE
[15:31:12.811]  - globals found/used: [n=1] 'FUN'
[15:31:12.812]  - needed namespaces: [n=0] 
[15:31:12.812] Finding globals ... DONE
[15:31:12.812]  - use_args: TRUE
[15:31:12.813]  - Getting '...' globals ...
[15:31:12.813] resolve() on list ...
[15:31:12.814]  recursive: 0
[15:31:12.814]  length: 1
[15:31:12.814]  elements: '...'
[15:31:12.814]  length: 0 (resolved future 1)
[15:31:12.815] resolve() on list ... DONE
[15:31:12.815]    - '...' content: [n=0] 
[15:31:12.815] List of 1
[15:31:12.815]  $ ...: list()
[15:31:12.815]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:12.815]  - attr(*, "where")=List of 1
[15:31:12.815]   ..$ ...:<environment: 0x0000019c838298b0> 
[15:31:12.815]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:12.815]  - attr(*, "resolved")= logi TRUE
[15:31:12.815]  - attr(*, "total_size")= num NA
[15:31:12.820]  - Getting '...' globals ... DONE
[15:31:12.820] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:12.821] List of 2
[15:31:12.821]  $ ...future.FUN:function (object, ...)  
[15:31:12.821]  $ ...          : list()
[15:31:12.821]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:12.821]  - attr(*, "where")=List of 2
[15:31:12.821]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:12.821]   ..$ ...          :<environment: 0x0000019c838298b0> 
[15:31:12.821]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:12.821]  - attr(*, "resolved")= logi FALSE
[15:31:12.821]  - attr(*, "total_size")= num 1240
[15:31:12.826] Packages to be attached in all futures: [n=0] 
[15:31:12.826] getGlobalsAndPackagesXApply() ... DONE
[15:31:12.827] Number of futures (= number of chunks): 2
[15:31:12.827] Launching 2 futures (chunks) ...
[15:31:12.827] Chunk #1 of 2 ...
[15:31:12.827]  - Finding globals in 'X' for chunk #1 ...
[15:31:12.828] getGlobalsAndPackages() ...
[15:31:12.828] Searching for globals...
[15:31:12.829] 
[15:31:12.829] Searching for globals ... DONE
[15:31:12.829] - globals: [0] <none>
[15:31:12.829] getGlobalsAndPackages() ... DONE
[15:31:12.830]    + additional globals found: [n=0] 
[15:31:12.830]    + additional namespaces needed: [n=0] 
[15:31:12.830]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:12.830]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:12.831]  - seeds: <none>
[15:31:12.831]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:12.831] getGlobalsAndPackages() ...
[15:31:12.831] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:12.832] Resolving globals: FALSE
[15:31:12.832] Tweak future expression to call with '...' arguments ...
[15:31:12.832] {
[15:31:12.832]     do.call(function(...) {
[15:31:12.832]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:12.832]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:12.832]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:12.832]             on.exit(options(oopts), add = TRUE)
[15:31:12.832]         }
[15:31:12.832]         {
[15:31:12.832]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:12.832]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:12.832]                 ...future.FUN(...future.X_jj, ...)
[15:31:12.832]             })
[15:31:12.832]         }
[15:31:12.832]     }, args = future.call.arguments)
[15:31:12.832] }
[15:31:12.833] Tweak future expression to call with '...' arguments ... DONE
[15:31:12.834] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:12.834] 
[15:31:12.834] getGlobalsAndPackages() ... DONE
[15:31:12.835] run() for 'Future' ...
[15:31:12.835] - state: 'created'
[15:31:12.836] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:12.852] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:12.852] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:12.852]   - Field: 'node'
[15:31:12.852]   - Field: 'label'
[15:31:12.853]   - Field: 'local'
[15:31:12.853]   - Field: 'owner'
[15:31:12.853]   - Field: 'envir'
[15:31:12.853]   - Field: 'workers'
[15:31:12.853]   - Field: 'packages'
[15:31:12.854]   - Field: 'gc'
[15:31:12.854]   - Field: 'conditions'
[15:31:12.854]   - Field: 'persistent'
[15:31:12.854]   - Field: 'expr'
[15:31:12.854]   - Field: 'uuid'
[15:31:12.855]   - Field: 'seed'
[15:31:12.855]   - Field: 'version'
[15:31:12.855]   - Field: 'result'
[15:31:12.855]   - Field: 'asynchronous'
[15:31:12.856]   - Field: 'calls'
[15:31:12.856]   - Field: 'globals'
[15:31:12.856]   - Field: 'stdout'
[15:31:12.856]   - Field: 'earlySignal'
[15:31:12.856]   - Field: 'lazy'
[15:31:12.857]   - Field: 'state'
[15:31:12.857] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:12.857] - Launch lazy future ...
[15:31:12.858] Packages needed by the future expression (n = 0): <none>
[15:31:12.858] Packages needed by future strategies (n = 0): <none>
[15:31:12.858] {
[15:31:12.858]     {
[15:31:12.858]         {
[15:31:12.858]             ...future.startTime <- base::Sys.time()
[15:31:12.858]             {
[15:31:12.858]                 {
[15:31:12.858]                   {
[15:31:12.858]                     {
[15:31:12.858]                       base::local({
[15:31:12.858]                         has_future <- base::requireNamespace("future", 
[15:31:12.858]                           quietly = TRUE)
[15:31:12.858]                         if (has_future) {
[15:31:12.858]                           ns <- base::getNamespace("future")
[15:31:12.858]                           version <- ns[[".package"]][["version"]]
[15:31:12.858]                           if (is.null(version)) 
[15:31:12.858]                             version <- utils::packageVersion("future")
[15:31:12.858]                         }
[15:31:12.858]                         else {
[15:31:12.858]                           version <- NULL
[15:31:12.858]                         }
[15:31:12.858]                         if (!has_future || version < "1.8.0") {
[15:31:12.858]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:12.858]                             "", base::R.version$version.string), 
[15:31:12.858]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:12.858]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:12.858]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:12.858]                               "release", "version")], collapse = " "), 
[15:31:12.858]                             hostname = base::Sys.info()[["nodename"]])
[15:31:12.858]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:12.858]                             info)
[15:31:12.858]                           info <- base::paste(info, collapse = "; ")
[15:31:12.858]                           if (!has_future) {
[15:31:12.858]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:12.858]                               info)
[15:31:12.858]                           }
[15:31:12.858]                           else {
[15:31:12.858]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:12.858]                               info, version)
[15:31:12.858]                           }
[15:31:12.858]                           base::stop(msg)
[15:31:12.858]                         }
[15:31:12.858]                       })
[15:31:12.858]                     }
[15:31:12.858]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:12.858]                     base::options(mc.cores = 1L)
[15:31:12.858]                   }
[15:31:12.858]                   ...future.strategy.old <- future::plan("list")
[15:31:12.858]                   options(future.plan = NULL)
[15:31:12.858]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:12.858]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:12.858]                 }
[15:31:12.858]                 ...future.workdir <- getwd()
[15:31:12.858]             }
[15:31:12.858]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:12.858]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:12.858]         }
[15:31:12.858]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:12.858]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:12.858]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:12.858]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:12.858]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:12.858]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:12.858]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:12.858]             base::names(...future.oldOptions))
[15:31:12.858]     }
[15:31:12.858]     if (FALSE) {
[15:31:12.858]     }
[15:31:12.858]     else {
[15:31:12.858]         if (TRUE) {
[15:31:12.858]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:12.858]                 open = "w")
[15:31:12.858]         }
[15:31:12.858]         else {
[15:31:12.858]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:12.858]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:12.858]         }
[15:31:12.858]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:12.858]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:12.858]             base::sink(type = "output", split = FALSE)
[15:31:12.858]             base::close(...future.stdout)
[15:31:12.858]         }, add = TRUE)
[15:31:12.858]     }
[15:31:12.858]     ...future.frame <- base::sys.nframe()
[15:31:12.858]     ...future.conditions <- base::list()
[15:31:12.858]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:12.858]     if (FALSE) {
[15:31:12.858]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:12.858]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:12.858]     }
[15:31:12.858]     ...future.result <- base::tryCatch({
[15:31:12.858]         base::withCallingHandlers({
[15:31:12.858]             ...future.value <- base::withVisible(base::local({
[15:31:12.858]                 ...future.makeSendCondition <- base::local({
[15:31:12.858]                   sendCondition <- NULL
[15:31:12.858]                   function(frame = 1L) {
[15:31:12.858]                     if (is.function(sendCondition)) 
[15:31:12.858]                       return(sendCondition)
[15:31:12.858]                     ns <- getNamespace("parallel")
[15:31:12.858]                     if (exists("sendData", mode = "function", 
[15:31:12.858]                       envir = ns)) {
[15:31:12.858]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:12.858]                         envir = ns)
[15:31:12.858]                       envir <- sys.frame(frame)
[15:31:12.858]                       master <- NULL
[15:31:12.858]                       while (!identical(envir, .GlobalEnv) && 
[15:31:12.858]                         !identical(envir, emptyenv())) {
[15:31:12.858]                         if (exists("master", mode = "list", envir = envir, 
[15:31:12.858]                           inherits = FALSE)) {
[15:31:12.858]                           master <- get("master", mode = "list", 
[15:31:12.858]                             envir = envir, inherits = FALSE)
[15:31:12.858]                           if (inherits(master, c("SOCKnode", 
[15:31:12.858]                             "SOCK0node"))) {
[15:31:12.858]                             sendCondition <<- function(cond) {
[15:31:12.858]                               data <- list(type = "VALUE", value = cond, 
[15:31:12.858]                                 success = TRUE)
[15:31:12.858]                               parallel_sendData(master, data)
[15:31:12.858]                             }
[15:31:12.858]                             return(sendCondition)
[15:31:12.858]                           }
[15:31:12.858]                         }
[15:31:12.858]                         frame <- frame + 1L
[15:31:12.858]                         envir <- sys.frame(frame)
[15:31:12.858]                       }
[15:31:12.858]                     }
[15:31:12.858]                     sendCondition <<- function(cond) NULL
[15:31:12.858]                   }
[15:31:12.858]                 })
[15:31:12.858]                 withCallingHandlers({
[15:31:12.858]                   {
[15:31:12.858]                     do.call(function(...) {
[15:31:12.858]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:12.858]                       if (!identical(...future.globals.maxSize.org, 
[15:31:12.858]                         ...future.globals.maxSize)) {
[15:31:12.858]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:12.858]                         on.exit(options(oopts), add = TRUE)
[15:31:12.858]                       }
[15:31:12.858]                       {
[15:31:12.858]                         lapply(seq_along(...future.elements_ii), 
[15:31:12.858]                           FUN = function(jj) {
[15:31:12.858]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:12.858]                             ...future.FUN(...future.X_jj, ...)
[15:31:12.858]                           })
[15:31:12.858]                       }
[15:31:12.858]                     }, args = future.call.arguments)
[15:31:12.858]                   }
[15:31:12.858]                 }, immediateCondition = function(cond) {
[15:31:12.858]                   sendCondition <- ...future.makeSendCondition()
[15:31:12.858]                   sendCondition(cond)
[15:31:12.858]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.858]                   {
[15:31:12.858]                     inherits <- base::inherits
[15:31:12.858]                     invokeRestart <- base::invokeRestart
[15:31:12.858]                     is.null <- base::is.null
[15:31:12.858]                     muffled <- FALSE
[15:31:12.858]                     if (inherits(cond, "message")) {
[15:31:12.858]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:12.858]                       if (muffled) 
[15:31:12.858]                         invokeRestart("muffleMessage")
[15:31:12.858]                     }
[15:31:12.858]                     else if (inherits(cond, "warning")) {
[15:31:12.858]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:12.858]                       if (muffled) 
[15:31:12.858]                         invokeRestart("muffleWarning")
[15:31:12.858]                     }
[15:31:12.858]                     else if (inherits(cond, "condition")) {
[15:31:12.858]                       if (!is.null(pattern)) {
[15:31:12.858]                         computeRestarts <- base::computeRestarts
[15:31:12.858]                         grepl <- base::grepl
[15:31:12.858]                         restarts <- computeRestarts(cond)
[15:31:12.858]                         for (restart in restarts) {
[15:31:12.858]                           name <- restart$name
[15:31:12.858]                           if (is.null(name)) 
[15:31:12.858]                             next
[15:31:12.858]                           if (!grepl(pattern, name)) 
[15:31:12.858]                             next
[15:31:12.858]                           invokeRestart(restart)
[15:31:12.858]                           muffled <- TRUE
[15:31:12.858]                           break
[15:31:12.858]                         }
[15:31:12.858]                       }
[15:31:12.858]                     }
[15:31:12.858]                     invisible(muffled)
[15:31:12.858]                   }
[15:31:12.858]                   muffleCondition(cond)
[15:31:12.858]                 })
[15:31:12.858]             }))
[15:31:12.858]             future::FutureResult(value = ...future.value$value, 
[15:31:12.858]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:12.858]                   ...future.rng), globalenv = if (FALSE) 
[15:31:12.858]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:12.858]                     ...future.globalenv.names))
[15:31:12.858]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:12.858]         }, condition = base::local({
[15:31:12.858]             c <- base::c
[15:31:12.858]             inherits <- base::inherits
[15:31:12.858]             invokeRestart <- base::invokeRestart
[15:31:12.858]             length <- base::length
[15:31:12.858]             list <- base::list
[15:31:12.858]             seq.int <- base::seq.int
[15:31:12.858]             signalCondition <- base::signalCondition
[15:31:12.858]             sys.calls <- base::sys.calls
[15:31:12.858]             `[[` <- base::`[[`
[15:31:12.858]             `+` <- base::`+`
[15:31:12.858]             `<<-` <- base::`<<-`
[15:31:12.858]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:12.858]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:12.858]                   3L)]
[15:31:12.858]             }
[15:31:12.858]             function(cond) {
[15:31:12.858]                 is_error <- inherits(cond, "error")
[15:31:12.858]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:12.858]                   NULL)
[15:31:12.858]                 if (is_error) {
[15:31:12.858]                   sessionInformation <- function() {
[15:31:12.858]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:12.858]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:12.858]                       search = base::search(), system = base::Sys.info())
[15:31:12.858]                   }
[15:31:12.858]                   ...future.conditions[[length(...future.conditions) + 
[15:31:12.858]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:12.858]                     cond$call), session = sessionInformation(), 
[15:31:12.858]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:12.858]                   signalCondition(cond)
[15:31:12.858]                 }
[15:31:12.858]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:12.858]                 "immediateCondition"))) {
[15:31:12.858]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:12.858]                   ...future.conditions[[length(...future.conditions) + 
[15:31:12.858]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:12.858]                   if (TRUE && !signal) {
[15:31:12.858]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.858]                     {
[15:31:12.858]                       inherits <- base::inherits
[15:31:12.858]                       invokeRestart <- base::invokeRestart
[15:31:12.858]                       is.null <- base::is.null
[15:31:12.858]                       muffled <- FALSE
[15:31:12.858]                       if (inherits(cond, "message")) {
[15:31:12.858]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:12.858]                         if (muffled) 
[15:31:12.858]                           invokeRestart("muffleMessage")
[15:31:12.858]                       }
[15:31:12.858]                       else if (inherits(cond, "warning")) {
[15:31:12.858]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:12.858]                         if (muffled) 
[15:31:12.858]                           invokeRestart("muffleWarning")
[15:31:12.858]                       }
[15:31:12.858]                       else if (inherits(cond, "condition")) {
[15:31:12.858]                         if (!is.null(pattern)) {
[15:31:12.858]                           computeRestarts <- base::computeRestarts
[15:31:12.858]                           grepl <- base::grepl
[15:31:12.858]                           restarts <- computeRestarts(cond)
[15:31:12.858]                           for (restart in restarts) {
[15:31:12.858]                             name <- restart$name
[15:31:12.858]                             if (is.null(name)) 
[15:31:12.858]                               next
[15:31:12.858]                             if (!grepl(pattern, name)) 
[15:31:12.858]                               next
[15:31:12.858]                             invokeRestart(restart)
[15:31:12.858]                             muffled <- TRUE
[15:31:12.858]                             break
[15:31:12.858]                           }
[15:31:12.858]                         }
[15:31:12.858]                       }
[15:31:12.858]                       invisible(muffled)
[15:31:12.858]                     }
[15:31:12.858]                     muffleCondition(cond, pattern = "^muffle")
[15:31:12.858]                   }
[15:31:12.858]                 }
[15:31:12.858]                 else {
[15:31:12.858]                   if (TRUE) {
[15:31:12.858]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.858]                     {
[15:31:12.858]                       inherits <- base::inherits
[15:31:12.858]                       invokeRestart <- base::invokeRestart
[15:31:12.858]                       is.null <- base::is.null
[15:31:12.858]                       muffled <- FALSE
[15:31:12.858]                       if (inherits(cond, "message")) {
[15:31:12.858]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:12.858]                         if (muffled) 
[15:31:12.858]                           invokeRestart("muffleMessage")
[15:31:12.858]                       }
[15:31:12.858]                       else if (inherits(cond, "warning")) {
[15:31:12.858]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:12.858]                         if (muffled) 
[15:31:12.858]                           invokeRestart("muffleWarning")
[15:31:12.858]                       }
[15:31:12.858]                       else if (inherits(cond, "condition")) {
[15:31:12.858]                         if (!is.null(pattern)) {
[15:31:12.858]                           computeRestarts <- base::computeRestarts
[15:31:12.858]                           grepl <- base::grepl
[15:31:12.858]                           restarts <- computeRestarts(cond)
[15:31:12.858]                           for (restart in restarts) {
[15:31:12.858]                             name <- restart$name
[15:31:12.858]                             if (is.null(name)) 
[15:31:12.858]                               next
[15:31:12.858]                             if (!grepl(pattern, name)) 
[15:31:12.858]                               next
[15:31:12.858]                             invokeRestart(restart)
[15:31:12.858]                             muffled <- TRUE
[15:31:12.858]                             break
[15:31:12.858]                           }
[15:31:12.858]                         }
[15:31:12.858]                       }
[15:31:12.858]                       invisible(muffled)
[15:31:12.858]                     }
[15:31:12.858]                     muffleCondition(cond, pattern = "^muffle")
[15:31:12.858]                   }
[15:31:12.858]                 }
[15:31:12.858]             }
[15:31:12.858]         }))
[15:31:12.858]     }, error = function(ex) {
[15:31:12.858]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:12.858]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:12.858]                 ...future.rng), started = ...future.startTime, 
[15:31:12.858]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:12.858]             version = "1.8"), class = "FutureResult")
[15:31:12.858]     }, finally = {
[15:31:12.858]         if (!identical(...future.workdir, getwd())) 
[15:31:12.858]             setwd(...future.workdir)
[15:31:12.858]         {
[15:31:12.858]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:12.858]                 ...future.oldOptions$nwarnings <- NULL
[15:31:12.858]             }
[15:31:12.858]             base::options(...future.oldOptions)
[15:31:12.858]             if (.Platform$OS.type == "windows") {
[15:31:12.858]                 old_names <- names(...future.oldEnvVars)
[15:31:12.858]                 envs <- base::Sys.getenv()
[15:31:12.858]                 names <- names(envs)
[15:31:12.858]                 common <- intersect(names, old_names)
[15:31:12.858]                 added <- setdiff(names, old_names)
[15:31:12.858]                 removed <- setdiff(old_names, names)
[15:31:12.858]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:12.858]                   envs[common]]
[15:31:12.858]                 NAMES <- toupper(changed)
[15:31:12.858]                 args <- list()
[15:31:12.858]                 for (kk in seq_along(NAMES)) {
[15:31:12.858]                   name <- changed[[kk]]
[15:31:12.858]                   NAME <- NAMES[[kk]]
[15:31:12.858]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.858]                     next
[15:31:12.858]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:12.858]                 }
[15:31:12.858]                 NAMES <- toupper(added)
[15:31:12.858]                 for (kk in seq_along(NAMES)) {
[15:31:12.858]                   name <- added[[kk]]
[15:31:12.858]                   NAME <- NAMES[[kk]]
[15:31:12.858]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.858]                     next
[15:31:12.858]                   args[[name]] <- ""
[15:31:12.858]                 }
[15:31:12.858]                 NAMES <- toupper(removed)
[15:31:12.858]                 for (kk in seq_along(NAMES)) {
[15:31:12.858]                   name <- removed[[kk]]
[15:31:12.858]                   NAME <- NAMES[[kk]]
[15:31:12.858]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.858]                     next
[15:31:12.858]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:12.858]                 }
[15:31:12.858]                 if (length(args) > 0) 
[15:31:12.858]                   base::do.call(base::Sys.setenv, args = args)
[15:31:12.858]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:12.858]             }
[15:31:12.858]             else {
[15:31:12.858]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:12.858]             }
[15:31:12.858]             {
[15:31:12.858]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:12.858]                   0L) {
[15:31:12.858]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:12.858]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:12.858]                   base::options(opts)
[15:31:12.858]                 }
[15:31:12.858]                 {
[15:31:12.858]                   {
[15:31:12.858]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:12.858]                     NULL
[15:31:12.858]                   }
[15:31:12.858]                   options(future.plan = NULL)
[15:31:12.858]                   if (is.na(NA_character_)) 
[15:31:12.858]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:12.858]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:12.858]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:12.858]                     .init = FALSE)
[15:31:12.858]                 }
[15:31:12.858]             }
[15:31:12.858]         }
[15:31:12.858]     })
[15:31:12.858]     if (TRUE) {
[15:31:12.858]         base::sink(type = "output", split = FALSE)
[15:31:12.858]         if (TRUE) {
[15:31:12.858]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:12.858]         }
[15:31:12.858]         else {
[15:31:12.858]             ...future.result["stdout"] <- base::list(NULL)
[15:31:12.858]         }
[15:31:12.858]         base::close(...future.stdout)
[15:31:12.858]         ...future.stdout <- NULL
[15:31:12.858]     }
[15:31:12.858]     ...future.result$conditions <- ...future.conditions
[15:31:12.858]     ...future.result$finished <- base::Sys.time()
[15:31:12.858]     ...future.result
[15:31:12.858] }
[15:31:12.865] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:12.866] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:12.867] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:12.867] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:12.868] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:12.868] Exporting '...future.elements_ii' (880 bytes) to cluster node #1 ...
[15:31:12.869] Exporting '...future.elements_ii' (880 bytes) to cluster node #1 ... DONE
[15:31:12.869] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:12.869] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:12.870] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:12.870] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:12.870] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:12.871] MultisessionFuture started
[15:31:12.871] - Launch lazy future ... done
[15:31:12.872] run() for 'MultisessionFuture' ... done
[15:31:12.872] Created future:
[15:31:12.893] receiveMessageFromWorker() for ClusterFuture ...
[15:31:12.894] - Validating connection of MultisessionFuture
[15:31:12.894] - received message: FutureResult
[15:31:12.894] - Received FutureResult
[15:31:12.895] - Erased future from FutureRegistry
[15:31:12.895] result() for ClusterFuture ...
[15:31:12.895] - result already collected: FutureResult
[15:31:12.895] result() for ClusterFuture ... done
[15:31:12.895] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:12.872] MultisessionFuture:
[15:31:12.872] Label: 'future_by-1'
[15:31:12.872] Expression:
[15:31:12.872] {
[15:31:12.872]     do.call(function(...) {
[15:31:12.872]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:12.872]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:12.872]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:12.872]             on.exit(options(oopts), add = TRUE)
[15:31:12.872]         }
[15:31:12.872]         {
[15:31:12.872]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:12.872]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:12.872]                 ...future.FUN(...future.X_jj, ...)
[15:31:12.872]             })
[15:31:12.872]         }
[15:31:12.872]     }, args = future.call.arguments)
[15:31:12.872] }
[15:31:12.872] Lazy evaluation: FALSE
[15:31:12.872] Asynchronous evaluation: TRUE
[15:31:12.872] Local evaluation: TRUE
[15:31:12.872] Environment: R_GlobalEnv
[15:31:12.872] Capture standard output: TRUE
[15:31:12.872] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:12.872] Globals: 5 objects totaling 2.07 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 880 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:12.872] Packages: <none>
[15:31:12.872] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:12.872] Resolved: TRUE
[15:31:12.872] Value: <not collected>
[15:31:12.872] Conditions captured: <none>
[15:31:12.872] Early signaling: FALSE
[15:31:12.872] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:12.872] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:12.896] Chunk #1 of 2 ... DONE
[15:31:12.896] Chunk #2 of 2 ...
[15:31:12.896]  - Finding globals in 'X' for chunk #2 ...
[15:31:12.897] getGlobalsAndPackages() ...
[15:31:12.897] Searching for globals...
[15:31:12.897] 
[15:31:12.898] Searching for globals ... DONE
[15:31:12.898] - globals: [0] <none>
[15:31:12.898] getGlobalsAndPackages() ... DONE
[15:31:12.898]    + additional globals found: [n=0] 
[15:31:12.898]    + additional namespaces needed: [n=0] 
[15:31:12.899]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:12.899]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:12.899]  - seeds: <none>
[15:31:12.899]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:12.899] getGlobalsAndPackages() ...
[15:31:12.899] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:12.900] Resolving globals: FALSE
[15:31:12.900] Tweak future expression to call with '...' arguments ...
[15:31:12.900] {
[15:31:12.900]     do.call(function(...) {
[15:31:12.900]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:12.900]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:12.900]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:12.900]             on.exit(options(oopts), add = TRUE)
[15:31:12.900]         }
[15:31:12.900]         {
[15:31:12.900]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:12.900]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:12.900]                 ...future.FUN(...future.X_jj, ...)
[15:31:12.900]             })
[15:31:12.900]         }
[15:31:12.900]     }, args = future.call.arguments)
[15:31:12.900] }
[15:31:12.901] Tweak future expression to call with '...' arguments ... DONE
[15:31:12.901] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:12.901] 
[15:31:12.902] getGlobalsAndPackages() ... DONE
[15:31:12.902] run() for 'Future' ...
[15:31:12.902] - state: 'created'
[15:31:12.902] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:12.920] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:12.921] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:12.921]   - Field: 'node'
[15:31:12.921]   - Field: 'label'
[15:31:12.922]   - Field: 'local'
[15:31:12.922]   - Field: 'owner'
[15:31:12.922]   - Field: 'envir'
[15:31:12.923]   - Field: 'workers'
[15:31:12.923]   - Field: 'packages'
[15:31:12.923]   - Field: 'gc'
[15:31:12.923]   - Field: 'conditions'
[15:31:12.924]   - Field: 'persistent'
[15:31:12.924]   - Field: 'expr'
[15:31:12.924]   - Field: 'uuid'
[15:31:12.925]   - Field: 'seed'
[15:31:12.925]   - Field: 'version'
[15:31:12.925]   - Field: 'result'
[15:31:12.926]   - Field: 'asynchronous'
[15:31:12.926]   - Field: 'calls'
[15:31:12.926]   - Field: 'globals'
[15:31:12.927]   - Field: 'stdout'
[15:31:12.927]   - Field: 'earlySignal'
[15:31:12.927]   - Field: 'lazy'
[15:31:12.927]   - Field: 'state'
[15:31:12.928] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:12.928] - Launch lazy future ...
[15:31:12.929] Packages needed by the future expression (n = 0): <none>
[15:31:12.929] Packages needed by future strategies (n = 0): <none>
[15:31:12.930] {
[15:31:12.930]     {
[15:31:12.930]         {
[15:31:12.930]             ...future.startTime <- base::Sys.time()
[15:31:12.930]             {
[15:31:12.930]                 {
[15:31:12.930]                   {
[15:31:12.930]                     {
[15:31:12.930]                       base::local({
[15:31:12.930]                         has_future <- base::requireNamespace("future", 
[15:31:12.930]                           quietly = TRUE)
[15:31:12.930]                         if (has_future) {
[15:31:12.930]                           ns <- base::getNamespace("future")
[15:31:12.930]                           version <- ns[[".package"]][["version"]]
[15:31:12.930]                           if (is.null(version)) 
[15:31:12.930]                             version <- utils::packageVersion("future")
[15:31:12.930]                         }
[15:31:12.930]                         else {
[15:31:12.930]                           version <- NULL
[15:31:12.930]                         }
[15:31:12.930]                         if (!has_future || version < "1.8.0") {
[15:31:12.930]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:12.930]                             "", base::R.version$version.string), 
[15:31:12.930]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:12.930]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:12.930]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:12.930]                               "release", "version")], collapse = " "), 
[15:31:12.930]                             hostname = base::Sys.info()[["nodename"]])
[15:31:12.930]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:12.930]                             info)
[15:31:12.930]                           info <- base::paste(info, collapse = "; ")
[15:31:12.930]                           if (!has_future) {
[15:31:12.930]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:12.930]                               info)
[15:31:12.930]                           }
[15:31:12.930]                           else {
[15:31:12.930]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:12.930]                               info, version)
[15:31:12.930]                           }
[15:31:12.930]                           base::stop(msg)
[15:31:12.930]                         }
[15:31:12.930]                       })
[15:31:12.930]                     }
[15:31:12.930]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:12.930]                     base::options(mc.cores = 1L)
[15:31:12.930]                   }
[15:31:12.930]                   ...future.strategy.old <- future::plan("list")
[15:31:12.930]                   options(future.plan = NULL)
[15:31:12.930]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:12.930]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:12.930]                 }
[15:31:12.930]                 ...future.workdir <- getwd()
[15:31:12.930]             }
[15:31:12.930]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:12.930]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:12.930]         }
[15:31:12.930]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:12.930]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:12.930]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:12.930]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:12.930]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:12.930]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:12.930]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:12.930]             base::names(...future.oldOptions))
[15:31:12.930]     }
[15:31:12.930]     if (FALSE) {
[15:31:12.930]     }
[15:31:12.930]     else {
[15:31:12.930]         if (TRUE) {
[15:31:12.930]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:12.930]                 open = "w")
[15:31:12.930]         }
[15:31:12.930]         else {
[15:31:12.930]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:12.930]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:12.930]         }
[15:31:12.930]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:12.930]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:12.930]             base::sink(type = "output", split = FALSE)
[15:31:12.930]             base::close(...future.stdout)
[15:31:12.930]         }, add = TRUE)
[15:31:12.930]     }
[15:31:12.930]     ...future.frame <- base::sys.nframe()
[15:31:12.930]     ...future.conditions <- base::list()
[15:31:12.930]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:12.930]     if (FALSE) {
[15:31:12.930]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:12.930]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:12.930]     }
[15:31:12.930]     ...future.result <- base::tryCatch({
[15:31:12.930]         base::withCallingHandlers({
[15:31:12.930]             ...future.value <- base::withVisible(base::local({
[15:31:12.930]                 ...future.makeSendCondition <- base::local({
[15:31:12.930]                   sendCondition <- NULL
[15:31:12.930]                   function(frame = 1L) {
[15:31:12.930]                     if (is.function(sendCondition)) 
[15:31:12.930]                       return(sendCondition)
[15:31:12.930]                     ns <- getNamespace("parallel")
[15:31:12.930]                     if (exists("sendData", mode = "function", 
[15:31:12.930]                       envir = ns)) {
[15:31:12.930]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:12.930]                         envir = ns)
[15:31:12.930]                       envir <- sys.frame(frame)
[15:31:12.930]                       master <- NULL
[15:31:12.930]                       while (!identical(envir, .GlobalEnv) && 
[15:31:12.930]                         !identical(envir, emptyenv())) {
[15:31:12.930]                         if (exists("master", mode = "list", envir = envir, 
[15:31:12.930]                           inherits = FALSE)) {
[15:31:12.930]                           master <- get("master", mode = "list", 
[15:31:12.930]                             envir = envir, inherits = FALSE)
[15:31:12.930]                           if (inherits(master, c("SOCKnode", 
[15:31:12.930]                             "SOCK0node"))) {
[15:31:12.930]                             sendCondition <<- function(cond) {
[15:31:12.930]                               data <- list(type = "VALUE", value = cond, 
[15:31:12.930]                                 success = TRUE)
[15:31:12.930]                               parallel_sendData(master, data)
[15:31:12.930]                             }
[15:31:12.930]                             return(sendCondition)
[15:31:12.930]                           }
[15:31:12.930]                         }
[15:31:12.930]                         frame <- frame + 1L
[15:31:12.930]                         envir <- sys.frame(frame)
[15:31:12.930]                       }
[15:31:12.930]                     }
[15:31:12.930]                     sendCondition <<- function(cond) NULL
[15:31:12.930]                   }
[15:31:12.930]                 })
[15:31:12.930]                 withCallingHandlers({
[15:31:12.930]                   {
[15:31:12.930]                     do.call(function(...) {
[15:31:12.930]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:12.930]                       if (!identical(...future.globals.maxSize.org, 
[15:31:12.930]                         ...future.globals.maxSize)) {
[15:31:12.930]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:12.930]                         on.exit(options(oopts), add = TRUE)
[15:31:12.930]                       }
[15:31:12.930]                       {
[15:31:12.930]                         lapply(seq_along(...future.elements_ii), 
[15:31:12.930]                           FUN = function(jj) {
[15:31:12.930]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:12.930]                             ...future.FUN(...future.X_jj, ...)
[15:31:12.930]                           })
[15:31:12.930]                       }
[15:31:12.930]                     }, args = future.call.arguments)
[15:31:12.930]                   }
[15:31:12.930]                 }, immediateCondition = function(cond) {
[15:31:12.930]                   sendCondition <- ...future.makeSendCondition()
[15:31:12.930]                   sendCondition(cond)
[15:31:12.930]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.930]                   {
[15:31:12.930]                     inherits <- base::inherits
[15:31:12.930]                     invokeRestart <- base::invokeRestart
[15:31:12.930]                     is.null <- base::is.null
[15:31:12.930]                     muffled <- FALSE
[15:31:12.930]                     if (inherits(cond, "message")) {
[15:31:12.930]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:12.930]                       if (muffled) 
[15:31:12.930]                         invokeRestart("muffleMessage")
[15:31:12.930]                     }
[15:31:12.930]                     else if (inherits(cond, "warning")) {
[15:31:12.930]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:12.930]                       if (muffled) 
[15:31:12.930]                         invokeRestart("muffleWarning")
[15:31:12.930]                     }
[15:31:12.930]                     else if (inherits(cond, "condition")) {
[15:31:12.930]                       if (!is.null(pattern)) {
[15:31:12.930]                         computeRestarts <- base::computeRestarts
[15:31:12.930]                         grepl <- base::grepl
[15:31:12.930]                         restarts <- computeRestarts(cond)
[15:31:12.930]                         for (restart in restarts) {
[15:31:12.930]                           name <- restart$name
[15:31:12.930]                           if (is.null(name)) 
[15:31:12.930]                             next
[15:31:12.930]                           if (!grepl(pattern, name)) 
[15:31:12.930]                             next
[15:31:12.930]                           invokeRestart(restart)
[15:31:12.930]                           muffled <- TRUE
[15:31:12.930]                           break
[15:31:12.930]                         }
[15:31:12.930]                       }
[15:31:12.930]                     }
[15:31:12.930]                     invisible(muffled)
[15:31:12.930]                   }
[15:31:12.930]                   muffleCondition(cond)
[15:31:12.930]                 })
[15:31:12.930]             }))
[15:31:12.930]             future::FutureResult(value = ...future.value$value, 
[15:31:12.930]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:12.930]                   ...future.rng), globalenv = if (FALSE) 
[15:31:12.930]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:12.930]                     ...future.globalenv.names))
[15:31:12.930]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:12.930]         }, condition = base::local({
[15:31:12.930]             c <- base::c
[15:31:12.930]             inherits <- base::inherits
[15:31:12.930]             invokeRestart <- base::invokeRestart
[15:31:12.930]             length <- base::length
[15:31:12.930]             list <- base::list
[15:31:12.930]             seq.int <- base::seq.int
[15:31:12.930]             signalCondition <- base::signalCondition
[15:31:12.930]             sys.calls <- base::sys.calls
[15:31:12.930]             `[[` <- base::`[[`
[15:31:12.930]             `+` <- base::`+`
[15:31:12.930]             `<<-` <- base::`<<-`
[15:31:12.930]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:12.930]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:12.930]                   3L)]
[15:31:12.930]             }
[15:31:12.930]             function(cond) {
[15:31:12.930]                 is_error <- inherits(cond, "error")
[15:31:12.930]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:12.930]                   NULL)
[15:31:12.930]                 if (is_error) {
[15:31:12.930]                   sessionInformation <- function() {
[15:31:12.930]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:12.930]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:12.930]                       search = base::search(), system = base::Sys.info())
[15:31:12.930]                   }
[15:31:12.930]                   ...future.conditions[[length(...future.conditions) + 
[15:31:12.930]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:12.930]                     cond$call), session = sessionInformation(), 
[15:31:12.930]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:12.930]                   signalCondition(cond)
[15:31:12.930]                 }
[15:31:12.930]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:12.930]                 "immediateCondition"))) {
[15:31:12.930]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:12.930]                   ...future.conditions[[length(...future.conditions) + 
[15:31:12.930]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:12.930]                   if (TRUE && !signal) {
[15:31:12.930]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.930]                     {
[15:31:12.930]                       inherits <- base::inherits
[15:31:12.930]                       invokeRestart <- base::invokeRestart
[15:31:12.930]                       is.null <- base::is.null
[15:31:12.930]                       muffled <- FALSE
[15:31:12.930]                       if (inherits(cond, "message")) {
[15:31:12.930]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:12.930]                         if (muffled) 
[15:31:12.930]                           invokeRestart("muffleMessage")
[15:31:12.930]                       }
[15:31:12.930]                       else if (inherits(cond, "warning")) {
[15:31:12.930]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:12.930]                         if (muffled) 
[15:31:12.930]                           invokeRestart("muffleWarning")
[15:31:12.930]                       }
[15:31:12.930]                       else if (inherits(cond, "condition")) {
[15:31:12.930]                         if (!is.null(pattern)) {
[15:31:12.930]                           computeRestarts <- base::computeRestarts
[15:31:12.930]                           grepl <- base::grepl
[15:31:12.930]                           restarts <- computeRestarts(cond)
[15:31:12.930]                           for (restart in restarts) {
[15:31:12.930]                             name <- restart$name
[15:31:12.930]                             if (is.null(name)) 
[15:31:12.930]                               next
[15:31:12.930]                             if (!grepl(pattern, name)) 
[15:31:12.930]                               next
[15:31:12.930]                             invokeRestart(restart)
[15:31:12.930]                             muffled <- TRUE
[15:31:12.930]                             break
[15:31:12.930]                           }
[15:31:12.930]                         }
[15:31:12.930]                       }
[15:31:12.930]                       invisible(muffled)
[15:31:12.930]                     }
[15:31:12.930]                     muffleCondition(cond, pattern = "^muffle")
[15:31:12.930]                   }
[15:31:12.930]                 }
[15:31:12.930]                 else {
[15:31:12.930]                   if (TRUE) {
[15:31:12.930]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:12.930]                     {
[15:31:12.930]                       inherits <- base::inherits
[15:31:12.930]                       invokeRestart <- base::invokeRestart
[15:31:12.930]                       is.null <- base::is.null
[15:31:12.930]                       muffled <- FALSE
[15:31:12.930]                       if (inherits(cond, "message")) {
[15:31:12.930]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:12.930]                         if (muffled) 
[15:31:12.930]                           invokeRestart("muffleMessage")
[15:31:12.930]                       }
[15:31:12.930]                       else if (inherits(cond, "warning")) {
[15:31:12.930]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:12.930]                         if (muffled) 
[15:31:12.930]                           invokeRestart("muffleWarning")
[15:31:12.930]                       }
[15:31:12.930]                       else if (inherits(cond, "condition")) {
[15:31:12.930]                         if (!is.null(pattern)) {
[15:31:12.930]                           computeRestarts <- base::computeRestarts
[15:31:12.930]                           grepl <- base::grepl
[15:31:12.930]                           restarts <- computeRestarts(cond)
[15:31:12.930]                           for (restart in restarts) {
[15:31:12.930]                             name <- restart$name
[15:31:12.930]                             if (is.null(name)) 
[15:31:12.930]                               next
[15:31:12.930]                             if (!grepl(pattern, name)) 
[15:31:12.930]                               next
[15:31:12.930]                             invokeRestart(restart)
[15:31:12.930]                             muffled <- TRUE
[15:31:12.930]                             break
[15:31:12.930]                           }
[15:31:12.930]                         }
[15:31:12.930]                       }
[15:31:12.930]                       invisible(muffled)
[15:31:12.930]                     }
[15:31:12.930]                     muffleCondition(cond, pattern = "^muffle")
[15:31:12.930]                   }
[15:31:12.930]                 }
[15:31:12.930]             }
[15:31:12.930]         }))
[15:31:12.930]     }, error = function(ex) {
[15:31:12.930]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:12.930]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:12.930]                 ...future.rng), started = ...future.startTime, 
[15:31:12.930]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:12.930]             version = "1.8"), class = "FutureResult")
[15:31:12.930]     }, finally = {
[15:31:12.930]         if (!identical(...future.workdir, getwd())) 
[15:31:12.930]             setwd(...future.workdir)
[15:31:12.930]         {
[15:31:12.930]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:12.930]                 ...future.oldOptions$nwarnings <- NULL
[15:31:12.930]             }
[15:31:12.930]             base::options(...future.oldOptions)
[15:31:12.930]             if (.Platform$OS.type == "windows") {
[15:31:12.930]                 old_names <- names(...future.oldEnvVars)
[15:31:12.930]                 envs <- base::Sys.getenv()
[15:31:12.930]                 names <- names(envs)
[15:31:12.930]                 common <- intersect(names, old_names)
[15:31:12.930]                 added <- setdiff(names, old_names)
[15:31:12.930]                 removed <- setdiff(old_names, names)
[15:31:12.930]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:12.930]                   envs[common]]
[15:31:12.930]                 NAMES <- toupper(changed)
[15:31:12.930]                 args <- list()
[15:31:12.930]                 for (kk in seq_along(NAMES)) {
[15:31:12.930]                   name <- changed[[kk]]
[15:31:12.930]                   NAME <- NAMES[[kk]]
[15:31:12.930]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.930]                     next
[15:31:12.930]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:12.930]                 }
[15:31:12.930]                 NAMES <- toupper(added)
[15:31:12.930]                 for (kk in seq_along(NAMES)) {
[15:31:12.930]                   name <- added[[kk]]
[15:31:12.930]                   NAME <- NAMES[[kk]]
[15:31:12.930]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.930]                     next
[15:31:12.930]                   args[[name]] <- ""
[15:31:12.930]                 }
[15:31:12.930]                 NAMES <- toupper(removed)
[15:31:12.930]                 for (kk in seq_along(NAMES)) {
[15:31:12.930]                   name <- removed[[kk]]
[15:31:12.930]                   NAME <- NAMES[[kk]]
[15:31:12.930]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:12.930]                     next
[15:31:12.930]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:12.930]                 }
[15:31:12.930]                 if (length(args) > 0) 
[15:31:12.930]                   base::do.call(base::Sys.setenv, args = args)
[15:31:12.930]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:12.930]             }
[15:31:12.930]             else {
[15:31:12.930]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:12.930]             }
[15:31:12.930]             {
[15:31:12.930]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:12.930]                   0L) {
[15:31:12.930]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:12.930]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:12.930]                   base::options(opts)
[15:31:12.930]                 }
[15:31:12.930]                 {
[15:31:12.930]                   {
[15:31:12.930]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:12.930]                     NULL
[15:31:12.930]                   }
[15:31:12.930]                   options(future.plan = NULL)
[15:31:12.930]                   if (is.na(NA_character_)) 
[15:31:12.930]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:12.930]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:12.930]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:12.930]                     .init = FALSE)
[15:31:12.930]                 }
[15:31:12.930]             }
[15:31:12.930]         }
[15:31:12.930]     })
[15:31:12.930]     if (TRUE) {
[15:31:12.930]         base::sink(type = "output", split = FALSE)
[15:31:12.930]         if (TRUE) {
[15:31:12.930]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:12.930]         }
[15:31:12.930]         else {
[15:31:12.930]             ...future.result["stdout"] <- base::list(NULL)
[15:31:12.930]         }
[15:31:12.930]         base::close(...future.stdout)
[15:31:12.930]         ...future.stdout <- NULL
[15:31:12.930]     }
[15:31:12.930]     ...future.result$conditions <- ...future.conditions
[15:31:12.930]     ...future.result$finished <- base::Sys.time()
[15:31:12.930]     ...future.result
[15:31:12.930] }
[15:31:12.940] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:12.940] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:12.941] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:12.942] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:12.942] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:12.943] Exporting '...future.elements_ii' (1.72 KiB) to cluster node #1 ...
[15:31:12.944] Exporting '...future.elements_ii' (1.72 KiB) to cluster node #1 ... DONE
[15:31:12.944] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:12.945] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:12.945] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:12.949] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:12.950] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:12.951] MultisessionFuture started
[15:31:12.951] - Launch lazy future ... done
[15:31:12.951] run() for 'MultisessionFuture' ... done
[15:31:12.952] Created future:
[15:31:12.981] receiveMessageFromWorker() for ClusterFuture ...
[15:31:12.981] - Validating connection of MultisessionFuture
[15:31:12.982] - received message: FutureResult
[15:31:12.982] - Received FutureResult
[15:31:12.983] - Erased future from FutureRegistry
[15:31:12.983] result() for ClusterFuture ...
[15:31:12.983] - result already collected: FutureResult
[15:31:12.984] result() for ClusterFuture ... done
[15:31:12.984] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:12.952] MultisessionFuture:
[15:31:12.952] Label: 'future_by-2'
[15:31:12.952] Expression:
[15:31:12.952] {
[15:31:12.952]     do.call(function(...) {
[15:31:12.952]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:12.952]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:12.952]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:12.952]             on.exit(options(oopts), add = TRUE)
[15:31:12.952]         }
[15:31:12.952]         {
[15:31:12.952]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:12.952]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:12.952]                 ...future.FUN(...future.X_jj, ...)
[15:31:12.952]             })
[15:31:12.952]         }
[15:31:12.952]     }, args = future.call.arguments)
[15:31:12.952] }
[15:31:12.952] Lazy evaluation: FALSE
[15:31:12.952] Asynchronous evaluation: TRUE
[15:31:12.952] Local evaluation: TRUE
[15:31:12.952] Environment: R_GlobalEnv
[15:31:12.952] Capture standard output: TRUE
[15:31:12.952] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:12.952] Globals: 5 objects totaling 2.93 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 1.72 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:12.952] Packages: <none>
[15:31:12.952] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:12.952] Resolved: TRUE
[15:31:12.952] Value: <not collected>
[15:31:12.952] Conditions captured: <none>
[15:31:12.952] Early signaling: FALSE
[15:31:12.952] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:12.952] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:12.985] Chunk #2 of 2 ... DONE
[15:31:12.985] Launching 2 futures (chunks) ... DONE
[15:31:12.985] Resolving 2 futures (chunks) ...
[15:31:12.986] resolve() on list ...
[15:31:12.986]  recursive: 0
[15:31:12.986]  length: 2
[15:31:12.986] 
[15:31:12.987] Future #1
[15:31:12.987] result() for ClusterFuture ...
[15:31:12.987] - result already collected: FutureResult
[15:31:12.988] result() for ClusterFuture ... done
[15:31:12.988] result() for ClusterFuture ...
[15:31:12.988] - result already collected: FutureResult
[15:31:12.988] result() for ClusterFuture ... done
[15:31:12.989] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:12.989] - nx: 2
[15:31:12.989] - relay: TRUE
[15:31:12.989] - stdout: TRUE
[15:31:12.990] - signal: TRUE
[15:31:12.990] - resignal: FALSE
[15:31:12.990] - force: TRUE
[15:31:12.991] - relayed: [n=2] FALSE, FALSE
[15:31:12.991] - queued futures: [n=2] FALSE, FALSE
[15:31:12.991]  - until=1
[15:31:12.991]  - relaying element #1
[15:31:12.992] result() for ClusterFuture ...
[15:31:12.992] - result already collected: FutureResult
[15:31:12.992] result() for ClusterFuture ... done
[15:31:12.992] result() for ClusterFuture ...
[15:31:12.993] - result already collected: FutureResult
[15:31:12.993] result() for ClusterFuture ... done
[15:31:12.993] result() for ClusterFuture ...
[15:31:12.994] - result already collected: FutureResult
[15:31:12.994] result() for ClusterFuture ... done
[15:31:12.994] result() for ClusterFuture ...
[15:31:12.994] - result already collected: FutureResult
[15:31:12.995] result() for ClusterFuture ... done
[15:31:12.995] - relayed: [n=2] TRUE, FALSE
[15:31:12.995] - queued futures: [n=2] TRUE, FALSE
[15:31:12.996] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:12.996]  length: 1 (resolved future 1)
[15:31:12.996] Future #2
[15:31:12.997] result() for ClusterFuture ...
[15:31:12.997] - result already collected: FutureResult
[15:31:12.997] result() for ClusterFuture ... done
[15:31:12.997] result() for ClusterFuture ...
[15:31:12.997] - result already collected: FutureResult
[15:31:12.998] result() for ClusterFuture ... done
[15:31:12.998] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:12.998] - nx: 2
[15:31:12.999] - relay: TRUE
[15:31:12.999] - stdout: TRUE
[15:31:12.999] - signal: TRUE
[15:31:13.000] - resignal: FALSE
[15:31:13.000] - force: TRUE
[15:31:13.000] - relayed: [n=2] TRUE, FALSE
[15:31:13.000] - queued futures: [n=2] TRUE, FALSE
[15:31:13.001]  - until=2
[15:31:13.001]  - relaying element #2
[15:31:13.001] result() for ClusterFuture ...
[15:31:13.002] - result already collected: FutureResult
[15:31:13.002] result() for ClusterFuture ... done
[15:31:13.002] result() for ClusterFuture ...
[15:31:13.002] - result already collected: FutureResult
[15:31:13.003] result() for ClusterFuture ... done
[15:31:13.003] result() for ClusterFuture ...
[15:31:13.003] - result already collected: FutureResult
[15:31:13.004] result() for ClusterFuture ... done
[15:31:13.004] result() for ClusterFuture ...
[15:31:13.004] - result already collected: FutureResult
[15:31:13.004] result() for ClusterFuture ... done
[15:31:13.005] - relayed: [n=2] TRUE, TRUE
[15:31:13.005] - queued futures: [n=2] TRUE, TRUE
[15:31:13.005] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:13.006]  length: 0 (resolved future 2)
[15:31:13.006] Relaying remaining futures
[15:31:13.006] signalConditionsASAP(NULL, pos=0) ...
[15:31:13.006] - nx: 2
[15:31:13.007] - relay: TRUE
[15:31:13.007] - stdout: TRUE
[15:31:13.007] - signal: TRUE
[15:31:13.008] - resignal: FALSE
[15:31:13.008] - force: TRUE
[15:31:13.008] - relayed: [n=2] TRUE, TRUE
[15:31:13.008] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:13.009] - relayed: [n=2] TRUE, TRUE
[15:31:13.009] - queued futures: [n=2] TRUE, TRUE
[15:31:13.009] signalConditionsASAP(NULL, pos=0) ... done
[15:31:13.010] resolve() on list ... DONE
[15:31:13.010] result() for ClusterFuture ...
[15:31:13.010] - result already collected: FutureResult
[15:31:13.010] result() for ClusterFuture ... done
[15:31:13.011] result() for ClusterFuture ...
[15:31:13.011] - result already collected: FutureResult
[15:31:13.011] result() for ClusterFuture ... done
[15:31:13.012] result() for ClusterFuture ...
[15:31:13.012] - result already collected: FutureResult
[15:31:13.012] result() for ClusterFuture ... done
[15:31:13.012] result() for ClusterFuture ...
[15:31:13.013] - result already collected: FutureResult
[15:31:13.013] result() for ClusterFuture ... done
[15:31:13.013]  - Number of value chunks collected: 2
[15:31:13.013] Resolving 2 futures (chunks) ... DONE
[15:31:13.014] Reducing values from 2 chunks ...
[15:31:13.014]  - Number of values collected after concatenation: 3
[15:31:13.014]  - Number of values expected: 3
[15:31:13.015] Reducing values from 2 chunks ... DONE
[15:31:13.015] future_lapply() ... DONE
[15:31:13.015] future_by_internal() ... DONE
[15:31:13.016] future_by_internal() ...
[15:31:13.016] future_lapply() ...
[15:31:13.021] Number of chunks: 2
[15:31:13.022] getGlobalsAndPackagesXApply() ...
[15:31:13.022]  - future.globals: TRUE
[15:31:13.022] getGlobalsAndPackages() ...
[15:31:13.022] Searching for globals...
[15:31:13.025] - globals found: [2] 'FUN', 'UseMethod'
[15:31:13.025] Searching for globals ... DONE
[15:31:13.025] Resolving globals: FALSE
[15:31:13.026] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:13.027] The total size of the 1 globals exported for future expression ('FUN(digits = 2L)') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:13.027] - globals: [1] 'FUN'
[15:31:13.027] 
[15:31:13.028] getGlobalsAndPackages() ... DONE
[15:31:13.028]  - globals found/used: [n=1] 'FUN'
[15:31:13.028]  - needed namespaces: [n=0] 
[15:31:13.028] Finding globals ... DONE
[15:31:13.029]  - use_args: TRUE
[15:31:13.029]  - Getting '...' globals ...
[15:31:13.030] resolve() on list ...
[15:31:13.030]  recursive: 0
[15:31:13.030]  length: 1
[15:31:13.030]  elements: '...'
[15:31:13.031]  length: 0 (resolved future 1)
[15:31:13.031] resolve() on list ... DONE
[15:31:13.031]    - '...' content: [n=1] 'digits'
[15:31:13.032] List of 1
[15:31:13.032]  $ ...:List of 1
[15:31:13.032]   ..$ digits: int 2
[15:31:13.032]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.032]  - attr(*, "where")=List of 1
[15:31:13.032]   ..$ ...:<environment: 0x0000019c7fc55d88> 
[15:31:13.032]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.032]  - attr(*, "resolved")= logi TRUE
[15:31:13.032]  - attr(*, "total_size")= num NA
[15:31:13.037]  - Getting '...' globals ... DONE
[15:31:13.038] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:13.038] List of 2
[15:31:13.038]  $ ...future.FUN:function (object, ...)  
[15:31:13.038]  $ ...          :List of 1
[15:31:13.038]   ..$ digits: int 2
[15:31:13.038]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.038]  - attr(*, "where")=List of 2
[15:31:13.038]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:13.038]   ..$ ...          :<environment: 0x0000019c7fc55d88> 
[15:31:13.038]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.038]  - attr(*, "resolved")= logi FALSE
[15:31:13.038]  - attr(*, "total_size")= num 1296
[15:31:13.044] Packages to be attached in all futures: [n=0] 
[15:31:13.044] getGlobalsAndPackagesXApply() ... DONE
[15:31:13.045] Number of futures (= number of chunks): 2
[15:31:13.045] Launching 2 futures (chunks) ...
[15:31:13.046] Chunk #1 of 2 ...
[15:31:13.046]  - Finding globals in 'X' for chunk #1 ...
[15:31:13.046] getGlobalsAndPackages() ...
[15:31:13.047] Searching for globals...
[15:31:13.047] 
[15:31:13.047] Searching for globals ... DONE
[15:31:13.048] - globals: [0] <none>
[15:31:13.048] getGlobalsAndPackages() ... DONE
[15:31:13.048]    + additional globals found: [n=0] 
[15:31:13.048]    + additional namespaces needed: [n=0] 
[15:31:13.049]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:13.049]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.049]  - seeds: <none>
[15:31:13.049]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.050] getGlobalsAndPackages() ...
[15:31:13.050] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.050] Resolving globals: FALSE
[15:31:13.051] Tweak future expression to call with '...' arguments ...
[15:31:13.051] {
[15:31:13.051]     do.call(function(...) {
[15:31:13.051]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.051]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.051]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.051]             on.exit(options(oopts), add = TRUE)
[15:31:13.051]         }
[15:31:13.051]         {
[15:31:13.051]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.051]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.051]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.051]             })
[15:31:13.051]         }
[15:31:13.051]     }, args = future.call.arguments)
[15:31:13.051] }
[15:31:13.052] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.053] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.053] 
[15:31:13.053] getGlobalsAndPackages() ... DONE
[15:31:13.054] run() for 'Future' ...
[15:31:13.054] - state: 'created'
[15:31:13.054] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.073] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.073] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.074]   - Field: 'node'
[15:31:13.074]   - Field: 'label'
[15:31:13.074]   - Field: 'local'
[15:31:13.074]   - Field: 'owner'
[15:31:13.075]   - Field: 'envir'
[15:31:13.075]   - Field: 'workers'
[15:31:13.075]   - Field: 'packages'
[15:31:13.076]   - Field: 'gc'
[15:31:13.076]   - Field: 'conditions'
[15:31:13.076]   - Field: 'persistent'
[15:31:13.077]   - Field: 'expr'
[15:31:13.077]   - Field: 'uuid'
[15:31:13.077]   - Field: 'seed'
[15:31:13.077]   - Field: 'version'
[15:31:13.078]   - Field: 'result'
[15:31:13.078]   - Field: 'asynchronous'
[15:31:13.078]   - Field: 'calls'
[15:31:13.079]   - Field: 'globals'
[15:31:13.079]   - Field: 'stdout'
[15:31:13.079]   - Field: 'earlySignal'
[15:31:13.080]   - Field: 'lazy'
[15:31:13.080]   - Field: 'state'
[15:31:13.080] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.080] - Launch lazy future ...
[15:31:13.081] Packages needed by the future expression (n = 0): <none>
[15:31:13.082] Packages needed by future strategies (n = 0): <none>
[15:31:13.083] {
[15:31:13.083]     {
[15:31:13.083]         {
[15:31:13.083]             ...future.startTime <- base::Sys.time()
[15:31:13.083]             {
[15:31:13.083]                 {
[15:31:13.083]                   {
[15:31:13.083]                     {
[15:31:13.083]                       base::local({
[15:31:13.083]                         has_future <- base::requireNamespace("future", 
[15:31:13.083]                           quietly = TRUE)
[15:31:13.083]                         if (has_future) {
[15:31:13.083]                           ns <- base::getNamespace("future")
[15:31:13.083]                           version <- ns[[".package"]][["version"]]
[15:31:13.083]                           if (is.null(version)) 
[15:31:13.083]                             version <- utils::packageVersion("future")
[15:31:13.083]                         }
[15:31:13.083]                         else {
[15:31:13.083]                           version <- NULL
[15:31:13.083]                         }
[15:31:13.083]                         if (!has_future || version < "1.8.0") {
[15:31:13.083]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.083]                             "", base::R.version$version.string), 
[15:31:13.083]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:13.083]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:13.083]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.083]                               "release", "version")], collapse = " "), 
[15:31:13.083]                             hostname = base::Sys.info()[["nodename"]])
[15:31:13.083]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.083]                             info)
[15:31:13.083]                           info <- base::paste(info, collapse = "; ")
[15:31:13.083]                           if (!has_future) {
[15:31:13.083]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.083]                               info)
[15:31:13.083]                           }
[15:31:13.083]                           else {
[15:31:13.083]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.083]                               info, version)
[15:31:13.083]                           }
[15:31:13.083]                           base::stop(msg)
[15:31:13.083]                         }
[15:31:13.083]                       })
[15:31:13.083]                     }
[15:31:13.083]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.083]                     base::options(mc.cores = 1L)
[15:31:13.083]                   }
[15:31:13.083]                   ...future.strategy.old <- future::plan("list")
[15:31:13.083]                   options(future.plan = NULL)
[15:31:13.083]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.083]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.083]                 }
[15:31:13.083]                 ...future.workdir <- getwd()
[15:31:13.083]             }
[15:31:13.083]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.083]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.083]         }
[15:31:13.083]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.083]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.083]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.083]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.083]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.083]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.083]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.083]             base::names(...future.oldOptions))
[15:31:13.083]     }
[15:31:13.083]     if (FALSE) {
[15:31:13.083]     }
[15:31:13.083]     else {
[15:31:13.083]         if (TRUE) {
[15:31:13.083]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.083]                 open = "w")
[15:31:13.083]         }
[15:31:13.083]         else {
[15:31:13.083]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.083]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.083]         }
[15:31:13.083]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.083]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.083]             base::sink(type = "output", split = FALSE)
[15:31:13.083]             base::close(...future.stdout)
[15:31:13.083]         }, add = TRUE)
[15:31:13.083]     }
[15:31:13.083]     ...future.frame <- base::sys.nframe()
[15:31:13.083]     ...future.conditions <- base::list()
[15:31:13.083]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.083]     if (FALSE) {
[15:31:13.083]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.083]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.083]     }
[15:31:13.083]     ...future.result <- base::tryCatch({
[15:31:13.083]         base::withCallingHandlers({
[15:31:13.083]             ...future.value <- base::withVisible(base::local({
[15:31:13.083]                 ...future.makeSendCondition <- base::local({
[15:31:13.083]                   sendCondition <- NULL
[15:31:13.083]                   function(frame = 1L) {
[15:31:13.083]                     if (is.function(sendCondition)) 
[15:31:13.083]                       return(sendCondition)
[15:31:13.083]                     ns <- getNamespace("parallel")
[15:31:13.083]                     if (exists("sendData", mode = "function", 
[15:31:13.083]                       envir = ns)) {
[15:31:13.083]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.083]                         envir = ns)
[15:31:13.083]                       envir <- sys.frame(frame)
[15:31:13.083]                       master <- NULL
[15:31:13.083]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.083]                         !identical(envir, emptyenv())) {
[15:31:13.083]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.083]                           inherits = FALSE)) {
[15:31:13.083]                           master <- get("master", mode = "list", 
[15:31:13.083]                             envir = envir, inherits = FALSE)
[15:31:13.083]                           if (inherits(master, c("SOCKnode", 
[15:31:13.083]                             "SOCK0node"))) {
[15:31:13.083]                             sendCondition <<- function(cond) {
[15:31:13.083]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.083]                                 success = TRUE)
[15:31:13.083]                               parallel_sendData(master, data)
[15:31:13.083]                             }
[15:31:13.083]                             return(sendCondition)
[15:31:13.083]                           }
[15:31:13.083]                         }
[15:31:13.083]                         frame <- frame + 1L
[15:31:13.083]                         envir <- sys.frame(frame)
[15:31:13.083]                       }
[15:31:13.083]                     }
[15:31:13.083]                     sendCondition <<- function(cond) NULL
[15:31:13.083]                   }
[15:31:13.083]                 })
[15:31:13.083]                 withCallingHandlers({
[15:31:13.083]                   {
[15:31:13.083]                     do.call(function(...) {
[15:31:13.083]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.083]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.083]                         ...future.globals.maxSize)) {
[15:31:13.083]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.083]                         on.exit(options(oopts), add = TRUE)
[15:31:13.083]                       }
[15:31:13.083]                       {
[15:31:13.083]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.083]                           FUN = function(jj) {
[15:31:13.083]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.083]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.083]                           })
[15:31:13.083]                       }
[15:31:13.083]                     }, args = future.call.arguments)
[15:31:13.083]                   }
[15:31:13.083]                 }, immediateCondition = function(cond) {
[15:31:13.083]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.083]                   sendCondition(cond)
[15:31:13.083]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.083]                   {
[15:31:13.083]                     inherits <- base::inherits
[15:31:13.083]                     invokeRestart <- base::invokeRestart
[15:31:13.083]                     is.null <- base::is.null
[15:31:13.083]                     muffled <- FALSE
[15:31:13.083]                     if (inherits(cond, "message")) {
[15:31:13.083]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.083]                       if (muffled) 
[15:31:13.083]                         invokeRestart("muffleMessage")
[15:31:13.083]                     }
[15:31:13.083]                     else if (inherits(cond, "warning")) {
[15:31:13.083]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.083]                       if (muffled) 
[15:31:13.083]                         invokeRestart("muffleWarning")
[15:31:13.083]                     }
[15:31:13.083]                     else if (inherits(cond, "condition")) {
[15:31:13.083]                       if (!is.null(pattern)) {
[15:31:13.083]                         computeRestarts <- base::computeRestarts
[15:31:13.083]                         grepl <- base::grepl
[15:31:13.083]                         restarts <- computeRestarts(cond)
[15:31:13.083]                         for (restart in restarts) {
[15:31:13.083]                           name <- restart$name
[15:31:13.083]                           if (is.null(name)) 
[15:31:13.083]                             next
[15:31:13.083]                           if (!grepl(pattern, name)) 
[15:31:13.083]                             next
[15:31:13.083]                           invokeRestart(restart)
[15:31:13.083]                           muffled <- TRUE
[15:31:13.083]                           break
[15:31:13.083]                         }
[15:31:13.083]                       }
[15:31:13.083]                     }
[15:31:13.083]                     invisible(muffled)
[15:31:13.083]                   }
[15:31:13.083]                   muffleCondition(cond)
[15:31:13.083]                 })
[15:31:13.083]             }))
[15:31:13.083]             future::FutureResult(value = ...future.value$value, 
[15:31:13.083]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.083]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.083]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.083]                     ...future.globalenv.names))
[15:31:13.083]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.083]         }, condition = base::local({
[15:31:13.083]             c <- base::c
[15:31:13.083]             inherits <- base::inherits
[15:31:13.083]             invokeRestart <- base::invokeRestart
[15:31:13.083]             length <- base::length
[15:31:13.083]             list <- base::list
[15:31:13.083]             seq.int <- base::seq.int
[15:31:13.083]             signalCondition <- base::signalCondition
[15:31:13.083]             sys.calls <- base::sys.calls
[15:31:13.083]             `[[` <- base::`[[`
[15:31:13.083]             `+` <- base::`+`
[15:31:13.083]             `<<-` <- base::`<<-`
[15:31:13.083]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.083]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.083]                   3L)]
[15:31:13.083]             }
[15:31:13.083]             function(cond) {
[15:31:13.083]                 is_error <- inherits(cond, "error")
[15:31:13.083]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.083]                   NULL)
[15:31:13.083]                 if (is_error) {
[15:31:13.083]                   sessionInformation <- function() {
[15:31:13.083]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.083]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.083]                       search = base::search(), system = base::Sys.info())
[15:31:13.083]                   }
[15:31:13.083]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.083]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.083]                     cond$call), session = sessionInformation(), 
[15:31:13.083]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.083]                   signalCondition(cond)
[15:31:13.083]                 }
[15:31:13.083]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.083]                 "immediateCondition"))) {
[15:31:13.083]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.083]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.083]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.083]                   if (TRUE && !signal) {
[15:31:13.083]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.083]                     {
[15:31:13.083]                       inherits <- base::inherits
[15:31:13.083]                       invokeRestart <- base::invokeRestart
[15:31:13.083]                       is.null <- base::is.null
[15:31:13.083]                       muffled <- FALSE
[15:31:13.083]                       if (inherits(cond, "message")) {
[15:31:13.083]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.083]                         if (muffled) 
[15:31:13.083]                           invokeRestart("muffleMessage")
[15:31:13.083]                       }
[15:31:13.083]                       else if (inherits(cond, "warning")) {
[15:31:13.083]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.083]                         if (muffled) 
[15:31:13.083]                           invokeRestart("muffleWarning")
[15:31:13.083]                       }
[15:31:13.083]                       else if (inherits(cond, "condition")) {
[15:31:13.083]                         if (!is.null(pattern)) {
[15:31:13.083]                           computeRestarts <- base::computeRestarts
[15:31:13.083]                           grepl <- base::grepl
[15:31:13.083]                           restarts <- computeRestarts(cond)
[15:31:13.083]                           for (restart in restarts) {
[15:31:13.083]                             name <- restart$name
[15:31:13.083]                             if (is.null(name)) 
[15:31:13.083]                               next
[15:31:13.083]                             if (!grepl(pattern, name)) 
[15:31:13.083]                               next
[15:31:13.083]                             invokeRestart(restart)
[15:31:13.083]                             muffled <- TRUE
[15:31:13.083]                             break
[15:31:13.083]                           }
[15:31:13.083]                         }
[15:31:13.083]                       }
[15:31:13.083]                       invisible(muffled)
[15:31:13.083]                     }
[15:31:13.083]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.083]                   }
[15:31:13.083]                 }
[15:31:13.083]                 else {
[15:31:13.083]                   if (TRUE) {
[15:31:13.083]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.083]                     {
[15:31:13.083]                       inherits <- base::inherits
[15:31:13.083]                       invokeRestart <- base::invokeRestart
[15:31:13.083]                       is.null <- base::is.null
[15:31:13.083]                       muffled <- FALSE
[15:31:13.083]                       if (inherits(cond, "message")) {
[15:31:13.083]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.083]                         if (muffled) 
[15:31:13.083]                           invokeRestart("muffleMessage")
[15:31:13.083]                       }
[15:31:13.083]                       else if (inherits(cond, "warning")) {
[15:31:13.083]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.083]                         if (muffled) 
[15:31:13.083]                           invokeRestart("muffleWarning")
[15:31:13.083]                       }
[15:31:13.083]                       else if (inherits(cond, "condition")) {
[15:31:13.083]                         if (!is.null(pattern)) {
[15:31:13.083]                           computeRestarts <- base::computeRestarts
[15:31:13.083]                           grepl <- base::grepl
[15:31:13.083]                           restarts <- computeRestarts(cond)
[15:31:13.083]                           for (restart in restarts) {
[15:31:13.083]                             name <- restart$name
[15:31:13.083]                             if (is.null(name)) 
[15:31:13.083]                               next
[15:31:13.083]                             if (!grepl(pattern, name)) 
[15:31:13.083]                               next
[15:31:13.083]                             invokeRestart(restart)
[15:31:13.083]                             muffled <- TRUE
[15:31:13.083]                             break
[15:31:13.083]                           }
[15:31:13.083]                         }
[15:31:13.083]                       }
[15:31:13.083]                       invisible(muffled)
[15:31:13.083]                     }
[15:31:13.083]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.083]                   }
[15:31:13.083]                 }
[15:31:13.083]             }
[15:31:13.083]         }))
[15:31:13.083]     }, error = function(ex) {
[15:31:13.083]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.083]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.083]                 ...future.rng), started = ...future.startTime, 
[15:31:13.083]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.083]             version = "1.8"), class = "FutureResult")
[15:31:13.083]     }, finally = {
[15:31:13.083]         if (!identical(...future.workdir, getwd())) 
[15:31:13.083]             setwd(...future.workdir)
[15:31:13.083]         {
[15:31:13.083]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.083]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.083]             }
[15:31:13.083]             base::options(...future.oldOptions)
[15:31:13.083]             if (.Platform$OS.type == "windows") {
[15:31:13.083]                 old_names <- names(...future.oldEnvVars)
[15:31:13.083]                 envs <- base::Sys.getenv()
[15:31:13.083]                 names <- names(envs)
[15:31:13.083]                 common <- intersect(names, old_names)
[15:31:13.083]                 added <- setdiff(names, old_names)
[15:31:13.083]                 removed <- setdiff(old_names, names)
[15:31:13.083]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.083]                   envs[common]]
[15:31:13.083]                 NAMES <- toupper(changed)
[15:31:13.083]                 args <- list()
[15:31:13.083]                 for (kk in seq_along(NAMES)) {
[15:31:13.083]                   name <- changed[[kk]]
[15:31:13.083]                   NAME <- NAMES[[kk]]
[15:31:13.083]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.083]                     next
[15:31:13.083]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.083]                 }
[15:31:13.083]                 NAMES <- toupper(added)
[15:31:13.083]                 for (kk in seq_along(NAMES)) {
[15:31:13.083]                   name <- added[[kk]]
[15:31:13.083]                   NAME <- NAMES[[kk]]
[15:31:13.083]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.083]                     next
[15:31:13.083]                   args[[name]] <- ""
[15:31:13.083]                 }
[15:31:13.083]                 NAMES <- toupper(removed)
[15:31:13.083]                 for (kk in seq_along(NAMES)) {
[15:31:13.083]                   name <- removed[[kk]]
[15:31:13.083]                   NAME <- NAMES[[kk]]
[15:31:13.083]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.083]                     next
[15:31:13.083]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.083]                 }
[15:31:13.083]                 if (length(args) > 0) 
[15:31:13.083]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.083]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.083]             }
[15:31:13.083]             else {
[15:31:13.083]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.083]             }
[15:31:13.083]             {
[15:31:13.083]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.083]                   0L) {
[15:31:13.083]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.083]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.083]                   base::options(opts)
[15:31:13.083]                 }
[15:31:13.083]                 {
[15:31:13.083]                   {
[15:31:13.083]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.083]                     NULL
[15:31:13.083]                   }
[15:31:13.083]                   options(future.plan = NULL)
[15:31:13.083]                   if (is.na(NA_character_)) 
[15:31:13.083]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.083]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.083]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.083]                     .init = FALSE)
[15:31:13.083]                 }
[15:31:13.083]             }
[15:31:13.083]         }
[15:31:13.083]     })
[15:31:13.083]     if (TRUE) {
[15:31:13.083]         base::sink(type = "output", split = FALSE)
[15:31:13.083]         if (TRUE) {
[15:31:13.083]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.083]         }
[15:31:13.083]         else {
[15:31:13.083]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.083]         }
[15:31:13.083]         base::close(...future.stdout)
[15:31:13.083]         ...future.stdout <- NULL
[15:31:13.083]     }
[15:31:13.083]     ...future.result$conditions <- ...future.conditions
[15:31:13.083]     ...future.result$finished <- base::Sys.time()
[15:31:13.083]     ...future.result
[15:31:13.083] }
[15:31:13.093] Exporting 5 global objects (1.27 KiB) to cluster node #1 ...
[15:31:13.093] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:13.094] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.095] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ...
[15:31:13.096] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ... DONE
[15:31:13.096] Exporting '...future.elements_ii' (528 bytes) to cluster node #1 ...
[15:31:13.097] Exporting '...future.elements_ii' (528 bytes) to cluster node #1 ... DONE
[15:31:13.097] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.098] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.098] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.098] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.099] Exporting 5 global objects (1.27 KiB) to cluster node #1 ... DONE
[15:31:13.100] MultisessionFuture started
[15:31:13.100] - Launch lazy future ... done
[15:31:13.100] run() for 'MultisessionFuture' ... done
[15:31:13.101] Created future:
[15:31:13.119] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.120] - Validating connection of MultisessionFuture
[15:31:13.120] - received message: FutureResult
[15:31:13.121] - Received FutureResult
[15:31:13.121] - Erased future from FutureRegistry
[15:31:13.121] result() for ClusterFuture ...
[15:31:13.122] - result already collected: FutureResult
[15:31:13.122] result() for ClusterFuture ... done
[15:31:13.122] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.101] MultisessionFuture:
[15:31:13.101] Label: 'future_by-1'
[15:31:13.101] Expression:
[15:31:13.101] {
[15:31:13.101]     do.call(function(...) {
[15:31:13.101]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.101]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.101]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.101]             on.exit(options(oopts), add = TRUE)
[15:31:13.101]         }
[15:31:13.101]         {
[15:31:13.101]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.101]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.101]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.101]             })
[15:31:13.101]         }
[15:31:13.101]     }, args = future.call.arguments)
[15:31:13.101] }
[15:31:13.101] Lazy evaluation: FALSE
[15:31:13.101] Asynchronous evaluation: TRUE
[15:31:13.101] Local evaluation: TRUE
[15:31:13.101] Environment: R_GlobalEnv
[15:31:13.101] Capture standard output: TRUE
[15:31:13.101] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.101] Globals: 5 objects totaling 1.78 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 528 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.101] Packages: <none>
[15:31:13.101] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.101] Resolved: TRUE
[15:31:13.101] Value: <not collected>
[15:31:13.101] Conditions captured: <none>
[15:31:13.101] Early signaling: FALSE
[15:31:13.101] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.101] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.123] Chunk #1 of 2 ... DONE
[15:31:13.123] Chunk #2 of 2 ...
[15:31:13.124]  - Finding globals in 'X' for chunk #2 ...
[15:31:13.124] getGlobalsAndPackages() ...
[15:31:13.124] Searching for globals...
[15:31:13.125] 
[15:31:13.125] Searching for globals ... DONE
[15:31:13.125] - globals: [0] <none>
[15:31:13.125] getGlobalsAndPackages() ... DONE
[15:31:13.126]    + additional globals found: [n=0] 
[15:31:13.126]    + additional namespaces needed: [n=0] 
[15:31:13.126]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:13.126]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.127]  - seeds: <none>
[15:31:13.127]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.127] getGlobalsAndPackages() ...
[15:31:13.128] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.128] Resolving globals: FALSE
[15:31:13.128] Tweak future expression to call with '...' arguments ...
[15:31:13.128] {
[15:31:13.128]     do.call(function(...) {
[15:31:13.128]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.128]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.128]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.128]             on.exit(options(oopts), add = TRUE)
[15:31:13.128]         }
[15:31:13.128]         {
[15:31:13.128]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.128]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.128]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.128]             })
[15:31:13.128]         }
[15:31:13.128]     }, args = future.call.arguments)
[15:31:13.128] }
[15:31:13.129] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.130] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.130] 
[15:31:13.131] getGlobalsAndPackages() ... DONE
[15:31:13.131] run() for 'Future' ...
[15:31:13.132] - state: 'created'
[15:31:13.132] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.149] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.149] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.149]   - Field: 'node'
[15:31:13.150]   - Field: 'label'
[15:31:13.150]   - Field: 'local'
[15:31:13.150]   - Field: 'owner'
[15:31:13.151]   - Field: 'envir'
[15:31:13.151]   - Field: 'workers'
[15:31:13.151]   - Field: 'packages'
[15:31:13.151]   - Field: 'gc'
[15:31:13.152]   - Field: 'conditions'
[15:31:13.152]   - Field: 'persistent'
[15:31:13.152]   - Field: 'expr'
[15:31:13.153]   - Field: 'uuid'
[15:31:13.153]   - Field: 'seed'
[15:31:13.153]   - Field: 'version'
[15:31:13.153]   - Field: 'result'
[15:31:13.154]   - Field: 'asynchronous'
[15:31:13.154]   - Field: 'calls'
[15:31:13.154]   - Field: 'globals'
[15:31:13.155]   - Field: 'stdout'
[15:31:13.155]   - Field: 'earlySignal'
[15:31:13.155]   - Field: 'lazy'
[15:31:13.156]   - Field: 'state'
[15:31:13.156] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.156] - Launch lazy future ...
[15:31:13.157] Packages needed by the future expression (n = 0): <none>
[15:31:13.157] Packages needed by future strategies (n = 0): <none>
[15:31:13.158] {
[15:31:13.158]     {
[15:31:13.158]         {
[15:31:13.158]             ...future.startTime <- base::Sys.time()
[15:31:13.158]             {
[15:31:13.158]                 {
[15:31:13.158]                   {
[15:31:13.158]                     {
[15:31:13.158]                       base::local({
[15:31:13.158]                         has_future <- base::requireNamespace("future", 
[15:31:13.158]                           quietly = TRUE)
[15:31:13.158]                         if (has_future) {
[15:31:13.158]                           ns <- base::getNamespace("future")
[15:31:13.158]                           version <- ns[[".package"]][["version"]]
[15:31:13.158]                           if (is.null(version)) 
[15:31:13.158]                             version <- utils::packageVersion("future")
[15:31:13.158]                         }
[15:31:13.158]                         else {
[15:31:13.158]                           version <- NULL
[15:31:13.158]                         }
[15:31:13.158]                         if (!has_future || version < "1.8.0") {
[15:31:13.158]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.158]                             "", base::R.version$version.string), 
[15:31:13.158]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:13.158]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:13.158]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.158]                               "release", "version")], collapse = " "), 
[15:31:13.158]                             hostname = base::Sys.info()[["nodename"]])
[15:31:13.158]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.158]                             info)
[15:31:13.158]                           info <- base::paste(info, collapse = "; ")
[15:31:13.158]                           if (!has_future) {
[15:31:13.158]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.158]                               info)
[15:31:13.158]                           }
[15:31:13.158]                           else {
[15:31:13.158]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.158]                               info, version)
[15:31:13.158]                           }
[15:31:13.158]                           base::stop(msg)
[15:31:13.158]                         }
[15:31:13.158]                       })
[15:31:13.158]                     }
[15:31:13.158]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.158]                     base::options(mc.cores = 1L)
[15:31:13.158]                   }
[15:31:13.158]                   ...future.strategy.old <- future::plan("list")
[15:31:13.158]                   options(future.plan = NULL)
[15:31:13.158]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.158]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.158]                 }
[15:31:13.158]                 ...future.workdir <- getwd()
[15:31:13.158]             }
[15:31:13.158]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.158]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.158]         }
[15:31:13.158]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.158]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.158]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.158]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.158]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.158]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.158]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.158]             base::names(...future.oldOptions))
[15:31:13.158]     }
[15:31:13.158]     if (FALSE) {
[15:31:13.158]     }
[15:31:13.158]     else {
[15:31:13.158]         if (TRUE) {
[15:31:13.158]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.158]                 open = "w")
[15:31:13.158]         }
[15:31:13.158]         else {
[15:31:13.158]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.158]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.158]         }
[15:31:13.158]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.158]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.158]             base::sink(type = "output", split = FALSE)
[15:31:13.158]             base::close(...future.stdout)
[15:31:13.158]         }, add = TRUE)
[15:31:13.158]     }
[15:31:13.158]     ...future.frame <- base::sys.nframe()
[15:31:13.158]     ...future.conditions <- base::list()
[15:31:13.158]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.158]     if (FALSE) {
[15:31:13.158]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.158]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.158]     }
[15:31:13.158]     ...future.result <- base::tryCatch({
[15:31:13.158]         base::withCallingHandlers({
[15:31:13.158]             ...future.value <- base::withVisible(base::local({
[15:31:13.158]                 ...future.makeSendCondition <- base::local({
[15:31:13.158]                   sendCondition <- NULL
[15:31:13.158]                   function(frame = 1L) {
[15:31:13.158]                     if (is.function(sendCondition)) 
[15:31:13.158]                       return(sendCondition)
[15:31:13.158]                     ns <- getNamespace("parallel")
[15:31:13.158]                     if (exists("sendData", mode = "function", 
[15:31:13.158]                       envir = ns)) {
[15:31:13.158]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.158]                         envir = ns)
[15:31:13.158]                       envir <- sys.frame(frame)
[15:31:13.158]                       master <- NULL
[15:31:13.158]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.158]                         !identical(envir, emptyenv())) {
[15:31:13.158]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.158]                           inherits = FALSE)) {
[15:31:13.158]                           master <- get("master", mode = "list", 
[15:31:13.158]                             envir = envir, inherits = FALSE)
[15:31:13.158]                           if (inherits(master, c("SOCKnode", 
[15:31:13.158]                             "SOCK0node"))) {
[15:31:13.158]                             sendCondition <<- function(cond) {
[15:31:13.158]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.158]                                 success = TRUE)
[15:31:13.158]                               parallel_sendData(master, data)
[15:31:13.158]                             }
[15:31:13.158]                             return(sendCondition)
[15:31:13.158]                           }
[15:31:13.158]                         }
[15:31:13.158]                         frame <- frame + 1L
[15:31:13.158]                         envir <- sys.frame(frame)
[15:31:13.158]                       }
[15:31:13.158]                     }
[15:31:13.158]                     sendCondition <<- function(cond) NULL
[15:31:13.158]                   }
[15:31:13.158]                 })
[15:31:13.158]                 withCallingHandlers({
[15:31:13.158]                   {
[15:31:13.158]                     do.call(function(...) {
[15:31:13.158]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.158]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.158]                         ...future.globals.maxSize)) {
[15:31:13.158]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.158]                         on.exit(options(oopts), add = TRUE)
[15:31:13.158]                       }
[15:31:13.158]                       {
[15:31:13.158]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.158]                           FUN = function(jj) {
[15:31:13.158]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.158]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.158]                           })
[15:31:13.158]                       }
[15:31:13.158]                     }, args = future.call.arguments)
[15:31:13.158]                   }
[15:31:13.158]                 }, immediateCondition = function(cond) {
[15:31:13.158]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.158]                   sendCondition(cond)
[15:31:13.158]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.158]                   {
[15:31:13.158]                     inherits <- base::inherits
[15:31:13.158]                     invokeRestart <- base::invokeRestart
[15:31:13.158]                     is.null <- base::is.null
[15:31:13.158]                     muffled <- FALSE
[15:31:13.158]                     if (inherits(cond, "message")) {
[15:31:13.158]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.158]                       if (muffled) 
[15:31:13.158]                         invokeRestart("muffleMessage")
[15:31:13.158]                     }
[15:31:13.158]                     else if (inherits(cond, "warning")) {
[15:31:13.158]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.158]                       if (muffled) 
[15:31:13.158]                         invokeRestart("muffleWarning")
[15:31:13.158]                     }
[15:31:13.158]                     else if (inherits(cond, "condition")) {
[15:31:13.158]                       if (!is.null(pattern)) {
[15:31:13.158]                         computeRestarts <- base::computeRestarts
[15:31:13.158]                         grepl <- base::grepl
[15:31:13.158]                         restarts <- computeRestarts(cond)
[15:31:13.158]                         for (restart in restarts) {
[15:31:13.158]                           name <- restart$name
[15:31:13.158]                           if (is.null(name)) 
[15:31:13.158]                             next
[15:31:13.158]                           if (!grepl(pattern, name)) 
[15:31:13.158]                             next
[15:31:13.158]                           invokeRestart(restart)
[15:31:13.158]                           muffled <- TRUE
[15:31:13.158]                           break
[15:31:13.158]                         }
[15:31:13.158]                       }
[15:31:13.158]                     }
[15:31:13.158]                     invisible(muffled)
[15:31:13.158]                   }
[15:31:13.158]                   muffleCondition(cond)
[15:31:13.158]                 })
[15:31:13.158]             }))
[15:31:13.158]             future::FutureResult(value = ...future.value$value, 
[15:31:13.158]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.158]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.158]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.158]                     ...future.globalenv.names))
[15:31:13.158]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.158]         }, condition = base::local({
[15:31:13.158]             c <- base::c
[15:31:13.158]             inherits <- base::inherits
[15:31:13.158]             invokeRestart <- base::invokeRestart
[15:31:13.158]             length <- base::length
[15:31:13.158]             list <- base::list
[15:31:13.158]             seq.int <- base::seq.int
[15:31:13.158]             signalCondition <- base::signalCondition
[15:31:13.158]             sys.calls <- base::sys.calls
[15:31:13.158]             `[[` <- base::`[[`
[15:31:13.158]             `+` <- base::`+`
[15:31:13.158]             `<<-` <- base::`<<-`
[15:31:13.158]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.158]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.158]                   3L)]
[15:31:13.158]             }
[15:31:13.158]             function(cond) {
[15:31:13.158]                 is_error <- inherits(cond, "error")
[15:31:13.158]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.158]                   NULL)
[15:31:13.158]                 if (is_error) {
[15:31:13.158]                   sessionInformation <- function() {
[15:31:13.158]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.158]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.158]                       search = base::search(), system = base::Sys.info())
[15:31:13.158]                   }
[15:31:13.158]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.158]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.158]                     cond$call), session = sessionInformation(), 
[15:31:13.158]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.158]                   signalCondition(cond)
[15:31:13.158]                 }
[15:31:13.158]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.158]                 "immediateCondition"))) {
[15:31:13.158]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.158]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.158]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.158]                   if (TRUE && !signal) {
[15:31:13.158]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.158]                     {
[15:31:13.158]                       inherits <- base::inherits
[15:31:13.158]                       invokeRestart <- base::invokeRestart
[15:31:13.158]                       is.null <- base::is.null
[15:31:13.158]                       muffled <- FALSE
[15:31:13.158]                       if (inherits(cond, "message")) {
[15:31:13.158]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.158]                         if (muffled) 
[15:31:13.158]                           invokeRestart("muffleMessage")
[15:31:13.158]                       }
[15:31:13.158]                       else if (inherits(cond, "warning")) {
[15:31:13.158]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.158]                         if (muffled) 
[15:31:13.158]                           invokeRestart("muffleWarning")
[15:31:13.158]                       }
[15:31:13.158]                       else if (inherits(cond, "condition")) {
[15:31:13.158]                         if (!is.null(pattern)) {
[15:31:13.158]                           computeRestarts <- base::computeRestarts
[15:31:13.158]                           grepl <- base::grepl
[15:31:13.158]                           restarts <- computeRestarts(cond)
[15:31:13.158]                           for (restart in restarts) {
[15:31:13.158]                             name <- restart$name
[15:31:13.158]                             if (is.null(name)) 
[15:31:13.158]                               next
[15:31:13.158]                             if (!grepl(pattern, name)) 
[15:31:13.158]                               next
[15:31:13.158]                             invokeRestart(restart)
[15:31:13.158]                             muffled <- TRUE
[15:31:13.158]                             break
[15:31:13.158]                           }
[15:31:13.158]                         }
[15:31:13.158]                       }
[15:31:13.158]                       invisible(muffled)
[15:31:13.158]                     }
[15:31:13.158]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.158]                   }
[15:31:13.158]                 }
[15:31:13.158]                 else {
[15:31:13.158]                   if (TRUE) {
[15:31:13.158]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.158]                     {
[15:31:13.158]                       inherits <- base::inherits
[15:31:13.158]                       invokeRestart <- base::invokeRestart
[15:31:13.158]                       is.null <- base::is.null
[15:31:13.158]                       muffled <- FALSE
[15:31:13.158]                       if (inherits(cond, "message")) {
[15:31:13.158]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.158]                         if (muffled) 
[15:31:13.158]                           invokeRestart("muffleMessage")
[15:31:13.158]                       }
[15:31:13.158]                       else if (inherits(cond, "warning")) {
[15:31:13.158]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.158]                         if (muffled) 
[15:31:13.158]                           invokeRestart("muffleWarning")
[15:31:13.158]                       }
[15:31:13.158]                       else if (inherits(cond, "condition")) {
[15:31:13.158]                         if (!is.null(pattern)) {
[15:31:13.158]                           computeRestarts <- base::computeRestarts
[15:31:13.158]                           grepl <- base::grepl
[15:31:13.158]                           restarts <- computeRestarts(cond)
[15:31:13.158]                           for (restart in restarts) {
[15:31:13.158]                             name <- restart$name
[15:31:13.158]                             if (is.null(name)) 
[15:31:13.158]                               next
[15:31:13.158]                             if (!grepl(pattern, name)) 
[15:31:13.158]                               next
[15:31:13.158]                             invokeRestart(restart)
[15:31:13.158]                             muffled <- TRUE
[15:31:13.158]                             break
[15:31:13.158]                           }
[15:31:13.158]                         }
[15:31:13.158]                       }
[15:31:13.158]                       invisible(muffled)
[15:31:13.158]                     }
[15:31:13.158]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.158]                   }
[15:31:13.158]                 }
[15:31:13.158]             }
[15:31:13.158]         }))
[15:31:13.158]     }, error = function(ex) {
[15:31:13.158]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.158]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.158]                 ...future.rng), started = ...future.startTime, 
[15:31:13.158]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.158]             version = "1.8"), class = "FutureResult")
[15:31:13.158]     }, finally = {
[15:31:13.158]         if (!identical(...future.workdir, getwd())) 
[15:31:13.158]             setwd(...future.workdir)
[15:31:13.158]         {
[15:31:13.158]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.158]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.158]             }
[15:31:13.158]             base::options(...future.oldOptions)
[15:31:13.158]             if (.Platform$OS.type == "windows") {
[15:31:13.158]                 old_names <- names(...future.oldEnvVars)
[15:31:13.158]                 envs <- base::Sys.getenv()
[15:31:13.158]                 names <- names(envs)
[15:31:13.158]                 common <- intersect(names, old_names)
[15:31:13.158]                 added <- setdiff(names, old_names)
[15:31:13.158]                 removed <- setdiff(old_names, names)
[15:31:13.158]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.158]                   envs[common]]
[15:31:13.158]                 NAMES <- toupper(changed)
[15:31:13.158]                 args <- list()
[15:31:13.158]                 for (kk in seq_along(NAMES)) {
[15:31:13.158]                   name <- changed[[kk]]
[15:31:13.158]                   NAME <- NAMES[[kk]]
[15:31:13.158]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.158]                     next
[15:31:13.158]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.158]                 }
[15:31:13.158]                 NAMES <- toupper(added)
[15:31:13.158]                 for (kk in seq_along(NAMES)) {
[15:31:13.158]                   name <- added[[kk]]
[15:31:13.158]                   NAME <- NAMES[[kk]]
[15:31:13.158]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.158]                     next
[15:31:13.158]                   args[[name]] <- ""
[15:31:13.158]                 }
[15:31:13.158]                 NAMES <- toupper(removed)
[15:31:13.158]                 for (kk in seq_along(NAMES)) {
[15:31:13.158]                   name <- removed[[kk]]
[15:31:13.158]                   NAME <- NAMES[[kk]]
[15:31:13.158]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.158]                     next
[15:31:13.158]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.158]                 }
[15:31:13.158]                 if (length(args) > 0) 
[15:31:13.158]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.158]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.158]             }
[15:31:13.158]             else {
[15:31:13.158]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.158]             }
[15:31:13.158]             {
[15:31:13.158]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.158]                   0L) {
[15:31:13.158]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.158]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.158]                   base::options(opts)
[15:31:13.158]                 }
[15:31:13.158]                 {
[15:31:13.158]                   {
[15:31:13.158]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.158]                     NULL
[15:31:13.158]                   }
[15:31:13.158]                   options(future.plan = NULL)
[15:31:13.158]                   if (is.na(NA_character_)) 
[15:31:13.158]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.158]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.158]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.158]                     .init = FALSE)
[15:31:13.158]                 }
[15:31:13.158]             }
[15:31:13.158]         }
[15:31:13.158]     })
[15:31:13.158]     if (TRUE) {
[15:31:13.158]         base::sink(type = "output", split = FALSE)
[15:31:13.158]         if (TRUE) {
[15:31:13.158]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.158]         }
[15:31:13.158]         else {
[15:31:13.158]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.158]         }
[15:31:13.158]         base::close(...future.stdout)
[15:31:13.158]         ...future.stdout <- NULL
[15:31:13.158]     }
[15:31:13.158]     ...future.result$conditions <- ...future.conditions
[15:31:13.158]     ...future.result$finished <- base::Sys.time()
[15:31:13.158]     ...future.result
[15:31:13.158] }
[15:31:13.165] Exporting 5 global objects (1.27 KiB) to cluster node #1 ...
[15:31:13.165] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:13.166] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.166] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ...
[15:31:13.167] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ... DONE
[15:31:13.167] Exporting '...future.elements_ii' (528 bytes) to cluster node #1 ...
[15:31:13.167] Exporting '...future.elements_ii' (528 bytes) to cluster node #1 ... DONE
[15:31:13.167] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.168] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.168] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.168] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.168] Exporting 5 global objects (1.27 KiB) to cluster node #1 ... DONE
[15:31:13.169] MultisessionFuture started
[15:31:13.169] - Launch lazy future ... done
[15:31:13.170] run() for 'MultisessionFuture' ... done
[15:31:13.170] Created future:
[15:31:13.193] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.194] - Validating connection of MultisessionFuture
[15:31:13.194] - received message: FutureResult
[15:31:13.195] - Received FutureResult
[15:31:13.195] - Erased future from FutureRegistry
[15:31:13.195] result() for ClusterFuture ...
[15:31:13.196] - result already collected: FutureResult
[15:31:13.196] result() for ClusterFuture ... done
[15:31:13.196] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.170] MultisessionFuture:
[15:31:13.170] Label: 'future_by-2'
[15:31:13.170] Expression:
[15:31:13.170] {
[15:31:13.170]     do.call(function(...) {
[15:31:13.170]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.170]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.170]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.170]             on.exit(options(oopts), add = TRUE)
[15:31:13.170]         }
[15:31:13.170]         {
[15:31:13.170]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.170]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.170]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.170]             })
[15:31:13.170]         }
[15:31:13.170]     }, args = future.call.arguments)
[15:31:13.170] }
[15:31:13.170] Lazy evaluation: FALSE
[15:31:13.170] Asynchronous evaluation: TRUE
[15:31:13.170] Local evaluation: TRUE
[15:31:13.170] Environment: R_GlobalEnv
[15:31:13.170] Capture standard output: TRUE
[15:31:13.170] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.170] Globals: 5 objects totaling 1.78 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 528 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.170] Packages: <none>
[15:31:13.170] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.170] Resolved: TRUE
[15:31:13.170] Value: <not collected>
[15:31:13.170] Conditions captured: <none>
[15:31:13.170] Early signaling: FALSE
[15:31:13.170] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.170] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.197] Chunk #2 of 2 ... DONE
[15:31:13.197] Launching 2 futures (chunks) ... DONE
[15:31:13.198] Resolving 2 futures (chunks) ...
[15:31:13.198] resolve() on list ...
[15:31:13.198]  recursive: 0
[15:31:13.198]  length: 2
[15:31:13.199] 
[15:31:13.199] Future #1
[15:31:13.199] result() for ClusterFuture ...
[15:31:13.199] - result already collected: FutureResult
[15:31:13.200] result() for ClusterFuture ... done
[15:31:13.200] result() for ClusterFuture ...
[15:31:13.200] - result already collected: FutureResult
[15:31:13.200] result() for ClusterFuture ... done
[15:31:13.201] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:13.201] - nx: 2
[15:31:13.201] - relay: TRUE
[15:31:13.201] - stdout: TRUE
[15:31:13.202] - signal: TRUE
[15:31:13.202] - resignal: FALSE
[15:31:13.202] - force: TRUE
[15:31:13.202] - relayed: [n=2] FALSE, FALSE
[15:31:13.202] - queued futures: [n=2] FALSE, FALSE
[15:31:13.203]  - until=1
[15:31:13.203]  - relaying element #1
[15:31:13.203] result() for ClusterFuture ...
[15:31:13.203] - result already collected: FutureResult
[15:31:13.204] result() for ClusterFuture ... done
[15:31:13.204] result() for ClusterFuture ...
[15:31:13.204] - result already collected: FutureResult
[15:31:13.204] result() for ClusterFuture ... done
[15:31:13.205] result() for ClusterFuture ...
[15:31:13.205] - result already collected: FutureResult
[15:31:13.205] result() for ClusterFuture ... done
[15:31:13.205] result() for ClusterFuture ...
[15:31:13.206] - result already collected: FutureResult
[15:31:13.206] result() for ClusterFuture ... done
[15:31:13.206] - relayed: [n=2] TRUE, FALSE
[15:31:13.206] - queued futures: [n=2] TRUE, FALSE
[15:31:13.207] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:13.207]  length: 1 (resolved future 1)
[15:31:13.207] Future #2
[15:31:13.208] result() for ClusterFuture ...
[15:31:13.208] - result already collected: FutureResult
[15:31:13.208] result() for ClusterFuture ... done
[15:31:13.208] result() for ClusterFuture ...
[15:31:13.209] - result already collected: FutureResult
[15:31:13.209] result() for ClusterFuture ... done
[15:31:13.209] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:13.209] - nx: 2
[15:31:13.209] - relay: TRUE
[15:31:13.210] - stdout: TRUE
[15:31:13.210] - signal: TRUE
[15:31:13.210] - resignal: FALSE
[15:31:13.210] - force: TRUE
[15:31:13.211] - relayed: [n=2] TRUE, FALSE
[15:31:13.211] - queued futures: [n=2] TRUE, FALSE
[15:31:13.211]  - until=2
[15:31:13.211]  - relaying element #2
[15:31:13.212] result() for ClusterFuture ...
[15:31:13.212] - result already collected: FutureResult
[15:31:13.212] result() for ClusterFuture ... done
[15:31:13.212] result() for ClusterFuture ...
[15:31:13.212] - result already collected: FutureResult
[15:31:13.213] result() for ClusterFuture ... done
[15:31:13.213] result() for ClusterFuture ...
[15:31:13.213] - result already collected: FutureResult
[15:31:13.213] result() for ClusterFuture ... done
[15:31:13.214] result() for ClusterFuture ...
[15:31:13.214] - result already collected: FutureResult
[15:31:13.214] result() for ClusterFuture ... done
[15:31:13.215] - relayed: [n=2] TRUE, TRUE
[15:31:13.215] - queued futures: [n=2] TRUE, TRUE
[15:31:13.215] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:13.215]  length: 0 (resolved future 2)
[15:31:13.216] Relaying remaining futures
[15:31:13.216] signalConditionsASAP(NULL, pos=0) ...
[15:31:13.216] - nx: 2
[15:31:13.216] - relay: TRUE
[15:31:13.217] - stdout: TRUE
[15:31:13.217] - signal: TRUE
[15:31:13.217] - resignal: FALSE
[15:31:13.217] - force: TRUE
[15:31:13.217] - relayed: [n=2] TRUE, TRUE
[15:31:13.218] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:13.218] - relayed: [n=2] TRUE, TRUE
[15:31:13.218] - queued futures: [n=2] TRUE, TRUE
[15:31:13.219] signalConditionsASAP(NULL, pos=0) ... done
[15:31:13.219] resolve() on list ... DONE
[15:31:13.219] result() for ClusterFuture ...
[15:31:13.219] - result already collected: FutureResult
[15:31:13.219] result() for ClusterFuture ... done
[15:31:13.220] result() for ClusterFuture ...
[15:31:13.220] - result already collected: FutureResult
[15:31:13.220] result() for ClusterFuture ... done
[15:31:13.221] result() for ClusterFuture ...
[15:31:13.221] - result already collected: FutureResult
[15:31:13.221] result() for ClusterFuture ... done
[15:31:13.221] result() for ClusterFuture ...
[15:31:13.222] - result already collected: FutureResult
[15:31:13.222] result() for ClusterFuture ... done
[15:31:13.222]  - Number of value chunks collected: 2
[15:31:13.223] Resolving 2 futures (chunks) ... DONE
[15:31:13.223] Reducing values from 2 chunks ...
[15:31:13.223]  - Number of values collected after concatenation: 6
[15:31:13.223]  - Number of values expected: 6
[15:31:13.223] Reducing values from 2 chunks ... DONE
[15:31:13.224] future_lapply() ... DONE
[15:31:13.224] future_by_internal() ... DONE
[15:31:13.226] future_by_internal() ...
[15:31:13.227] future_lapply() ...
[15:31:13.232] Number of chunks: 2
[15:31:13.232] getGlobalsAndPackagesXApply() ...
[15:31:13.232]  - future.globals: TRUE
[15:31:13.233] getGlobalsAndPackages() ...
[15:31:13.233] Searching for globals...
[15:31:13.236] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:13.236] Searching for globals ... DONE
[15:31:13.236] Resolving globals: FALSE
[15:31:13.237] The total size of the 1 globals is 5.20 KiB (5328 bytes)
[15:31:13.238] The total size of the 1 globals exported for future expression ('FUN(singular.ok = FALSE)') is 5.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (5.20 KiB of class 'function')
[15:31:13.238] - globals: [1] 'FUN'
[15:31:13.239] - packages: [1] 'stats'
[15:31:13.239] getGlobalsAndPackages() ... DONE
[15:31:13.239]  - globals found/used: [n=1] 'FUN'
[15:31:13.239]  - needed namespaces: [n=1] 'stats'
[15:31:13.240] Finding globals ... DONE
[15:31:13.240]  - use_args: TRUE
[15:31:13.240]  - Getting '...' globals ...
[15:31:13.244] resolve() on list ...
[15:31:13.244]  recursive: 0
[15:31:13.244]  length: 1
[15:31:13.244]  elements: '...'
[15:31:13.245]  length: 0 (resolved future 1)
[15:31:13.245] resolve() on list ... DONE
[15:31:13.245]    - '...' content: [n=1] 'singular.ok'
[15:31:13.245] List of 1
[15:31:13.245]  $ ...:List of 1
[15:31:13.245]   ..$ singular.ok: logi FALSE
[15:31:13.245]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.245]  - attr(*, "where")=List of 1
[15:31:13.245]   ..$ ...:<environment: 0x0000019c8246cc48> 
[15:31:13.245]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.245]  - attr(*, "resolved")= logi TRUE
[15:31:13.245]  - attr(*, "total_size")= num NA
[15:31:13.250]  - Getting '...' globals ... DONE
[15:31:13.251] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:13.251] List of 2
[15:31:13.251]  $ ...future.FUN:function (x, ...)  
[15:31:13.251]  $ ...          :List of 1
[15:31:13.251]   ..$ singular.ok: logi FALSE
[15:31:13.251]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.251]  - attr(*, "where")=List of 2
[15:31:13.251]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:13.251]   ..$ ...          :<environment: 0x0000019c8246cc48> 
[15:31:13.251]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.251]  - attr(*, "resolved")= logi FALSE
[15:31:13.251]  - attr(*, "total_size")= num 5384
[15:31:13.256] Packages to be attached in all futures: [n=1] 'stats'
[15:31:13.256] getGlobalsAndPackagesXApply() ... DONE
[15:31:13.257] Number of futures (= number of chunks): 2
[15:31:13.257] Launching 2 futures (chunks) ...
[15:31:13.257] Chunk #1 of 2 ...
[15:31:13.258]  - Finding globals in 'X' for chunk #1 ...
[15:31:13.258] getGlobalsAndPackages() ...
[15:31:13.258] Searching for globals...
[15:31:13.259] 
[15:31:13.259] Searching for globals ... DONE
[15:31:13.259] - globals: [0] <none>
[15:31:13.260] getGlobalsAndPackages() ... DONE
[15:31:13.260]    + additional globals found: [n=0] 
[15:31:13.260]    + additional namespaces needed: [n=0] 
[15:31:13.260]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:13.260]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.261]  - seeds: <none>
[15:31:13.261]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.261] getGlobalsAndPackages() ...
[15:31:13.261] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.262] Resolving globals: FALSE
[15:31:13.262] Tweak future expression to call with '...' arguments ...
[15:31:13.262] {
[15:31:13.262]     do.call(function(...) {
[15:31:13.262]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.262]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.262]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.262]             on.exit(options(oopts), add = TRUE)
[15:31:13.262]         }
[15:31:13.262]         {
[15:31:13.262]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.262]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.262]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.262]             })
[15:31:13.262]         }
[15:31:13.262]     }, args = future.call.arguments)
[15:31:13.262] }
[15:31:13.263] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.264] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.264] 
[15:31:13.264] getGlobalsAndPackages() ... DONE
[15:31:13.265] run() for 'Future' ...
[15:31:13.265] - state: 'created'
[15:31:13.265] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.283] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.283]   - Field: 'node'
[15:31:13.284]   - Field: 'label'
[15:31:13.284]   - Field: 'local'
[15:31:13.284]   - Field: 'owner'
[15:31:13.284]   - Field: 'envir'
[15:31:13.285]   - Field: 'workers'
[15:31:13.285]   - Field: 'packages'
[15:31:13.285]   - Field: 'gc'
[15:31:13.285]   - Field: 'conditions'
[15:31:13.286]   - Field: 'persistent'
[15:31:13.286]   - Field: 'expr'
[15:31:13.286]   - Field: 'uuid'
[15:31:13.286]   - Field: 'seed'
[15:31:13.287]   - Field: 'version'
[15:31:13.287]   - Field: 'result'
[15:31:13.287]   - Field: 'asynchronous'
[15:31:13.287]   - Field: 'calls'
[15:31:13.288]   - Field: 'globals'
[15:31:13.288]   - Field: 'stdout'
[15:31:13.288]   - Field: 'earlySignal'
[15:31:13.289]   - Field: 'lazy'
[15:31:13.289]   - Field: 'state'
[15:31:13.289] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.289] - Launch lazy future ...
[15:31:13.290] Packages needed by the future expression (n = 1): 'stats'
[15:31:13.290] Packages needed by future strategies (n = 0): <none>
[15:31:13.291] {
[15:31:13.291]     {
[15:31:13.291]         {
[15:31:13.291]             ...future.startTime <- base::Sys.time()
[15:31:13.291]             {
[15:31:13.291]                 {
[15:31:13.291]                   {
[15:31:13.291]                     {
[15:31:13.291]                       {
[15:31:13.291]                         base::local({
[15:31:13.291]                           has_future <- base::requireNamespace("future", 
[15:31:13.291]                             quietly = TRUE)
[15:31:13.291]                           if (has_future) {
[15:31:13.291]                             ns <- base::getNamespace("future")
[15:31:13.291]                             version <- ns[[".package"]][["version"]]
[15:31:13.291]                             if (is.null(version)) 
[15:31:13.291]                               version <- utils::packageVersion("future")
[15:31:13.291]                           }
[15:31:13.291]                           else {
[15:31:13.291]                             version <- NULL
[15:31:13.291]                           }
[15:31:13.291]                           if (!has_future || version < "1.8.0") {
[15:31:13.291]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.291]                               "", base::R.version$version.string), 
[15:31:13.291]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:13.291]                                 base::R.version$platform, 8 * 
[15:31:13.291]                                   base::.Machine$sizeof.pointer), 
[15:31:13.291]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.291]                                 "release", "version")], collapse = " "), 
[15:31:13.291]                               hostname = base::Sys.info()[["nodename"]])
[15:31:13.291]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.291]                               info)
[15:31:13.291]                             info <- base::paste(info, collapse = "; ")
[15:31:13.291]                             if (!has_future) {
[15:31:13.291]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.291]                                 info)
[15:31:13.291]                             }
[15:31:13.291]                             else {
[15:31:13.291]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.291]                                 info, version)
[15:31:13.291]                             }
[15:31:13.291]                             base::stop(msg)
[15:31:13.291]                           }
[15:31:13.291]                         })
[15:31:13.291]                       }
[15:31:13.291]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.291]                       base::options(mc.cores = 1L)
[15:31:13.291]                     }
[15:31:13.291]                     base::local({
[15:31:13.291]                       for (pkg in "stats") {
[15:31:13.291]                         base::loadNamespace(pkg)
[15:31:13.291]                         base::library(pkg, character.only = TRUE)
[15:31:13.291]                       }
[15:31:13.291]                     })
[15:31:13.291]                   }
[15:31:13.291]                   ...future.strategy.old <- future::plan("list")
[15:31:13.291]                   options(future.plan = NULL)
[15:31:13.291]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.291]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.291]                 }
[15:31:13.291]                 ...future.workdir <- getwd()
[15:31:13.291]             }
[15:31:13.291]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.291]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.291]         }
[15:31:13.291]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.291]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.291]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.291]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.291]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.291]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.291]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.291]             base::names(...future.oldOptions))
[15:31:13.291]     }
[15:31:13.291]     if (FALSE) {
[15:31:13.291]     }
[15:31:13.291]     else {
[15:31:13.291]         if (TRUE) {
[15:31:13.291]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.291]                 open = "w")
[15:31:13.291]         }
[15:31:13.291]         else {
[15:31:13.291]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.291]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.291]         }
[15:31:13.291]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.291]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.291]             base::sink(type = "output", split = FALSE)
[15:31:13.291]             base::close(...future.stdout)
[15:31:13.291]         }, add = TRUE)
[15:31:13.291]     }
[15:31:13.291]     ...future.frame <- base::sys.nframe()
[15:31:13.291]     ...future.conditions <- base::list()
[15:31:13.291]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.291]     if (FALSE) {
[15:31:13.291]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.291]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.291]     }
[15:31:13.291]     ...future.result <- base::tryCatch({
[15:31:13.291]         base::withCallingHandlers({
[15:31:13.291]             ...future.value <- base::withVisible(base::local({
[15:31:13.291]                 ...future.makeSendCondition <- base::local({
[15:31:13.291]                   sendCondition <- NULL
[15:31:13.291]                   function(frame = 1L) {
[15:31:13.291]                     if (is.function(sendCondition)) 
[15:31:13.291]                       return(sendCondition)
[15:31:13.291]                     ns <- getNamespace("parallel")
[15:31:13.291]                     if (exists("sendData", mode = "function", 
[15:31:13.291]                       envir = ns)) {
[15:31:13.291]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.291]                         envir = ns)
[15:31:13.291]                       envir <- sys.frame(frame)
[15:31:13.291]                       master <- NULL
[15:31:13.291]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.291]                         !identical(envir, emptyenv())) {
[15:31:13.291]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.291]                           inherits = FALSE)) {
[15:31:13.291]                           master <- get("master", mode = "list", 
[15:31:13.291]                             envir = envir, inherits = FALSE)
[15:31:13.291]                           if (inherits(master, c("SOCKnode", 
[15:31:13.291]                             "SOCK0node"))) {
[15:31:13.291]                             sendCondition <<- function(cond) {
[15:31:13.291]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.291]                                 success = TRUE)
[15:31:13.291]                               parallel_sendData(master, data)
[15:31:13.291]                             }
[15:31:13.291]                             return(sendCondition)
[15:31:13.291]                           }
[15:31:13.291]                         }
[15:31:13.291]                         frame <- frame + 1L
[15:31:13.291]                         envir <- sys.frame(frame)
[15:31:13.291]                       }
[15:31:13.291]                     }
[15:31:13.291]                     sendCondition <<- function(cond) NULL
[15:31:13.291]                   }
[15:31:13.291]                 })
[15:31:13.291]                 withCallingHandlers({
[15:31:13.291]                   {
[15:31:13.291]                     do.call(function(...) {
[15:31:13.291]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.291]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.291]                         ...future.globals.maxSize)) {
[15:31:13.291]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.291]                         on.exit(options(oopts), add = TRUE)
[15:31:13.291]                       }
[15:31:13.291]                       {
[15:31:13.291]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.291]                           FUN = function(jj) {
[15:31:13.291]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.291]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.291]                           })
[15:31:13.291]                       }
[15:31:13.291]                     }, args = future.call.arguments)
[15:31:13.291]                   }
[15:31:13.291]                 }, immediateCondition = function(cond) {
[15:31:13.291]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.291]                   sendCondition(cond)
[15:31:13.291]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.291]                   {
[15:31:13.291]                     inherits <- base::inherits
[15:31:13.291]                     invokeRestart <- base::invokeRestart
[15:31:13.291]                     is.null <- base::is.null
[15:31:13.291]                     muffled <- FALSE
[15:31:13.291]                     if (inherits(cond, "message")) {
[15:31:13.291]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.291]                       if (muffled) 
[15:31:13.291]                         invokeRestart("muffleMessage")
[15:31:13.291]                     }
[15:31:13.291]                     else if (inherits(cond, "warning")) {
[15:31:13.291]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.291]                       if (muffled) 
[15:31:13.291]                         invokeRestart("muffleWarning")
[15:31:13.291]                     }
[15:31:13.291]                     else if (inherits(cond, "condition")) {
[15:31:13.291]                       if (!is.null(pattern)) {
[15:31:13.291]                         computeRestarts <- base::computeRestarts
[15:31:13.291]                         grepl <- base::grepl
[15:31:13.291]                         restarts <- computeRestarts(cond)
[15:31:13.291]                         for (restart in restarts) {
[15:31:13.291]                           name <- restart$name
[15:31:13.291]                           if (is.null(name)) 
[15:31:13.291]                             next
[15:31:13.291]                           if (!grepl(pattern, name)) 
[15:31:13.291]                             next
[15:31:13.291]                           invokeRestart(restart)
[15:31:13.291]                           muffled <- TRUE
[15:31:13.291]                           break
[15:31:13.291]                         }
[15:31:13.291]                       }
[15:31:13.291]                     }
[15:31:13.291]                     invisible(muffled)
[15:31:13.291]                   }
[15:31:13.291]                   muffleCondition(cond)
[15:31:13.291]                 })
[15:31:13.291]             }))
[15:31:13.291]             future::FutureResult(value = ...future.value$value, 
[15:31:13.291]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.291]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.291]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.291]                     ...future.globalenv.names))
[15:31:13.291]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.291]         }, condition = base::local({
[15:31:13.291]             c <- base::c
[15:31:13.291]             inherits <- base::inherits
[15:31:13.291]             invokeRestart <- base::invokeRestart
[15:31:13.291]             length <- base::length
[15:31:13.291]             list <- base::list
[15:31:13.291]             seq.int <- base::seq.int
[15:31:13.291]             signalCondition <- base::signalCondition
[15:31:13.291]             sys.calls <- base::sys.calls
[15:31:13.291]             `[[` <- base::`[[`
[15:31:13.291]             `+` <- base::`+`
[15:31:13.291]             `<<-` <- base::`<<-`
[15:31:13.291]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.291]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.291]                   3L)]
[15:31:13.291]             }
[15:31:13.291]             function(cond) {
[15:31:13.291]                 is_error <- inherits(cond, "error")
[15:31:13.291]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.291]                   NULL)
[15:31:13.291]                 if (is_error) {
[15:31:13.291]                   sessionInformation <- function() {
[15:31:13.291]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.291]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.291]                       search = base::search(), system = base::Sys.info())
[15:31:13.291]                   }
[15:31:13.291]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.291]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.291]                     cond$call), session = sessionInformation(), 
[15:31:13.291]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.291]                   signalCondition(cond)
[15:31:13.291]                 }
[15:31:13.291]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.291]                 "immediateCondition"))) {
[15:31:13.291]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.291]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.291]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.291]                   if (TRUE && !signal) {
[15:31:13.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.291]                     {
[15:31:13.291]                       inherits <- base::inherits
[15:31:13.291]                       invokeRestart <- base::invokeRestart
[15:31:13.291]                       is.null <- base::is.null
[15:31:13.291]                       muffled <- FALSE
[15:31:13.291]                       if (inherits(cond, "message")) {
[15:31:13.291]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.291]                         if (muffled) 
[15:31:13.291]                           invokeRestart("muffleMessage")
[15:31:13.291]                       }
[15:31:13.291]                       else if (inherits(cond, "warning")) {
[15:31:13.291]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.291]                         if (muffled) 
[15:31:13.291]                           invokeRestart("muffleWarning")
[15:31:13.291]                       }
[15:31:13.291]                       else if (inherits(cond, "condition")) {
[15:31:13.291]                         if (!is.null(pattern)) {
[15:31:13.291]                           computeRestarts <- base::computeRestarts
[15:31:13.291]                           grepl <- base::grepl
[15:31:13.291]                           restarts <- computeRestarts(cond)
[15:31:13.291]                           for (restart in restarts) {
[15:31:13.291]                             name <- restart$name
[15:31:13.291]                             if (is.null(name)) 
[15:31:13.291]                               next
[15:31:13.291]                             if (!grepl(pattern, name)) 
[15:31:13.291]                               next
[15:31:13.291]                             invokeRestart(restart)
[15:31:13.291]                             muffled <- TRUE
[15:31:13.291]                             break
[15:31:13.291]                           }
[15:31:13.291]                         }
[15:31:13.291]                       }
[15:31:13.291]                       invisible(muffled)
[15:31:13.291]                     }
[15:31:13.291]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.291]                   }
[15:31:13.291]                 }
[15:31:13.291]                 else {
[15:31:13.291]                   if (TRUE) {
[15:31:13.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.291]                     {
[15:31:13.291]                       inherits <- base::inherits
[15:31:13.291]                       invokeRestart <- base::invokeRestart
[15:31:13.291]                       is.null <- base::is.null
[15:31:13.291]                       muffled <- FALSE
[15:31:13.291]                       if (inherits(cond, "message")) {
[15:31:13.291]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.291]                         if (muffled) 
[15:31:13.291]                           invokeRestart("muffleMessage")
[15:31:13.291]                       }
[15:31:13.291]                       else if (inherits(cond, "warning")) {
[15:31:13.291]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.291]                         if (muffled) 
[15:31:13.291]                           invokeRestart("muffleWarning")
[15:31:13.291]                       }
[15:31:13.291]                       else if (inherits(cond, "condition")) {
[15:31:13.291]                         if (!is.null(pattern)) {
[15:31:13.291]                           computeRestarts <- base::computeRestarts
[15:31:13.291]                           grepl <- base::grepl
[15:31:13.291]                           restarts <- computeRestarts(cond)
[15:31:13.291]                           for (restart in restarts) {
[15:31:13.291]                             name <- restart$name
[15:31:13.291]                             if (is.null(name)) 
[15:31:13.291]                               next
[15:31:13.291]                             if (!grepl(pattern, name)) 
[15:31:13.291]                               next
[15:31:13.291]                             invokeRestart(restart)
[15:31:13.291]                             muffled <- TRUE
[15:31:13.291]                             break
[15:31:13.291]                           }
[15:31:13.291]                         }
[15:31:13.291]                       }
[15:31:13.291]                       invisible(muffled)
[15:31:13.291]                     }
[15:31:13.291]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.291]                   }
[15:31:13.291]                 }
[15:31:13.291]             }
[15:31:13.291]         }))
[15:31:13.291]     }, error = function(ex) {
[15:31:13.291]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.291]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.291]                 ...future.rng), started = ...future.startTime, 
[15:31:13.291]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.291]             version = "1.8"), class = "FutureResult")
[15:31:13.291]     }, finally = {
[15:31:13.291]         if (!identical(...future.workdir, getwd())) 
[15:31:13.291]             setwd(...future.workdir)
[15:31:13.291]         {
[15:31:13.291]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.291]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.291]             }
[15:31:13.291]             base::options(...future.oldOptions)
[15:31:13.291]             if (.Platform$OS.type == "windows") {
[15:31:13.291]                 old_names <- names(...future.oldEnvVars)
[15:31:13.291]                 envs <- base::Sys.getenv()
[15:31:13.291]                 names <- names(envs)
[15:31:13.291]                 common <- intersect(names, old_names)
[15:31:13.291]                 added <- setdiff(names, old_names)
[15:31:13.291]                 removed <- setdiff(old_names, names)
[15:31:13.291]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.291]                   envs[common]]
[15:31:13.291]                 NAMES <- toupper(changed)
[15:31:13.291]                 args <- list()
[15:31:13.291]                 for (kk in seq_along(NAMES)) {
[15:31:13.291]                   name <- changed[[kk]]
[15:31:13.291]                   NAME <- NAMES[[kk]]
[15:31:13.291]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.291]                     next
[15:31:13.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.291]                 }
[15:31:13.291]                 NAMES <- toupper(added)
[15:31:13.291]                 for (kk in seq_along(NAMES)) {
[15:31:13.291]                   name <- added[[kk]]
[15:31:13.291]                   NAME <- NAMES[[kk]]
[15:31:13.291]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.291]                     next
[15:31:13.291]                   args[[name]] <- ""
[15:31:13.291]                 }
[15:31:13.291]                 NAMES <- toupper(removed)
[15:31:13.291]                 for (kk in seq_along(NAMES)) {
[15:31:13.291]                   name <- removed[[kk]]
[15:31:13.291]                   NAME <- NAMES[[kk]]
[15:31:13.291]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.291]                     next
[15:31:13.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.291]                 }
[15:31:13.291]                 if (length(args) > 0) 
[15:31:13.291]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.291]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.291]             }
[15:31:13.291]             else {
[15:31:13.291]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.291]             }
[15:31:13.291]             {
[15:31:13.291]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.291]                   0L) {
[15:31:13.291]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.291]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.291]                   base::options(opts)
[15:31:13.291]                 }
[15:31:13.291]                 {
[15:31:13.291]                   {
[15:31:13.291]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.291]                     NULL
[15:31:13.291]                   }
[15:31:13.291]                   options(future.plan = NULL)
[15:31:13.291]                   if (is.na(NA_character_)) 
[15:31:13.291]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.291]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.291]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.291]                     .init = FALSE)
[15:31:13.291]                 }
[15:31:13.291]             }
[15:31:13.291]         }
[15:31:13.291]     })
[15:31:13.291]     if (TRUE) {
[15:31:13.291]         base::sink(type = "output", split = FALSE)
[15:31:13.291]         if (TRUE) {
[15:31:13.291]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.291]         }
[15:31:13.291]         else {
[15:31:13.291]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.291]         }
[15:31:13.291]         base::close(...future.stdout)
[15:31:13.291]         ...future.stdout <- NULL
[15:31:13.291]     }
[15:31:13.291]     ...future.result$conditions <- ...future.conditions
[15:31:13.291]     ...future.result$finished <- base::Sys.time()
[15:31:13.291]     ...future.result
[15:31:13.291] }
[15:31:13.299] Exporting 5 global objects (5.26 KiB) to cluster node #1 ...
[15:31:13.300] Exporting '...future.FUN' (5.20 KiB) to cluster node #1 ...
[15:31:13.300] Exporting '...future.FUN' (5.20 KiB) to cluster node #1 ... DONE
[15:31:13.301] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ...
[15:31:13.301] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ... DONE
[15:31:13.302] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ...
[15:31:13.302] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ... DONE
[15:31:13.303] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.303] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.303] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.304] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.305] Exporting 5 global objects (5.26 KiB) to cluster node #1 ... DONE
[15:31:13.306] MultisessionFuture started
[15:31:13.306] - Launch lazy future ... done
[15:31:13.306] run() for 'MultisessionFuture' ... done
[15:31:13.307] Created future:
[15:31:13.334] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.335] - Validating connection of MultisessionFuture
[15:31:13.335] - received message: FutureResult
[15:31:13.336] - Received FutureResult
[15:31:13.336] - Erased future from FutureRegistry
[15:31:13.336] result() for ClusterFuture ...
[15:31:13.336] - result already collected: FutureResult
[15:31:13.337] result() for ClusterFuture ... done
[15:31:13.337] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.307] MultisessionFuture:
[15:31:13.307] Label: 'future_by-1'
[15:31:13.307] Expression:
[15:31:13.307] {
[15:31:13.307]     do.call(function(...) {
[15:31:13.307]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.307]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.307]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.307]             on.exit(options(oopts), add = TRUE)
[15:31:13.307]         }
[15:31:13.307]         {
[15:31:13.307]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.307]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.307]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.307]             })
[15:31:13.307]         }
[15:31:13.307]     }, args = future.call.arguments)
[15:31:13.307] }
[15:31:13.307] Lazy evaluation: FALSE
[15:31:13.307] Asynchronous evaluation: TRUE
[15:31:13.307] Local evaluation: TRUE
[15:31:13.307] Environment: R_GlobalEnv
[15:31:13.307] Capture standard output: TRUE
[15:31:13.307] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.307] Globals: 5 objects totaling 6.86 KiB (function '...future.FUN' of 5.20 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 1.60 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.307] Packages: 1 packages ('stats')
[15:31:13.307] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.307] Resolved: TRUE
[15:31:13.307] Value: <not collected>
[15:31:13.307] Conditions captured: <none>
[15:31:13.307] Early signaling: FALSE
[15:31:13.307] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.307] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.338] Chunk #1 of 2 ... DONE
[15:31:13.338] Chunk #2 of 2 ...
[15:31:13.338]  - Finding globals in 'X' for chunk #2 ...
[15:31:13.338] getGlobalsAndPackages() ...
[15:31:13.339] Searching for globals...
[15:31:13.339] 
[15:31:13.340] Searching for globals ... DONE
[15:31:13.340] - globals: [0] <none>
[15:31:13.340] getGlobalsAndPackages() ... DONE
[15:31:13.340]    + additional globals found: [n=0] 
[15:31:13.341]    + additional namespaces needed: [n=0] 
[15:31:13.341]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:13.341]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.341]  - seeds: <none>
[15:31:13.341]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.342] getGlobalsAndPackages() ...
[15:31:13.342] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.342] Resolving globals: FALSE
[15:31:13.343] Tweak future expression to call with '...' arguments ...
[15:31:13.343] {
[15:31:13.343]     do.call(function(...) {
[15:31:13.343]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.343]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.343]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.343]             on.exit(options(oopts), add = TRUE)
[15:31:13.343]         }
[15:31:13.343]         {
[15:31:13.343]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.343]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.343]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.343]             })
[15:31:13.343]         }
[15:31:13.343]     }, args = future.call.arguments)
[15:31:13.343] }
[15:31:13.344] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.344] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.345] 
[15:31:13.345] getGlobalsAndPackages() ... DONE
[15:31:13.345] run() for 'Future' ...
[15:31:13.346] - state: 'created'
[15:31:13.346] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.364] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.365] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.365]   - Field: 'node'
[15:31:13.365]   - Field: 'label'
[15:31:13.366]   - Field: 'local'
[15:31:13.366]   - Field: 'owner'
[15:31:13.366]   - Field: 'envir'
[15:31:13.367]   - Field: 'workers'
[15:31:13.367]   - Field: 'packages'
[15:31:13.367]   - Field: 'gc'
[15:31:13.367]   - Field: 'conditions'
[15:31:13.368]   - Field: 'persistent'
[15:31:13.368]   - Field: 'expr'
[15:31:13.368]   - Field: 'uuid'
[15:31:13.369]   - Field: 'seed'
[15:31:13.369]   - Field: 'version'
[15:31:13.369]   - Field: 'result'
[15:31:13.370]   - Field: 'asynchronous'
[15:31:13.370]   - Field: 'calls'
[15:31:13.370]   - Field: 'globals'
[15:31:13.371]   - Field: 'stdout'
[15:31:13.371]   - Field: 'earlySignal'
[15:31:13.371]   - Field: 'lazy'
[15:31:13.372]   - Field: 'state'
[15:31:13.372] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.372] - Launch lazy future ...
[15:31:13.373] Packages needed by the future expression (n = 1): 'stats'
[15:31:13.373] Packages needed by future strategies (n = 0): <none>
[15:31:13.375] {
[15:31:13.375]     {
[15:31:13.375]         {
[15:31:13.375]             ...future.startTime <- base::Sys.time()
[15:31:13.375]             {
[15:31:13.375]                 {
[15:31:13.375]                   {
[15:31:13.375]                     {
[15:31:13.375]                       {
[15:31:13.375]                         base::local({
[15:31:13.375]                           has_future <- base::requireNamespace("future", 
[15:31:13.375]                             quietly = TRUE)
[15:31:13.375]                           if (has_future) {
[15:31:13.375]                             ns <- base::getNamespace("future")
[15:31:13.375]                             version <- ns[[".package"]][["version"]]
[15:31:13.375]                             if (is.null(version)) 
[15:31:13.375]                               version <- utils::packageVersion("future")
[15:31:13.375]                           }
[15:31:13.375]                           else {
[15:31:13.375]                             version <- NULL
[15:31:13.375]                           }
[15:31:13.375]                           if (!has_future || version < "1.8.0") {
[15:31:13.375]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.375]                               "", base::R.version$version.string), 
[15:31:13.375]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:13.375]                                 base::R.version$platform, 8 * 
[15:31:13.375]                                   base::.Machine$sizeof.pointer), 
[15:31:13.375]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.375]                                 "release", "version")], collapse = " "), 
[15:31:13.375]                               hostname = base::Sys.info()[["nodename"]])
[15:31:13.375]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.375]                               info)
[15:31:13.375]                             info <- base::paste(info, collapse = "; ")
[15:31:13.375]                             if (!has_future) {
[15:31:13.375]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.375]                                 info)
[15:31:13.375]                             }
[15:31:13.375]                             else {
[15:31:13.375]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.375]                                 info, version)
[15:31:13.375]                             }
[15:31:13.375]                             base::stop(msg)
[15:31:13.375]                           }
[15:31:13.375]                         })
[15:31:13.375]                       }
[15:31:13.375]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.375]                       base::options(mc.cores = 1L)
[15:31:13.375]                     }
[15:31:13.375]                     base::local({
[15:31:13.375]                       for (pkg in "stats") {
[15:31:13.375]                         base::loadNamespace(pkg)
[15:31:13.375]                         base::library(pkg, character.only = TRUE)
[15:31:13.375]                       }
[15:31:13.375]                     })
[15:31:13.375]                   }
[15:31:13.375]                   ...future.strategy.old <- future::plan("list")
[15:31:13.375]                   options(future.plan = NULL)
[15:31:13.375]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.375]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.375]                 }
[15:31:13.375]                 ...future.workdir <- getwd()
[15:31:13.375]             }
[15:31:13.375]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.375]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.375]         }
[15:31:13.375]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.375]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.375]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.375]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.375]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.375]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.375]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.375]             base::names(...future.oldOptions))
[15:31:13.375]     }
[15:31:13.375]     if (FALSE) {
[15:31:13.375]     }
[15:31:13.375]     else {
[15:31:13.375]         if (TRUE) {
[15:31:13.375]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.375]                 open = "w")
[15:31:13.375]         }
[15:31:13.375]         else {
[15:31:13.375]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.375]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.375]         }
[15:31:13.375]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.375]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.375]             base::sink(type = "output", split = FALSE)
[15:31:13.375]             base::close(...future.stdout)
[15:31:13.375]         }, add = TRUE)
[15:31:13.375]     }
[15:31:13.375]     ...future.frame <- base::sys.nframe()
[15:31:13.375]     ...future.conditions <- base::list()
[15:31:13.375]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.375]     if (FALSE) {
[15:31:13.375]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.375]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.375]     }
[15:31:13.375]     ...future.result <- base::tryCatch({
[15:31:13.375]         base::withCallingHandlers({
[15:31:13.375]             ...future.value <- base::withVisible(base::local({
[15:31:13.375]                 ...future.makeSendCondition <- base::local({
[15:31:13.375]                   sendCondition <- NULL
[15:31:13.375]                   function(frame = 1L) {
[15:31:13.375]                     if (is.function(sendCondition)) 
[15:31:13.375]                       return(sendCondition)
[15:31:13.375]                     ns <- getNamespace("parallel")
[15:31:13.375]                     if (exists("sendData", mode = "function", 
[15:31:13.375]                       envir = ns)) {
[15:31:13.375]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.375]                         envir = ns)
[15:31:13.375]                       envir <- sys.frame(frame)
[15:31:13.375]                       master <- NULL
[15:31:13.375]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.375]                         !identical(envir, emptyenv())) {
[15:31:13.375]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.375]                           inherits = FALSE)) {
[15:31:13.375]                           master <- get("master", mode = "list", 
[15:31:13.375]                             envir = envir, inherits = FALSE)
[15:31:13.375]                           if (inherits(master, c("SOCKnode", 
[15:31:13.375]                             "SOCK0node"))) {
[15:31:13.375]                             sendCondition <<- function(cond) {
[15:31:13.375]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.375]                                 success = TRUE)
[15:31:13.375]                               parallel_sendData(master, data)
[15:31:13.375]                             }
[15:31:13.375]                             return(sendCondition)
[15:31:13.375]                           }
[15:31:13.375]                         }
[15:31:13.375]                         frame <- frame + 1L
[15:31:13.375]                         envir <- sys.frame(frame)
[15:31:13.375]                       }
[15:31:13.375]                     }
[15:31:13.375]                     sendCondition <<- function(cond) NULL
[15:31:13.375]                   }
[15:31:13.375]                 })
[15:31:13.375]                 withCallingHandlers({
[15:31:13.375]                   {
[15:31:13.375]                     do.call(function(...) {
[15:31:13.375]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.375]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.375]                         ...future.globals.maxSize)) {
[15:31:13.375]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.375]                         on.exit(options(oopts), add = TRUE)
[15:31:13.375]                       }
[15:31:13.375]                       {
[15:31:13.375]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.375]                           FUN = function(jj) {
[15:31:13.375]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.375]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.375]                           })
[15:31:13.375]                       }
[15:31:13.375]                     }, args = future.call.arguments)
[15:31:13.375]                   }
[15:31:13.375]                 }, immediateCondition = function(cond) {
[15:31:13.375]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.375]                   sendCondition(cond)
[15:31:13.375]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.375]                   {
[15:31:13.375]                     inherits <- base::inherits
[15:31:13.375]                     invokeRestart <- base::invokeRestart
[15:31:13.375]                     is.null <- base::is.null
[15:31:13.375]                     muffled <- FALSE
[15:31:13.375]                     if (inherits(cond, "message")) {
[15:31:13.375]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.375]                       if (muffled) 
[15:31:13.375]                         invokeRestart("muffleMessage")
[15:31:13.375]                     }
[15:31:13.375]                     else if (inherits(cond, "warning")) {
[15:31:13.375]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.375]                       if (muffled) 
[15:31:13.375]                         invokeRestart("muffleWarning")
[15:31:13.375]                     }
[15:31:13.375]                     else if (inherits(cond, "condition")) {
[15:31:13.375]                       if (!is.null(pattern)) {
[15:31:13.375]                         computeRestarts <- base::computeRestarts
[15:31:13.375]                         grepl <- base::grepl
[15:31:13.375]                         restarts <- computeRestarts(cond)
[15:31:13.375]                         for (restart in restarts) {
[15:31:13.375]                           name <- restart$name
[15:31:13.375]                           if (is.null(name)) 
[15:31:13.375]                             next
[15:31:13.375]                           if (!grepl(pattern, name)) 
[15:31:13.375]                             next
[15:31:13.375]                           invokeRestart(restart)
[15:31:13.375]                           muffled <- TRUE
[15:31:13.375]                           break
[15:31:13.375]                         }
[15:31:13.375]                       }
[15:31:13.375]                     }
[15:31:13.375]                     invisible(muffled)
[15:31:13.375]                   }
[15:31:13.375]                   muffleCondition(cond)
[15:31:13.375]                 })
[15:31:13.375]             }))
[15:31:13.375]             future::FutureResult(value = ...future.value$value, 
[15:31:13.375]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.375]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.375]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.375]                     ...future.globalenv.names))
[15:31:13.375]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.375]         }, condition = base::local({
[15:31:13.375]             c <- base::c
[15:31:13.375]             inherits <- base::inherits
[15:31:13.375]             invokeRestart <- base::invokeRestart
[15:31:13.375]             length <- base::length
[15:31:13.375]             list <- base::list
[15:31:13.375]             seq.int <- base::seq.int
[15:31:13.375]             signalCondition <- base::signalCondition
[15:31:13.375]             sys.calls <- base::sys.calls
[15:31:13.375]             `[[` <- base::`[[`
[15:31:13.375]             `+` <- base::`+`
[15:31:13.375]             `<<-` <- base::`<<-`
[15:31:13.375]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.375]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.375]                   3L)]
[15:31:13.375]             }
[15:31:13.375]             function(cond) {
[15:31:13.375]                 is_error <- inherits(cond, "error")
[15:31:13.375]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.375]                   NULL)
[15:31:13.375]                 if (is_error) {
[15:31:13.375]                   sessionInformation <- function() {
[15:31:13.375]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.375]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.375]                       search = base::search(), system = base::Sys.info())
[15:31:13.375]                   }
[15:31:13.375]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.375]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.375]                     cond$call), session = sessionInformation(), 
[15:31:13.375]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.375]                   signalCondition(cond)
[15:31:13.375]                 }
[15:31:13.375]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.375]                 "immediateCondition"))) {
[15:31:13.375]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.375]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.375]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.375]                   if (TRUE && !signal) {
[15:31:13.375]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.375]                     {
[15:31:13.375]                       inherits <- base::inherits
[15:31:13.375]                       invokeRestart <- base::invokeRestart
[15:31:13.375]                       is.null <- base::is.null
[15:31:13.375]                       muffled <- FALSE
[15:31:13.375]                       if (inherits(cond, "message")) {
[15:31:13.375]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.375]                         if (muffled) 
[15:31:13.375]                           invokeRestart("muffleMessage")
[15:31:13.375]                       }
[15:31:13.375]                       else if (inherits(cond, "warning")) {
[15:31:13.375]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.375]                         if (muffled) 
[15:31:13.375]                           invokeRestart("muffleWarning")
[15:31:13.375]                       }
[15:31:13.375]                       else if (inherits(cond, "condition")) {
[15:31:13.375]                         if (!is.null(pattern)) {
[15:31:13.375]                           computeRestarts <- base::computeRestarts
[15:31:13.375]                           grepl <- base::grepl
[15:31:13.375]                           restarts <- computeRestarts(cond)
[15:31:13.375]                           for (restart in restarts) {
[15:31:13.375]                             name <- restart$name
[15:31:13.375]                             if (is.null(name)) 
[15:31:13.375]                               next
[15:31:13.375]                             if (!grepl(pattern, name)) 
[15:31:13.375]                               next
[15:31:13.375]                             invokeRestart(restart)
[15:31:13.375]                             muffled <- TRUE
[15:31:13.375]                             break
[15:31:13.375]                           }
[15:31:13.375]                         }
[15:31:13.375]                       }
[15:31:13.375]                       invisible(muffled)
[15:31:13.375]                     }
[15:31:13.375]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.375]                   }
[15:31:13.375]                 }
[15:31:13.375]                 else {
[15:31:13.375]                   if (TRUE) {
[15:31:13.375]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.375]                     {
[15:31:13.375]                       inherits <- base::inherits
[15:31:13.375]                       invokeRestart <- base::invokeRestart
[15:31:13.375]                       is.null <- base::is.null
[15:31:13.375]                       muffled <- FALSE
[15:31:13.375]                       if (inherits(cond, "message")) {
[15:31:13.375]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.375]                         if (muffled) 
[15:31:13.375]                           invokeRestart("muffleMessage")
[15:31:13.375]                       }
[15:31:13.375]                       else if (inherits(cond, "warning")) {
[15:31:13.375]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.375]                         if (muffled) 
[15:31:13.375]                           invokeRestart("muffleWarning")
[15:31:13.375]                       }
[15:31:13.375]                       else if (inherits(cond, "condition")) {
[15:31:13.375]                         if (!is.null(pattern)) {
[15:31:13.375]                           computeRestarts <- base::computeRestarts
[15:31:13.375]                           grepl <- base::grepl
[15:31:13.375]                           restarts <- computeRestarts(cond)
[15:31:13.375]                           for (restart in restarts) {
[15:31:13.375]                             name <- restart$name
[15:31:13.375]                             if (is.null(name)) 
[15:31:13.375]                               next
[15:31:13.375]                             if (!grepl(pattern, name)) 
[15:31:13.375]                               next
[15:31:13.375]                             invokeRestart(restart)
[15:31:13.375]                             muffled <- TRUE
[15:31:13.375]                             break
[15:31:13.375]                           }
[15:31:13.375]                         }
[15:31:13.375]                       }
[15:31:13.375]                       invisible(muffled)
[15:31:13.375]                     }
[15:31:13.375]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.375]                   }
[15:31:13.375]                 }
[15:31:13.375]             }
[15:31:13.375]         }))
[15:31:13.375]     }, error = function(ex) {
[15:31:13.375]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.375]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.375]                 ...future.rng), started = ...future.startTime, 
[15:31:13.375]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.375]             version = "1.8"), class = "FutureResult")
[15:31:13.375]     }, finally = {
[15:31:13.375]         if (!identical(...future.workdir, getwd())) 
[15:31:13.375]             setwd(...future.workdir)
[15:31:13.375]         {
[15:31:13.375]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.375]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.375]             }
[15:31:13.375]             base::options(...future.oldOptions)
[15:31:13.375]             if (.Platform$OS.type == "windows") {
[15:31:13.375]                 old_names <- names(...future.oldEnvVars)
[15:31:13.375]                 envs <- base::Sys.getenv()
[15:31:13.375]                 names <- names(envs)
[15:31:13.375]                 common <- intersect(names, old_names)
[15:31:13.375]                 added <- setdiff(names, old_names)
[15:31:13.375]                 removed <- setdiff(old_names, names)
[15:31:13.375]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.375]                   envs[common]]
[15:31:13.375]                 NAMES <- toupper(changed)
[15:31:13.375]                 args <- list()
[15:31:13.375]                 for (kk in seq_along(NAMES)) {
[15:31:13.375]                   name <- changed[[kk]]
[15:31:13.375]                   NAME <- NAMES[[kk]]
[15:31:13.375]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.375]                     next
[15:31:13.375]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.375]                 }
[15:31:13.375]                 NAMES <- toupper(added)
[15:31:13.375]                 for (kk in seq_along(NAMES)) {
[15:31:13.375]                   name <- added[[kk]]
[15:31:13.375]                   NAME <- NAMES[[kk]]
[15:31:13.375]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.375]                     next
[15:31:13.375]                   args[[name]] <- ""
[15:31:13.375]                 }
[15:31:13.375]                 NAMES <- toupper(removed)
[15:31:13.375]                 for (kk in seq_along(NAMES)) {
[15:31:13.375]                   name <- removed[[kk]]
[15:31:13.375]                   NAME <- NAMES[[kk]]
[15:31:13.375]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.375]                     next
[15:31:13.375]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.375]                 }
[15:31:13.375]                 if (length(args) > 0) 
[15:31:13.375]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.375]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.375]             }
[15:31:13.375]             else {
[15:31:13.375]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.375]             }
[15:31:13.375]             {
[15:31:13.375]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.375]                   0L) {
[15:31:13.375]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.375]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.375]                   base::options(opts)
[15:31:13.375]                 }
[15:31:13.375]                 {
[15:31:13.375]                   {
[15:31:13.375]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.375]                     NULL
[15:31:13.375]                   }
[15:31:13.375]                   options(future.plan = NULL)
[15:31:13.375]                   if (is.na(NA_character_)) 
[15:31:13.375]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.375]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.375]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.375]                     .init = FALSE)
[15:31:13.375]                 }
[15:31:13.375]             }
[15:31:13.375]         }
[15:31:13.375]     })
[15:31:13.375]     if (TRUE) {
[15:31:13.375]         base::sink(type = "output", split = FALSE)
[15:31:13.375]         if (TRUE) {
[15:31:13.375]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.375]         }
[15:31:13.375]         else {
[15:31:13.375]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.375]         }
[15:31:13.375]         base::close(...future.stdout)
[15:31:13.375]         ...future.stdout <- NULL
[15:31:13.375]     }
[15:31:13.375]     ...future.result$conditions <- ...future.conditions
[15:31:13.375]     ...future.result$finished <- base::Sys.time()
[15:31:13.375]     ...future.result
[15:31:13.375] }
[15:31:13.382] Exporting 5 global objects (5.26 KiB) to cluster node #1 ...
[15:31:13.382] Exporting '...future.FUN' (5.20 KiB) to cluster node #1 ...
[15:31:13.383] Exporting '...future.FUN' (5.20 KiB) to cluster node #1 ... DONE
[15:31:13.383] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ...
[15:31:13.383] Exporting 'future.call.arguments' (56 bytes) to cluster node #1 ... DONE
[15:31:13.384] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ...
[15:31:13.384] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ... DONE
[15:31:13.385] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.385] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.385] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.386] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.386] Exporting 5 global objects (5.26 KiB) to cluster node #1 ... DONE
[15:31:13.387] MultisessionFuture started
[15:31:13.387] - Launch lazy future ... done
[15:31:13.387] run() for 'MultisessionFuture' ... done
[15:31:13.388] Created future:
[15:31:13.408] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.408] - Validating connection of MultisessionFuture
[15:31:13.409] - received message: FutureResult
[15:31:13.409] - Received FutureResult
[15:31:13.410] - Erased future from FutureRegistry
[15:31:13.410] result() for ClusterFuture ...
[15:31:13.410] - result already collected: FutureResult
[15:31:13.411] result() for ClusterFuture ... done
[15:31:13.411] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.388] MultisessionFuture:
[15:31:13.388] Label: 'future_by-2'
[15:31:13.388] Expression:
[15:31:13.388] {
[15:31:13.388]     do.call(function(...) {
[15:31:13.388]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.388]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.388]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.388]             on.exit(options(oopts), add = TRUE)
[15:31:13.388]         }
[15:31:13.388]         {
[15:31:13.388]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.388]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.388]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.388]             })
[15:31:13.388]         }
[15:31:13.388]     }, args = future.call.arguments)
[15:31:13.388] }
[15:31:13.388] Lazy evaluation: FALSE
[15:31:13.388] Asynchronous evaluation: TRUE
[15:31:13.388] Local evaluation: TRUE
[15:31:13.388] Environment: R_GlobalEnv
[15:31:13.388] Capture standard output: TRUE
[15:31:13.388] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.388] Globals: 5 objects totaling 8.46 KiB (function '...future.FUN' of 5.20 KiB, DotDotDotList 'future.call.arguments' of 56 bytes, list '...future.elements_ii' of 3.20 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.388] Packages: 1 packages ('stats')
[15:31:13.388] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.388] Resolved: TRUE
[15:31:13.388] Value: <not collected>
[15:31:13.388] Conditions captured: <none>
[15:31:13.388] Early signaling: FALSE
[15:31:13.388] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.388] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.412] Chunk #2 of 2 ... DONE
[15:31:13.412] Launching 2 futures (chunks) ... DONE
[15:31:13.412] Resolving 2 futures (chunks) ...
[15:31:13.413] resolve() on list ...
[15:31:13.413]  recursive: 0
[15:31:13.413]  length: 2
[15:31:13.413] 
[15:31:13.414] Future #1
[15:31:13.414] result() for ClusterFuture ...
[15:31:13.414] - result already collected: FutureResult
[15:31:13.414] result() for ClusterFuture ... done
[15:31:13.414] result() for ClusterFuture ...
[15:31:13.415] - result already collected: FutureResult
[15:31:13.415] result() for ClusterFuture ... done
[15:31:13.415] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:13.416] - nx: 2
[15:31:13.416] - relay: TRUE
[15:31:13.416] - stdout: TRUE
[15:31:13.416] - signal: TRUE
[15:31:13.417] - resignal: FALSE
[15:31:13.417] - force: TRUE
[15:31:13.417] - relayed: [n=2] FALSE, FALSE
[15:31:13.417] - queued futures: [n=2] FALSE, FALSE
[15:31:13.418]  - until=1
[15:31:13.418]  - relaying element #1
[15:31:13.418] result() for ClusterFuture ...
[15:31:13.418] - result already collected: FutureResult
[15:31:13.418] result() for ClusterFuture ... done
[15:31:13.419] result() for ClusterFuture ...
[15:31:13.419] - result already collected: FutureResult
[15:31:13.419] result() for ClusterFuture ... done
[15:31:13.419] result() for ClusterFuture ...
[15:31:13.419] - result already collected: FutureResult
[15:31:13.420] result() for ClusterFuture ... done
[15:31:13.420] result() for ClusterFuture ...
[15:31:13.420] - result already collected: FutureResult
[15:31:13.420] result() for ClusterFuture ... done
[15:31:13.420] - relayed: [n=2] TRUE, FALSE
[15:31:13.421] - queued futures: [n=2] TRUE, FALSE
[15:31:13.421] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:13.421]  length: 1 (resolved future 1)
[15:31:13.422] Future #2
[15:31:13.422] result() for ClusterFuture ...
[15:31:13.422] - result already collected: FutureResult
[15:31:13.422] result() for ClusterFuture ... done
[15:31:13.422] result() for ClusterFuture ...
[15:31:13.423] - result already collected: FutureResult
[15:31:13.423] result() for ClusterFuture ... done
[15:31:13.423] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:13.423] - nx: 2
[15:31:13.423] - relay: TRUE
[15:31:13.424] - stdout: TRUE
[15:31:13.424] - signal: TRUE
[15:31:13.424] - resignal: FALSE
[15:31:13.425] - force: TRUE
[15:31:13.425] - relayed: [n=2] TRUE, FALSE
[15:31:13.425] - queued futures: [n=2] TRUE, FALSE
[15:31:13.426]  - until=2
[15:31:13.426]  - relaying element #2
[15:31:13.426] result() for ClusterFuture ...
[15:31:13.426] - result already collected: FutureResult
[15:31:13.427] result() for ClusterFuture ... done
[15:31:13.427] result() for ClusterFuture ...
[15:31:13.427] - result already collected: FutureResult
[15:31:13.428] result() for ClusterFuture ... done
[15:31:13.428] result() for ClusterFuture ...
[15:31:13.428] - result already collected: FutureResult
[15:31:13.429] result() for ClusterFuture ... done
[15:31:13.429] result() for ClusterFuture ...
[15:31:13.429] - result already collected: FutureResult
[15:31:13.430] result() for ClusterFuture ... done
[15:31:13.430] - relayed: [n=2] TRUE, TRUE
[15:31:13.430] - queued futures: [n=2] TRUE, TRUE
[15:31:13.431] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:13.431]  length: 0 (resolved future 2)
[15:31:13.431] Relaying remaining futures
[15:31:13.432] signalConditionsASAP(NULL, pos=0) ...
[15:31:13.432] - nx: 2
[15:31:13.432] - relay: TRUE
[15:31:13.432] - stdout: TRUE
[15:31:13.433] - signal: TRUE
[15:31:13.433] - resignal: FALSE
[15:31:13.433] - force: TRUE
[15:31:13.434] - relayed: [n=2] TRUE, TRUE
[15:31:13.434] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:13.434] - relayed: [n=2] TRUE, TRUE
[15:31:13.435] - queued futures: [n=2] TRUE, TRUE
[15:31:13.435] signalConditionsASAP(NULL, pos=0) ... done
[15:31:13.435] resolve() on list ... DONE
[15:31:13.436] result() for ClusterFuture ...
[15:31:13.436] - result already collected: FutureResult
[15:31:13.436] result() for ClusterFuture ... done
[15:31:13.436] result() for ClusterFuture ...
[15:31:13.437] - result already collected: FutureResult
[15:31:13.437] result() for ClusterFuture ... done
[15:31:13.437] result() for ClusterFuture ...
[15:31:13.438] - result already collected: FutureResult
[15:31:13.438] result() for ClusterFuture ... done
[15:31:13.438] result() for ClusterFuture ...
[15:31:13.439] - result already collected: FutureResult
[15:31:13.439] result() for ClusterFuture ... done
[15:31:13.439]  - Number of value chunks collected: 2
[15:31:13.439] Resolving 2 futures (chunks) ... DONE
[15:31:13.440] Reducing values from 2 chunks ...
[15:31:13.440]  - Number of values collected after concatenation: 3
[15:31:13.440]  - Number of values expected: 3
[15:31:13.441] Reducing values from 2 chunks ... DONE
[15:31:13.441] future_lapply() ... DONE
[15:31:13.441] future_by_internal() ... DONE
[15:31:13.450] future_by_internal() ...
[15:31:13.451] future_lapply() ...
[15:31:13.455] Number of chunks: 2
[15:31:13.455] getGlobalsAndPackagesXApply() ...
[15:31:13.456]  - future.globals: TRUE
[15:31:13.456] getGlobalsAndPackages() ...
[15:31:13.456] Searching for globals...
[15:31:13.460] - globals found: [6] 'FUN', '{', 'lm', '~', 'breaks', 'wool'
[15:31:13.460] Searching for globals ... DONE
[15:31:13.460] Resolving globals: FALSE
[15:31:13.461] The total size of the 3 globals is 2.27 KiB (2320 bytes)
[15:31:13.462] The total size of the 3 globals exported for future expression ('FUN()') is 2.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'FUN' (1.04 KiB of class 'function'), 'wool' (776 bytes of class 'numeric') and 'breaks' (480 bytes of class 'numeric')
[15:31:13.463] - globals: [3] 'FUN', 'breaks', 'wool'
[15:31:13.463] - packages: [1] 'stats'
[15:31:13.463] getGlobalsAndPackages() ... DONE
[15:31:13.464]  - globals found/used: [n=3] 'FUN', 'breaks', 'wool'
[15:31:13.464]  - needed namespaces: [n=1] 'stats'
[15:31:13.464] Finding globals ... DONE
[15:31:13.464]  - use_args: TRUE
[15:31:13.464]  - Getting '...' globals ...
[15:31:13.465] resolve() on list ...
[15:31:13.465]  recursive: 0
[15:31:13.466]  length: 1
[15:31:13.466]  elements: '...'
[15:31:13.466]  length: 0 (resolved future 1)
[15:31:13.467] resolve() on list ... DONE
[15:31:13.467]    - '...' content: [n=0] 
[15:31:13.467] List of 1
[15:31:13.467]  $ ...: list()
[15:31:13.467]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.467]  - attr(*, "where")=List of 1
[15:31:13.467]   ..$ ...:<environment: 0x0000019c82e0b258> 
[15:31:13.467]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.467]  - attr(*, "resolved")= logi TRUE
[15:31:13.467]  - attr(*, "total_size")= num NA
[15:31:13.472]  - Getting '...' globals ... DONE
[15:31:13.472] Globals to be used in all futures (chunks): [n=4] '...future.FUN', 'breaks', 'wool', '...'
[15:31:13.472] List of 4
[15:31:13.472]  $ ...future.FUN:function (x)  
[15:31:13.472]  $ breaks       : num [1:54] 26 30 54 25 70 52 51 26 67 18 ...
[15:31:13.472]  $ wool         : Factor w/ 2 levels "A","B": 1 1 1 1 1 1 1 1 1 1 ...
[15:31:13.472]  $ ...          : list()
[15:31:13.472]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.472]  - attr(*, "where")=List of 4
[15:31:13.472]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:13.472]   ..$ breaks       :<environment: R_EmptyEnv> 
[15:31:13.472]   ..$ wool         :<environment: R_EmptyEnv> 
[15:31:13.472]   ..$ ...          :<environment: 0x0000019c82e0b258> 
[15:31:13.472]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.472]  - attr(*, "resolved")= logi FALSE
[15:31:13.472]  - attr(*, "total_size")= num 2320
[15:31:13.477] Packages to be attached in all futures: [n=1] 'stats'
[15:31:13.478] getGlobalsAndPackagesXApply() ... DONE
[15:31:13.478] Number of futures (= number of chunks): 2
[15:31:13.478] Launching 2 futures (chunks) ...
[15:31:13.478] Chunk #1 of 2 ...
[15:31:13.479]  - Finding globals in 'X' for chunk #1 ...
[15:31:13.479] getGlobalsAndPackages() ...
[15:31:13.479] Searching for globals...
[15:31:13.479] 
[15:31:13.480] Searching for globals ... DONE
[15:31:13.480] - globals: [0] <none>
[15:31:13.480] getGlobalsAndPackages() ... DONE
[15:31:13.480]    + additional globals found: [n=0] 
[15:31:13.480]    + additional namespaces needed: [n=0] 
[15:31:13.481]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:13.481]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.481]  - seeds: <none>
[15:31:13.481]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.481] getGlobalsAndPackages() ...
[15:31:13.482] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.482] Resolving globals: FALSE
[15:31:13.482] Tweak future expression to call with '...' arguments ...
[15:31:13.483] {
[15:31:13.483]     do.call(function(...) {
[15:31:13.483]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.483]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.483]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.483]             on.exit(options(oopts), add = TRUE)
[15:31:13.483]         }
[15:31:13.483]         {
[15:31:13.483]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.483]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.483]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.483]             })
[15:31:13.483]         }
[15:31:13.483]     }, args = future.call.arguments)
[15:31:13.483] }
[15:31:13.483] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.484] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.485] 
[15:31:13.485] getGlobalsAndPackages() ... DONE
[15:31:13.486] run() for 'Future' ...
[15:31:13.486] - state: 'created'
[15:31:13.486] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.504] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.504] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.505]   - Field: 'node'
[15:31:13.505]   - Field: 'label'
[15:31:13.505]   - Field: 'local'
[15:31:13.506]   - Field: 'owner'
[15:31:13.506]   - Field: 'envir'
[15:31:13.506]   - Field: 'workers'
[15:31:13.507]   - Field: 'packages'
[15:31:13.507]   - Field: 'gc'
[15:31:13.507]   - Field: 'conditions'
[15:31:13.507]   - Field: 'persistent'
[15:31:13.508]   - Field: 'expr'
[15:31:13.508]   - Field: 'uuid'
[15:31:13.508]   - Field: 'seed'
[15:31:13.508]   - Field: 'version'
[15:31:13.509]   - Field: 'result'
[15:31:13.509]   - Field: 'asynchronous'
[15:31:13.509]   - Field: 'calls'
[15:31:13.510]   - Field: 'globals'
[15:31:13.510]   - Field: 'stdout'
[15:31:13.510]   - Field: 'earlySignal'
[15:31:13.511]   - Field: 'lazy'
[15:31:13.511]   - Field: 'state'
[15:31:13.511] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.511] - Launch lazy future ...
[15:31:13.512] Packages needed by the future expression (n = 1): 'stats'
[15:31:13.512] Packages needed by future strategies (n = 0): <none>
[15:31:13.513] {
[15:31:13.513]     {
[15:31:13.513]         {
[15:31:13.513]             ...future.startTime <- base::Sys.time()
[15:31:13.513]             {
[15:31:13.513]                 {
[15:31:13.513]                   {
[15:31:13.513]                     {
[15:31:13.513]                       {
[15:31:13.513]                         base::local({
[15:31:13.513]                           has_future <- base::requireNamespace("future", 
[15:31:13.513]                             quietly = TRUE)
[15:31:13.513]                           if (has_future) {
[15:31:13.513]                             ns <- base::getNamespace("future")
[15:31:13.513]                             version <- ns[[".package"]][["version"]]
[15:31:13.513]                             if (is.null(version)) 
[15:31:13.513]                               version <- utils::packageVersion("future")
[15:31:13.513]                           }
[15:31:13.513]                           else {
[15:31:13.513]                             version <- NULL
[15:31:13.513]                           }
[15:31:13.513]                           if (!has_future || version < "1.8.0") {
[15:31:13.513]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.513]                               "", base::R.version$version.string), 
[15:31:13.513]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:13.513]                                 base::R.version$platform, 8 * 
[15:31:13.513]                                   base::.Machine$sizeof.pointer), 
[15:31:13.513]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.513]                                 "release", "version")], collapse = " "), 
[15:31:13.513]                               hostname = base::Sys.info()[["nodename"]])
[15:31:13.513]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.513]                               info)
[15:31:13.513]                             info <- base::paste(info, collapse = "; ")
[15:31:13.513]                             if (!has_future) {
[15:31:13.513]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.513]                                 info)
[15:31:13.513]                             }
[15:31:13.513]                             else {
[15:31:13.513]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.513]                                 info, version)
[15:31:13.513]                             }
[15:31:13.513]                             base::stop(msg)
[15:31:13.513]                           }
[15:31:13.513]                         })
[15:31:13.513]                       }
[15:31:13.513]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.513]                       base::options(mc.cores = 1L)
[15:31:13.513]                     }
[15:31:13.513]                     base::local({
[15:31:13.513]                       for (pkg in "stats") {
[15:31:13.513]                         base::loadNamespace(pkg)
[15:31:13.513]                         base::library(pkg, character.only = TRUE)
[15:31:13.513]                       }
[15:31:13.513]                     })
[15:31:13.513]                   }
[15:31:13.513]                   ...future.strategy.old <- future::plan("list")
[15:31:13.513]                   options(future.plan = NULL)
[15:31:13.513]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.513]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.513]                 }
[15:31:13.513]                 ...future.workdir <- getwd()
[15:31:13.513]             }
[15:31:13.513]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.513]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.513]         }
[15:31:13.513]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.513]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.513]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.513]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.513]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.513]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.513]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.513]             base::names(...future.oldOptions))
[15:31:13.513]     }
[15:31:13.513]     if (FALSE) {
[15:31:13.513]     }
[15:31:13.513]     else {
[15:31:13.513]         if (TRUE) {
[15:31:13.513]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.513]                 open = "w")
[15:31:13.513]         }
[15:31:13.513]         else {
[15:31:13.513]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.513]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.513]         }
[15:31:13.513]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.513]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.513]             base::sink(type = "output", split = FALSE)
[15:31:13.513]             base::close(...future.stdout)
[15:31:13.513]         }, add = TRUE)
[15:31:13.513]     }
[15:31:13.513]     ...future.frame <- base::sys.nframe()
[15:31:13.513]     ...future.conditions <- base::list()
[15:31:13.513]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.513]     if (FALSE) {
[15:31:13.513]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.513]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.513]     }
[15:31:13.513]     ...future.result <- base::tryCatch({
[15:31:13.513]         base::withCallingHandlers({
[15:31:13.513]             ...future.value <- base::withVisible(base::local({
[15:31:13.513]                 ...future.makeSendCondition <- base::local({
[15:31:13.513]                   sendCondition <- NULL
[15:31:13.513]                   function(frame = 1L) {
[15:31:13.513]                     if (is.function(sendCondition)) 
[15:31:13.513]                       return(sendCondition)
[15:31:13.513]                     ns <- getNamespace("parallel")
[15:31:13.513]                     if (exists("sendData", mode = "function", 
[15:31:13.513]                       envir = ns)) {
[15:31:13.513]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.513]                         envir = ns)
[15:31:13.513]                       envir <- sys.frame(frame)
[15:31:13.513]                       master <- NULL
[15:31:13.513]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.513]                         !identical(envir, emptyenv())) {
[15:31:13.513]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.513]                           inherits = FALSE)) {
[15:31:13.513]                           master <- get("master", mode = "list", 
[15:31:13.513]                             envir = envir, inherits = FALSE)
[15:31:13.513]                           if (inherits(master, c("SOCKnode", 
[15:31:13.513]                             "SOCK0node"))) {
[15:31:13.513]                             sendCondition <<- function(cond) {
[15:31:13.513]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.513]                                 success = TRUE)
[15:31:13.513]                               parallel_sendData(master, data)
[15:31:13.513]                             }
[15:31:13.513]                             return(sendCondition)
[15:31:13.513]                           }
[15:31:13.513]                         }
[15:31:13.513]                         frame <- frame + 1L
[15:31:13.513]                         envir <- sys.frame(frame)
[15:31:13.513]                       }
[15:31:13.513]                     }
[15:31:13.513]                     sendCondition <<- function(cond) NULL
[15:31:13.513]                   }
[15:31:13.513]                 })
[15:31:13.513]                 withCallingHandlers({
[15:31:13.513]                   {
[15:31:13.513]                     do.call(function(...) {
[15:31:13.513]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.513]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.513]                         ...future.globals.maxSize)) {
[15:31:13.513]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.513]                         on.exit(options(oopts), add = TRUE)
[15:31:13.513]                       }
[15:31:13.513]                       {
[15:31:13.513]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.513]                           FUN = function(jj) {
[15:31:13.513]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.513]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.513]                           })
[15:31:13.513]                       }
[15:31:13.513]                     }, args = future.call.arguments)
[15:31:13.513]                   }
[15:31:13.513]                 }, immediateCondition = function(cond) {
[15:31:13.513]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.513]                   sendCondition(cond)
[15:31:13.513]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.513]                   {
[15:31:13.513]                     inherits <- base::inherits
[15:31:13.513]                     invokeRestart <- base::invokeRestart
[15:31:13.513]                     is.null <- base::is.null
[15:31:13.513]                     muffled <- FALSE
[15:31:13.513]                     if (inherits(cond, "message")) {
[15:31:13.513]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.513]                       if (muffled) 
[15:31:13.513]                         invokeRestart("muffleMessage")
[15:31:13.513]                     }
[15:31:13.513]                     else if (inherits(cond, "warning")) {
[15:31:13.513]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.513]                       if (muffled) 
[15:31:13.513]                         invokeRestart("muffleWarning")
[15:31:13.513]                     }
[15:31:13.513]                     else if (inherits(cond, "condition")) {
[15:31:13.513]                       if (!is.null(pattern)) {
[15:31:13.513]                         computeRestarts <- base::computeRestarts
[15:31:13.513]                         grepl <- base::grepl
[15:31:13.513]                         restarts <- computeRestarts(cond)
[15:31:13.513]                         for (restart in restarts) {
[15:31:13.513]                           name <- restart$name
[15:31:13.513]                           if (is.null(name)) 
[15:31:13.513]                             next
[15:31:13.513]                           if (!grepl(pattern, name)) 
[15:31:13.513]                             next
[15:31:13.513]                           invokeRestart(restart)
[15:31:13.513]                           muffled <- TRUE
[15:31:13.513]                           break
[15:31:13.513]                         }
[15:31:13.513]                       }
[15:31:13.513]                     }
[15:31:13.513]                     invisible(muffled)
[15:31:13.513]                   }
[15:31:13.513]                   muffleCondition(cond)
[15:31:13.513]                 })
[15:31:13.513]             }))
[15:31:13.513]             future::FutureResult(value = ...future.value$value, 
[15:31:13.513]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.513]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.513]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.513]                     ...future.globalenv.names))
[15:31:13.513]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.513]         }, condition = base::local({
[15:31:13.513]             c <- base::c
[15:31:13.513]             inherits <- base::inherits
[15:31:13.513]             invokeRestart <- base::invokeRestart
[15:31:13.513]             length <- base::length
[15:31:13.513]             list <- base::list
[15:31:13.513]             seq.int <- base::seq.int
[15:31:13.513]             signalCondition <- base::signalCondition
[15:31:13.513]             sys.calls <- base::sys.calls
[15:31:13.513]             `[[` <- base::`[[`
[15:31:13.513]             `+` <- base::`+`
[15:31:13.513]             `<<-` <- base::`<<-`
[15:31:13.513]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.513]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.513]                   3L)]
[15:31:13.513]             }
[15:31:13.513]             function(cond) {
[15:31:13.513]                 is_error <- inherits(cond, "error")
[15:31:13.513]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.513]                   NULL)
[15:31:13.513]                 if (is_error) {
[15:31:13.513]                   sessionInformation <- function() {
[15:31:13.513]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.513]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.513]                       search = base::search(), system = base::Sys.info())
[15:31:13.513]                   }
[15:31:13.513]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.513]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.513]                     cond$call), session = sessionInformation(), 
[15:31:13.513]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.513]                   signalCondition(cond)
[15:31:13.513]                 }
[15:31:13.513]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.513]                 "immediateCondition"))) {
[15:31:13.513]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.513]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.513]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.513]                   if (TRUE && !signal) {
[15:31:13.513]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.513]                     {
[15:31:13.513]                       inherits <- base::inherits
[15:31:13.513]                       invokeRestart <- base::invokeRestart
[15:31:13.513]                       is.null <- base::is.null
[15:31:13.513]                       muffled <- FALSE
[15:31:13.513]                       if (inherits(cond, "message")) {
[15:31:13.513]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.513]                         if (muffled) 
[15:31:13.513]                           invokeRestart("muffleMessage")
[15:31:13.513]                       }
[15:31:13.513]                       else if (inherits(cond, "warning")) {
[15:31:13.513]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.513]                         if (muffled) 
[15:31:13.513]                           invokeRestart("muffleWarning")
[15:31:13.513]                       }
[15:31:13.513]                       else if (inherits(cond, "condition")) {
[15:31:13.513]                         if (!is.null(pattern)) {
[15:31:13.513]                           computeRestarts <- base::computeRestarts
[15:31:13.513]                           grepl <- base::grepl
[15:31:13.513]                           restarts <- computeRestarts(cond)
[15:31:13.513]                           for (restart in restarts) {
[15:31:13.513]                             name <- restart$name
[15:31:13.513]                             if (is.null(name)) 
[15:31:13.513]                               next
[15:31:13.513]                             if (!grepl(pattern, name)) 
[15:31:13.513]                               next
[15:31:13.513]                             invokeRestart(restart)
[15:31:13.513]                             muffled <- TRUE
[15:31:13.513]                             break
[15:31:13.513]                           }
[15:31:13.513]                         }
[15:31:13.513]                       }
[15:31:13.513]                       invisible(muffled)
[15:31:13.513]                     }
[15:31:13.513]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.513]                   }
[15:31:13.513]                 }
[15:31:13.513]                 else {
[15:31:13.513]                   if (TRUE) {
[15:31:13.513]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.513]                     {
[15:31:13.513]                       inherits <- base::inherits
[15:31:13.513]                       invokeRestart <- base::invokeRestart
[15:31:13.513]                       is.null <- base::is.null
[15:31:13.513]                       muffled <- FALSE
[15:31:13.513]                       if (inherits(cond, "message")) {
[15:31:13.513]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.513]                         if (muffled) 
[15:31:13.513]                           invokeRestart("muffleMessage")
[15:31:13.513]                       }
[15:31:13.513]                       else if (inherits(cond, "warning")) {
[15:31:13.513]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.513]                         if (muffled) 
[15:31:13.513]                           invokeRestart("muffleWarning")
[15:31:13.513]                       }
[15:31:13.513]                       else if (inherits(cond, "condition")) {
[15:31:13.513]                         if (!is.null(pattern)) {
[15:31:13.513]                           computeRestarts <- base::computeRestarts
[15:31:13.513]                           grepl <- base::grepl
[15:31:13.513]                           restarts <- computeRestarts(cond)
[15:31:13.513]                           for (restart in restarts) {
[15:31:13.513]                             name <- restart$name
[15:31:13.513]                             if (is.null(name)) 
[15:31:13.513]                               next
[15:31:13.513]                             if (!grepl(pattern, name)) 
[15:31:13.513]                               next
[15:31:13.513]                             invokeRestart(restart)
[15:31:13.513]                             muffled <- TRUE
[15:31:13.513]                             break
[15:31:13.513]                           }
[15:31:13.513]                         }
[15:31:13.513]                       }
[15:31:13.513]                       invisible(muffled)
[15:31:13.513]                     }
[15:31:13.513]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.513]                   }
[15:31:13.513]                 }
[15:31:13.513]             }
[15:31:13.513]         }))
[15:31:13.513]     }, error = function(ex) {
[15:31:13.513]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.513]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.513]                 ...future.rng), started = ...future.startTime, 
[15:31:13.513]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.513]             version = "1.8"), class = "FutureResult")
[15:31:13.513]     }, finally = {
[15:31:13.513]         if (!identical(...future.workdir, getwd())) 
[15:31:13.513]             setwd(...future.workdir)
[15:31:13.513]         {
[15:31:13.513]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.513]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.513]             }
[15:31:13.513]             base::options(...future.oldOptions)
[15:31:13.513]             if (.Platform$OS.type == "windows") {
[15:31:13.513]                 old_names <- names(...future.oldEnvVars)
[15:31:13.513]                 envs <- base::Sys.getenv()
[15:31:13.513]                 names <- names(envs)
[15:31:13.513]                 common <- intersect(names, old_names)
[15:31:13.513]                 added <- setdiff(names, old_names)
[15:31:13.513]                 removed <- setdiff(old_names, names)
[15:31:13.513]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.513]                   envs[common]]
[15:31:13.513]                 NAMES <- toupper(changed)
[15:31:13.513]                 args <- list()
[15:31:13.513]                 for (kk in seq_along(NAMES)) {
[15:31:13.513]                   name <- changed[[kk]]
[15:31:13.513]                   NAME <- NAMES[[kk]]
[15:31:13.513]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.513]                     next
[15:31:13.513]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.513]                 }
[15:31:13.513]                 NAMES <- toupper(added)
[15:31:13.513]                 for (kk in seq_along(NAMES)) {
[15:31:13.513]                   name <- added[[kk]]
[15:31:13.513]                   NAME <- NAMES[[kk]]
[15:31:13.513]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.513]                     next
[15:31:13.513]                   args[[name]] <- ""
[15:31:13.513]                 }
[15:31:13.513]                 NAMES <- toupper(removed)
[15:31:13.513]                 for (kk in seq_along(NAMES)) {
[15:31:13.513]                   name <- removed[[kk]]
[15:31:13.513]                   NAME <- NAMES[[kk]]
[15:31:13.513]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.513]                     next
[15:31:13.513]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.513]                 }
[15:31:13.513]                 if (length(args) > 0) 
[15:31:13.513]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.513]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.513]             }
[15:31:13.513]             else {
[15:31:13.513]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.513]             }
[15:31:13.513]             {
[15:31:13.513]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.513]                   0L) {
[15:31:13.513]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.513]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.513]                   base::options(opts)
[15:31:13.513]                 }
[15:31:13.513]                 {
[15:31:13.513]                   {
[15:31:13.513]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.513]                     NULL
[15:31:13.513]                   }
[15:31:13.513]                   options(future.plan = NULL)
[15:31:13.513]                   if (is.na(NA_character_)) 
[15:31:13.513]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.513]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.513]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.513]                     .init = FALSE)
[15:31:13.513]                 }
[15:31:13.513]             }
[15:31:13.513]         }
[15:31:13.513]     })
[15:31:13.513]     if (TRUE) {
[15:31:13.513]         base::sink(type = "output", split = FALSE)
[15:31:13.513]         if (TRUE) {
[15:31:13.513]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.513]         }
[15:31:13.513]         else {
[15:31:13.513]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.513]         }
[15:31:13.513]         base::close(...future.stdout)
[15:31:13.513]         ...future.stdout <- NULL
[15:31:13.513]     }
[15:31:13.513]     ...future.result$conditions <- ...future.conditions
[15:31:13.513]     ...future.result$finished <- base::Sys.time()
[15:31:13.513]     ...future.result
[15:31:13.513] }
[15:31:13.520] Exporting 7 global objects (2.27 KiB) to cluster node #1 ...
[15:31:13.520] Exporting '...future.FUN' (1.04 KiB) to cluster node #1 ...
[15:31:13.520] Exporting '...future.FUN' (1.04 KiB) to cluster node #1 ... DONE
[15:31:13.521] Exporting 'breaks' (480 bytes) to cluster node #1 ...
[15:31:13.521] Exporting 'breaks' (480 bytes) to cluster node #1 ... DONE
[15:31:13.521] Exporting 'wool' (776 bytes) to cluster node #1 ...
[15:31:13.522] Exporting 'wool' (776 bytes) to cluster node #1 ... DONE
[15:31:13.523] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:13.523] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:13.524] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ...
[15:31:13.524] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ... DONE
[15:31:13.525] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.525] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.526] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.526] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.527] Exporting 7 global objects (2.27 KiB) to cluster node #1 ... DONE
[15:31:13.527] MultisessionFuture started
[15:31:13.528] - Launch lazy future ... done
[15:31:13.528] run() for 'MultisessionFuture' ... done
[15:31:13.528] Created future:
[15:31:13.555] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.555] - Validating connection of MultisessionFuture
[15:31:13.556] - received message: FutureResult
[15:31:13.556] - Received FutureResult
[15:31:13.557] - Erased future from FutureRegistry
[15:31:13.557] result() for ClusterFuture ...
[15:31:13.557] - result already collected: FutureResult
[15:31:13.558] result() for ClusterFuture ... done
[15:31:13.558] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.529] MultisessionFuture:
[15:31:13.529] Label: 'future_by-1'
[15:31:13.529] Expression:
[15:31:13.529] {
[15:31:13.529]     do.call(function(...) {
[15:31:13.529]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.529]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.529]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.529]             on.exit(options(oopts), add = TRUE)
[15:31:13.529]         }
[15:31:13.529]         {
[15:31:13.529]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.529]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.529]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.529]             })
[15:31:13.529]         }
[15:31:13.529]     }, args = future.call.arguments)
[15:31:13.529] }
[15:31:13.529] Lazy evaluation: FALSE
[15:31:13.529] Asynchronous evaluation: TRUE
[15:31:13.529] Local evaluation: TRUE
[15:31:13.529] Environment: 0x0000019c82e5bd50
[15:31:13.529] Capture standard output: TRUE
[15:31:13.529] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.529] Globals: 7 objects totaling 3.87 KiB (function '...future.FUN' of 1.04 KiB, numeric 'breaks' of 480 bytes, factor 'wool' of 776 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 1.60 KiB, ...)
[15:31:13.529] Packages: 1 packages ('stats')
[15:31:13.529] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.529] Resolved: TRUE
[15:31:13.529] Value: <not collected>
[15:31:13.529] Conditions captured: <none>
[15:31:13.529] Early signaling: FALSE
[15:31:13.529] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.529] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.559] Chunk #1 of 2 ... DONE
[15:31:13.559] Chunk #2 of 2 ...
[15:31:13.559]  - Finding globals in 'X' for chunk #2 ...
[15:31:13.560] getGlobalsAndPackages() ...
[15:31:13.560] Searching for globals...
[15:31:13.561] 
[15:31:13.561] Searching for globals ... DONE
[15:31:13.561] - globals: [0] <none>
[15:31:13.562] getGlobalsAndPackages() ... DONE
[15:31:13.562]    + additional globals found: [n=0] 
[15:31:13.562]    + additional namespaces needed: [n=0] 
[15:31:13.563]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:13.563]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.563]  - seeds: <none>
[15:31:13.563]  - All globals exported: [n=7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.564] getGlobalsAndPackages() ...
[15:31:13.564] - globals passed as-is: [7] '...future.FUN', 'breaks', 'wool', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.564] Resolving globals: FALSE
[15:31:13.565] Tweak future expression to call with '...' arguments ...
[15:31:13.565] {
[15:31:13.565]     do.call(function(...) {
[15:31:13.565]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.565]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.565]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.565]             on.exit(options(oopts), add = TRUE)
[15:31:13.565]         }
[15:31:13.565]         {
[15:31:13.565]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.565]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.565]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.565]             })
[15:31:13.565]         }
[15:31:13.565]     }, args = future.call.arguments)
[15:31:13.565] }
[15:31:13.566] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.567] - globals: [7] '...future.FUN', 'breaks', 'wool', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.567] 
[15:31:13.567] getGlobalsAndPackages() ... DONE
[15:31:13.568] run() for 'Future' ...
[15:31:13.568] - state: 'created'
[15:31:13.569] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.589] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.590] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.590]   - Field: 'node'
[15:31:13.590]   - Field: 'label'
[15:31:13.590]   - Field: 'local'
[15:31:13.591]   - Field: 'owner'
[15:31:13.591]   - Field: 'envir'
[15:31:13.591]   - Field: 'workers'
[15:31:13.592]   - Field: 'packages'
[15:31:13.592]   - Field: 'gc'
[15:31:13.592]   - Field: 'conditions'
[15:31:13.593]   - Field: 'persistent'
[15:31:13.593]   - Field: 'expr'
[15:31:13.593]   - Field: 'uuid'
[15:31:13.593]   - Field: 'seed'
[15:31:13.594]   - Field: 'version'
[15:31:13.594]   - Field: 'result'
[15:31:13.594]   - Field: 'asynchronous'
[15:31:13.595]   - Field: 'calls'
[15:31:13.595]   - Field: 'globals'
[15:31:13.595]   - Field: 'stdout'
[15:31:13.595]   - Field: 'earlySignal'
[15:31:13.596]   - Field: 'lazy'
[15:31:13.596]   - Field: 'state'
[15:31:13.596] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.596] - Launch lazy future ...
[15:31:13.597] Packages needed by the future expression (n = 1): 'stats'
[15:31:13.598] Packages needed by future strategies (n = 0): <none>
[15:31:13.599] {
[15:31:13.599]     {
[15:31:13.599]         {
[15:31:13.599]             ...future.startTime <- base::Sys.time()
[15:31:13.599]             {
[15:31:13.599]                 {
[15:31:13.599]                   {
[15:31:13.599]                     {
[15:31:13.599]                       {
[15:31:13.599]                         base::local({
[15:31:13.599]                           has_future <- base::requireNamespace("future", 
[15:31:13.599]                             quietly = TRUE)
[15:31:13.599]                           if (has_future) {
[15:31:13.599]                             ns <- base::getNamespace("future")
[15:31:13.599]                             version <- ns[[".package"]][["version"]]
[15:31:13.599]                             if (is.null(version)) 
[15:31:13.599]                               version <- utils::packageVersion("future")
[15:31:13.599]                           }
[15:31:13.599]                           else {
[15:31:13.599]                             version <- NULL
[15:31:13.599]                           }
[15:31:13.599]                           if (!has_future || version < "1.8.0") {
[15:31:13.599]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.599]                               "", base::R.version$version.string), 
[15:31:13.599]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:13.599]                                 base::R.version$platform, 8 * 
[15:31:13.599]                                   base::.Machine$sizeof.pointer), 
[15:31:13.599]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.599]                                 "release", "version")], collapse = " "), 
[15:31:13.599]                               hostname = base::Sys.info()[["nodename"]])
[15:31:13.599]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.599]                               info)
[15:31:13.599]                             info <- base::paste(info, collapse = "; ")
[15:31:13.599]                             if (!has_future) {
[15:31:13.599]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.599]                                 info)
[15:31:13.599]                             }
[15:31:13.599]                             else {
[15:31:13.599]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.599]                                 info, version)
[15:31:13.599]                             }
[15:31:13.599]                             base::stop(msg)
[15:31:13.599]                           }
[15:31:13.599]                         })
[15:31:13.599]                       }
[15:31:13.599]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.599]                       base::options(mc.cores = 1L)
[15:31:13.599]                     }
[15:31:13.599]                     base::local({
[15:31:13.599]                       for (pkg in "stats") {
[15:31:13.599]                         base::loadNamespace(pkg)
[15:31:13.599]                         base::library(pkg, character.only = TRUE)
[15:31:13.599]                       }
[15:31:13.599]                     })
[15:31:13.599]                   }
[15:31:13.599]                   ...future.strategy.old <- future::plan("list")
[15:31:13.599]                   options(future.plan = NULL)
[15:31:13.599]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.599]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.599]                 }
[15:31:13.599]                 ...future.workdir <- getwd()
[15:31:13.599]             }
[15:31:13.599]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.599]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.599]         }
[15:31:13.599]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.599]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.599]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.599]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.599]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.599]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.599]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.599]             base::names(...future.oldOptions))
[15:31:13.599]     }
[15:31:13.599]     if (FALSE) {
[15:31:13.599]     }
[15:31:13.599]     else {
[15:31:13.599]         if (TRUE) {
[15:31:13.599]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.599]                 open = "w")
[15:31:13.599]         }
[15:31:13.599]         else {
[15:31:13.599]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.599]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.599]         }
[15:31:13.599]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.599]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.599]             base::sink(type = "output", split = FALSE)
[15:31:13.599]             base::close(...future.stdout)
[15:31:13.599]         }, add = TRUE)
[15:31:13.599]     }
[15:31:13.599]     ...future.frame <- base::sys.nframe()
[15:31:13.599]     ...future.conditions <- base::list()
[15:31:13.599]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.599]     if (FALSE) {
[15:31:13.599]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.599]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.599]     }
[15:31:13.599]     ...future.result <- base::tryCatch({
[15:31:13.599]         base::withCallingHandlers({
[15:31:13.599]             ...future.value <- base::withVisible(base::local({
[15:31:13.599]                 ...future.makeSendCondition <- base::local({
[15:31:13.599]                   sendCondition <- NULL
[15:31:13.599]                   function(frame = 1L) {
[15:31:13.599]                     if (is.function(sendCondition)) 
[15:31:13.599]                       return(sendCondition)
[15:31:13.599]                     ns <- getNamespace("parallel")
[15:31:13.599]                     if (exists("sendData", mode = "function", 
[15:31:13.599]                       envir = ns)) {
[15:31:13.599]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.599]                         envir = ns)
[15:31:13.599]                       envir <- sys.frame(frame)
[15:31:13.599]                       master <- NULL
[15:31:13.599]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.599]                         !identical(envir, emptyenv())) {
[15:31:13.599]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.599]                           inherits = FALSE)) {
[15:31:13.599]                           master <- get("master", mode = "list", 
[15:31:13.599]                             envir = envir, inherits = FALSE)
[15:31:13.599]                           if (inherits(master, c("SOCKnode", 
[15:31:13.599]                             "SOCK0node"))) {
[15:31:13.599]                             sendCondition <<- function(cond) {
[15:31:13.599]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.599]                                 success = TRUE)
[15:31:13.599]                               parallel_sendData(master, data)
[15:31:13.599]                             }
[15:31:13.599]                             return(sendCondition)
[15:31:13.599]                           }
[15:31:13.599]                         }
[15:31:13.599]                         frame <- frame + 1L
[15:31:13.599]                         envir <- sys.frame(frame)
[15:31:13.599]                       }
[15:31:13.599]                     }
[15:31:13.599]                     sendCondition <<- function(cond) NULL
[15:31:13.599]                   }
[15:31:13.599]                 })
[15:31:13.599]                 withCallingHandlers({
[15:31:13.599]                   {
[15:31:13.599]                     do.call(function(...) {
[15:31:13.599]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.599]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.599]                         ...future.globals.maxSize)) {
[15:31:13.599]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.599]                         on.exit(options(oopts), add = TRUE)
[15:31:13.599]                       }
[15:31:13.599]                       {
[15:31:13.599]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.599]                           FUN = function(jj) {
[15:31:13.599]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.599]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.599]                           })
[15:31:13.599]                       }
[15:31:13.599]                     }, args = future.call.arguments)
[15:31:13.599]                   }
[15:31:13.599]                 }, immediateCondition = function(cond) {
[15:31:13.599]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.599]                   sendCondition(cond)
[15:31:13.599]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.599]                   {
[15:31:13.599]                     inherits <- base::inherits
[15:31:13.599]                     invokeRestart <- base::invokeRestart
[15:31:13.599]                     is.null <- base::is.null
[15:31:13.599]                     muffled <- FALSE
[15:31:13.599]                     if (inherits(cond, "message")) {
[15:31:13.599]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.599]                       if (muffled) 
[15:31:13.599]                         invokeRestart("muffleMessage")
[15:31:13.599]                     }
[15:31:13.599]                     else if (inherits(cond, "warning")) {
[15:31:13.599]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.599]                       if (muffled) 
[15:31:13.599]                         invokeRestart("muffleWarning")
[15:31:13.599]                     }
[15:31:13.599]                     else if (inherits(cond, "condition")) {
[15:31:13.599]                       if (!is.null(pattern)) {
[15:31:13.599]                         computeRestarts <- base::computeRestarts
[15:31:13.599]                         grepl <- base::grepl
[15:31:13.599]                         restarts <- computeRestarts(cond)
[15:31:13.599]                         for (restart in restarts) {
[15:31:13.599]                           name <- restart$name
[15:31:13.599]                           if (is.null(name)) 
[15:31:13.599]                             next
[15:31:13.599]                           if (!grepl(pattern, name)) 
[15:31:13.599]                             next
[15:31:13.599]                           invokeRestart(restart)
[15:31:13.599]                           muffled <- TRUE
[15:31:13.599]                           break
[15:31:13.599]                         }
[15:31:13.599]                       }
[15:31:13.599]                     }
[15:31:13.599]                     invisible(muffled)
[15:31:13.599]                   }
[15:31:13.599]                   muffleCondition(cond)
[15:31:13.599]                 })
[15:31:13.599]             }))
[15:31:13.599]             future::FutureResult(value = ...future.value$value, 
[15:31:13.599]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.599]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.599]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.599]                     ...future.globalenv.names))
[15:31:13.599]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.599]         }, condition = base::local({
[15:31:13.599]             c <- base::c
[15:31:13.599]             inherits <- base::inherits
[15:31:13.599]             invokeRestart <- base::invokeRestart
[15:31:13.599]             length <- base::length
[15:31:13.599]             list <- base::list
[15:31:13.599]             seq.int <- base::seq.int
[15:31:13.599]             signalCondition <- base::signalCondition
[15:31:13.599]             sys.calls <- base::sys.calls
[15:31:13.599]             `[[` <- base::`[[`
[15:31:13.599]             `+` <- base::`+`
[15:31:13.599]             `<<-` <- base::`<<-`
[15:31:13.599]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.599]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.599]                   3L)]
[15:31:13.599]             }
[15:31:13.599]             function(cond) {
[15:31:13.599]                 is_error <- inherits(cond, "error")
[15:31:13.599]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.599]                   NULL)
[15:31:13.599]                 if (is_error) {
[15:31:13.599]                   sessionInformation <- function() {
[15:31:13.599]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.599]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.599]                       search = base::search(), system = base::Sys.info())
[15:31:13.599]                   }
[15:31:13.599]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.599]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.599]                     cond$call), session = sessionInformation(), 
[15:31:13.599]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.599]                   signalCondition(cond)
[15:31:13.599]                 }
[15:31:13.599]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.599]                 "immediateCondition"))) {
[15:31:13.599]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.599]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.599]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.599]                   if (TRUE && !signal) {
[15:31:13.599]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.599]                     {
[15:31:13.599]                       inherits <- base::inherits
[15:31:13.599]                       invokeRestart <- base::invokeRestart
[15:31:13.599]                       is.null <- base::is.null
[15:31:13.599]                       muffled <- FALSE
[15:31:13.599]                       if (inherits(cond, "message")) {
[15:31:13.599]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.599]                         if (muffled) 
[15:31:13.599]                           invokeRestart("muffleMessage")
[15:31:13.599]                       }
[15:31:13.599]                       else if (inherits(cond, "warning")) {
[15:31:13.599]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.599]                         if (muffled) 
[15:31:13.599]                           invokeRestart("muffleWarning")
[15:31:13.599]                       }
[15:31:13.599]                       else if (inherits(cond, "condition")) {
[15:31:13.599]                         if (!is.null(pattern)) {
[15:31:13.599]                           computeRestarts <- base::computeRestarts
[15:31:13.599]                           grepl <- base::grepl
[15:31:13.599]                           restarts <- computeRestarts(cond)
[15:31:13.599]                           for (restart in restarts) {
[15:31:13.599]                             name <- restart$name
[15:31:13.599]                             if (is.null(name)) 
[15:31:13.599]                               next
[15:31:13.599]                             if (!grepl(pattern, name)) 
[15:31:13.599]                               next
[15:31:13.599]                             invokeRestart(restart)
[15:31:13.599]                             muffled <- TRUE
[15:31:13.599]                             break
[15:31:13.599]                           }
[15:31:13.599]                         }
[15:31:13.599]                       }
[15:31:13.599]                       invisible(muffled)
[15:31:13.599]                     }
[15:31:13.599]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.599]                   }
[15:31:13.599]                 }
[15:31:13.599]                 else {
[15:31:13.599]                   if (TRUE) {
[15:31:13.599]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.599]                     {
[15:31:13.599]                       inherits <- base::inherits
[15:31:13.599]                       invokeRestart <- base::invokeRestart
[15:31:13.599]                       is.null <- base::is.null
[15:31:13.599]                       muffled <- FALSE
[15:31:13.599]                       if (inherits(cond, "message")) {
[15:31:13.599]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.599]                         if (muffled) 
[15:31:13.599]                           invokeRestart("muffleMessage")
[15:31:13.599]                       }
[15:31:13.599]                       else if (inherits(cond, "warning")) {
[15:31:13.599]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.599]                         if (muffled) 
[15:31:13.599]                           invokeRestart("muffleWarning")
[15:31:13.599]                       }
[15:31:13.599]                       else if (inherits(cond, "condition")) {
[15:31:13.599]                         if (!is.null(pattern)) {
[15:31:13.599]                           computeRestarts <- base::computeRestarts
[15:31:13.599]                           grepl <- base::grepl
[15:31:13.599]                           restarts <- computeRestarts(cond)
[15:31:13.599]                           for (restart in restarts) {
[15:31:13.599]                             name <- restart$name
[15:31:13.599]                             if (is.null(name)) 
[15:31:13.599]                               next
[15:31:13.599]                             if (!grepl(pattern, name)) 
[15:31:13.599]                               next
[15:31:13.599]                             invokeRestart(restart)
[15:31:13.599]                             muffled <- TRUE
[15:31:13.599]                             break
[15:31:13.599]                           }
[15:31:13.599]                         }
[15:31:13.599]                       }
[15:31:13.599]                       invisible(muffled)
[15:31:13.599]                     }
[15:31:13.599]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.599]                   }
[15:31:13.599]                 }
[15:31:13.599]             }
[15:31:13.599]         }))
[15:31:13.599]     }, error = function(ex) {
[15:31:13.599]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.599]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.599]                 ...future.rng), started = ...future.startTime, 
[15:31:13.599]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.599]             version = "1.8"), class = "FutureResult")
[15:31:13.599]     }, finally = {
[15:31:13.599]         if (!identical(...future.workdir, getwd())) 
[15:31:13.599]             setwd(...future.workdir)
[15:31:13.599]         {
[15:31:13.599]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.599]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.599]             }
[15:31:13.599]             base::options(...future.oldOptions)
[15:31:13.599]             if (.Platform$OS.type == "windows") {
[15:31:13.599]                 old_names <- names(...future.oldEnvVars)
[15:31:13.599]                 envs <- base::Sys.getenv()
[15:31:13.599]                 names <- names(envs)
[15:31:13.599]                 common <- intersect(names, old_names)
[15:31:13.599]                 added <- setdiff(names, old_names)
[15:31:13.599]                 removed <- setdiff(old_names, names)
[15:31:13.599]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.599]                   envs[common]]
[15:31:13.599]                 NAMES <- toupper(changed)
[15:31:13.599]                 args <- list()
[15:31:13.599]                 for (kk in seq_along(NAMES)) {
[15:31:13.599]                   name <- changed[[kk]]
[15:31:13.599]                   NAME <- NAMES[[kk]]
[15:31:13.599]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.599]                     next
[15:31:13.599]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.599]                 }
[15:31:13.599]                 NAMES <- toupper(added)
[15:31:13.599]                 for (kk in seq_along(NAMES)) {
[15:31:13.599]                   name <- added[[kk]]
[15:31:13.599]                   NAME <- NAMES[[kk]]
[15:31:13.599]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.599]                     next
[15:31:13.599]                   args[[name]] <- ""
[15:31:13.599]                 }
[15:31:13.599]                 NAMES <- toupper(removed)
[15:31:13.599]                 for (kk in seq_along(NAMES)) {
[15:31:13.599]                   name <- removed[[kk]]
[15:31:13.599]                   NAME <- NAMES[[kk]]
[15:31:13.599]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.599]                     next
[15:31:13.599]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.599]                 }
[15:31:13.599]                 if (length(args) > 0) 
[15:31:13.599]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.599]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.599]             }
[15:31:13.599]             else {
[15:31:13.599]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.599]             }
[15:31:13.599]             {
[15:31:13.599]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.599]                   0L) {
[15:31:13.599]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.599]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.599]                   base::options(opts)
[15:31:13.599]                 }
[15:31:13.599]                 {
[15:31:13.599]                   {
[15:31:13.599]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.599]                     NULL
[15:31:13.599]                   }
[15:31:13.599]                   options(future.plan = NULL)
[15:31:13.599]                   if (is.na(NA_character_)) 
[15:31:13.599]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.599]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.599]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.599]                     .init = FALSE)
[15:31:13.599]                 }
[15:31:13.599]             }
[15:31:13.599]         }
[15:31:13.599]     })
[15:31:13.599]     if (TRUE) {
[15:31:13.599]         base::sink(type = "output", split = FALSE)
[15:31:13.599]         if (TRUE) {
[15:31:13.599]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.599]         }
[15:31:13.599]         else {
[15:31:13.599]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.599]         }
[15:31:13.599]         base::close(...future.stdout)
[15:31:13.599]         ...future.stdout <- NULL
[15:31:13.599]     }
[15:31:13.599]     ...future.result$conditions <- ...future.conditions
[15:31:13.599]     ...future.result$finished <- base::Sys.time()
[15:31:13.599]     ...future.result
[15:31:13.599] }
[15:31:13.610] Exporting 7 global objects (2.27 KiB) to cluster node #1 ...
[15:31:13.610] Exporting '...future.FUN' (1.04 KiB) to cluster node #1 ...
[15:31:13.611] Exporting '...future.FUN' (1.04 KiB) to cluster node #1 ... DONE
[15:31:13.611] Exporting 'breaks' (480 bytes) to cluster node #1 ...
[15:31:13.612] Exporting 'breaks' (480 bytes) to cluster node #1 ... DONE
[15:31:13.612] Exporting 'wool' (776 bytes) to cluster node #1 ...
[15:31:13.613] Exporting 'wool' (776 bytes) to cluster node #1 ... DONE
[15:31:13.613] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:13.614] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:13.614] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ...
[15:31:13.614] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ... DONE
[15:31:13.615] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.615] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.615] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.616] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.616] Exporting 7 global objects (2.27 KiB) to cluster node #1 ... DONE
[15:31:13.617] MultisessionFuture started
[15:31:13.617] - Launch lazy future ... done
[15:31:13.618] run() for 'MultisessionFuture' ... done
[15:31:13.618] Created future:
[15:31:13.643] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.644] - Validating connection of MultisessionFuture
[15:31:13.644] - received message: FutureResult
[15:31:13.644] - Received FutureResult
[15:31:13.644] - Erased future from FutureRegistry
[15:31:13.645] result() for ClusterFuture ...
[15:31:13.645] - result already collected: FutureResult
[15:31:13.645] result() for ClusterFuture ... done
[15:31:13.645] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.618] MultisessionFuture:
[15:31:13.618] Label: 'future_by-2'
[15:31:13.618] Expression:
[15:31:13.618] {
[15:31:13.618]     do.call(function(...) {
[15:31:13.618]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.618]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.618]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.618]             on.exit(options(oopts), add = TRUE)
[15:31:13.618]         }
[15:31:13.618]         {
[15:31:13.618]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.618]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.618]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.618]             })
[15:31:13.618]         }
[15:31:13.618]     }, args = future.call.arguments)
[15:31:13.618] }
[15:31:13.618] Lazy evaluation: FALSE
[15:31:13.618] Asynchronous evaluation: TRUE
[15:31:13.618] Local evaluation: TRUE
[15:31:13.618] Environment: 0x0000019c82e5bd50
[15:31:13.618] Capture standard output: TRUE
[15:31:13.618] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.618] Globals: 7 objects totaling 5.47 KiB (function '...future.FUN' of 1.04 KiB, numeric 'breaks' of 480 bytes, factor 'wool' of 776 bytes, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 3.20 KiB, ...)
[15:31:13.618] Packages: 1 packages ('stats')
[15:31:13.618] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.618] Resolved: TRUE
[15:31:13.618] Value: <not collected>
[15:31:13.618] Conditions captured: <none>
[15:31:13.618] Early signaling: FALSE
[15:31:13.618] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.618] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.646] Chunk #2 of 2 ... DONE
[15:31:13.646] Launching 2 futures (chunks) ... DONE
[15:31:13.646] Resolving 2 futures (chunks) ...
[15:31:13.646] resolve() on list ...
[15:31:13.646]  recursive: 0
[15:31:13.646]  length: 2
[15:31:13.646] 
[15:31:13.647] Future #1
[15:31:13.647] result() for ClusterFuture ...
[15:31:13.647] - result already collected: FutureResult
[15:31:13.647] result() for ClusterFuture ... done
[15:31:13.647] result() for ClusterFuture ...
[15:31:13.647] - result already collected: FutureResult
[15:31:13.647] result() for ClusterFuture ... done
[15:31:13.648] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:13.648] - nx: 2
[15:31:13.648] - relay: TRUE
[15:31:13.648] - stdout: TRUE
[15:31:13.648] - signal: TRUE
[15:31:13.648] - resignal: FALSE
[15:31:13.648] - force: TRUE
[15:31:13.649] - relayed: [n=2] FALSE, FALSE
[15:31:13.649] - queued futures: [n=2] FALSE, FALSE
[15:31:13.649]  - until=1
[15:31:13.649]  - relaying element #1
[15:31:13.649] result() for ClusterFuture ...
[15:31:13.649] - result already collected: FutureResult
[15:31:13.650] result() for ClusterFuture ... done
[15:31:13.650] result() for ClusterFuture ...
[15:31:13.650] - result already collected: FutureResult
[15:31:13.650] result() for ClusterFuture ... done
[15:31:13.650] result() for ClusterFuture ...
[15:31:13.650] - result already collected: FutureResult
[15:31:13.650] result() for ClusterFuture ... done
[15:31:13.651] result() for ClusterFuture ...
[15:31:13.651] - result already collected: FutureResult
[15:31:13.651] result() for ClusterFuture ... done
[15:31:13.651] - relayed: [n=2] TRUE, FALSE
[15:31:13.651] - queued futures: [n=2] TRUE, FALSE
[15:31:13.651] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:13.651]  length: 1 (resolved future 1)
[15:31:13.652] Future #2
[15:31:13.652] result() for ClusterFuture ...
[15:31:13.652] - result already collected: FutureResult
[15:31:13.652] result() for ClusterFuture ... done
[15:31:13.652] result() for ClusterFuture ...
[15:31:13.652] - result already collected: FutureResult
[15:31:13.653] result() for ClusterFuture ... done
[15:31:13.653] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:13.653] - nx: 2
[15:31:13.653] - relay: TRUE
[15:31:13.653] - stdout: TRUE
[15:31:13.653] - signal: TRUE
[15:31:13.653] - resignal: FALSE
[15:31:13.654] - force: TRUE
[15:31:13.654] - relayed: [n=2] TRUE, FALSE
[15:31:13.654] - queued futures: [n=2] TRUE, FALSE
[15:31:13.654]  - until=2
[15:31:13.654]  - relaying element #2
[15:31:13.654] result() for ClusterFuture ...
[15:31:13.654] - result already collected: FutureResult
[15:31:13.655] result() for ClusterFuture ... done
[15:31:13.655] result() for ClusterFuture ...
[15:31:13.655] - result already collected: FutureResult
[15:31:13.655] result() for ClusterFuture ... done
[15:31:13.655] result() for ClusterFuture ...
[15:31:13.655] - result already collected: FutureResult
[15:31:13.656] result() for ClusterFuture ... done
[15:31:13.656] result() for ClusterFuture ...
[15:31:13.656] - result already collected: FutureResult
[15:31:13.656] result() for ClusterFuture ... done
[15:31:13.656] - relayed: [n=2] TRUE, TRUE
[15:31:13.656] - queued futures: [n=2] TRUE, TRUE
[15:31:13.656] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:13.657]  length: 0 (resolved future 2)
[15:31:13.657] Relaying remaining futures
[15:31:13.657] signalConditionsASAP(NULL, pos=0) ...
[15:31:13.657] - nx: 2
[15:31:13.657] - relay: TRUE
[15:31:13.657] - stdout: TRUE
[15:31:13.657] - signal: TRUE
[15:31:13.658] - resignal: FALSE
[15:31:13.658] - force: TRUE
[15:31:13.658] - relayed: [n=2] TRUE, TRUE
[15:31:13.658] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:13.658] - relayed: [n=2] TRUE, TRUE
[15:31:13.658] - queued futures: [n=2] TRUE, TRUE
[15:31:13.659] signalConditionsASAP(NULL, pos=0) ... done
[15:31:13.659] resolve() on list ... DONE
[15:31:13.659] result() for ClusterFuture ...
[15:31:13.659] - result already collected: FutureResult
[15:31:13.659] result() for ClusterFuture ... done
[15:31:13.659] result() for ClusterFuture ...
[15:31:13.659] - result already collected: FutureResult
[15:31:13.660] result() for ClusterFuture ... done
[15:31:13.660] result() for ClusterFuture ...
[15:31:13.660] - result already collected: FutureResult
[15:31:13.660] result() for ClusterFuture ... done
[15:31:13.660] result() for ClusterFuture ...
[15:31:13.660] - result already collected: FutureResult
[15:31:13.660] result() for ClusterFuture ... done
[15:31:13.661]  - Number of value chunks collected: 2
[15:31:13.661] Resolving 2 futures (chunks) ... DONE
[15:31:13.661] Reducing values from 2 chunks ...
[15:31:13.661]  - Number of values collected after concatenation: 3
[15:31:13.661]  - Number of values expected: 3
[15:31:13.661] Reducing values from 2 chunks ... DONE
[15:31:13.661] future_lapply() ... DONE
[15:31:13.662] future_by_internal() ... DONE
[15:31:13.662] future_by_internal() ...
[15:31:13.663] future_lapply() ...
[15:31:13.666] Number of chunks: 2
[15:31:13.666] getGlobalsAndPackagesXApply() ...
[15:31:13.666]  - future.globals: TRUE
[15:31:13.666] getGlobalsAndPackages() ...
[15:31:13.666] Searching for globals...
[15:31:13.667] - globals found: [2] 'FUN', 'UseMethod'
[15:31:13.668] Searching for globals ... DONE
[15:31:13.668] Resolving globals: FALSE
[15:31:13.668] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:13.669] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:13.669] - globals: [1] 'FUN'
[15:31:13.669] 
[15:31:13.669] getGlobalsAndPackages() ... DONE
[15:31:13.669]  - globals found/used: [n=1] 'FUN'
[15:31:13.670]  - needed namespaces: [n=0] 
[15:31:13.670] Finding globals ... DONE
[15:31:13.670]  - use_args: TRUE
[15:31:13.670]  - Getting '...' globals ...
[15:31:13.671] resolve() on list ...
[15:31:13.671]  recursive: 0
[15:31:13.671]  length: 1
[15:31:13.671]  elements: '...'
[15:31:13.671]  length: 0 (resolved future 1)
[15:31:13.672] resolve() on list ... DONE
[15:31:13.672]    - '...' content: [n=0] 
[15:31:13.672] List of 1
[15:31:13.672]  $ ...: list()
[15:31:13.672]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.672]  - attr(*, "where")=List of 1
[15:31:13.672]   ..$ ...:<environment: 0x0000019c83754a70> 
[15:31:13.672]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.672]  - attr(*, "resolved")= logi TRUE
[15:31:13.672]  - attr(*, "total_size")= num NA
[15:31:13.675]  - Getting '...' globals ... DONE
[15:31:13.675] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:13.676] List of 2
[15:31:13.676]  $ ...future.FUN:function (object, ...)  
[15:31:13.676]  $ ...          : list()
[15:31:13.676]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.676]  - attr(*, "where")=List of 2
[15:31:13.676]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:13.676]   ..$ ...          :<environment: 0x0000019c83754a70> 
[15:31:13.676]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.676]  - attr(*, "resolved")= logi FALSE
[15:31:13.676]  - attr(*, "total_size")= num 1240
[15:31:13.679] Packages to be attached in all futures: [n=0] 
[15:31:13.679] getGlobalsAndPackagesXApply() ... DONE
[15:31:13.679] Number of futures (= number of chunks): 2
[15:31:13.679] Launching 2 futures (chunks) ...
[15:31:13.679] Chunk #1 of 2 ...
[15:31:13.679]  - Finding globals in 'X' for chunk #1 ...
[15:31:13.680] getGlobalsAndPackages() ...
[15:31:13.680] Searching for globals...
[15:31:13.680] 
[15:31:13.680] Searching for globals ... DONE
[15:31:13.680] - globals: [0] <none>
[15:31:13.681] getGlobalsAndPackages() ... DONE
[15:31:13.681]    + additional globals found: [n=0] 
[15:31:13.681]    + additional namespaces needed: [n=0] 
[15:31:13.681]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:13.681]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.681]  - seeds: <none>
[15:31:13.681]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.682] getGlobalsAndPackages() ...
[15:31:13.682] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.682] Resolving globals: FALSE
[15:31:13.682] Tweak future expression to call with '...' arguments ...
[15:31:13.682] {
[15:31:13.682]     do.call(function(...) {
[15:31:13.682]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.682]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.682]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.682]             on.exit(options(oopts), add = TRUE)
[15:31:13.682]         }
[15:31:13.682]         {
[15:31:13.682]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.682]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.682]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.682]             })
[15:31:13.682]         }
[15:31:13.682]     }, args = future.call.arguments)
[15:31:13.682] }
[15:31:13.683] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.683] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.683] 
[15:31:13.684] getGlobalsAndPackages() ... DONE
[15:31:13.684] run() for 'Future' ...
[15:31:13.684] - state: 'created'
[15:31:13.684] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.698] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.698] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.698]   - Field: 'node'
[15:31:13.698]   - Field: 'label'
[15:31:13.699]   - Field: 'local'
[15:31:13.699]   - Field: 'owner'
[15:31:13.699]   - Field: 'envir'
[15:31:13.699]   - Field: 'workers'
[15:31:13.700]   - Field: 'packages'
[15:31:13.700]   - Field: 'gc'
[15:31:13.700]   - Field: 'conditions'
[15:31:13.700]   - Field: 'persistent'
[15:31:13.701]   - Field: 'expr'
[15:31:13.701]   - Field: 'uuid'
[15:31:13.701]   - Field: 'seed'
[15:31:13.701]   - Field: 'version'
[15:31:13.702]   - Field: 'result'
[15:31:13.702]   - Field: 'asynchronous'
[15:31:13.702]   - Field: 'calls'
[15:31:13.703]   - Field: 'globals'
[15:31:13.703]   - Field: 'stdout'
[15:31:13.703]   - Field: 'earlySignal'
[15:31:13.703]   - Field: 'lazy'
[15:31:13.704]   - Field: 'state'
[15:31:13.704] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.704] - Launch lazy future ...
[15:31:13.705] Packages needed by the future expression (n = 0): <none>
[15:31:13.705] Packages needed by future strategies (n = 0): <none>
[15:31:13.706] {
[15:31:13.706]     {
[15:31:13.706]         {
[15:31:13.706]             ...future.startTime <- base::Sys.time()
[15:31:13.706]             {
[15:31:13.706]                 {
[15:31:13.706]                   {
[15:31:13.706]                     {
[15:31:13.706]                       base::local({
[15:31:13.706]                         has_future <- base::requireNamespace("future", 
[15:31:13.706]                           quietly = TRUE)
[15:31:13.706]                         if (has_future) {
[15:31:13.706]                           ns <- base::getNamespace("future")
[15:31:13.706]                           version <- ns[[".package"]][["version"]]
[15:31:13.706]                           if (is.null(version)) 
[15:31:13.706]                             version <- utils::packageVersion("future")
[15:31:13.706]                         }
[15:31:13.706]                         else {
[15:31:13.706]                           version <- NULL
[15:31:13.706]                         }
[15:31:13.706]                         if (!has_future || version < "1.8.0") {
[15:31:13.706]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.706]                             "", base::R.version$version.string), 
[15:31:13.706]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:13.706]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:13.706]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.706]                               "release", "version")], collapse = " "), 
[15:31:13.706]                             hostname = base::Sys.info()[["nodename"]])
[15:31:13.706]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.706]                             info)
[15:31:13.706]                           info <- base::paste(info, collapse = "; ")
[15:31:13.706]                           if (!has_future) {
[15:31:13.706]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.706]                               info)
[15:31:13.706]                           }
[15:31:13.706]                           else {
[15:31:13.706]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.706]                               info, version)
[15:31:13.706]                           }
[15:31:13.706]                           base::stop(msg)
[15:31:13.706]                         }
[15:31:13.706]                       })
[15:31:13.706]                     }
[15:31:13.706]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.706]                     base::options(mc.cores = 1L)
[15:31:13.706]                   }
[15:31:13.706]                   ...future.strategy.old <- future::plan("list")
[15:31:13.706]                   options(future.plan = NULL)
[15:31:13.706]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.706]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.706]                 }
[15:31:13.706]                 ...future.workdir <- getwd()
[15:31:13.706]             }
[15:31:13.706]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.706]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.706]         }
[15:31:13.706]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.706]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.706]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.706]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.706]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.706]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.706]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.706]             base::names(...future.oldOptions))
[15:31:13.706]     }
[15:31:13.706]     if (FALSE) {
[15:31:13.706]     }
[15:31:13.706]     else {
[15:31:13.706]         if (TRUE) {
[15:31:13.706]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.706]                 open = "w")
[15:31:13.706]         }
[15:31:13.706]         else {
[15:31:13.706]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.706]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.706]         }
[15:31:13.706]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.706]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.706]             base::sink(type = "output", split = FALSE)
[15:31:13.706]             base::close(...future.stdout)
[15:31:13.706]         }, add = TRUE)
[15:31:13.706]     }
[15:31:13.706]     ...future.frame <- base::sys.nframe()
[15:31:13.706]     ...future.conditions <- base::list()
[15:31:13.706]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.706]     if (FALSE) {
[15:31:13.706]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.706]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.706]     }
[15:31:13.706]     ...future.result <- base::tryCatch({
[15:31:13.706]         base::withCallingHandlers({
[15:31:13.706]             ...future.value <- base::withVisible(base::local({
[15:31:13.706]                 ...future.makeSendCondition <- base::local({
[15:31:13.706]                   sendCondition <- NULL
[15:31:13.706]                   function(frame = 1L) {
[15:31:13.706]                     if (is.function(sendCondition)) 
[15:31:13.706]                       return(sendCondition)
[15:31:13.706]                     ns <- getNamespace("parallel")
[15:31:13.706]                     if (exists("sendData", mode = "function", 
[15:31:13.706]                       envir = ns)) {
[15:31:13.706]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.706]                         envir = ns)
[15:31:13.706]                       envir <- sys.frame(frame)
[15:31:13.706]                       master <- NULL
[15:31:13.706]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.706]                         !identical(envir, emptyenv())) {
[15:31:13.706]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.706]                           inherits = FALSE)) {
[15:31:13.706]                           master <- get("master", mode = "list", 
[15:31:13.706]                             envir = envir, inherits = FALSE)
[15:31:13.706]                           if (inherits(master, c("SOCKnode", 
[15:31:13.706]                             "SOCK0node"))) {
[15:31:13.706]                             sendCondition <<- function(cond) {
[15:31:13.706]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.706]                                 success = TRUE)
[15:31:13.706]                               parallel_sendData(master, data)
[15:31:13.706]                             }
[15:31:13.706]                             return(sendCondition)
[15:31:13.706]                           }
[15:31:13.706]                         }
[15:31:13.706]                         frame <- frame + 1L
[15:31:13.706]                         envir <- sys.frame(frame)
[15:31:13.706]                       }
[15:31:13.706]                     }
[15:31:13.706]                     sendCondition <<- function(cond) NULL
[15:31:13.706]                   }
[15:31:13.706]                 })
[15:31:13.706]                 withCallingHandlers({
[15:31:13.706]                   {
[15:31:13.706]                     do.call(function(...) {
[15:31:13.706]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.706]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.706]                         ...future.globals.maxSize)) {
[15:31:13.706]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.706]                         on.exit(options(oopts), add = TRUE)
[15:31:13.706]                       }
[15:31:13.706]                       {
[15:31:13.706]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.706]                           FUN = function(jj) {
[15:31:13.706]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.706]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.706]                           })
[15:31:13.706]                       }
[15:31:13.706]                     }, args = future.call.arguments)
[15:31:13.706]                   }
[15:31:13.706]                 }, immediateCondition = function(cond) {
[15:31:13.706]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.706]                   sendCondition(cond)
[15:31:13.706]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.706]                   {
[15:31:13.706]                     inherits <- base::inherits
[15:31:13.706]                     invokeRestart <- base::invokeRestart
[15:31:13.706]                     is.null <- base::is.null
[15:31:13.706]                     muffled <- FALSE
[15:31:13.706]                     if (inherits(cond, "message")) {
[15:31:13.706]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.706]                       if (muffled) 
[15:31:13.706]                         invokeRestart("muffleMessage")
[15:31:13.706]                     }
[15:31:13.706]                     else if (inherits(cond, "warning")) {
[15:31:13.706]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.706]                       if (muffled) 
[15:31:13.706]                         invokeRestart("muffleWarning")
[15:31:13.706]                     }
[15:31:13.706]                     else if (inherits(cond, "condition")) {
[15:31:13.706]                       if (!is.null(pattern)) {
[15:31:13.706]                         computeRestarts <- base::computeRestarts
[15:31:13.706]                         grepl <- base::grepl
[15:31:13.706]                         restarts <- computeRestarts(cond)
[15:31:13.706]                         for (restart in restarts) {
[15:31:13.706]                           name <- restart$name
[15:31:13.706]                           if (is.null(name)) 
[15:31:13.706]                             next
[15:31:13.706]                           if (!grepl(pattern, name)) 
[15:31:13.706]                             next
[15:31:13.706]                           invokeRestart(restart)
[15:31:13.706]                           muffled <- TRUE
[15:31:13.706]                           break
[15:31:13.706]                         }
[15:31:13.706]                       }
[15:31:13.706]                     }
[15:31:13.706]                     invisible(muffled)
[15:31:13.706]                   }
[15:31:13.706]                   muffleCondition(cond)
[15:31:13.706]                 })
[15:31:13.706]             }))
[15:31:13.706]             future::FutureResult(value = ...future.value$value, 
[15:31:13.706]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.706]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.706]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.706]                     ...future.globalenv.names))
[15:31:13.706]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.706]         }, condition = base::local({
[15:31:13.706]             c <- base::c
[15:31:13.706]             inherits <- base::inherits
[15:31:13.706]             invokeRestart <- base::invokeRestart
[15:31:13.706]             length <- base::length
[15:31:13.706]             list <- base::list
[15:31:13.706]             seq.int <- base::seq.int
[15:31:13.706]             signalCondition <- base::signalCondition
[15:31:13.706]             sys.calls <- base::sys.calls
[15:31:13.706]             `[[` <- base::`[[`
[15:31:13.706]             `+` <- base::`+`
[15:31:13.706]             `<<-` <- base::`<<-`
[15:31:13.706]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.706]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.706]                   3L)]
[15:31:13.706]             }
[15:31:13.706]             function(cond) {
[15:31:13.706]                 is_error <- inherits(cond, "error")
[15:31:13.706]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.706]                   NULL)
[15:31:13.706]                 if (is_error) {
[15:31:13.706]                   sessionInformation <- function() {
[15:31:13.706]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.706]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.706]                       search = base::search(), system = base::Sys.info())
[15:31:13.706]                   }
[15:31:13.706]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.706]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.706]                     cond$call), session = sessionInformation(), 
[15:31:13.706]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.706]                   signalCondition(cond)
[15:31:13.706]                 }
[15:31:13.706]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.706]                 "immediateCondition"))) {
[15:31:13.706]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.706]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.706]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.706]                   if (TRUE && !signal) {
[15:31:13.706]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.706]                     {
[15:31:13.706]                       inherits <- base::inherits
[15:31:13.706]                       invokeRestart <- base::invokeRestart
[15:31:13.706]                       is.null <- base::is.null
[15:31:13.706]                       muffled <- FALSE
[15:31:13.706]                       if (inherits(cond, "message")) {
[15:31:13.706]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.706]                         if (muffled) 
[15:31:13.706]                           invokeRestart("muffleMessage")
[15:31:13.706]                       }
[15:31:13.706]                       else if (inherits(cond, "warning")) {
[15:31:13.706]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.706]                         if (muffled) 
[15:31:13.706]                           invokeRestart("muffleWarning")
[15:31:13.706]                       }
[15:31:13.706]                       else if (inherits(cond, "condition")) {
[15:31:13.706]                         if (!is.null(pattern)) {
[15:31:13.706]                           computeRestarts <- base::computeRestarts
[15:31:13.706]                           grepl <- base::grepl
[15:31:13.706]                           restarts <- computeRestarts(cond)
[15:31:13.706]                           for (restart in restarts) {
[15:31:13.706]                             name <- restart$name
[15:31:13.706]                             if (is.null(name)) 
[15:31:13.706]                               next
[15:31:13.706]                             if (!grepl(pattern, name)) 
[15:31:13.706]                               next
[15:31:13.706]                             invokeRestart(restart)
[15:31:13.706]                             muffled <- TRUE
[15:31:13.706]                             break
[15:31:13.706]                           }
[15:31:13.706]                         }
[15:31:13.706]                       }
[15:31:13.706]                       invisible(muffled)
[15:31:13.706]                     }
[15:31:13.706]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.706]                   }
[15:31:13.706]                 }
[15:31:13.706]                 else {
[15:31:13.706]                   if (TRUE) {
[15:31:13.706]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.706]                     {
[15:31:13.706]                       inherits <- base::inherits
[15:31:13.706]                       invokeRestart <- base::invokeRestart
[15:31:13.706]                       is.null <- base::is.null
[15:31:13.706]                       muffled <- FALSE
[15:31:13.706]                       if (inherits(cond, "message")) {
[15:31:13.706]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.706]                         if (muffled) 
[15:31:13.706]                           invokeRestart("muffleMessage")
[15:31:13.706]                       }
[15:31:13.706]                       else if (inherits(cond, "warning")) {
[15:31:13.706]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.706]                         if (muffled) 
[15:31:13.706]                           invokeRestart("muffleWarning")
[15:31:13.706]                       }
[15:31:13.706]                       else if (inherits(cond, "condition")) {
[15:31:13.706]                         if (!is.null(pattern)) {
[15:31:13.706]                           computeRestarts <- base::computeRestarts
[15:31:13.706]                           grepl <- base::grepl
[15:31:13.706]                           restarts <- computeRestarts(cond)
[15:31:13.706]                           for (restart in restarts) {
[15:31:13.706]                             name <- restart$name
[15:31:13.706]                             if (is.null(name)) 
[15:31:13.706]                               next
[15:31:13.706]                             if (!grepl(pattern, name)) 
[15:31:13.706]                               next
[15:31:13.706]                             invokeRestart(restart)
[15:31:13.706]                             muffled <- TRUE
[15:31:13.706]                             break
[15:31:13.706]                           }
[15:31:13.706]                         }
[15:31:13.706]                       }
[15:31:13.706]                       invisible(muffled)
[15:31:13.706]                     }
[15:31:13.706]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.706]                   }
[15:31:13.706]                 }
[15:31:13.706]             }
[15:31:13.706]         }))
[15:31:13.706]     }, error = function(ex) {
[15:31:13.706]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.706]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.706]                 ...future.rng), started = ...future.startTime, 
[15:31:13.706]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.706]             version = "1.8"), class = "FutureResult")
[15:31:13.706]     }, finally = {
[15:31:13.706]         if (!identical(...future.workdir, getwd())) 
[15:31:13.706]             setwd(...future.workdir)
[15:31:13.706]         {
[15:31:13.706]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.706]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.706]             }
[15:31:13.706]             base::options(...future.oldOptions)
[15:31:13.706]             if (.Platform$OS.type == "windows") {
[15:31:13.706]                 old_names <- names(...future.oldEnvVars)
[15:31:13.706]                 envs <- base::Sys.getenv()
[15:31:13.706]                 names <- names(envs)
[15:31:13.706]                 common <- intersect(names, old_names)
[15:31:13.706]                 added <- setdiff(names, old_names)
[15:31:13.706]                 removed <- setdiff(old_names, names)
[15:31:13.706]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.706]                   envs[common]]
[15:31:13.706]                 NAMES <- toupper(changed)
[15:31:13.706]                 args <- list()
[15:31:13.706]                 for (kk in seq_along(NAMES)) {
[15:31:13.706]                   name <- changed[[kk]]
[15:31:13.706]                   NAME <- NAMES[[kk]]
[15:31:13.706]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.706]                     next
[15:31:13.706]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.706]                 }
[15:31:13.706]                 NAMES <- toupper(added)
[15:31:13.706]                 for (kk in seq_along(NAMES)) {
[15:31:13.706]                   name <- added[[kk]]
[15:31:13.706]                   NAME <- NAMES[[kk]]
[15:31:13.706]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.706]                     next
[15:31:13.706]                   args[[name]] <- ""
[15:31:13.706]                 }
[15:31:13.706]                 NAMES <- toupper(removed)
[15:31:13.706]                 for (kk in seq_along(NAMES)) {
[15:31:13.706]                   name <- removed[[kk]]
[15:31:13.706]                   NAME <- NAMES[[kk]]
[15:31:13.706]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.706]                     next
[15:31:13.706]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.706]                 }
[15:31:13.706]                 if (length(args) > 0) 
[15:31:13.706]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.706]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.706]             }
[15:31:13.706]             else {
[15:31:13.706]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.706]             }
[15:31:13.706]             {
[15:31:13.706]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.706]                   0L) {
[15:31:13.706]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.706]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.706]                   base::options(opts)
[15:31:13.706]                 }
[15:31:13.706]                 {
[15:31:13.706]                   {
[15:31:13.706]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.706]                     NULL
[15:31:13.706]                   }
[15:31:13.706]                   options(future.plan = NULL)
[15:31:13.706]                   if (is.na(NA_character_)) 
[15:31:13.706]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.706]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.706]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.706]                     .init = FALSE)
[15:31:13.706]                 }
[15:31:13.706]             }
[15:31:13.706]         }
[15:31:13.706]     })
[15:31:13.706]     if (TRUE) {
[15:31:13.706]         base::sink(type = "output", split = FALSE)
[15:31:13.706]         if (TRUE) {
[15:31:13.706]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.706]         }
[15:31:13.706]         else {
[15:31:13.706]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.706]         }
[15:31:13.706]         base::close(...future.stdout)
[15:31:13.706]         ...future.stdout <- NULL
[15:31:13.706]     }
[15:31:13.706]     ...future.result$conditions <- ...future.conditions
[15:31:13.706]     ...future.result$finished <- base::Sys.time()
[15:31:13.706]     ...future.result
[15:31:13.706] }
[15:31:13.714] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:13.714] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:13.715] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.715] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:13.716] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:13.716] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ...
[15:31:13.717] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ... DONE
[15:31:13.717] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.718] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.718] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.719] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.719] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.720] MultisessionFuture started
[15:31:13.720] - Launch lazy future ... done
[15:31:13.721] run() for 'MultisessionFuture' ... done
[15:31:13.721] Created future:
[15:31:13.751] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.752] - Validating connection of MultisessionFuture
[15:31:13.752] - received message: FutureResult
[15:31:13.752] - Received FutureResult
[15:31:13.753] - Erased future from FutureRegistry
[15:31:13.753] result() for ClusterFuture ...
[15:31:13.753] - result already collected: FutureResult
[15:31:13.753] result() for ClusterFuture ... done
[15:31:13.754] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.721] MultisessionFuture:
[15:31:13.721] Label: 'future_by-1'
[15:31:13.721] Expression:
[15:31:13.721] {
[15:31:13.721]     do.call(function(...) {
[15:31:13.721]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.721]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.721]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.721]             on.exit(options(oopts), add = TRUE)
[15:31:13.721]         }
[15:31:13.721]         {
[15:31:13.721]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.721]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.721]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.721]             })
[15:31:13.721]         }
[15:31:13.721]     }, args = future.call.arguments)
[15:31:13.721] }
[15:31:13.721] Lazy evaluation: FALSE
[15:31:13.721] Asynchronous evaluation: TRUE
[15:31:13.721] Local evaluation: TRUE
[15:31:13.721] Environment: 0x0000019c8379e490
[15:31:13.721] Capture standard output: TRUE
[15:31:13.721] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.721] Globals: 5 objects totaling 2.81 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 1.60 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.721] Packages: <none>
[15:31:13.721] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.721] Resolved: TRUE
[15:31:13.721] Value: <not collected>
[15:31:13.721] Conditions captured: <none>
[15:31:13.721] Early signaling: FALSE
[15:31:13.721] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.721] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.754] Chunk #1 of 2 ... DONE
[15:31:13.754] Chunk #2 of 2 ...
[15:31:13.755]  - Finding globals in 'X' for chunk #2 ...
[15:31:13.755] getGlobalsAndPackages() ...
[15:31:13.755] Searching for globals...
[15:31:13.756] 
[15:31:13.756] Searching for globals ... DONE
[15:31:13.757] - globals: [0] <none>
[15:31:13.757] getGlobalsAndPackages() ... DONE
[15:31:13.757]    + additional globals found: [n=0] 
[15:31:13.757]    + additional namespaces needed: [n=0] 
[15:31:13.757]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:13.758]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.758]  - seeds: <none>
[15:31:13.758]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.758] getGlobalsAndPackages() ...
[15:31:13.759] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.759] Resolving globals: FALSE
[15:31:13.759] Tweak future expression to call with '...' arguments ...
[15:31:13.759] {
[15:31:13.759]     do.call(function(...) {
[15:31:13.759]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.759]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.759]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.759]             on.exit(options(oopts), add = TRUE)
[15:31:13.759]         }
[15:31:13.759]         {
[15:31:13.759]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.759]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.759]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.759]             })
[15:31:13.759]         }
[15:31:13.759]     }, args = future.call.arguments)
[15:31:13.759] }
[15:31:13.760] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.761] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.761] 
[15:31:13.761] getGlobalsAndPackages() ... DONE
[15:31:13.762] run() for 'Future' ...
[15:31:13.762] - state: 'created'
[15:31:13.762] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.779] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.779] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.780]   - Field: 'node'
[15:31:13.780]   - Field: 'label'
[15:31:13.780]   - Field: 'local'
[15:31:13.781]   - Field: 'owner'
[15:31:13.781]   - Field: 'envir'
[15:31:13.781]   - Field: 'workers'
[15:31:13.781]   - Field: 'packages'
[15:31:13.782]   - Field: 'gc'
[15:31:13.782]   - Field: 'conditions'
[15:31:13.782]   - Field: 'persistent'
[15:31:13.782]   - Field: 'expr'
[15:31:13.783]   - Field: 'uuid'
[15:31:13.783]   - Field: 'seed'
[15:31:13.783]   - Field: 'version'
[15:31:13.783]   - Field: 'result'
[15:31:13.784]   - Field: 'asynchronous'
[15:31:13.784]   - Field: 'calls'
[15:31:13.784]   - Field: 'globals'
[15:31:13.784]   - Field: 'stdout'
[15:31:13.785]   - Field: 'earlySignal'
[15:31:13.785]   - Field: 'lazy'
[15:31:13.788]   - Field: 'state'
[15:31:13.788] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.789] - Launch lazy future ...
[15:31:13.789] Packages needed by the future expression (n = 0): <none>
[15:31:13.789] Packages needed by future strategies (n = 0): <none>
[15:31:13.790] {
[15:31:13.790]     {
[15:31:13.790]         {
[15:31:13.790]             ...future.startTime <- base::Sys.time()
[15:31:13.790]             {
[15:31:13.790]                 {
[15:31:13.790]                   {
[15:31:13.790]                     {
[15:31:13.790]                       base::local({
[15:31:13.790]                         has_future <- base::requireNamespace("future", 
[15:31:13.790]                           quietly = TRUE)
[15:31:13.790]                         if (has_future) {
[15:31:13.790]                           ns <- base::getNamespace("future")
[15:31:13.790]                           version <- ns[[".package"]][["version"]]
[15:31:13.790]                           if (is.null(version)) 
[15:31:13.790]                             version <- utils::packageVersion("future")
[15:31:13.790]                         }
[15:31:13.790]                         else {
[15:31:13.790]                           version <- NULL
[15:31:13.790]                         }
[15:31:13.790]                         if (!has_future || version < "1.8.0") {
[15:31:13.790]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.790]                             "", base::R.version$version.string), 
[15:31:13.790]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:13.790]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:13.790]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.790]                               "release", "version")], collapse = " "), 
[15:31:13.790]                             hostname = base::Sys.info()[["nodename"]])
[15:31:13.790]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.790]                             info)
[15:31:13.790]                           info <- base::paste(info, collapse = "; ")
[15:31:13.790]                           if (!has_future) {
[15:31:13.790]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.790]                               info)
[15:31:13.790]                           }
[15:31:13.790]                           else {
[15:31:13.790]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.790]                               info, version)
[15:31:13.790]                           }
[15:31:13.790]                           base::stop(msg)
[15:31:13.790]                         }
[15:31:13.790]                       })
[15:31:13.790]                     }
[15:31:13.790]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.790]                     base::options(mc.cores = 1L)
[15:31:13.790]                   }
[15:31:13.790]                   ...future.strategy.old <- future::plan("list")
[15:31:13.790]                   options(future.plan = NULL)
[15:31:13.790]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.790]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.790]                 }
[15:31:13.790]                 ...future.workdir <- getwd()
[15:31:13.790]             }
[15:31:13.790]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.790]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.790]         }
[15:31:13.790]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.790]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.790]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.790]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.790]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.790]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.790]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.790]             base::names(...future.oldOptions))
[15:31:13.790]     }
[15:31:13.790]     if (FALSE) {
[15:31:13.790]     }
[15:31:13.790]     else {
[15:31:13.790]         if (TRUE) {
[15:31:13.790]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.790]                 open = "w")
[15:31:13.790]         }
[15:31:13.790]         else {
[15:31:13.790]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.790]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.790]         }
[15:31:13.790]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.790]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.790]             base::sink(type = "output", split = FALSE)
[15:31:13.790]             base::close(...future.stdout)
[15:31:13.790]         }, add = TRUE)
[15:31:13.790]     }
[15:31:13.790]     ...future.frame <- base::sys.nframe()
[15:31:13.790]     ...future.conditions <- base::list()
[15:31:13.790]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.790]     if (FALSE) {
[15:31:13.790]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.790]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.790]     }
[15:31:13.790]     ...future.result <- base::tryCatch({
[15:31:13.790]         base::withCallingHandlers({
[15:31:13.790]             ...future.value <- base::withVisible(base::local({
[15:31:13.790]                 ...future.makeSendCondition <- base::local({
[15:31:13.790]                   sendCondition <- NULL
[15:31:13.790]                   function(frame = 1L) {
[15:31:13.790]                     if (is.function(sendCondition)) 
[15:31:13.790]                       return(sendCondition)
[15:31:13.790]                     ns <- getNamespace("parallel")
[15:31:13.790]                     if (exists("sendData", mode = "function", 
[15:31:13.790]                       envir = ns)) {
[15:31:13.790]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.790]                         envir = ns)
[15:31:13.790]                       envir <- sys.frame(frame)
[15:31:13.790]                       master <- NULL
[15:31:13.790]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.790]                         !identical(envir, emptyenv())) {
[15:31:13.790]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.790]                           inherits = FALSE)) {
[15:31:13.790]                           master <- get("master", mode = "list", 
[15:31:13.790]                             envir = envir, inherits = FALSE)
[15:31:13.790]                           if (inherits(master, c("SOCKnode", 
[15:31:13.790]                             "SOCK0node"))) {
[15:31:13.790]                             sendCondition <<- function(cond) {
[15:31:13.790]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.790]                                 success = TRUE)
[15:31:13.790]                               parallel_sendData(master, data)
[15:31:13.790]                             }
[15:31:13.790]                             return(sendCondition)
[15:31:13.790]                           }
[15:31:13.790]                         }
[15:31:13.790]                         frame <- frame + 1L
[15:31:13.790]                         envir <- sys.frame(frame)
[15:31:13.790]                       }
[15:31:13.790]                     }
[15:31:13.790]                     sendCondition <<- function(cond) NULL
[15:31:13.790]                   }
[15:31:13.790]                 })
[15:31:13.790]                 withCallingHandlers({
[15:31:13.790]                   {
[15:31:13.790]                     do.call(function(...) {
[15:31:13.790]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.790]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.790]                         ...future.globals.maxSize)) {
[15:31:13.790]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.790]                         on.exit(options(oopts), add = TRUE)
[15:31:13.790]                       }
[15:31:13.790]                       {
[15:31:13.790]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.790]                           FUN = function(jj) {
[15:31:13.790]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.790]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.790]                           })
[15:31:13.790]                       }
[15:31:13.790]                     }, args = future.call.arguments)
[15:31:13.790]                   }
[15:31:13.790]                 }, immediateCondition = function(cond) {
[15:31:13.790]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.790]                   sendCondition(cond)
[15:31:13.790]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.790]                   {
[15:31:13.790]                     inherits <- base::inherits
[15:31:13.790]                     invokeRestart <- base::invokeRestart
[15:31:13.790]                     is.null <- base::is.null
[15:31:13.790]                     muffled <- FALSE
[15:31:13.790]                     if (inherits(cond, "message")) {
[15:31:13.790]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.790]                       if (muffled) 
[15:31:13.790]                         invokeRestart("muffleMessage")
[15:31:13.790]                     }
[15:31:13.790]                     else if (inherits(cond, "warning")) {
[15:31:13.790]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.790]                       if (muffled) 
[15:31:13.790]                         invokeRestart("muffleWarning")
[15:31:13.790]                     }
[15:31:13.790]                     else if (inherits(cond, "condition")) {
[15:31:13.790]                       if (!is.null(pattern)) {
[15:31:13.790]                         computeRestarts <- base::computeRestarts
[15:31:13.790]                         grepl <- base::grepl
[15:31:13.790]                         restarts <- computeRestarts(cond)
[15:31:13.790]                         for (restart in restarts) {
[15:31:13.790]                           name <- restart$name
[15:31:13.790]                           if (is.null(name)) 
[15:31:13.790]                             next
[15:31:13.790]                           if (!grepl(pattern, name)) 
[15:31:13.790]                             next
[15:31:13.790]                           invokeRestart(restart)
[15:31:13.790]                           muffled <- TRUE
[15:31:13.790]                           break
[15:31:13.790]                         }
[15:31:13.790]                       }
[15:31:13.790]                     }
[15:31:13.790]                     invisible(muffled)
[15:31:13.790]                   }
[15:31:13.790]                   muffleCondition(cond)
[15:31:13.790]                 })
[15:31:13.790]             }))
[15:31:13.790]             future::FutureResult(value = ...future.value$value, 
[15:31:13.790]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.790]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.790]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.790]                     ...future.globalenv.names))
[15:31:13.790]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.790]         }, condition = base::local({
[15:31:13.790]             c <- base::c
[15:31:13.790]             inherits <- base::inherits
[15:31:13.790]             invokeRestart <- base::invokeRestart
[15:31:13.790]             length <- base::length
[15:31:13.790]             list <- base::list
[15:31:13.790]             seq.int <- base::seq.int
[15:31:13.790]             signalCondition <- base::signalCondition
[15:31:13.790]             sys.calls <- base::sys.calls
[15:31:13.790]             `[[` <- base::`[[`
[15:31:13.790]             `+` <- base::`+`
[15:31:13.790]             `<<-` <- base::`<<-`
[15:31:13.790]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.790]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.790]                   3L)]
[15:31:13.790]             }
[15:31:13.790]             function(cond) {
[15:31:13.790]                 is_error <- inherits(cond, "error")
[15:31:13.790]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.790]                   NULL)
[15:31:13.790]                 if (is_error) {
[15:31:13.790]                   sessionInformation <- function() {
[15:31:13.790]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.790]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.790]                       search = base::search(), system = base::Sys.info())
[15:31:13.790]                   }
[15:31:13.790]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.790]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.790]                     cond$call), session = sessionInformation(), 
[15:31:13.790]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.790]                   signalCondition(cond)
[15:31:13.790]                 }
[15:31:13.790]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.790]                 "immediateCondition"))) {
[15:31:13.790]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.790]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.790]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.790]                   if (TRUE && !signal) {
[15:31:13.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.790]                     {
[15:31:13.790]                       inherits <- base::inherits
[15:31:13.790]                       invokeRestart <- base::invokeRestart
[15:31:13.790]                       is.null <- base::is.null
[15:31:13.790]                       muffled <- FALSE
[15:31:13.790]                       if (inherits(cond, "message")) {
[15:31:13.790]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.790]                         if (muffled) 
[15:31:13.790]                           invokeRestart("muffleMessage")
[15:31:13.790]                       }
[15:31:13.790]                       else if (inherits(cond, "warning")) {
[15:31:13.790]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.790]                         if (muffled) 
[15:31:13.790]                           invokeRestart("muffleWarning")
[15:31:13.790]                       }
[15:31:13.790]                       else if (inherits(cond, "condition")) {
[15:31:13.790]                         if (!is.null(pattern)) {
[15:31:13.790]                           computeRestarts <- base::computeRestarts
[15:31:13.790]                           grepl <- base::grepl
[15:31:13.790]                           restarts <- computeRestarts(cond)
[15:31:13.790]                           for (restart in restarts) {
[15:31:13.790]                             name <- restart$name
[15:31:13.790]                             if (is.null(name)) 
[15:31:13.790]                               next
[15:31:13.790]                             if (!grepl(pattern, name)) 
[15:31:13.790]                               next
[15:31:13.790]                             invokeRestart(restart)
[15:31:13.790]                             muffled <- TRUE
[15:31:13.790]                             break
[15:31:13.790]                           }
[15:31:13.790]                         }
[15:31:13.790]                       }
[15:31:13.790]                       invisible(muffled)
[15:31:13.790]                     }
[15:31:13.790]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.790]                   }
[15:31:13.790]                 }
[15:31:13.790]                 else {
[15:31:13.790]                   if (TRUE) {
[15:31:13.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.790]                     {
[15:31:13.790]                       inherits <- base::inherits
[15:31:13.790]                       invokeRestart <- base::invokeRestart
[15:31:13.790]                       is.null <- base::is.null
[15:31:13.790]                       muffled <- FALSE
[15:31:13.790]                       if (inherits(cond, "message")) {
[15:31:13.790]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.790]                         if (muffled) 
[15:31:13.790]                           invokeRestart("muffleMessage")
[15:31:13.790]                       }
[15:31:13.790]                       else if (inherits(cond, "warning")) {
[15:31:13.790]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.790]                         if (muffled) 
[15:31:13.790]                           invokeRestart("muffleWarning")
[15:31:13.790]                       }
[15:31:13.790]                       else if (inherits(cond, "condition")) {
[15:31:13.790]                         if (!is.null(pattern)) {
[15:31:13.790]                           computeRestarts <- base::computeRestarts
[15:31:13.790]                           grepl <- base::grepl
[15:31:13.790]                           restarts <- computeRestarts(cond)
[15:31:13.790]                           for (restart in restarts) {
[15:31:13.790]                             name <- restart$name
[15:31:13.790]                             if (is.null(name)) 
[15:31:13.790]                               next
[15:31:13.790]                             if (!grepl(pattern, name)) 
[15:31:13.790]                               next
[15:31:13.790]                             invokeRestart(restart)
[15:31:13.790]                             muffled <- TRUE
[15:31:13.790]                             break
[15:31:13.790]                           }
[15:31:13.790]                         }
[15:31:13.790]                       }
[15:31:13.790]                       invisible(muffled)
[15:31:13.790]                     }
[15:31:13.790]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.790]                   }
[15:31:13.790]                 }
[15:31:13.790]             }
[15:31:13.790]         }))
[15:31:13.790]     }, error = function(ex) {
[15:31:13.790]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.790]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.790]                 ...future.rng), started = ...future.startTime, 
[15:31:13.790]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.790]             version = "1.8"), class = "FutureResult")
[15:31:13.790]     }, finally = {
[15:31:13.790]         if (!identical(...future.workdir, getwd())) 
[15:31:13.790]             setwd(...future.workdir)
[15:31:13.790]         {
[15:31:13.790]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.790]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.790]             }
[15:31:13.790]             base::options(...future.oldOptions)
[15:31:13.790]             if (.Platform$OS.type == "windows") {
[15:31:13.790]                 old_names <- names(...future.oldEnvVars)
[15:31:13.790]                 envs <- base::Sys.getenv()
[15:31:13.790]                 names <- names(envs)
[15:31:13.790]                 common <- intersect(names, old_names)
[15:31:13.790]                 added <- setdiff(names, old_names)
[15:31:13.790]                 removed <- setdiff(old_names, names)
[15:31:13.790]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.790]                   envs[common]]
[15:31:13.790]                 NAMES <- toupper(changed)
[15:31:13.790]                 args <- list()
[15:31:13.790]                 for (kk in seq_along(NAMES)) {
[15:31:13.790]                   name <- changed[[kk]]
[15:31:13.790]                   NAME <- NAMES[[kk]]
[15:31:13.790]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.790]                     next
[15:31:13.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.790]                 }
[15:31:13.790]                 NAMES <- toupper(added)
[15:31:13.790]                 for (kk in seq_along(NAMES)) {
[15:31:13.790]                   name <- added[[kk]]
[15:31:13.790]                   NAME <- NAMES[[kk]]
[15:31:13.790]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.790]                     next
[15:31:13.790]                   args[[name]] <- ""
[15:31:13.790]                 }
[15:31:13.790]                 NAMES <- toupper(removed)
[15:31:13.790]                 for (kk in seq_along(NAMES)) {
[15:31:13.790]                   name <- removed[[kk]]
[15:31:13.790]                   NAME <- NAMES[[kk]]
[15:31:13.790]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.790]                     next
[15:31:13.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.790]                 }
[15:31:13.790]                 if (length(args) > 0) 
[15:31:13.790]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.790]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.790]             }
[15:31:13.790]             else {
[15:31:13.790]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.790]             }
[15:31:13.790]             {
[15:31:13.790]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.790]                   0L) {
[15:31:13.790]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.790]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.790]                   base::options(opts)
[15:31:13.790]                 }
[15:31:13.790]                 {
[15:31:13.790]                   {
[15:31:13.790]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.790]                     NULL
[15:31:13.790]                   }
[15:31:13.790]                   options(future.plan = NULL)
[15:31:13.790]                   if (is.na(NA_character_)) 
[15:31:13.790]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.790]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.790]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.790]                     .init = FALSE)
[15:31:13.790]                 }
[15:31:13.790]             }
[15:31:13.790]         }
[15:31:13.790]     })
[15:31:13.790]     if (TRUE) {
[15:31:13.790]         base::sink(type = "output", split = FALSE)
[15:31:13.790]         if (TRUE) {
[15:31:13.790]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.790]         }
[15:31:13.790]         else {
[15:31:13.790]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.790]         }
[15:31:13.790]         base::close(...future.stdout)
[15:31:13.790]         ...future.stdout <- NULL
[15:31:13.790]     }
[15:31:13.790]     ...future.result$conditions <- ...future.conditions
[15:31:13.790]     ...future.result$finished <- base::Sys.time()
[15:31:13.790]     ...future.result
[15:31:13.790] }
[15:31:13.798] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:13.798] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:13.799] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.799] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:13.800] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:13.800] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ...
[15:31:13.801] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ... DONE
[15:31:13.801] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.801] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.802] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.802] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.802] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.803] MultisessionFuture started
[15:31:13.803] - Launch lazy future ... done
[15:31:13.803] run() for 'MultisessionFuture' ... done
[15:31:13.804] Created future:
[15:31:13.820] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.820] - Validating connection of MultisessionFuture
[15:31:13.820] - received message: FutureResult
[15:31:13.821] - Received FutureResult
[15:31:13.821] - Erased future from FutureRegistry
[15:31:13.821] result() for ClusterFuture ...
[15:31:13.821] - result already collected: FutureResult
[15:31:13.821] result() for ClusterFuture ... done
[15:31:13.821] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.804] MultisessionFuture:
[15:31:13.804] Label: 'future_by-2'
[15:31:13.804] Expression:
[15:31:13.804] {
[15:31:13.804]     do.call(function(...) {
[15:31:13.804]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.804]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.804]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.804]             on.exit(options(oopts), add = TRUE)
[15:31:13.804]         }
[15:31:13.804]         {
[15:31:13.804]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.804]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.804]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.804]             })
[15:31:13.804]         }
[15:31:13.804]     }, args = future.call.arguments)
[15:31:13.804] }
[15:31:13.804] Lazy evaluation: FALSE
[15:31:13.804] Asynchronous evaluation: TRUE
[15:31:13.804] Local evaluation: TRUE
[15:31:13.804] Environment: 0x0000019c8379e490
[15:31:13.804] Capture standard output: TRUE
[15:31:13.804] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.804] Globals: 5 objects totaling 4.41 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 3.20 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.804] Packages: <none>
[15:31:13.804] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.804] Resolved: TRUE
[15:31:13.804] Value: <not collected>
[15:31:13.804] Conditions captured: <none>
[15:31:13.804] Early signaling: FALSE
[15:31:13.804] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.804] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.822] Chunk #2 of 2 ... DONE
[15:31:13.822] Launching 2 futures (chunks) ... DONE
[15:31:13.822] Resolving 2 futures (chunks) ...
[15:31:13.822] resolve() on list ...
[15:31:13.823]  recursive: 0
[15:31:13.823]  length: 2
[15:31:13.823] 
[15:31:13.823] Future #1
[15:31:13.823] result() for ClusterFuture ...
[15:31:13.823] - result already collected: FutureResult
[15:31:13.824] result() for ClusterFuture ... done
[15:31:13.824] result() for ClusterFuture ...
[15:31:13.824] - result already collected: FutureResult
[15:31:13.824] result() for ClusterFuture ... done
[15:31:13.824] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:13.824] - nx: 2
[15:31:13.825] - relay: TRUE
[15:31:13.825] - stdout: TRUE
[15:31:13.825] - signal: TRUE
[15:31:13.825] - resignal: FALSE
[15:31:13.825] - force: TRUE
[15:31:13.825] - relayed: [n=2] FALSE, FALSE
[15:31:13.826] - queued futures: [n=2] FALSE, FALSE
[15:31:13.826]  - until=1
[15:31:13.826]  - relaying element #1
[15:31:13.826] result() for ClusterFuture ...
[15:31:13.826] - result already collected: FutureResult
[15:31:13.826] result() for ClusterFuture ... done
[15:31:13.827] result() for ClusterFuture ...
[15:31:13.827] - result already collected: FutureResult
[15:31:13.827] result() for ClusterFuture ... done
[15:31:13.827] result() for ClusterFuture ...
[15:31:13.827] - result already collected: FutureResult
[15:31:13.827] result() for ClusterFuture ... done
[15:31:13.828] result() for ClusterFuture ...
[15:31:13.828] - result already collected: FutureResult
[15:31:13.828] result() for ClusterFuture ... done
[15:31:13.828] - relayed: [n=2] TRUE, FALSE
[15:31:13.828] - queued futures: [n=2] TRUE, FALSE
[15:31:13.828] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:13.829]  length: 1 (resolved future 1)
[15:31:13.829] Future #2
[15:31:13.829] result() for ClusterFuture ...
[15:31:13.829] - result already collected: FutureResult
[15:31:13.829] result() for ClusterFuture ... done
[15:31:13.829] result() for ClusterFuture ...
[15:31:13.829] - result already collected: FutureResult
[15:31:13.830] result() for ClusterFuture ... done
[15:31:13.830] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:13.830] - nx: 2
[15:31:13.830] - relay: TRUE
[15:31:13.830] - stdout: TRUE
[15:31:13.830] - signal: TRUE
[15:31:13.831] - resignal: FALSE
[15:31:13.831] - force: TRUE
[15:31:13.831] - relayed: [n=2] TRUE, FALSE
[15:31:13.831] - queued futures: [n=2] TRUE, FALSE
[15:31:13.831]  - until=2
[15:31:13.831]  - relaying element #2
[15:31:13.832] result() for ClusterFuture ...
[15:31:13.832] - result already collected: FutureResult
[15:31:13.832] result() for ClusterFuture ... done
[15:31:13.832] result() for ClusterFuture ...
[15:31:13.832] - result already collected: FutureResult
[15:31:13.832] result() for ClusterFuture ... done
[15:31:13.833] result() for ClusterFuture ...
[15:31:13.833] - result already collected: FutureResult
[15:31:13.833] result() for ClusterFuture ... done
[15:31:13.833] result() for ClusterFuture ...
[15:31:13.833] - result already collected: FutureResult
[15:31:13.833] result() for ClusterFuture ... done
[15:31:13.833] - relayed: [n=2] TRUE, TRUE
[15:31:13.834] - queued futures: [n=2] TRUE, TRUE
[15:31:13.834] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:13.834]  length: 0 (resolved future 2)
[15:31:13.834] Relaying remaining futures
[15:31:13.834] signalConditionsASAP(NULL, pos=0) ...
[15:31:13.834] - nx: 2
[15:31:13.835] - relay: TRUE
[15:31:13.835] - stdout: TRUE
[15:31:13.835] - signal: TRUE
[15:31:13.835] - resignal: FALSE
[15:31:13.835] - force: TRUE
[15:31:13.835] - relayed: [n=2] TRUE, TRUE
[15:31:13.835] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:13.836] - relayed: [n=2] TRUE, TRUE
[15:31:13.836] - queued futures: [n=2] TRUE, TRUE
[15:31:13.836] signalConditionsASAP(NULL, pos=0) ... done
[15:31:13.836] resolve() on list ... DONE
[15:31:13.836] result() for ClusterFuture ...
[15:31:13.837] - result already collected: FutureResult
[15:31:13.837] result() for ClusterFuture ... done
[15:31:13.837] result() for ClusterFuture ...
[15:31:13.837] - result already collected: FutureResult
[15:31:13.837] result() for ClusterFuture ... done
[15:31:13.837] result() for ClusterFuture ...
[15:31:13.838] - result already collected: FutureResult
[15:31:13.838] result() for ClusterFuture ... done
[15:31:13.838] result() for ClusterFuture ...
[15:31:13.838] - result already collected: FutureResult
[15:31:13.838] result() for ClusterFuture ... done
[15:31:13.838]  - Number of value chunks collected: 2
[15:31:13.838] Resolving 2 futures (chunks) ... DONE
[15:31:13.839] Reducing values from 2 chunks ...
[15:31:13.839]  - Number of values collected after concatenation: 3
[15:31:13.839]  - Number of values expected: 3
[15:31:13.839] Reducing values from 2 chunks ... DONE
[15:31:13.839] future_lapply() ... DONE
[15:31:13.839] future_by_internal() ... DONE
[15:31:13.841] 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.
[15:31:13.841] future_lapply() ...
[15:31:13.844] Number of chunks: 2
[15:31:13.845] getGlobalsAndPackagesXApply() ...
[15:31:13.845]  - future.globals: TRUE
[15:31:13.845] getGlobalsAndPackages() ...
[15:31:13.845] Searching for globals...
[15:31:13.846] - globals found: [2] 'FUN', 'UseMethod'
[15:31:13.847] Searching for globals ... DONE
[15:31:13.847] Resolving globals: FALSE
[15:31:13.847] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:13.848] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:13.848] - globals: [1] 'FUN'
[15:31:13.848] 
[15:31:13.848] getGlobalsAndPackages() ... DONE
[15:31:13.848]  - globals found/used: [n=1] 'FUN'
[15:31:13.849]  - needed namespaces: [n=0] 
[15:31:13.849] Finding globals ... DONE
[15:31:13.849]  - use_args: TRUE
[15:31:13.849]  - Getting '...' globals ...
[15:31:13.850] resolve() on list ...
[15:31:13.850]  recursive: 0
[15:31:13.850]  length: 1
[15:31:13.850]  elements: '...'
[15:31:13.850]  length: 0 (resolved future 1)
[15:31:13.850] resolve() on list ... DONE
[15:31:13.851]    - '...' content: [n=0] 
[15:31:13.851] List of 1
[15:31:13.851]  $ ...: list()
[15:31:13.851]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.851]  - attr(*, "where")=List of 1
[15:31:13.851]   ..$ ...:<environment: 0x0000019c7f358db8> 
[15:31:13.851]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.851]  - attr(*, "resolved")= logi TRUE
[15:31:13.851]  - attr(*, "total_size")= num NA
[15:31:13.854]  - Getting '...' globals ... DONE
[15:31:13.854] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:13.854] List of 2
[15:31:13.854]  $ ...future.FUN:function (object, ...)  
[15:31:13.854]  $ ...          : list()
[15:31:13.854]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:13.854]  - attr(*, "where")=List of 2
[15:31:13.854]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:13.854]   ..$ ...          :<environment: 0x0000019c7f358db8> 
[15:31:13.854]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:13.854]  - attr(*, "resolved")= logi FALSE
[15:31:13.854]  - attr(*, "total_size")= num 1240
[15:31:13.858] Packages to be attached in all futures: [n=0] 
[15:31:13.858] getGlobalsAndPackagesXApply() ... DONE
[15:31:13.859] Number of futures (= number of chunks): 2
[15:31:13.859] Launching 2 futures (chunks) ...
[15:31:13.859] Chunk #1 of 2 ...
[15:31:13.860]  - Finding globals in 'X' for chunk #1 ...
[15:31:13.860] getGlobalsAndPackages() ...
[15:31:13.860] Searching for globals...
[15:31:13.861] 
[15:31:13.861] Searching for globals ... DONE
[15:31:13.862] - globals: [0] <none>
[15:31:13.862] getGlobalsAndPackages() ... DONE
[15:31:13.862]    + additional globals found: [n=0] 
[15:31:13.862]    + additional namespaces needed: [n=0] 
[15:31:13.863]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:13.863]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.863]  - seeds: <none>
[15:31:13.863]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.864] getGlobalsAndPackages() ...
[15:31:13.864] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.864] Resolving globals: FALSE
[15:31:13.865] Tweak future expression to call with '...' arguments ...
[15:31:13.865] {
[15:31:13.865]     do.call(function(...) {
[15:31:13.865]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.865]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.865]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.865]             on.exit(options(oopts), add = TRUE)
[15:31:13.865]         }
[15:31:13.865]         {
[15:31:13.865]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.865]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.865]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.865]             })
[15:31:13.865]         }
[15:31:13.865]     }, args = future.call.arguments)
[15:31:13.865] }
[15:31:13.866] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.866] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.867] 
[15:31:13.867] getGlobalsAndPackages() ... DONE
[15:31:13.868] run() for 'Future' ...
[15:31:13.868] - state: 'created'
[15:31:13.868] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.887] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.887] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.887]   - Field: 'node'
[15:31:13.888]   - Field: 'label'
[15:31:13.888]   - Field: 'local'
[15:31:13.888]   - Field: 'owner'
[15:31:13.889]   - Field: 'envir'
[15:31:13.889]   - Field: 'workers'
[15:31:13.889]   - Field: 'packages'
[15:31:13.890]   - Field: 'gc'
[15:31:13.890]   - Field: 'conditions'
[15:31:13.890]   - Field: 'persistent'
[15:31:13.891]   - Field: 'expr'
[15:31:13.891]   - Field: 'uuid'
[15:31:13.891]   - Field: 'seed'
[15:31:13.892]   - Field: 'version'
[15:31:13.892]   - Field: 'result'
[15:31:13.892]   - Field: 'asynchronous'
[15:31:13.892]   - Field: 'calls'
[15:31:13.893]   - Field: 'globals'
[15:31:13.893]   - Field: 'stdout'
[15:31:13.894]   - Field: 'earlySignal'
[15:31:13.894]   - Field: 'lazy'
[15:31:13.894]   - Field: 'state'
[15:31:13.894] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.895] - Launch lazy future ...
[15:31:13.895] Packages needed by the future expression (n = 0): <none>
[15:31:13.896] Packages needed by future strategies (n = 0): <none>
[15:31:13.897] {
[15:31:13.897]     {
[15:31:13.897]         {
[15:31:13.897]             ...future.startTime <- base::Sys.time()
[15:31:13.897]             {
[15:31:13.897]                 {
[15:31:13.897]                   {
[15:31:13.897]                     {
[15:31:13.897]                       base::local({
[15:31:13.897]                         has_future <- base::requireNamespace("future", 
[15:31:13.897]                           quietly = TRUE)
[15:31:13.897]                         if (has_future) {
[15:31:13.897]                           ns <- base::getNamespace("future")
[15:31:13.897]                           version <- ns[[".package"]][["version"]]
[15:31:13.897]                           if (is.null(version)) 
[15:31:13.897]                             version <- utils::packageVersion("future")
[15:31:13.897]                         }
[15:31:13.897]                         else {
[15:31:13.897]                           version <- NULL
[15:31:13.897]                         }
[15:31:13.897]                         if (!has_future || version < "1.8.0") {
[15:31:13.897]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.897]                             "", base::R.version$version.string), 
[15:31:13.897]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:13.897]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:13.897]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.897]                               "release", "version")], collapse = " "), 
[15:31:13.897]                             hostname = base::Sys.info()[["nodename"]])
[15:31:13.897]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.897]                             info)
[15:31:13.897]                           info <- base::paste(info, collapse = "; ")
[15:31:13.897]                           if (!has_future) {
[15:31:13.897]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.897]                               info)
[15:31:13.897]                           }
[15:31:13.897]                           else {
[15:31:13.897]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.897]                               info, version)
[15:31:13.897]                           }
[15:31:13.897]                           base::stop(msg)
[15:31:13.897]                         }
[15:31:13.897]                       })
[15:31:13.897]                     }
[15:31:13.897]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.897]                     base::options(mc.cores = 1L)
[15:31:13.897]                   }
[15:31:13.897]                   ...future.strategy.old <- future::plan("list")
[15:31:13.897]                   options(future.plan = NULL)
[15:31:13.897]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.897]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.897]                 }
[15:31:13.897]                 ...future.workdir <- getwd()
[15:31:13.897]             }
[15:31:13.897]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.897]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.897]         }
[15:31:13.897]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.897]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.897]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.897]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.897]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.897]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.897]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.897]             base::names(...future.oldOptions))
[15:31:13.897]     }
[15:31:13.897]     if (FALSE) {
[15:31:13.897]     }
[15:31:13.897]     else {
[15:31:13.897]         if (TRUE) {
[15:31:13.897]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.897]                 open = "w")
[15:31:13.897]         }
[15:31:13.897]         else {
[15:31:13.897]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.897]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.897]         }
[15:31:13.897]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.897]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.897]             base::sink(type = "output", split = FALSE)
[15:31:13.897]             base::close(...future.stdout)
[15:31:13.897]         }, add = TRUE)
[15:31:13.897]     }
[15:31:13.897]     ...future.frame <- base::sys.nframe()
[15:31:13.897]     ...future.conditions <- base::list()
[15:31:13.897]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.897]     if (FALSE) {
[15:31:13.897]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.897]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.897]     }
[15:31:13.897]     ...future.result <- base::tryCatch({
[15:31:13.897]         base::withCallingHandlers({
[15:31:13.897]             ...future.value <- base::withVisible(base::local({
[15:31:13.897]                 ...future.makeSendCondition <- base::local({
[15:31:13.897]                   sendCondition <- NULL
[15:31:13.897]                   function(frame = 1L) {
[15:31:13.897]                     if (is.function(sendCondition)) 
[15:31:13.897]                       return(sendCondition)
[15:31:13.897]                     ns <- getNamespace("parallel")
[15:31:13.897]                     if (exists("sendData", mode = "function", 
[15:31:13.897]                       envir = ns)) {
[15:31:13.897]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.897]                         envir = ns)
[15:31:13.897]                       envir <- sys.frame(frame)
[15:31:13.897]                       master <- NULL
[15:31:13.897]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.897]                         !identical(envir, emptyenv())) {
[15:31:13.897]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.897]                           inherits = FALSE)) {
[15:31:13.897]                           master <- get("master", mode = "list", 
[15:31:13.897]                             envir = envir, inherits = FALSE)
[15:31:13.897]                           if (inherits(master, c("SOCKnode", 
[15:31:13.897]                             "SOCK0node"))) {
[15:31:13.897]                             sendCondition <<- function(cond) {
[15:31:13.897]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.897]                                 success = TRUE)
[15:31:13.897]                               parallel_sendData(master, data)
[15:31:13.897]                             }
[15:31:13.897]                             return(sendCondition)
[15:31:13.897]                           }
[15:31:13.897]                         }
[15:31:13.897]                         frame <- frame + 1L
[15:31:13.897]                         envir <- sys.frame(frame)
[15:31:13.897]                       }
[15:31:13.897]                     }
[15:31:13.897]                     sendCondition <<- function(cond) NULL
[15:31:13.897]                   }
[15:31:13.897]                 })
[15:31:13.897]                 withCallingHandlers({
[15:31:13.897]                   {
[15:31:13.897]                     do.call(function(...) {
[15:31:13.897]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.897]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.897]                         ...future.globals.maxSize)) {
[15:31:13.897]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.897]                         on.exit(options(oopts), add = TRUE)
[15:31:13.897]                       }
[15:31:13.897]                       {
[15:31:13.897]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.897]                           FUN = function(jj) {
[15:31:13.897]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.897]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.897]                           })
[15:31:13.897]                       }
[15:31:13.897]                     }, args = future.call.arguments)
[15:31:13.897]                   }
[15:31:13.897]                 }, immediateCondition = function(cond) {
[15:31:13.897]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.897]                   sendCondition(cond)
[15:31:13.897]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.897]                   {
[15:31:13.897]                     inherits <- base::inherits
[15:31:13.897]                     invokeRestart <- base::invokeRestart
[15:31:13.897]                     is.null <- base::is.null
[15:31:13.897]                     muffled <- FALSE
[15:31:13.897]                     if (inherits(cond, "message")) {
[15:31:13.897]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.897]                       if (muffled) 
[15:31:13.897]                         invokeRestart("muffleMessage")
[15:31:13.897]                     }
[15:31:13.897]                     else if (inherits(cond, "warning")) {
[15:31:13.897]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.897]                       if (muffled) 
[15:31:13.897]                         invokeRestart("muffleWarning")
[15:31:13.897]                     }
[15:31:13.897]                     else if (inherits(cond, "condition")) {
[15:31:13.897]                       if (!is.null(pattern)) {
[15:31:13.897]                         computeRestarts <- base::computeRestarts
[15:31:13.897]                         grepl <- base::grepl
[15:31:13.897]                         restarts <- computeRestarts(cond)
[15:31:13.897]                         for (restart in restarts) {
[15:31:13.897]                           name <- restart$name
[15:31:13.897]                           if (is.null(name)) 
[15:31:13.897]                             next
[15:31:13.897]                           if (!grepl(pattern, name)) 
[15:31:13.897]                             next
[15:31:13.897]                           invokeRestart(restart)
[15:31:13.897]                           muffled <- TRUE
[15:31:13.897]                           break
[15:31:13.897]                         }
[15:31:13.897]                       }
[15:31:13.897]                     }
[15:31:13.897]                     invisible(muffled)
[15:31:13.897]                   }
[15:31:13.897]                   muffleCondition(cond)
[15:31:13.897]                 })
[15:31:13.897]             }))
[15:31:13.897]             future::FutureResult(value = ...future.value$value, 
[15:31:13.897]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.897]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.897]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.897]                     ...future.globalenv.names))
[15:31:13.897]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.897]         }, condition = base::local({
[15:31:13.897]             c <- base::c
[15:31:13.897]             inherits <- base::inherits
[15:31:13.897]             invokeRestart <- base::invokeRestart
[15:31:13.897]             length <- base::length
[15:31:13.897]             list <- base::list
[15:31:13.897]             seq.int <- base::seq.int
[15:31:13.897]             signalCondition <- base::signalCondition
[15:31:13.897]             sys.calls <- base::sys.calls
[15:31:13.897]             `[[` <- base::`[[`
[15:31:13.897]             `+` <- base::`+`
[15:31:13.897]             `<<-` <- base::`<<-`
[15:31:13.897]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.897]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.897]                   3L)]
[15:31:13.897]             }
[15:31:13.897]             function(cond) {
[15:31:13.897]                 is_error <- inherits(cond, "error")
[15:31:13.897]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.897]                   NULL)
[15:31:13.897]                 if (is_error) {
[15:31:13.897]                   sessionInformation <- function() {
[15:31:13.897]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.897]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.897]                       search = base::search(), system = base::Sys.info())
[15:31:13.897]                   }
[15:31:13.897]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.897]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.897]                     cond$call), session = sessionInformation(), 
[15:31:13.897]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.897]                   signalCondition(cond)
[15:31:13.897]                 }
[15:31:13.897]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.897]                 "immediateCondition"))) {
[15:31:13.897]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.897]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.897]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.897]                   if (TRUE && !signal) {
[15:31:13.897]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.897]                     {
[15:31:13.897]                       inherits <- base::inherits
[15:31:13.897]                       invokeRestart <- base::invokeRestart
[15:31:13.897]                       is.null <- base::is.null
[15:31:13.897]                       muffled <- FALSE
[15:31:13.897]                       if (inherits(cond, "message")) {
[15:31:13.897]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.897]                         if (muffled) 
[15:31:13.897]                           invokeRestart("muffleMessage")
[15:31:13.897]                       }
[15:31:13.897]                       else if (inherits(cond, "warning")) {
[15:31:13.897]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.897]                         if (muffled) 
[15:31:13.897]                           invokeRestart("muffleWarning")
[15:31:13.897]                       }
[15:31:13.897]                       else if (inherits(cond, "condition")) {
[15:31:13.897]                         if (!is.null(pattern)) {
[15:31:13.897]                           computeRestarts <- base::computeRestarts
[15:31:13.897]                           grepl <- base::grepl
[15:31:13.897]                           restarts <- computeRestarts(cond)
[15:31:13.897]                           for (restart in restarts) {
[15:31:13.897]                             name <- restart$name
[15:31:13.897]                             if (is.null(name)) 
[15:31:13.897]                               next
[15:31:13.897]                             if (!grepl(pattern, name)) 
[15:31:13.897]                               next
[15:31:13.897]                             invokeRestart(restart)
[15:31:13.897]                             muffled <- TRUE
[15:31:13.897]                             break
[15:31:13.897]                           }
[15:31:13.897]                         }
[15:31:13.897]                       }
[15:31:13.897]                       invisible(muffled)
[15:31:13.897]                     }
[15:31:13.897]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.897]                   }
[15:31:13.897]                 }
[15:31:13.897]                 else {
[15:31:13.897]                   if (TRUE) {
[15:31:13.897]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.897]                     {
[15:31:13.897]                       inherits <- base::inherits
[15:31:13.897]                       invokeRestart <- base::invokeRestart
[15:31:13.897]                       is.null <- base::is.null
[15:31:13.897]                       muffled <- FALSE
[15:31:13.897]                       if (inherits(cond, "message")) {
[15:31:13.897]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.897]                         if (muffled) 
[15:31:13.897]                           invokeRestart("muffleMessage")
[15:31:13.897]                       }
[15:31:13.897]                       else if (inherits(cond, "warning")) {
[15:31:13.897]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.897]                         if (muffled) 
[15:31:13.897]                           invokeRestart("muffleWarning")
[15:31:13.897]                       }
[15:31:13.897]                       else if (inherits(cond, "condition")) {
[15:31:13.897]                         if (!is.null(pattern)) {
[15:31:13.897]                           computeRestarts <- base::computeRestarts
[15:31:13.897]                           grepl <- base::grepl
[15:31:13.897]                           restarts <- computeRestarts(cond)
[15:31:13.897]                           for (restart in restarts) {
[15:31:13.897]                             name <- restart$name
[15:31:13.897]                             if (is.null(name)) 
[15:31:13.897]                               next
[15:31:13.897]                             if (!grepl(pattern, name)) 
[15:31:13.897]                               next
[15:31:13.897]                             invokeRestart(restart)
[15:31:13.897]                             muffled <- TRUE
[15:31:13.897]                             break
[15:31:13.897]                           }
[15:31:13.897]                         }
[15:31:13.897]                       }
[15:31:13.897]                       invisible(muffled)
[15:31:13.897]                     }
[15:31:13.897]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.897]                   }
[15:31:13.897]                 }
[15:31:13.897]             }
[15:31:13.897]         }))
[15:31:13.897]     }, error = function(ex) {
[15:31:13.897]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.897]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.897]                 ...future.rng), started = ...future.startTime, 
[15:31:13.897]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.897]             version = "1.8"), class = "FutureResult")
[15:31:13.897]     }, finally = {
[15:31:13.897]         if (!identical(...future.workdir, getwd())) 
[15:31:13.897]             setwd(...future.workdir)
[15:31:13.897]         {
[15:31:13.897]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.897]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.897]             }
[15:31:13.897]             base::options(...future.oldOptions)
[15:31:13.897]             if (.Platform$OS.type == "windows") {
[15:31:13.897]                 old_names <- names(...future.oldEnvVars)
[15:31:13.897]                 envs <- base::Sys.getenv()
[15:31:13.897]                 names <- names(envs)
[15:31:13.897]                 common <- intersect(names, old_names)
[15:31:13.897]                 added <- setdiff(names, old_names)
[15:31:13.897]                 removed <- setdiff(old_names, names)
[15:31:13.897]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.897]                   envs[common]]
[15:31:13.897]                 NAMES <- toupper(changed)
[15:31:13.897]                 args <- list()
[15:31:13.897]                 for (kk in seq_along(NAMES)) {
[15:31:13.897]                   name <- changed[[kk]]
[15:31:13.897]                   NAME <- NAMES[[kk]]
[15:31:13.897]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.897]                     next
[15:31:13.897]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.897]                 }
[15:31:13.897]                 NAMES <- toupper(added)
[15:31:13.897]                 for (kk in seq_along(NAMES)) {
[15:31:13.897]                   name <- added[[kk]]
[15:31:13.897]                   NAME <- NAMES[[kk]]
[15:31:13.897]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.897]                     next
[15:31:13.897]                   args[[name]] <- ""
[15:31:13.897]                 }
[15:31:13.897]                 NAMES <- toupper(removed)
[15:31:13.897]                 for (kk in seq_along(NAMES)) {
[15:31:13.897]                   name <- removed[[kk]]
[15:31:13.897]                   NAME <- NAMES[[kk]]
[15:31:13.897]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.897]                     next
[15:31:13.897]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.897]                 }
[15:31:13.897]                 if (length(args) > 0) 
[15:31:13.897]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.897]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.897]             }
[15:31:13.897]             else {
[15:31:13.897]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.897]             }
[15:31:13.897]             {
[15:31:13.897]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.897]                   0L) {
[15:31:13.897]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.897]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.897]                   base::options(opts)
[15:31:13.897]                 }
[15:31:13.897]                 {
[15:31:13.897]                   {
[15:31:13.897]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.897]                     NULL
[15:31:13.897]                   }
[15:31:13.897]                   options(future.plan = NULL)
[15:31:13.897]                   if (is.na(NA_character_)) 
[15:31:13.897]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.897]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.897]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.897]                     .init = FALSE)
[15:31:13.897]                 }
[15:31:13.897]             }
[15:31:13.897]         }
[15:31:13.897]     })
[15:31:13.897]     if (TRUE) {
[15:31:13.897]         base::sink(type = "output", split = FALSE)
[15:31:13.897]         if (TRUE) {
[15:31:13.897]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.897]         }
[15:31:13.897]         else {
[15:31:13.897]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.897]         }
[15:31:13.897]         base::close(...future.stdout)
[15:31:13.897]         ...future.stdout <- NULL
[15:31:13.897]     }
[15:31:13.897]     ...future.result$conditions <- ...future.conditions
[15:31:13.897]     ...future.result$finished <- base::Sys.time()
[15:31:13.897]     ...future.result
[15:31:13.897] }
[15:31:13.907] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:13.907] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:13.908] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.908] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:13.909] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:13.910] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ...
[15:31:13.911] Exporting '...future.elements_ii' (1.60 KiB) to cluster node #1 ... DONE
[15:31:13.911] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.912] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.912] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.913] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.913] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.914] MultisessionFuture started
[15:31:13.914] - Launch lazy future ... done
[15:31:13.915] run() for 'MultisessionFuture' ... done
[15:31:13.915] Created future:
[15:31:13.941] receiveMessageFromWorker() for ClusterFuture ...
[15:31:13.941] - Validating connection of MultisessionFuture
[15:31:13.942] - received message: FutureResult
[15:31:13.942] - Received FutureResult
[15:31:13.942] - Erased future from FutureRegistry
[15:31:13.943] result() for ClusterFuture ...
[15:31:13.943] - result already collected: FutureResult
[15:31:13.943] result() for ClusterFuture ... done
[15:31:13.943] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.915] MultisessionFuture:
[15:31:13.915] Label: 'future_by-1'
[15:31:13.915] Expression:
[15:31:13.915] {
[15:31:13.915]     do.call(function(...) {
[15:31:13.915]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.915]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.915]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.915]             on.exit(options(oopts), add = TRUE)
[15:31:13.915]         }
[15:31:13.915]         {
[15:31:13.915]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.915]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.915]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.915]             })
[15:31:13.915]         }
[15:31:13.915]     }, args = future.call.arguments)
[15:31:13.915] }
[15:31:13.915] Lazy evaluation: FALSE
[15:31:13.915] Asynchronous evaluation: TRUE
[15:31:13.915] Local evaluation: TRUE
[15:31:13.915] Environment: 0x0000019c7f3ada38
[15:31:13.915] Capture standard output: TRUE
[15:31:13.915] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.915] Globals: 5 objects totaling 2.81 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 1.60 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.915] Packages: <none>
[15:31:13.915] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.915] Resolved: TRUE
[15:31:13.915] Value: <not collected>
[15:31:13.915] Conditions captured: <none>
[15:31:13.915] Early signaling: FALSE
[15:31:13.915] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.915] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.944] Chunk #1 of 2 ... DONE
[15:31:13.944] Chunk #2 of 2 ...
[15:31:13.945]  - Finding globals in 'X' for chunk #2 ...
[15:31:13.945] getGlobalsAndPackages() ...
[15:31:13.945] Searching for globals...
[15:31:13.946] 
[15:31:13.946] Searching for globals ... DONE
[15:31:13.946] - globals: [0] <none>
[15:31:13.947] getGlobalsAndPackages() ... DONE
[15:31:13.947]    + additional globals found: [n=0] 
[15:31:13.947]    + additional namespaces needed: [n=0] 
[15:31:13.947]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:13.948]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:13.948]  - seeds: <none>
[15:31:13.948]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.948] getGlobalsAndPackages() ...
[15:31:13.949] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.949] Resolving globals: FALSE
[15:31:13.949] Tweak future expression to call with '...' arguments ...
[15:31:13.949] {
[15:31:13.949]     do.call(function(...) {
[15:31:13.949]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.949]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.949]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.949]             on.exit(options(oopts), add = TRUE)
[15:31:13.949]         }
[15:31:13.949]         {
[15:31:13.949]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.949]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.949]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.949]             })
[15:31:13.949]         }
[15:31:13.949]     }, args = future.call.arguments)
[15:31:13.949] }
[15:31:13.950] Tweak future expression to call with '...' arguments ... DONE
[15:31:13.951] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:13.951] 
[15:31:13.951] getGlobalsAndPackages() ... DONE
[15:31:13.952] run() for 'Future' ...
[15:31:13.952] - state: 'created'
[15:31:13.953] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:13.970] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:13.970] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:13.970]   - Field: 'node'
[15:31:13.970]   - Field: 'label'
[15:31:13.971]   - Field: 'local'
[15:31:13.971]   - Field: 'owner'
[15:31:13.971]   - Field: 'envir'
[15:31:13.972]   - Field: 'workers'
[15:31:13.972]   - Field: 'packages'
[15:31:13.972]   - Field: 'gc'
[15:31:13.972]   - Field: 'conditions'
[15:31:13.973]   - Field: 'persistent'
[15:31:13.973]   - Field: 'expr'
[15:31:13.973]   - Field: 'uuid'
[15:31:13.973]   - Field: 'seed'
[15:31:13.974]   - Field: 'version'
[15:31:13.974]   - Field: 'result'
[15:31:13.974]   - Field: 'asynchronous'
[15:31:13.974]   - Field: 'calls'
[15:31:13.975]   - Field: 'globals'
[15:31:13.975]   - Field: 'stdout'
[15:31:13.975]   - Field: 'earlySignal'
[15:31:13.975]   - Field: 'lazy'
[15:31:13.975]   - Field: 'state'
[15:31:13.976] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:13.976] - Launch lazy future ...
[15:31:13.977] Packages needed by the future expression (n = 0): <none>
[15:31:13.977] Packages needed by future strategies (n = 0): <none>
[15:31:13.978] {
[15:31:13.978]     {
[15:31:13.978]         {
[15:31:13.978]             ...future.startTime <- base::Sys.time()
[15:31:13.978]             {
[15:31:13.978]                 {
[15:31:13.978]                   {
[15:31:13.978]                     {
[15:31:13.978]                       base::local({
[15:31:13.978]                         has_future <- base::requireNamespace("future", 
[15:31:13.978]                           quietly = TRUE)
[15:31:13.978]                         if (has_future) {
[15:31:13.978]                           ns <- base::getNamespace("future")
[15:31:13.978]                           version <- ns[[".package"]][["version"]]
[15:31:13.978]                           if (is.null(version)) 
[15:31:13.978]                             version <- utils::packageVersion("future")
[15:31:13.978]                         }
[15:31:13.978]                         else {
[15:31:13.978]                           version <- NULL
[15:31:13.978]                         }
[15:31:13.978]                         if (!has_future || version < "1.8.0") {
[15:31:13.978]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:13.978]                             "", base::R.version$version.string), 
[15:31:13.978]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:13.978]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:13.978]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:13.978]                               "release", "version")], collapse = " "), 
[15:31:13.978]                             hostname = base::Sys.info()[["nodename"]])
[15:31:13.978]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:13.978]                             info)
[15:31:13.978]                           info <- base::paste(info, collapse = "; ")
[15:31:13.978]                           if (!has_future) {
[15:31:13.978]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:13.978]                               info)
[15:31:13.978]                           }
[15:31:13.978]                           else {
[15:31:13.978]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:13.978]                               info, version)
[15:31:13.978]                           }
[15:31:13.978]                           base::stop(msg)
[15:31:13.978]                         }
[15:31:13.978]                       })
[15:31:13.978]                     }
[15:31:13.978]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:13.978]                     base::options(mc.cores = 1L)
[15:31:13.978]                   }
[15:31:13.978]                   ...future.strategy.old <- future::plan("list")
[15:31:13.978]                   options(future.plan = NULL)
[15:31:13.978]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.978]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:13.978]                 }
[15:31:13.978]                 ...future.workdir <- getwd()
[15:31:13.978]             }
[15:31:13.978]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:13.978]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:13.978]         }
[15:31:13.978]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:13.978]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:13.978]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:13.978]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:13.978]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:13.978]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:13.978]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:13.978]             base::names(...future.oldOptions))
[15:31:13.978]     }
[15:31:13.978]     if (FALSE) {
[15:31:13.978]     }
[15:31:13.978]     else {
[15:31:13.978]         if (TRUE) {
[15:31:13.978]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:13.978]                 open = "w")
[15:31:13.978]         }
[15:31:13.978]         else {
[15:31:13.978]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:13.978]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:13.978]         }
[15:31:13.978]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:13.978]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:13.978]             base::sink(type = "output", split = FALSE)
[15:31:13.978]             base::close(...future.stdout)
[15:31:13.978]         }, add = TRUE)
[15:31:13.978]     }
[15:31:13.978]     ...future.frame <- base::sys.nframe()
[15:31:13.978]     ...future.conditions <- base::list()
[15:31:13.978]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:13.978]     if (FALSE) {
[15:31:13.978]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:13.978]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:13.978]     }
[15:31:13.978]     ...future.result <- base::tryCatch({
[15:31:13.978]         base::withCallingHandlers({
[15:31:13.978]             ...future.value <- base::withVisible(base::local({
[15:31:13.978]                 ...future.makeSendCondition <- base::local({
[15:31:13.978]                   sendCondition <- NULL
[15:31:13.978]                   function(frame = 1L) {
[15:31:13.978]                     if (is.function(sendCondition)) 
[15:31:13.978]                       return(sendCondition)
[15:31:13.978]                     ns <- getNamespace("parallel")
[15:31:13.978]                     if (exists("sendData", mode = "function", 
[15:31:13.978]                       envir = ns)) {
[15:31:13.978]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:13.978]                         envir = ns)
[15:31:13.978]                       envir <- sys.frame(frame)
[15:31:13.978]                       master <- NULL
[15:31:13.978]                       while (!identical(envir, .GlobalEnv) && 
[15:31:13.978]                         !identical(envir, emptyenv())) {
[15:31:13.978]                         if (exists("master", mode = "list", envir = envir, 
[15:31:13.978]                           inherits = FALSE)) {
[15:31:13.978]                           master <- get("master", mode = "list", 
[15:31:13.978]                             envir = envir, inherits = FALSE)
[15:31:13.978]                           if (inherits(master, c("SOCKnode", 
[15:31:13.978]                             "SOCK0node"))) {
[15:31:13.978]                             sendCondition <<- function(cond) {
[15:31:13.978]                               data <- list(type = "VALUE", value = cond, 
[15:31:13.978]                                 success = TRUE)
[15:31:13.978]                               parallel_sendData(master, data)
[15:31:13.978]                             }
[15:31:13.978]                             return(sendCondition)
[15:31:13.978]                           }
[15:31:13.978]                         }
[15:31:13.978]                         frame <- frame + 1L
[15:31:13.978]                         envir <- sys.frame(frame)
[15:31:13.978]                       }
[15:31:13.978]                     }
[15:31:13.978]                     sendCondition <<- function(cond) NULL
[15:31:13.978]                   }
[15:31:13.978]                 })
[15:31:13.978]                 withCallingHandlers({
[15:31:13.978]                   {
[15:31:13.978]                     do.call(function(...) {
[15:31:13.978]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.978]                       if (!identical(...future.globals.maxSize.org, 
[15:31:13.978]                         ...future.globals.maxSize)) {
[15:31:13.978]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.978]                         on.exit(options(oopts), add = TRUE)
[15:31:13.978]                       }
[15:31:13.978]                       {
[15:31:13.978]                         lapply(seq_along(...future.elements_ii), 
[15:31:13.978]                           FUN = function(jj) {
[15:31:13.978]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.978]                             ...future.FUN(...future.X_jj, ...)
[15:31:13.978]                           })
[15:31:13.978]                       }
[15:31:13.978]                     }, args = future.call.arguments)
[15:31:13.978]                   }
[15:31:13.978]                 }, immediateCondition = function(cond) {
[15:31:13.978]                   sendCondition <- ...future.makeSendCondition()
[15:31:13.978]                   sendCondition(cond)
[15:31:13.978]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.978]                   {
[15:31:13.978]                     inherits <- base::inherits
[15:31:13.978]                     invokeRestart <- base::invokeRestart
[15:31:13.978]                     is.null <- base::is.null
[15:31:13.978]                     muffled <- FALSE
[15:31:13.978]                     if (inherits(cond, "message")) {
[15:31:13.978]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:13.978]                       if (muffled) 
[15:31:13.978]                         invokeRestart("muffleMessage")
[15:31:13.978]                     }
[15:31:13.978]                     else if (inherits(cond, "warning")) {
[15:31:13.978]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:13.978]                       if (muffled) 
[15:31:13.978]                         invokeRestart("muffleWarning")
[15:31:13.978]                     }
[15:31:13.978]                     else if (inherits(cond, "condition")) {
[15:31:13.978]                       if (!is.null(pattern)) {
[15:31:13.978]                         computeRestarts <- base::computeRestarts
[15:31:13.978]                         grepl <- base::grepl
[15:31:13.978]                         restarts <- computeRestarts(cond)
[15:31:13.978]                         for (restart in restarts) {
[15:31:13.978]                           name <- restart$name
[15:31:13.978]                           if (is.null(name)) 
[15:31:13.978]                             next
[15:31:13.978]                           if (!grepl(pattern, name)) 
[15:31:13.978]                             next
[15:31:13.978]                           invokeRestart(restart)
[15:31:13.978]                           muffled <- TRUE
[15:31:13.978]                           break
[15:31:13.978]                         }
[15:31:13.978]                       }
[15:31:13.978]                     }
[15:31:13.978]                     invisible(muffled)
[15:31:13.978]                   }
[15:31:13.978]                   muffleCondition(cond)
[15:31:13.978]                 })
[15:31:13.978]             }))
[15:31:13.978]             future::FutureResult(value = ...future.value$value, 
[15:31:13.978]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.978]                   ...future.rng), globalenv = if (FALSE) 
[15:31:13.978]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:13.978]                     ...future.globalenv.names))
[15:31:13.978]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:13.978]         }, condition = base::local({
[15:31:13.978]             c <- base::c
[15:31:13.978]             inherits <- base::inherits
[15:31:13.978]             invokeRestart <- base::invokeRestart
[15:31:13.978]             length <- base::length
[15:31:13.978]             list <- base::list
[15:31:13.978]             seq.int <- base::seq.int
[15:31:13.978]             signalCondition <- base::signalCondition
[15:31:13.978]             sys.calls <- base::sys.calls
[15:31:13.978]             `[[` <- base::`[[`
[15:31:13.978]             `+` <- base::`+`
[15:31:13.978]             `<<-` <- base::`<<-`
[15:31:13.978]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:13.978]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:13.978]                   3L)]
[15:31:13.978]             }
[15:31:13.978]             function(cond) {
[15:31:13.978]                 is_error <- inherits(cond, "error")
[15:31:13.978]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:13.978]                   NULL)
[15:31:13.978]                 if (is_error) {
[15:31:13.978]                   sessionInformation <- function() {
[15:31:13.978]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:13.978]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:13.978]                       search = base::search(), system = base::Sys.info())
[15:31:13.978]                   }
[15:31:13.978]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.978]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:13.978]                     cond$call), session = sessionInformation(), 
[15:31:13.978]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:13.978]                   signalCondition(cond)
[15:31:13.978]                 }
[15:31:13.978]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:13.978]                 "immediateCondition"))) {
[15:31:13.978]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:13.978]                   ...future.conditions[[length(...future.conditions) + 
[15:31:13.978]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:13.978]                   if (TRUE && !signal) {
[15:31:13.978]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.978]                     {
[15:31:13.978]                       inherits <- base::inherits
[15:31:13.978]                       invokeRestart <- base::invokeRestart
[15:31:13.978]                       is.null <- base::is.null
[15:31:13.978]                       muffled <- FALSE
[15:31:13.978]                       if (inherits(cond, "message")) {
[15:31:13.978]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.978]                         if (muffled) 
[15:31:13.978]                           invokeRestart("muffleMessage")
[15:31:13.978]                       }
[15:31:13.978]                       else if (inherits(cond, "warning")) {
[15:31:13.978]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.978]                         if (muffled) 
[15:31:13.978]                           invokeRestart("muffleWarning")
[15:31:13.978]                       }
[15:31:13.978]                       else if (inherits(cond, "condition")) {
[15:31:13.978]                         if (!is.null(pattern)) {
[15:31:13.978]                           computeRestarts <- base::computeRestarts
[15:31:13.978]                           grepl <- base::grepl
[15:31:13.978]                           restarts <- computeRestarts(cond)
[15:31:13.978]                           for (restart in restarts) {
[15:31:13.978]                             name <- restart$name
[15:31:13.978]                             if (is.null(name)) 
[15:31:13.978]                               next
[15:31:13.978]                             if (!grepl(pattern, name)) 
[15:31:13.978]                               next
[15:31:13.978]                             invokeRestart(restart)
[15:31:13.978]                             muffled <- TRUE
[15:31:13.978]                             break
[15:31:13.978]                           }
[15:31:13.978]                         }
[15:31:13.978]                       }
[15:31:13.978]                       invisible(muffled)
[15:31:13.978]                     }
[15:31:13.978]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.978]                   }
[15:31:13.978]                 }
[15:31:13.978]                 else {
[15:31:13.978]                   if (TRUE) {
[15:31:13.978]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:13.978]                     {
[15:31:13.978]                       inherits <- base::inherits
[15:31:13.978]                       invokeRestart <- base::invokeRestart
[15:31:13.978]                       is.null <- base::is.null
[15:31:13.978]                       muffled <- FALSE
[15:31:13.978]                       if (inherits(cond, "message")) {
[15:31:13.978]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:13.978]                         if (muffled) 
[15:31:13.978]                           invokeRestart("muffleMessage")
[15:31:13.978]                       }
[15:31:13.978]                       else if (inherits(cond, "warning")) {
[15:31:13.978]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:13.978]                         if (muffled) 
[15:31:13.978]                           invokeRestart("muffleWarning")
[15:31:13.978]                       }
[15:31:13.978]                       else if (inherits(cond, "condition")) {
[15:31:13.978]                         if (!is.null(pattern)) {
[15:31:13.978]                           computeRestarts <- base::computeRestarts
[15:31:13.978]                           grepl <- base::grepl
[15:31:13.978]                           restarts <- computeRestarts(cond)
[15:31:13.978]                           for (restart in restarts) {
[15:31:13.978]                             name <- restart$name
[15:31:13.978]                             if (is.null(name)) 
[15:31:13.978]                               next
[15:31:13.978]                             if (!grepl(pattern, name)) 
[15:31:13.978]                               next
[15:31:13.978]                             invokeRestart(restart)
[15:31:13.978]                             muffled <- TRUE
[15:31:13.978]                             break
[15:31:13.978]                           }
[15:31:13.978]                         }
[15:31:13.978]                       }
[15:31:13.978]                       invisible(muffled)
[15:31:13.978]                     }
[15:31:13.978]                     muffleCondition(cond, pattern = "^muffle")
[15:31:13.978]                   }
[15:31:13.978]                 }
[15:31:13.978]             }
[15:31:13.978]         }))
[15:31:13.978]     }, error = function(ex) {
[15:31:13.978]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:13.978]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:13.978]                 ...future.rng), started = ...future.startTime, 
[15:31:13.978]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:13.978]             version = "1.8"), class = "FutureResult")
[15:31:13.978]     }, finally = {
[15:31:13.978]         if (!identical(...future.workdir, getwd())) 
[15:31:13.978]             setwd(...future.workdir)
[15:31:13.978]         {
[15:31:13.978]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:13.978]                 ...future.oldOptions$nwarnings <- NULL
[15:31:13.978]             }
[15:31:13.978]             base::options(...future.oldOptions)
[15:31:13.978]             if (.Platform$OS.type == "windows") {
[15:31:13.978]                 old_names <- names(...future.oldEnvVars)
[15:31:13.978]                 envs <- base::Sys.getenv()
[15:31:13.978]                 names <- names(envs)
[15:31:13.978]                 common <- intersect(names, old_names)
[15:31:13.978]                 added <- setdiff(names, old_names)
[15:31:13.978]                 removed <- setdiff(old_names, names)
[15:31:13.978]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:13.978]                   envs[common]]
[15:31:13.978]                 NAMES <- toupper(changed)
[15:31:13.978]                 args <- list()
[15:31:13.978]                 for (kk in seq_along(NAMES)) {
[15:31:13.978]                   name <- changed[[kk]]
[15:31:13.978]                   NAME <- NAMES[[kk]]
[15:31:13.978]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.978]                     next
[15:31:13.978]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.978]                 }
[15:31:13.978]                 NAMES <- toupper(added)
[15:31:13.978]                 for (kk in seq_along(NAMES)) {
[15:31:13.978]                   name <- added[[kk]]
[15:31:13.978]                   NAME <- NAMES[[kk]]
[15:31:13.978]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.978]                     next
[15:31:13.978]                   args[[name]] <- ""
[15:31:13.978]                 }
[15:31:13.978]                 NAMES <- toupper(removed)
[15:31:13.978]                 for (kk in seq_along(NAMES)) {
[15:31:13.978]                   name <- removed[[kk]]
[15:31:13.978]                   NAME <- NAMES[[kk]]
[15:31:13.978]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:13.978]                     next
[15:31:13.978]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:13.978]                 }
[15:31:13.978]                 if (length(args) > 0) 
[15:31:13.978]                   base::do.call(base::Sys.setenv, args = args)
[15:31:13.978]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:13.978]             }
[15:31:13.978]             else {
[15:31:13.978]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:13.978]             }
[15:31:13.978]             {
[15:31:13.978]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:13.978]                   0L) {
[15:31:13.978]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:13.978]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:13.978]                   base::options(opts)
[15:31:13.978]                 }
[15:31:13.978]                 {
[15:31:13.978]                   {
[15:31:13.978]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:13.978]                     NULL
[15:31:13.978]                   }
[15:31:13.978]                   options(future.plan = NULL)
[15:31:13.978]                   if (is.na(NA_character_)) 
[15:31:13.978]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:13.978]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:13.978]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:13.978]                     .init = FALSE)
[15:31:13.978]                 }
[15:31:13.978]             }
[15:31:13.978]         }
[15:31:13.978]     })
[15:31:13.978]     if (TRUE) {
[15:31:13.978]         base::sink(type = "output", split = FALSE)
[15:31:13.978]         if (TRUE) {
[15:31:13.978]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:13.978]         }
[15:31:13.978]         else {
[15:31:13.978]             ...future.result["stdout"] <- base::list(NULL)
[15:31:13.978]         }
[15:31:13.978]         base::close(...future.stdout)
[15:31:13.978]         ...future.stdout <- NULL
[15:31:13.978]     }
[15:31:13.978]     ...future.result$conditions <- ...future.conditions
[15:31:13.978]     ...future.result$finished <- base::Sys.time()
[15:31:13.978]     ...future.result
[15:31:13.978] }
[15:31:13.987] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:13.987] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:13.988] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.988] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:13.989] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:13.990] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ...
[15:31:13.990] Exporting '...future.elements_ii' (3.20 KiB) to cluster node #1 ... DONE
[15:31:13.991] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:13.991] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:13.992] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:13.992] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:13.992] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:13.993] MultisessionFuture started
[15:31:13.994] - Launch lazy future ... done
[15:31:13.994] run() for 'MultisessionFuture' ... done
[15:31:13.994] Created future:
[15:31:14.028] receiveMessageFromWorker() for ClusterFuture ...
[15:31:14.028] - Validating connection of MultisessionFuture
[15:31:14.029] - received message: FutureResult
[15:31:14.029] - Received FutureResult
[15:31:14.029] - Erased future from FutureRegistry
[15:31:14.030] result() for ClusterFuture ...
[15:31:14.030] - result already collected: FutureResult
[15:31:14.030] result() for ClusterFuture ... done
[15:31:14.030] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:13.995] MultisessionFuture:
[15:31:13.995] Label: 'future_by-2'
[15:31:13.995] Expression:
[15:31:13.995] {
[15:31:13.995]     do.call(function(...) {
[15:31:13.995]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:13.995]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:13.995]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:13.995]             on.exit(options(oopts), add = TRUE)
[15:31:13.995]         }
[15:31:13.995]         {
[15:31:13.995]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:13.995]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:13.995]                 ...future.FUN(...future.X_jj, ...)
[15:31:13.995]             })
[15:31:13.995]         }
[15:31:13.995]     }, args = future.call.arguments)
[15:31:13.995] }
[15:31:13.995] Lazy evaluation: FALSE
[15:31:13.995] Asynchronous evaluation: TRUE
[15:31:13.995] Local evaluation: TRUE
[15:31:13.995] Environment: 0x0000019c7f3ada38
[15:31:13.995] Capture standard output: TRUE
[15:31:13.995] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:13.995] Globals: 5 objects totaling 4.41 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 3.20 KiB, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:13.995] Packages: <none>
[15:31:13.995] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:13.995] Resolved: TRUE
[15:31:13.995] Value: <not collected>
[15:31:13.995] Conditions captured: <none>
[15:31:13.995] Early signaling: FALSE
[15:31:13.995] Owner process: d6a18383-b575-80f9-d064-bc9bd6954543
[15:31:13.995] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:14.031] Chunk #2 of 2 ... DONE
[15:31:14.031] Launching 2 futures (chunks) ... DONE
[15:31:14.032] Resolving 2 futures (chunks) ...
[15:31:14.032] resolve() on list ...
[15:31:14.032]  recursive: 0
[15:31:14.033]  length: 2
[15:31:14.033] 
[15:31:14.033] Future #1
[15:31:14.033] result() for ClusterFuture ...
[15:31:14.034] - result already collected: FutureResult
[15:31:14.034] result() for ClusterFuture ... done
[15:31:14.034] result() for ClusterFuture ...
[15:31:14.034] - result already collected: FutureResult
[15:31:14.035] result() for ClusterFuture ... done
[15:31:14.035] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:14.035] - nx: 2
[15:31:14.035] - relay: TRUE
[15:31:14.036] - stdout: TRUE
[15:31:14.036] - signal: TRUE
[15:31:14.036] - resignal: FALSE
[15:31:14.037] - force: TRUE
[15:31:14.037] - relayed: [n=2] FALSE, FALSE
[15:31:14.037] - queued futures: [n=2] FALSE, FALSE
[15:31:14.037]  - until=1
[15:31:14.038]  - relaying element #1
[15:31:14.038] result() for ClusterFuture ...
[15:31:14.038] - result already collected: FutureResult
[15:31:14.038] result() for ClusterFuture ... done
[15:31:14.039] result() for ClusterFuture ...
[15:31:14.039] - result already collected: FutureResult
[15:31:14.039] result() for ClusterFuture ... done
[15:31:14.040] result() for ClusterFuture ...
[15:31:14.040] - result already collected: FutureResult
[15:31:14.040] result() for ClusterFuture ... done
[15:31:14.040] result() for ClusterFuture ...
[15:31:14.041] - result already collected: FutureResult
[15:31:14.041] result() for ClusterFuture ... done
[15:31:14.041] - relayed: [n=2] TRUE, FALSE
[15:31:14.041] - queued futures: [n=2] TRUE, FALSE
[15:31:14.042] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:14.042]  length: 1 (resolved future 1)
[15:31:14.042] Future #2
[15:31:14.043] result() for ClusterFuture ...
[15:31:14.043] - result already collected: FutureResult
[15:31:14.043] result() for ClusterFuture ... done
[15:31:14.044] result() for ClusterFuture ...
[15:31:14.044] - result already collected: FutureResult
[15:31:14.044] result() for ClusterFuture ... done
[15:31:14.044] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:14.045] - nx: 2
[15:31:14.045] - relay: TRUE
[15:31:14.045] - stdout: TRUE
[15:31:14.045] - signal: TRUE
[15:31:14.046] - resignal: FALSE
[15:31:14.046] - force: TRUE
[15:31:14.046] - relayed: [n=2] TRUE, FALSE
[15:31:14.046] - queued futures: [n=2] TRUE, FALSE
[15:31:14.047]  - until=2
[15:31:14.047]  - relaying element #2
[15:31:14.047] result() for ClusterFuture ...
[15:31:14.048] - result already collected: FutureResult
[15:31:14.048] result() for ClusterFuture ... done
[15:31:14.048] result() for ClusterFuture ...
[15:31:14.048] - result already collected: FutureResult
[15:31:14.049] result() for ClusterFuture ... done
[15:31:14.049] result() for ClusterFuture ...
[15:31:14.049] - result already collected: FutureResult
[15:31:14.050] result() for ClusterFuture ... done
[15:31:14.050] result() for ClusterFuture ...
[15:31:14.050] - result already collected: FutureResult
[15:31:14.050] result() for ClusterFuture ... done
[15:31:14.051] - relayed: [n=2] TRUE, TRUE
[15:31:14.051] - queued futures: [n=2] TRUE, TRUE
[15:31:14.051] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:14.051]  length: 0 (resolved future 2)
[15:31:14.052] Relaying remaining futures
[15:31:14.052] signalConditionsASAP(NULL, pos=0) ...
[15:31:14.052] - nx: 2
[15:31:14.052] - relay: TRUE
[15:31:14.053] - stdout: TRUE
[15:31:14.053] - signal: TRUE
[15:31:14.053] - resignal: FALSE
[15:31:14.053] - force: TRUE
[15:31:14.054] - relayed: [n=2] TRUE, TRUE
[15:31:14.054] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:14.054] - relayed: [n=2] TRUE, TRUE
[15:31:14.055] - queued futures: [n=2] TRUE, TRUE
[15:31:14.055] signalConditionsASAP(NULL, pos=0) ... done
[15:31:14.055] resolve() on list ... DONE
[15:31:14.055] result() for ClusterFuture ...
[15:31:14.056] - result already collected: FutureResult
[15:31:14.056] result() for ClusterFuture ... done
[15:31:14.056] result() for ClusterFuture ...
[15:31:14.057] - result already collected: FutureResult
[15:31:14.057] result() for ClusterFuture ... done
[15:31:14.057] result() for ClusterFuture ...
[15:31:14.057] - result already collected: FutureResult
[15:31:14.058] result() for ClusterFuture ... done
[15:31:14.058] result() for ClusterFuture ...
[15:31:14.058] - result already collected: FutureResult
[15:31:14.058] result() for ClusterFuture ... done
[15:31:14.059]  - Number of value chunks collected: 2
[15:31:14.059] Resolving 2 futures (chunks) ... DONE
[15:31:14.059] Reducing values from 2 chunks ...
[15:31:14.059]  - Number of values collected after concatenation: 3
[15:31:14.060]  - Number of values expected: 3
[15:31:14.060] Reducing values from 2 chunks ... DONE
[15:31:14.060] future_lapply() ... DONE
[15:31:14.061] future_by_internal() ... DONE
[15:31:14.062] future_by_internal() ...
Testing with 2 cores ... DONE
> 
> message("*** future_by() ... DONE")
*** future_by() ... DONE
> 
> source("incl/end.R")
[15:31:14.065] plan(): Setting new future strategy stack:
[15:31:14.065] List of future strategies:
[15:31:14.065] 1. FutureStrategy:
[15:31:14.065]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.065]    - tweaked: FALSE
[15:31:14.065]    - call: future::plan(oplan)
[15:31:14.067] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   3.53    0.25    5.09