R Under development (unstable) (2024-03-25 r86192 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

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

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

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

> source("incl/start.R")
[17:26:42.447] plan(): Setting new future strategy stack:
[17:26:42.449] List of future strategies:
[17:26:42.449] 1. sequential:
[17:26:42.449]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.449]    - tweaked: FALSE
[17:26:42.449]    - call: future::plan("sequential")
[17:26:42.473] plan(): nbrOfWorkers() = 1
> library("listenv")
> 
> ## Backward compatibility
> if (getRversion() < "3.2.0") {
+   names <- function(x) {
+     if (class(x)[1] == "environment") {
+       ls(envir = x, all.names = TRUE)
+     } else {
+       base::names(x)
+     }
+   }
+ }
> 
> dims <- list(
+   NULL,
+   c(1, 6),
+   c(2, 3),
+   c(2, 3, 1),
+   c(2, 1, 3, 1)
+ )
> 
> 
> message("*** futures() / resolved() / value() ...")
*** futures() / resolved() / value() ...
> 
> for (cores in 1:availCores) {
+   message(sprintf("Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+ 
+   for (type in c("list", "environment", "listenv")) {
+     message(sprintf("Type of object: %s", type))
+ 
+     for (strategy in supportedStrategies(cores)) {
+       message("Type of future: ", strategy)
+       plan(strategy)
+ 
+       for (dim in dims) {
+         message("Dimensions: ", deparse(dim))
+ 
+         if (type == "list") {
+           x <- list()
+         } else if (type == "listenv") {
+           x <- listenv()
+         } else if (type == "environment") {
+           x <- new.env()
+         }
+ 
+         x$a <- 1
+         x$b <- future(2)
+         x$c <- future(NULL)
+         if (type != "list") x$d %<-% { 4 }
+         if (type != "environment") x[[6]] <- 6
+         str(x)
+ 
+         if (!is.null(dim)) {
+           if (type != "environment") {
+             names <- names(x)
+             dim(x) <- dim
+             dimnames(x) <- lapply(dim, FUN = function(n) letters[1:n])
+             names(x) <- names
+           }
+         }
+ 
+         f <- futures(x)
+         str(f)
+         if (type != "environment") {
+           stopifnot(length(f) == length(x))
+           stopifnot(identical(names(f), names(x)))
+         }
+         stopifnot(identical(dim(f), dim(x)))
+         stopifnot(identical(dimnames(f), dimnames(x)))
+ 
+         r <- resolved(x)
+         str(r)
+         if (type != "environment") {
+           stopifnot(length(r) == length(x))
+           stopifnot(identical(names(r), names(x)))
+         }
+         stopifnot(identical(dim(r), dim(x)))
+         stopifnot(identical(dimnames(r), dimnames(x)))
+ 
+         v <- value(x)
+         str(v)
+         if (type != "environment") {
+           stopifnot(length(v) == length(x))
+           stopifnot(identical(names(v), names(x)))
+         }
+         stopifnot(identical(dim(v), dim(x)))
+         stopifnot(identical(dimnames(v), dimnames(x)))
+       } # for (dim ...)
+     } # for (strategy ...)
+ 
+     message(sprintf("*** futures() - %s ... DONE", type))
+   } # for (type ...)
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
Type of object: list
Type of future: sequential
[17:26:42.546] plan(): Setting new future strategy stack:
[17:26:42.546] List of future strategies:
[17:26:42.546] 1. sequential:
[17:26:42.546]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.546]    - tweaked: FALSE
[17:26:42.546]    - call: plan(strategy)
[17:26:42.560] plan(): nbrOfWorkers() = 1
Dimensions: NULL
[17:26:42.560] getGlobalsAndPackages() ...
[17:26:42.561] Searching for globals...
[17:26:42.563] 
[17:26:42.563] Searching for globals ... DONE
[17:26:42.564] - globals: [0] <none>
[17:26:42.564] getGlobalsAndPackages() ... DONE
[17:26:42.565] run() for 'Future' ...
[17:26:42.565] - state: 'created'
[17:26:42.565] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.565] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.566] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.566]   - Field: 'label'
[17:26:42.566]   - Field: 'local'
[17:26:42.566]   - Field: 'owner'
[17:26:42.566]   - Field: 'envir'
[17:26:42.567]   - Field: 'packages'
[17:26:42.568]   - Field: 'gc'
[17:26:42.568]   - Field: 'conditions'
[17:26:42.568]   - Field: 'expr'
[17:26:42.568]   - Field: 'uuid'
[17:26:42.569]   - Field: 'seed'
[17:26:42.569]   - Field: 'version'
[17:26:42.569]   - Field: 'result'
[17:26:42.569]   - Field: 'asynchronous'
[17:26:42.569]   - Field: 'calls'
[17:26:42.570]   - Field: 'globals'
[17:26:42.570]   - Field: 'stdout'
[17:26:42.570]   - Field: 'earlySignal'
[17:26:42.570]   - Field: 'lazy'
[17:26:42.570]   - Field: 'state'
[17:26:42.570] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.571] - Launch lazy future ...
[17:26:42.571] Packages needed by the future expression (n = 0): <none>
[17:26:42.572] Packages needed by future strategies (n = 0): <none>
[17:26:42.573] {
[17:26:42.573]     {
[17:26:42.573]         {
[17:26:42.573]             ...future.startTime <- base::Sys.time()
[17:26:42.573]             {
[17:26:42.573]                 {
[17:26:42.573]                   {
[17:26:42.573]                     base::local({
[17:26:42.573]                       has_future <- base::requireNamespace("future", 
[17:26:42.573]                         quietly = TRUE)
[17:26:42.573]                       if (has_future) {
[17:26:42.573]                         ns <- base::getNamespace("future")
[17:26:42.573]                         version <- ns[[".package"]][["version"]]
[17:26:42.573]                         if (is.null(version)) 
[17:26:42.573]                           version <- utils::packageVersion("future")
[17:26:42.573]                       }
[17:26:42.573]                       else {
[17:26:42.573]                         version <- NULL
[17:26:42.573]                       }
[17:26:42.573]                       if (!has_future || version < "1.8.0") {
[17:26:42.573]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.573]                           "", base::R.version$version.string), 
[17:26:42.573]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.573]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.573]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.573]                             "release", "version")], collapse = " "), 
[17:26:42.573]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.573]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.573]                           info)
[17:26:42.573]                         info <- base::paste(info, collapse = "; ")
[17:26:42.573]                         if (!has_future) {
[17:26:42.573]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.573]                             info)
[17:26:42.573]                         }
[17:26:42.573]                         else {
[17:26:42.573]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.573]                             info, version)
[17:26:42.573]                         }
[17:26:42.573]                         base::stop(msg)
[17:26:42.573]                       }
[17:26:42.573]                     })
[17:26:42.573]                   }
[17:26:42.573]                   ...future.strategy.old <- future::plan("list")
[17:26:42.573]                   options(future.plan = NULL)
[17:26:42.573]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.573]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.573]                 }
[17:26:42.573]                 ...future.workdir <- getwd()
[17:26:42.573]             }
[17:26:42.573]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.573]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.573]         }
[17:26:42.573]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.573]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.573]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.573]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.573]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.573]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.573]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.573]             base::names(...future.oldOptions))
[17:26:42.573]     }
[17:26:42.573]     if (FALSE) {
[17:26:42.573]     }
[17:26:42.573]     else {
[17:26:42.573]         if (TRUE) {
[17:26:42.573]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.573]                 open = "w")
[17:26:42.573]         }
[17:26:42.573]         else {
[17:26:42.573]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.573]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.573]         }
[17:26:42.573]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.573]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.573]             base::sink(type = "output", split = FALSE)
[17:26:42.573]             base::close(...future.stdout)
[17:26:42.573]         }, add = TRUE)
[17:26:42.573]     }
[17:26:42.573]     ...future.frame <- base::sys.nframe()
[17:26:42.573]     ...future.conditions <- base::list()
[17:26:42.573]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.573]     if (FALSE) {
[17:26:42.573]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.573]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.573]     }
[17:26:42.573]     ...future.result <- base::tryCatch({
[17:26:42.573]         base::withCallingHandlers({
[17:26:42.573]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.573]             future::FutureResult(value = ...future.value$value, 
[17:26:42.573]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.573]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.573]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.573]                     ...future.globalenv.names))
[17:26:42.573]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.573]         }, condition = base::local({
[17:26:42.573]             c <- base::c
[17:26:42.573]             inherits <- base::inherits
[17:26:42.573]             invokeRestart <- base::invokeRestart
[17:26:42.573]             length <- base::length
[17:26:42.573]             list <- base::list
[17:26:42.573]             seq.int <- base::seq.int
[17:26:42.573]             signalCondition <- base::signalCondition
[17:26:42.573]             sys.calls <- base::sys.calls
[17:26:42.573]             `[[` <- base::`[[`
[17:26:42.573]             `+` <- base::`+`
[17:26:42.573]             `<<-` <- base::`<<-`
[17:26:42.573]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.573]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.573]                   3L)]
[17:26:42.573]             }
[17:26:42.573]             function(cond) {
[17:26:42.573]                 is_error <- inherits(cond, "error")
[17:26:42.573]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.573]                   NULL)
[17:26:42.573]                 if (is_error) {
[17:26:42.573]                   sessionInformation <- function() {
[17:26:42.573]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.573]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.573]                       search = base::search(), system = base::Sys.info())
[17:26:42.573]                   }
[17:26:42.573]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.573]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.573]                     cond$call), session = sessionInformation(), 
[17:26:42.573]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.573]                   signalCondition(cond)
[17:26:42.573]                 }
[17:26:42.573]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.573]                 "immediateCondition"))) {
[17:26:42.573]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.573]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.573]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.573]                   if (TRUE && !signal) {
[17:26:42.573]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.573]                     {
[17:26:42.573]                       inherits <- base::inherits
[17:26:42.573]                       invokeRestart <- base::invokeRestart
[17:26:42.573]                       is.null <- base::is.null
[17:26:42.573]                       muffled <- FALSE
[17:26:42.573]                       if (inherits(cond, "message")) {
[17:26:42.573]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.573]                         if (muffled) 
[17:26:42.573]                           invokeRestart("muffleMessage")
[17:26:42.573]                       }
[17:26:42.573]                       else if (inherits(cond, "warning")) {
[17:26:42.573]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.573]                         if (muffled) 
[17:26:42.573]                           invokeRestart("muffleWarning")
[17:26:42.573]                       }
[17:26:42.573]                       else if (inherits(cond, "condition")) {
[17:26:42.573]                         if (!is.null(pattern)) {
[17:26:42.573]                           computeRestarts <- base::computeRestarts
[17:26:42.573]                           grepl <- base::grepl
[17:26:42.573]                           restarts <- computeRestarts(cond)
[17:26:42.573]                           for (restart in restarts) {
[17:26:42.573]                             name <- restart$name
[17:26:42.573]                             if (is.null(name)) 
[17:26:42.573]                               next
[17:26:42.573]                             if (!grepl(pattern, name)) 
[17:26:42.573]                               next
[17:26:42.573]                             invokeRestart(restart)
[17:26:42.573]                             muffled <- TRUE
[17:26:42.573]                             break
[17:26:42.573]                           }
[17:26:42.573]                         }
[17:26:42.573]                       }
[17:26:42.573]                       invisible(muffled)
[17:26:42.573]                     }
[17:26:42.573]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.573]                   }
[17:26:42.573]                 }
[17:26:42.573]                 else {
[17:26:42.573]                   if (TRUE) {
[17:26:42.573]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.573]                     {
[17:26:42.573]                       inherits <- base::inherits
[17:26:42.573]                       invokeRestart <- base::invokeRestart
[17:26:42.573]                       is.null <- base::is.null
[17:26:42.573]                       muffled <- FALSE
[17:26:42.573]                       if (inherits(cond, "message")) {
[17:26:42.573]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.573]                         if (muffled) 
[17:26:42.573]                           invokeRestart("muffleMessage")
[17:26:42.573]                       }
[17:26:42.573]                       else if (inherits(cond, "warning")) {
[17:26:42.573]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.573]                         if (muffled) 
[17:26:42.573]                           invokeRestart("muffleWarning")
[17:26:42.573]                       }
[17:26:42.573]                       else if (inherits(cond, "condition")) {
[17:26:42.573]                         if (!is.null(pattern)) {
[17:26:42.573]                           computeRestarts <- base::computeRestarts
[17:26:42.573]                           grepl <- base::grepl
[17:26:42.573]                           restarts <- computeRestarts(cond)
[17:26:42.573]                           for (restart in restarts) {
[17:26:42.573]                             name <- restart$name
[17:26:42.573]                             if (is.null(name)) 
[17:26:42.573]                               next
[17:26:42.573]                             if (!grepl(pattern, name)) 
[17:26:42.573]                               next
[17:26:42.573]                             invokeRestart(restart)
[17:26:42.573]                             muffled <- TRUE
[17:26:42.573]                             break
[17:26:42.573]                           }
[17:26:42.573]                         }
[17:26:42.573]                       }
[17:26:42.573]                       invisible(muffled)
[17:26:42.573]                     }
[17:26:42.573]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.573]                   }
[17:26:42.573]                 }
[17:26:42.573]             }
[17:26:42.573]         }))
[17:26:42.573]     }, error = function(ex) {
[17:26:42.573]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.573]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.573]                 ...future.rng), started = ...future.startTime, 
[17:26:42.573]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.573]             version = "1.8"), class = "FutureResult")
[17:26:42.573]     }, finally = {
[17:26:42.573]         if (!identical(...future.workdir, getwd())) 
[17:26:42.573]             setwd(...future.workdir)
[17:26:42.573]         {
[17:26:42.573]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.573]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.573]             }
[17:26:42.573]             base::options(...future.oldOptions)
[17:26:42.573]             if (.Platform$OS.type == "windows") {
[17:26:42.573]                 old_names <- names(...future.oldEnvVars)
[17:26:42.573]                 envs <- base::Sys.getenv()
[17:26:42.573]                 names <- names(envs)
[17:26:42.573]                 common <- intersect(names, old_names)
[17:26:42.573]                 added <- setdiff(names, old_names)
[17:26:42.573]                 removed <- setdiff(old_names, names)
[17:26:42.573]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.573]                   envs[common]]
[17:26:42.573]                 NAMES <- toupper(changed)
[17:26:42.573]                 args <- list()
[17:26:42.573]                 for (kk in seq_along(NAMES)) {
[17:26:42.573]                   name <- changed[[kk]]
[17:26:42.573]                   NAME <- NAMES[[kk]]
[17:26:42.573]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.573]                     next
[17:26:42.573]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.573]                 }
[17:26:42.573]                 NAMES <- toupper(added)
[17:26:42.573]                 for (kk in seq_along(NAMES)) {
[17:26:42.573]                   name <- added[[kk]]
[17:26:42.573]                   NAME <- NAMES[[kk]]
[17:26:42.573]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.573]                     next
[17:26:42.573]                   args[[name]] <- ""
[17:26:42.573]                 }
[17:26:42.573]                 NAMES <- toupper(removed)
[17:26:42.573]                 for (kk in seq_along(NAMES)) {
[17:26:42.573]                   name <- removed[[kk]]
[17:26:42.573]                   NAME <- NAMES[[kk]]
[17:26:42.573]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.573]                     next
[17:26:42.573]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.573]                 }
[17:26:42.573]                 if (length(args) > 0) 
[17:26:42.573]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.573]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.573]             }
[17:26:42.573]             else {
[17:26:42.573]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.573]             }
[17:26:42.573]             {
[17:26:42.573]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.573]                   0L) {
[17:26:42.573]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.573]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.573]                   base::options(opts)
[17:26:42.573]                 }
[17:26:42.573]                 {
[17:26:42.573]                   {
[17:26:42.573]                     NULL
[17:26:42.573]                     RNGkind("Mersenne-Twister")
[17:26:42.573]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.573]                       inherits = FALSE)
[17:26:42.573]                   }
[17:26:42.573]                   options(future.plan = NULL)
[17:26:42.573]                   if (is.na(NA_character_)) 
[17:26:42.573]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.573]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.573]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.573]                     .init = FALSE)
[17:26:42.573]                 }
[17:26:42.573]             }
[17:26:42.573]         }
[17:26:42.573]     })
[17:26:42.573]     if (TRUE) {
[17:26:42.573]         base::sink(type = "output", split = FALSE)
[17:26:42.573]         if (TRUE) {
[17:26:42.573]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.573]         }
[17:26:42.573]         else {
[17:26:42.573]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.573]         }
[17:26:42.573]         base::close(...future.stdout)
[17:26:42.573]         ...future.stdout <- NULL
[17:26:42.573]     }
[17:26:42.573]     ...future.result$conditions <- ...future.conditions
[17:26:42.573]     ...future.result$finished <- base::Sys.time()
[17:26:42.573]     ...future.result
[17:26:42.573] }
[17:26:42.577] plan(): Setting new future strategy stack:
[17:26:42.577] List of future strategies:
[17:26:42.577] 1. sequential:
[17:26:42.577]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.577]    - tweaked: FALSE
[17:26:42.577]    - call: NULL
[17:26:42.578] plan(): nbrOfWorkers() = 1
[17:26:42.580] plan(): Setting new future strategy stack:
[17:26:42.580] List of future strategies:
[17:26:42.580] 1. sequential:
[17:26:42.580]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.580]    - tweaked: FALSE
[17:26:42.580]    - call: plan(strategy)
[17:26:42.581] plan(): nbrOfWorkers() = 1
[17:26:42.581] SequentialFuture started (and completed)
[17:26:42.582] - Launch lazy future ... done
[17:26:42.582] run() for 'SequentialFuture' ... done
[17:26:42.582] getGlobalsAndPackages() ...
[17:26:42.582] Searching for globals...
[17:26:42.583] 
[17:26:42.583] Searching for globals ... DONE
[17:26:42.583] - globals: [0] <none>
[17:26:42.583] getGlobalsAndPackages() ... DONE
[17:26:42.583] run() for 'Future' ...
[17:26:42.584] - state: 'created'
[17:26:42.584] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.584] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.584] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.585]   - Field: 'label'
[17:26:42.585]   - Field: 'local'
[17:26:42.585]   - Field: 'owner'
[17:26:42.585]   - Field: 'envir'
[17:26:42.585]   - Field: 'packages'
[17:26:42.585]   - Field: 'gc'
[17:26:42.586]   - Field: 'conditions'
[17:26:42.586]   - Field: 'expr'
[17:26:42.586]   - Field: 'uuid'
[17:26:42.586]   - Field: 'seed'
[17:26:42.586]   - Field: 'version'
[17:26:42.587]   - Field: 'result'
[17:26:42.587]   - Field: 'asynchronous'
[17:26:42.587]   - Field: 'calls'
[17:26:42.587]   - Field: 'globals'
[17:26:42.587]   - Field: 'stdout'
[17:26:42.587]   - Field: 'earlySignal'
[17:26:42.588]   - Field: 'lazy'
[17:26:42.588]   - Field: 'state'
[17:26:42.588] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.588] - Launch lazy future ...
[17:26:42.588] Packages needed by the future expression (n = 0): <none>
[17:26:42.589] Packages needed by future strategies (n = 0): <none>
[17:26:42.589] {
[17:26:42.589]     {
[17:26:42.589]         {
[17:26:42.589]             ...future.startTime <- base::Sys.time()
[17:26:42.589]             {
[17:26:42.589]                 {
[17:26:42.589]                   {
[17:26:42.589]                     base::local({
[17:26:42.589]                       has_future <- base::requireNamespace("future", 
[17:26:42.589]                         quietly = TRUE)
[17:26:42.589]                       if (has_future) {
[17:26:42.589]                         ns <- base::getNamespace("future")
[17:26:42.589]                         version <- ns[[".package"]][["version"]]
[17:26:42.589]                         if (is.null(version)) 
[17:26:42.589]                           version <- utils::packageVersion("future")
[17:26:42.589]                       }
[17:26:42.589]                       else {
[17:26:42.589]                         version <- NULL
[17:26:42.589]                       }
[17:26:42.589]                       if (!has_future || version < "1.8.0") {
[17:26:42.589]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.589]                           "", base::R.version$version.string), 
[17:26:42.589]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.589]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.589]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.589]                             "release", "version")], collapse = " "), 
[17:26:42.589]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.589]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.589]                           info)
[17:26:42.589]                         info <- base::paste(info, collapse = "; ")
[17:26:42.589]                         if (!has_future) {
[17:26:42.589]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.589]                             info)
[17:26:42.589]                         }
[17:26:42.589]                         else {
[17:26:42.589]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.589]                             info, version)
[17:26:42.589]                         }
[17:26:42.589]                         base::stop(msg)
[17:26:42.589]                       }
[17:26:42.589]                     })
[17:26:42.589]                   }
[17:26:42.589]                   ...future.strategy.old <- future::plan("list")
[17:26:42.589]                   options(future.plan = NULL)
[17:26:42.589]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.589]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.589]                 }
[17:26:42.589]                 ...future.workdir <- getwd()
[17:26:42.589]             }
[17:26:42.589]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.589]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.589]         }
[17:26:42.589]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.589]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.589]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.589]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.589]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.589]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.589]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.589]             base::names(...future.oldOptions))
[17:26:42.589]     }
[17:26:42.589]     if (FALSE) {
[17:26:42.589]     }
[17:26:42.589]     else {
[17:26:42.589]         if (TRUE) {
[17:26:42.589]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.589]                 open = "w")
[17:26:42.589]         }
[17:26:42.589]         else {
[17:26:42.589]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.589]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.589]         }
[17:26:42.589]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.589]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.589]             base::sink(type = "output", split = FALSE)
[17:26:42.589]             base::close(...future.stdout)
[17:26:42.589]         }, add = TRUE)
[17:26:42.589]     }
[17:26:42.589]     ...future.frame <- base::sys.nframe()
[17:26:42.589]     ...future.conditions <- base::list()
[17:26:42.589]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.589]     if (FALSE) {
[17:26:42.589]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.589]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.589]     }
[17:26:42.589]     ...future.result <- base::tryCatch({
[17:26:42.589]         base::withCallingHandlers({
[17:26:42.589]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.589]             future::FutureResult(value = ...future.value$value, 
[17:26:42.589]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.589]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.589]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.589]                     ...future.globalenv.names))
[17:26:42.589]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.589]         }, condition = base::local({
[17:26:42.589]             c <- base::c
[17:26:42.589]             inherits <- base::inherits
[17:26:42.589]             invokeRestart <- base::invokeRestart
[17:26:42.589]             length <- base::length
[17:26:42.589]             list <- base::list
[17:26:42.589]             seq.int <- base::seq.int
[17:26:42.589]             signalCondition <- base::signalCondition
[17:26:42.589]             sys.calls <- base::sys.calls
[17:26:42.589]             `[[` <- base::`[[`
[17:26:42.589]             `+` <- base::`+`
[17:26:42.589]             `<<-` <- base::`<<-`
[17:26:42.589]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.589]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.589]                   3L)]
[17:26:42.589]             }
[17:26:42.589]             function(cond) {
[17:26:42.589]                 is_error <- inherits(cond, "error")
[17:26:42.589]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.589]                   NULL)
[17:26:42.589]                 if (is_error) {
[17:26:42.589]                   sessionInformation <- function() {
[17:26:42.589]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.589]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.589]                       search = base::search(), system = base::Sys.info())
[17:26:42.589]                   }
[17:26:42.589]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.589]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.589]                     cond$call), session = sessionInformation(), 
[17:26:42.589]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.589]                   signalCondition(cond)
[17:26:42.589]                 }
[17:26:42.589]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.589]                 "immediateCondition"))) {
[17:26:42.589]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.589]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.589]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.589]                   if (TRUE && !signal) {
[17:26:42.589]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.589]                     {
[17:26:42.589]                       inherits <- base::inherits
[17:26:42.589]                       invokeRestart <- base::invokeRestart
[17:26:42.589]                       is.null <- base::is.null
[17:26:42.589]                       muffled <- FALSE
[17:26:42.589]                       if (inherits(cond, "message")) {
[17:26:42.589]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.589]                         if (muffled) 
[17:26:42.589]                           invokeRestart("muffleMessage")
[17:26:42.589]                       }
[17:26:42.589]                       else if (inherits(cond, "warning")) {
[17:26:42.589]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.589]                         if (muffled) 
[17:26:42.589]                           invokeRestart("muffleWarning")
[17:26:42.589]                       }
[17:26:42.589]                       else if (inherits(cond, "condition")) {
[17:26:42.589]                         if (!is.null(pattern)) {
[17:26:42.589]                           computeRestarts <- base::computeRestarts
[17:26:42.589]                           grepl <- base::grepl
[17:26:42.589]                           restarts <- computeRestarts(cond)
[17:26:42.589]                           for (restart in restarts) {
[17:26:42.589]                             name <- restart$name
[17:26:42.589]                             if (is.null(name)) 
[17:26:42.589]                               next
[17:26:42.589]                             if (!grepl(pattern, name)) 
[17:26:42.589]                               next
[17:26:42.589]                             invokeRestart(restart)
[17:26:42.589]                             muffled <- TRUE
[17:26:42.589]                             break
[17:26:42.589]                           }
[17:26:42.589]                         }
[17:26:42.589]                       }
[17:26:42.589]                       invisible(muffled)
[17:26:42.589]                     }
[17:26:42.589]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.589]                   }
[17:26:42.589]                 }
[17:26:42.589]                 else {
[17:26:42.589]                   if (TRUE) {
[17:26:42.589]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.589]                     {
[17:26:42.589]                       inherits <- base::inherits
[17:26:42.589]                       invokeRestart <- base::invokeRestart
[17:26:42.589]                       is.null <- base::is.null
[17:26:42.589]                       muffled <- FALSE
[17:26:42.589]                       if (inherits(cond, "message")) {
[17:26:42.589]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.589]                         if (muffled) 
[17:26:42.589]                           invokeRestart("muffleMessage")
[17:26:42.589]                       }
[17:26:42.589]                       else if (inherits(cond, "warning")) {
[17:26:42.589]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.589]                         if (muffled) 
[17:26:42.589]                           invokeRestart("muffleWarning")
[17:26:42.589]                       }
[17:26:42.589]                       else if (inherits(cond, "condition")) {
[17:26:42.589]                         if (!is.null(pattern)) {
[17:26:42.589]                           computeRestarts <- base::computeRestarts
[17:26:42.589]                           grepl <- base::grepl
[17:26:42.589]                           restarts <- computeRestarts(cond)
[17:26:42.589]                           for (restart in restarts) {
[17:26:42.589]                             name <- restart$name
[17:26:42.589]                             if (is.null(name)) 
[17:26:42.589]                               next
[17:26:42.589]                             if (!grepl(pattern, name)) 
[17:26:42.589]                               next
[17:26:42.589]                             invokeRestart(restart)
[17:26:42.589]                             muffled <- TRUE
[17:26:42.589]                             break
[17:26:42.589]                           }
[17:26:42.589]                         }
[17:26:42.589]                       }
[17:26:42.589]                       invisible(muffled)
[17:26:42.589]                     }
[17:26:42.589]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.589]                   }
[17:26:42.589]                 }
[17:26:42.589]             }
[17:26:42.589]         }))
[17:26:42.589]     }, error = function(ex) {
[17:26:42.589]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.589]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.589]                 ...future.rng), started = ...future.startTime, 
[17:26:42.589]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.589]             version = "1.8"), class = "FutureResult")
[17:26:42.589]     }, finally = {
[17:26:42.589]         if (!identical(...future.workdir, getwd())) 
[17:26:42.589]             setwd(...future.workdir)
[17:26:42.589]         {
[17:26:42.589]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.589]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.589]             }
[17:26:42.589]             base::options(...future.oldOptions)
[17:26:42.589]             if (.Platform$OS.type == "windows") {
[17:26:42.589]                 old_names <- names(...future.oldEnvVars)
[17:26:42.589]                 envs <- base::Sys.getenv()
[17:26:42.589]                 names <- names(envs)
[17:26:42.589]                 common <- intersect(names, old_names)
[17:26:42.589]                 added <- setdiff(names, old_names)
[17:26:42.589]                 removed <- setdiff(old_names, names)
[17:26:42.589]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.589]                   envs[common]]
[17:26:42.589]                 NAMES <- toupper(changed)
[17:26:42.589]                 args <- list()
[17:26:42.589]                 for (kk in seq_along(NAMES)) {
[17:26:42.589]                   name <- changed[[kk]]
[17:26:42.589]                   NAME <- NAMES[[kk]]
[17:26:42.589]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.589]                     next
[17:26:42.589]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.589]                 }
[17:26:42.589]                 NAMES <- toupper(added)
[17:26:42.589]                 for (kk in seq_along(NAMES)) {
[17:26:42.589]                   name <- added[[kk]]
[17:26:42.589]                   NAME <- NAMES[[kk]]
[17:26:42.589]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.589]                     next
[17:26:42.589]                   args[[name]] <- ""
[17:26:42.589]                 }
[17:26:42.589]                 NAMES <- toupper(removed)
[17:26:42.589]                 for (kk in seq_along(NAMES)) {
[17:26:42.589]                   name <- removed[[kk]]
[17:26:42.589]                   NAME <- NAMES[[kk]]
[17:26:42.589]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.589]                     next
[17:26:42.589]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.589]                 }
[17:26:42.589]                 if (length(args) > 0) 
[17:26:42.589]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.589]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.589]             }
[17:26:42.589]             else {
[17:26:42.589]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.589]             }
[17:26:42.589]             {
[17:26:42.589]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.589]                   0L) {
[17:26:42.589]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.589]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.589]                   base::options(opts)
[17:26:42.589]                 }
[17:26:42.589]                 {
[17:26:42.589]                   {
[17:26:42.589]                     NULL
[17:26:42.589]                     RNGkind("Mersenne-Twister")
[17:26:42.589]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.589]                       inherits = FALSE)
[17:26:42.589]                   }
[17:26:42.589]                   options(future.plan = NULL)
[17:26:42.589]                   if (is.na(NA_character_)) 
[17:26:42.589]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.589]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.589]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.589]                     .init = FALSE)
[17:26:42.589]                 }
[17:26:42.589]             }
[17:26:42.589]         }
[17:26:42.589]     })
[17:26:42.589]     if (TRUE) {
[17:26:42.589]         base::sink(type = "output", split = FALSE)
[17:26:42.589]         if (TRUE) {
[17:26:42.589]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.589]         }
[17:26:42.589]         else {
[17:26:42.589]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.589]         }
[17:26:42.589]         base::close(...future.stdout)
[17:26:42.589]         ...future.stdout <- NULL
[17:26:42.589]     }
[17:26:42.589]     ...future.result$conditions <- ...future.conditions
[17:26:42.589]     ...future.result$finished <- base::Sys.time()
[17:26:42.589]     ...future.result
[17:26:42.589] }
[17:26:42.593] plan(): Setting new future strategy stack:
[17:26:42.593] List of future strategies:
[17:26:42.593] 1. sequential:
[17:26:42.593]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.593]    - tweaked: FALSE
[17:26:42.593]    - call: NULL
[17:26:42.594] plan(): nbrOfWorkers() = 1
[17:26:42.595] plan(): Setting new future strategy stack:
[17:26:42.595] List of future strategies:
[17:26:42.595] 1. sequential:
[17:26:42.595]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.595]    - tweaked: FALSE
[17:26:42.595]    - call: plan(strategy)
[17:26:42.596] plan(): nbrOfWorkers() = 1
[17:26:42.596] SequentialFuture started (and completed)
[17:26:42.597] - Launch lazy future ... done
[17:26:42.597] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230da92298> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000022309a99078> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230da92298> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000022309a99078> 
 $  : NULL
 $  : NULL
 $  : num 6
[17:26:42.604] resolved() for 'SequentialFuture' ...
[17:26:42.604] - state: 'finished'
[17:26:42.604] - run: TRUE
[17:26:42.604] - result: 'FutureResult'
[17:26:42.605] resolved() for 'SequentialFuture' ... done
[17:26:42.605] resolved() for 'SequentialFuture' ...
[17:26:42.605] - state: 'finished'
[17:26:42.605] - run: TRUE
[17:26:42.605] - result: 'FutureResult'
[17:26:42.606] resolved() for 'SequentialFuture' ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:42.607] resolve() on list ...
[17:26:42.607]  recursive: 0
[17:26:42.607]  length: 6
[17:26:42.608]  elements: 'a', 'b', 'c', '', '', ''
[17:26:42.608] signalConditionsASAP(numeric, pos=1) ...
[17:26:42.608] - nx: 6
[17:26:42.608] - relay: TRUE
[17:26:42.608] - stdout: TRUE
[17:26:42.608] - signal: TRUE
[17:26:42.609] - resignal: FALSE
[17:26:42.609] - force: TRUE
[17:26:42.609] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.609] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.609]  - until=2
[17:26:42.609]  - relaying element #2
[17:26:42.610] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.610] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.610] signalConditionsASAP(NULL, pos=1) ... done
[17:26:42.610]  length: 5 (resolved future 1)
[17:26:42.610] resolved() for 'SequentialFuture' ...
[17:26:42.611] - state: 'finished'
[17:26:42.611] - run: TRUE
[17:26:42.611] - result: 'FutureResult'
[17:26:42.611] resolved() for 'SequentialFuture' ... done
[17:26:42.611] Future #2
[17:26:42.612] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:42.612] - nx: 6
[17:26:42.612] - relay: TRUE
[17:26:42.612] - stdout: TRUE
[17:26:42.612] - signal: TRUE
[17:26:42.613] - resignal: FALSE
[17:26:42.613] - force: TRUE
[17:26:42.613] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.613] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.613]  - until=2
[17:26:42.613]  - relaying element #2
[17:26:42.614] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.614] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.614] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:42.614]  length: 4 (resolved future 2)
[17:26:42.615] resolved() for 'SequentialFuture' ...
[17:26:42.615] - state: 'finished'
[17:26:42.615] - run: TRUE
[17:26:42.615] - result: 'FutureResult'
[17:26:42.617] resolved() for 'SequentialFuture' ... done
[17:26:42.617] Future #3
[17:26:42.617] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:42.617] - nx: 6
[17:26:42.618] - relay: TRUE
[17:26:42.618] - stdout: TRUE
[17:26:42.618] - signal: TRUE
[17:26:42.618] - resignal: FALSE
[17:26:42.618] - force: TRUE
[17:26:42.618] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.619] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.619]  - until=3
[17:26:42.619]  - relaying element #3
[17:26:42.619] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.619] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.620] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:42.620]  length: 3 (resolved future 3)
[17:26:42.620] signalConditionsASAP(NULL, pos=4) ...
[17:26:42.620] - nx: 6
[17:26:42.620] - relay: TRUE
[17:26:42.620] - stdout: TRUE
[17:26:42.620] - signal: TRUE
[17:26:42.621] - resignal: FALSE
[17:26:42.621] - force: TRUE
[17:26:42.621] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.621] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.621]  - until=5
[17:26:42.621]  - relaying element #5
[17:26:42.622] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.622] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.622] signalConditionsASAP(NULL, pos=4) ... done
[17:26:42.622]  length: 2 (resolved future 4)
[17:26:42.622] signalConditionsASAP(NULL, pos=5) ...
[17:26:42.622] - nx: 6
[17:26:42.623] - relay: TRUE
[17:26:42.623] - stdout: TRUE
[17:26:42.623] - signal: TRUE
[17:26:42.623] - resignal: FALSE
[17:26:42.623] - force: TRUE
[17:26:42.623] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.623] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.624]  - until=6
[17:26:42.624]  - relaying element #6
[17:26:42.624] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.624] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.624] signalConditionsASAP(NULL, pos=5) ... done
[17:26:42.624]  length: 1 (resolved future 5)
[17:26:42.625] signalConditionsASAP(numeric, pos=6) ...
[17:26:42.625] - nx: 6
[17:26:42.625] - relay: TRUE
[17:26:42.625] - stdout: TRUE
[17:26:42.625] - signal: TRUE
[17:26:42.625] - resignal: FALSE
[17:26:42.625] - force: TRUE
[17:26:42.626] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.626] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.626]  - until=6
[17:26:42.626] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.626] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.626] signalConditionsASAP(numeric, pos=6) ... done
[17:26:42.627]  length: 0 (resolved future 6)
[17:26:42.627] Relaying remaining futures
[17:26:42.627] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.627] - nx: 6
[17:26:42.627] - relay: TRUE
[17:26:42.627] - stdout: TRUE
[17:26:42.628] - signal: TRUE
[17:26:42.628] - resignal: FALSE
[17:26:42.628] - force: TRUE
[17:26:42.628] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.628] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:42.628] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.629] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.629] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.629] resolve() on list ... DONE
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
Dimensions: c(1, 6)
[17:26:42.631] getGlobalsAndPackages() ...
[17:26:42.632] Searching for globals...
[17:26:42.632] 
[17:26:42.632] Searching for globals ... DONE
[17:26:42.632] - globals: [0] <none>
[17:26:42.633] getGlobalsAndPackages() ... DONE
[17:26:42.633] run() for 'Future' ...
[17:26:42.633] - state: 'created'
[17:26:42.633] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.634] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.634] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.634]   - Field: 'label'
[17:26:42.634]   - Field: 'local'
[17:26:42.634]   - Field: 'owner'
[17:26:42.635]   - Field: 'envir'
[17:26:42.635]   - Field: 'packages'
[17:26:42.635]   - Field: 'gc'
[17:26:42.635]   - Field: 'conditions'
[17:26:42.635]   - Field: 'expr'
[17:26:42.635]   - Field: 'uuid'
[17:26:42.636]   - Field: 'seed'
[17:26:42.636]   - Field: 'version'
[17:26:42.636]   - Field: 'result'
[17:26:42.636]   - Field: 'asynchronous'
[17:26:42.636]   - Field: 'calls'
[17:26:42.636]   - Field: 'globals'
[17:26:42.637]   - Field: 'stdout'
[17:26:42.637]   - Field: 'earlySignal'
[17:26:42.637]   - Field: 'lazy'
[17:26:42.637]   - Field: 'state'
[17:26:42.637] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.638] - Launch lazy future ...
[17:26:42.638] Packages needed by the future expression (n = 0): <none>
[17:26:42.638] Packages needed by future strategies (n = 0): <none>
[17:26:42.638] {
[17:26:42.638]     {
[17:26:42.638]         {
[17:26:42.638]             ...future.startTime <- base::Sys.time()
[17:26:42.638]             {
[17:26:42.638]                 {
[17:26:42.638]                   {
[17:26:42.638]                     base::local({
[17:26:42.638]                       has_future <- base::requireNamespace("future", 
[17:26:42.638]                         quietly = TRUE)
[17:26:42.638]                       if (has_future) {
[17:26:42.638]                         ns <- base::getNamespace("future")
[17:26:42.638]                         version <- ns[[".package"]][["version"]]
[17:26:42.638]                         if (is.null(version)) 
[17:26:42.638]                           version <- utils::packageVersion("future")
[17:26:42.638]                       }
[17:26:42.638]                       else {
[17:26:42.638]                         version <- NULL
[17:26:42.638]                       }
[17:26:42.638]                       if (!has_future || version < "1.8.0") {
[17:26:42.638]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.638]                           "", base::R.version$version.string), 
[17:26:42.638]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.638]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.638]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.638]                             "release", "version")], collapse = " "), 
[17:26:42.638]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.638]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.638]                           info)
[17:26:42.638]                         info <- base::paste(info, collapse = "; ")
[17:26:42.638]                         if (!has_future) {
[17:26:42.638]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.638]                             info)
[17:26:42.638]                         }
[17:26:42.638]                         else {
[17:26:42.638]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.638]                             info, version)
[17:26:42.638]                         }
[17:26:42.638]                         base::stop(msg)
[17:26:42.638]                       }
[17:26:42.638]                     })
[17:26:42.638]                   }
[17:26:42.638]                   ...future.strategy.old <- future::plan("list")
[17:26:42.638]                   options(future.plan = NULL)
[17:26:42.638]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.638]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.638]                 }
[17:26:42.638]                 ...future.workdir <- getwd()
[17:26:42.638]             }
[17:26:42.638]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.638]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.638]         }
[17:26:42.638]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.638]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.638]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.638]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.638]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.638]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.638]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.638]             base::names(...future.oldOptions))
[17:26:42.638]     }
[17:26:42.638]     if (FALSE) {
[17:26:42.638]     }
[17:26:42.638]     else {
[17:26:42.638]         if (TRUE) {
[17:26:42.638]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.638]                 open = "w")
[17:26:42.638]         }
[17:26:42.638]         else {
[17:26:42.638]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.638]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.638]         }
[17:26:42.638]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.638]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.638]             base::sink(type = "output", split = FALSE)
[17:26:42.638]             base::close(...future.stdout)
[17:26:42.638]         }, add = TRUE)
[17:26:42.638]     }
[17:26:42.638]     ...future.frame <- base::sys.nframe()
[17:26:42.638]     ...future.conditions <- base::list()
[17:26:42.638]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.638]     if (FALSE) {
[17:26:42.638]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.638]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.638]     }
[17:26:42.638]     ...future.result <- base::tryCatch({
[17:26:42.638]         base::withCallingHandlers({
[17:26:42.638]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.638]             future::FutureResult(value = ...future.value$value, 
[17:26:42.638]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.638]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.638]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.638]                     ...future.globalenv.names))
[17:26:42.638]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.638]         }, condition = base::local({
[17:26:42.638]             c <- base::c
[17:26:42.638]             inherits <- base::inherits
[17:26:42.638]             invokeRestart <- base::invokeRestart
[17:26:42.638]             length <- base::length
[17:26:42.638]             list <- base::list
[17:26:42.638]             seq.int <- base::seq.int
[17:26:42.638]             signalCondition <- base::signalCondition
[17:26:42.638]             sys.calls <- base::sys.calls
[17:26:42.638]             `[[` <- base::`[[`
[17:26:42.638]             `+` <- base::`+`
[17:26:42.638]             `<<-` <- base::`<<-`
[17:26:42.638]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.638]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.638]                   3L)]
[17:26:42.638]             }
[17:26:42.638]             function(cond) {
[17:26:42.638]                 is_error <- inherits(cond, "error")
[17:26:42.638]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.638]                   NULL)
[17:26:42.638]                 if (is_error) {
[17:26:42.638]                   sessionInformation <- function() {
[17:26:42.638]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.638]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.638]                       search = base::search(), system = base::Sys.info())
[17:26:42.638]                   }
[17:26:42.638]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.638]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.638]                     cond$call), session = sessionInformation(), 
[17:26:42.638]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.638]                   signalCondition(cond)
[17:26:42.638]                 }
[17:26:42.638]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.638]                 "immediateCondition"))) {
[17:26:42.638]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.638]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.638]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.638]                   if (TRUE && !signal) {
[17:26:42.638]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.638]                     {
[17:26:42.638]                       inherits <- base::inherits
[17:26:42.638]                       invokeRestart <- base::invokeRestart
[17:26:42.638]                       is.null <- base::is.null
[17:26:42.638]                       muffled <- FALSE
[17:26:42.638]                       if (inherits(cond, "message")) {
[17:26:42.638]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.638]                         if (muffled) 
[17:26:42.638]                           invokeRestart("muffleMessage")
[17:26:42.638]                       }
[17:26:42.638]                       else if (inherits(cond, "warning")) {
[17:26:42.638]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.638]                         if (muffled) 
[17:26:42.638]                           invokeRestart("muffleWarning")
[17:26:42.638]                       }
[17:26:42.638]                       else if (inherits(cond, "condition")) {
[17:26:42.638]                         if (!is.null(pattern)) {
[17:26:42.638]                           computeRestarts <- base::computeRestarts
[17:26:42.638]                           grepl <- base::grepl
[17:26:42.638]                           restarts <- computeRestarts(cond)
[17:26:42.638]                           for (restart in restarts) {
[17:26:42.638]                             name <- restart$name
[17:26:42.638]                             if (is.null(name)) 
[17:26:42.638]                               next
[17:26:42.638]                             if (!grepl(pattern, name)) 
[17:26:42.638]                               next
[17:26:42.638]                             invokeRestart(restart)
[17:26:42.638]                             muffled <- TRUE
[17:26:42.638]                             break
[17:26:42.638]                           }
[17:26:42.638]                         }
[17:26:42.638]                       }
[17:26:42.638]                       invisible(muffled)
[17:26:42.638]                     }
[17:26:42.638]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.638]                   }
[17:26:42.638]                 }
[17:26:42.638]                 else {
[17:26:42.638]                   if (TRUE) {
[17:26:42.638]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.638]                     {
[17:26:42.638]                       inherits <- base::inherits
[17:26:42.638]                       invokeRestart <- base::invokeRestart
[17:26:42.638]                       is.null <- base::is.null
[17:26:42.638]                       muffled <- FALSE
[17:26:42.638]                       if (inherits(cond, "message")) {
[17:26:42.638]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.638]                         if (muffled) 
[17:26:42.638]                           invokeRestart("muffleMessage")
[17:26:42.638]                       }
[17:26:42.638]                       else if (inherits(cond, "warning")) {
[17:26:42.638]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.638]                         if (muffled) 
[17:26:42.638]                           invokeRestart("muffleWarning")
[17:26:42.638]                       }
[17:26:42.638]                       else if (inherits(cond, "condition")) {
[17:26:42.638]                         if (!is.null(pattern)) {
[17:26:42.638]                           computeRestarts <- base::computeRestarts
[17:26:42.638]                           grepl <- base::grepl
[17:26:42.638]                           restarts <- computeRestarts(cond)
[17:26:42.638]                           for (restart in restarts) {
[17:26:42.638]                             name <- restart$name
[17:26:42.638]                             if (is.null(name)) 
[17:26:42.638]                               next
[17:26:42.638]                             if (!grepl(pattern, name)) 
[17:26:42.638]                               next
[17:26:42.638]                             invokeRestart(restart)
[17:26:42.638]                             muffled <- TRUE
[17:26:42.638]                             break
[17:26:42.638]                           }
[17:26:42.638]                         }
[17:26:42.638]                       }
[17:26:42.638]                       invisible(muffled)
[17:26:42.638]                     }
[17:26:42.638]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.638]                   }
[17:26:42.638]                 }
[17:26:42.638]             }
[17:26:42.638]         }))
[17:26:42.638]     }, error = function(ex) {
[17:26:42.638]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.638]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.638]                 ...future.rng), started = ...future.startTime, 
[17:26:42.638]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.638]             version = "1.8"), class = "FutureResult")
[17:26:42.638]     }, finally = {
[17:26:42.638]         if (!identical(...future.workdir, getwd())) 
[17:26:42.638]             setwd(...future.workdir)
[17:26:42.638]         {
[17:26:42.638]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.638]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.638]             }
[17:26:42.638]             base::options(...future.oldOptions)
[17:26:42.638]             if (.Platform$OS.type == "windows") {
[17:26:42.638]                 old_names <- names(...future.oldEnvVars)
[17:26:42.638]                 envs <- base::Sys.getenv()
[17:26:42.638]                 names <- names(envs)
[17:26:42.638]                 common <- intersect(names, old_names)
[17:26:42.638]                 added <- setdiff(names, old_names)
[17:26:42.638]                 removed <- setdiff(old_names, names)
[17:26:42.638]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.638]                   envs[common]]
[17:26:42.638]                 NAMES <- toupper(changed)
[17:26:42.638]                 args <- list()
[17:26:42.638]                 for (kk in seq_along(NAMES)) {
[17:26:42.638]                   name <- changed[[kk]]
[17:26:42.638]                   NAME <- NAMES[[kk]]
[17:26:42.638]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.638]                     next
[17:26:42.638]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.638]                 }
[17:26:42.638]                 NAMES <- toupper(added)
[17:26:42.638]                 for (kk in seq_along(NAMES)) {
[17:26:42.638]                   name <- added[[kk]]
[17:26:42.638]                   NAME <- NAMES[[kk]]
[17:26:42.638]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.638]                     next
[17:26:42.638]                   args[[name]] <- ""
[17:26:42.638]                 }
[17:26:42.638]                 NAMES <- toupper(removed)
[17:26:42.638]                 for (kk in seq_along(NAMES)) {
[17:26:42.638]                   name <- removed[[kk]]
[17:26:42.638]                   NAME <- NAMES[[kk]]
[17:26:42.638]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.638]                     next
[17:26:42.638]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.638]                 }
[17:26:42.638]                 if (length(args) > 0) 
[17:26:42.638]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.638]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.638]             }
[17:26:42.638]             else {
[17:26:42.638]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.638]             }
[17:26:42.638]             {
[17:26:42.638]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.638]                   0L) {
[17:26:42.638]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.638]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.638]                   base::options(opts)
[17:26:42.638]                 }
[17:26:42.638]                 {
[17:26:42.638]                   {
[17:26:42.638]                     NULL
[17:26:42.638]                     RNGkind("Mersenne-Twister")
[17:26:42.638]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.638]                       inherits = FALSE)
[17:26:42.638]                   }
[17:26:42.638]                   options(future.plan = NULL)
[17:26:42.638]                   if (is.na(NA_character_)) 
[17:26:42.638]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.638]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.638]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.638]                     .init = FALSE)
[17:26:42.638]                 }
[17:26:42.638]             }
[17:26:42.638]         }
[17:26:42.638]     })
[17:26:42.638]     if (TRUE) {
[17:26:42.638]         base::sink(type = "output", split = FALSE)
[17:26:42.638]         if (TRUE) {
[17:26:42.638]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.638]         }
[17:26:42.638]         else {
[17:26:42.638]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.638]         }
[17:26:42.638]         base::close(...future.stdout)
[17:26:42.638]         ...future.stdout <- NULL
[17:26:42.638]     }
[17:26:42.638]     ...future.result$conditions <- ...future.conditions
[17:26:42.638]     ...future.result$finished <- base::Sys.time()
[17:26:42.638]     ...future.result
[17:26:42.638] }
[17:26:42.643] plan(): Setting new future strategy stack:
[17:26:42.643] List of future strategies:
[17:26:42.643] 1. sequential:
[17:26:42.643]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.643]    - tweaked: FALSE
[17:26:42.643]    - call: NULL
[17:26:42.644] plan(): nbrOfWorkers() = 1
[17:26:42.645] plan(): Setting new future strategy stack:
[17:26:42.645] List of future strategies:
[17:26:42.645] 1. sequential:
[17:26:42.645]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.645]    - tweaked: FALSE
[17:26:42.645]    - call: plan(strategy)
[17:26:42.646] plan(): nbrOfWorkers() = 1
[17:26:42.646] SequentialFuture started (and completed)
[17:26:42.646] - Launch lazy future ... done
[17:26:42.646] run() for 'SequentialFuture' ... done
[17:26:42.647] getGlobalsAndPackages() ...
[17:26:42.647] Searching for globals...
[17:26:42.647] 
[17:26:42.647] Searching for globals ... DONE
[17:26:42.647] - globals: [0] <none>
[17:26:42.648] getGlobalsAndPackages() ... DONE
[17:26:42.648] run() for 'Future' ...
[17:26:42.648] - state: 'created'
[17:26:42.648] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.649] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.649] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.649]   - Field: 'label'
[17:26:42.649]   - Field: 'local'
[17:26:42.650]   - Field: 'owner'
[17:26:42.650]   - Field: 'envir'
[17:26:42.650]   - Field: 'packages'
[17:26:42.650]   - Field: 'gc'
[17:26:42.650]   - Field: 'conditions'
[17:26:42.651]   - Field: 'expr'
[17:26:42.651]   - Field: 'uuid'
[17:26:42.651]   - Field: 'seed'
[17:26:42.651]   - Field: 'version'
[17:26:42.651]   - Field: 'result'
[17:26:42.651]   - Field: 'asynchronous'
[17:26:42.652]   - Field: 'calls'
[17:26:42.652]   - Field: 'globals'
[17:26:42.652]   - Field: 'stdout'
[17:26:42.652]   - Field: 'earlySignal'
[17:26:42.652]   - Field: 'lazy'
[17:26:42.652]   - Field: 'state'
[17:26:42.653] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.653] - Launch lazy future ...
[17:26:42.653] Packages needed by the future expression (n = 0): <none>
[17:26:42.653] Packages needed by future strategies (n = 0): <none>
[17:26:42.654] {
[17:26:42.654]     {
[17:26:42.654]         {
[17:26:42.654]             ...future.startTime <- base::Sys.time()
[17:26:42.654]             {
[17:26:42.654]                 {
[17:26:42.654]                   {
[17:26:42.654]                     base::local({
[17:26:42.654]                       has_future <- base::requireNamespace("future", 
[17:26:42.654]                         quietly = TRUE)
[17:26:42.654]                       if (has_future) {
[17:26:42.654]                         ns <- base::getNamespace("future")
[17:26:42.654]                         version <- ns[[".package"]][["version"]]
[17:26:42.654]                         if (is.null(version)) 
[17:26:42.654]                           version <- utils::packageVersion("future")
[17:26:42.654]                       }
[17:26:42.654]                       else {
[17:26:42.654]                         version <- NULL
[17:26:42.654]                       }
[17:26:42.654]                       if (!has_future || version < "1.8.0") {
[17:26:42.654]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.654]                           "", base::R.version$version.string), 
[17:26:42.654]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.654]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.654]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.654]                             "release", "version")], collapse = " "), 
[17:26:42.654]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.654]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.654]                           info)
[17:26:42.654]                         info <- base::paste(info, collapse = "; ")
[17:26:42.654]                         if (!has_future) {
[17:26:42.654]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.654]                             info)
[17:26:42.654]                         }
[17:26:42.654]                         else {
[17:26:42.654]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.654]                             info, version)
[17:26:42.654]                         }
[17:26:42.654]                         base::stop(msg)
[17:26:42.654]                       }
[17:26:42.654]                     })
[17:26:42.654]                   }
[17:26:42.654]                   ...future.strategy.old <- future::plan("list")
[17:26:42.654]                   options(future.plan = NULL)
[17:26:42.654]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.654]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.654]                 }
[17:26:42.654]                 ...future.workdir <- getwd()
[17:26:42.654]             }
[17:26:42.654]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.654]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.654]         }
[17:26:42.654]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.654]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.654]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.654]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.654]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.654]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.654]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.654]             base::names(...future.oldOptions))
[17:26:42.654]     }
[17:26:42.654]     if (FALSE) {
[17:26:42.654]     }
[17:26:42.654]     else {
[17:26:42.654]         if (TRUE) {
[17:26:42.654]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.654]                 open = "w")
[17:26:42.654]         }
[17:26:42.654]         else {
[17:26:42.654]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.654]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.654]         }
[17:26:42.654]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.654]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.654]             base::sink(type = "output", split = FALSE)
[17:26:42.654]             base::close(...future.stdout)
[17:26:42.654]         }, add = TRUE)
[17:26:42.654]     }
[17:26:42.654]     ...future.frame <- base::sys.nframe()
[17:26:42.654]     ...future.conditions <- base::list()
[17:26:42.654]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.654]     if (FALSE) {
[17:26:42.654]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.654]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.654]     }
[17:26:42.654]     ...future.result <- base::tryCatch({
[17:26:42.654]         base::withCallingHandlers({
[17:26:42.654]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.654]             future::FutureResult(value = ...future.value$value, 
[17:26:42.654]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.654]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.654]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.654]                     ...future.globalenv.names))
[17:26:42.654]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.654]         }, condition = base::local({
[17:26:42.654]             c <- base::c
[17:26:42.654]             inherits <- base::inherits
[17:26:42.654]             invokeRestart <- base::invokeRestart
[17:26:42.654]             length <- base::length
[17:26:42.654]             list <- base::list
[17:26:42.654]             seq.int <- base::seq.int
[17:26:42.654]             signalCondition <- base::signalCondition
[17:26:42.654]             sys.calls <- base::sys.calls
[17:26:42.654]             `[[` <- base::`[[`
[17:26:42.654]             `+` <- base::`+`
[17:26:42.654]             `<<-` <- base::`<<-`
[17:26:42.654]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.654]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.654]                   3L)]
[17:26:42.654]             }
[17:26:42.654]             function(cond) {
[17:26:42.654]                 is_error <- inherits(cond, "error")
[17:26:42.654]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.654]                   NULL)
[17:26:42.654]                 if (is_error) {
[17:26:42.654]                   sessionInformation <- function() {
[17:26:42.654]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.654]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.654]                       search = base::search(), system = base::Sys.info())
[17:26:42.654]                   }
[17:26:42.654]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.654]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.654]                     cond$call), session = sessionInformation(), 
[17:26:42.654]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.654]                   signalCondition(cond)
[17:26:42.654]                 }
[17:26:42.654]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.654]                 "immediateCondition"))) {
[17:26:42.654]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.654]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.654]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.654]                   if (TRUE && !signal) {
[17:26:42.654]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.654]                     {
[17:26:42.654]                       inherits <- base::inherits
[17:26:42.654]                       invokeRestart <- base::invokeRestart
[17:26:42.654]                       is.null <- base::is.null
[17:26:42.654]                       muffled <- FALSE
[17:26:42.654]                       if (inherits(cond, "message")) {
[17:26:42.654]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.654]                         if (muffled) 
[17:26:42.654]                           invokeRestart("muffleMessage")
[17:26:42.654]                       }
[17:26:42.654]                       else if (inherits(cond, "warning")) {
[17:26:42.654]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.654]                         if (muffled) 
[17:26:42.654]                           invokeRestart("muffleWarning")
[17:26:42.654]                       }
[17:26:42.654]                       else if (inherits(cond, "condition")) {
[17:26:42.654]                         if (!is.null(pattern)) {
[17:26:42.654]                           computeRestarts <- base::computeRestarts
[17:26:42.654]                           grepl <- base::grepl
[17:26:42.654]                           restarts <- computeRestarts(cond)
[17:26:42.654]                           for (restart in restarts) {
[17:26:42.654]                             name <- restart$name
[17:26:42.654]                             if (is.null(name)) 
[17:26:42.654]                               next
[17:26:42.654]                             if (!grepl(pattern, name)) 
[17:26:42.654]                               next
[17:26:42.654]                             invokeRestart(restart)
[17:26:42.654]                             muffled <- TRUE
[17:26:42.654]                             break
[17:26:42.654]                           }
[17:26:42.654]                         }
[17:26:42.654]                       }
[17:26:42.654]                       invisible(muffled)
[17:26:42.654]                     }
[17:26:42.654]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.654]                   }
[17:26:42.654]                 }
[17:26:42.654]                 else {
[17:26:42.654]                   if (TRUE) {
[17:26:42.654]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.654]                     {
[17:26:42.654]                       inherits <- base::inherits
[17:26:42.654]                       invokeRestart <- base::invokeRestart
[17:26:42.654]                       is.null <- base::is.null
[17:26:42.654]                       muffled <- FALSE
[17:26:42.654]                       if (inherits(cond, "message")) {
[17:26:42.654]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.654]                         if (muffled) 
[17:26:42.654]                           invokeRestart("muffleMessage")
[17:26:42.654]                       }
[17:26:42.654]                       else if (inherits(cond, "warning")) {
[17:26:42.654]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.654]                         if (muffled) 
[17:26:42.654]                           invokeRestart("muffleWarning")
[17:26:42.654]                       }
[17:26:42.654]                       else if (inherits(cond, "condition")) {
[17:26:42.654]                         if (!is.null(pattern)) {
[17:26:42.654]                           computeRestarts <- base::computeRestarts
[17:26:42.654]                           grepl <- base::grepl
[17:26:42.654]                           restarts <- computeRestarts(cond)
[17:26:42.654]                           for (restart in restarts) {
[17:26:42.654]                             name <- restart$name
[17:26:42.654]                             if (is.null(name)) 
[17:26:42.654]                               next
[17:26:42.654]                             if (!grepl(pattern, name)) 
[17:26:42.654]                               next
[17:26:42.654]                             invokeRestart(restart)
[17:26:42.654]                             muffled <- TRUE
[17:26:42.654]                             break
[17:26:42.654]                           }
[17:26:42.654]                         }
[17:26:42.654]                       }
[17:26:42.654]                       invisible(muffled)
[17:26:42.654]                     }
[17:26:42.654]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.654]                   }
[17:26:42.654]                 }
[17:26:42.654]             }
[17:26:42.654]         }))
[17:26:42.654]     }, error = function(ex) {
[17:26:42.654]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.654]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.654]                 ...future.rng), started = ...future.startTime, 
[17:26:42.654]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.654]             version = "1.8"), class = "FutureResult")
[17:26:42.654]     }, finally = {
[17:26:42.654]         if (!identical(...future.workdir, getwd())) 
[17:26:42.654]             setwd(...future.workdir)
[17:26:42.654]         {
[17:26:42.654]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.654]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.654]             }
[17:26:42.654]             base::options(...future.oldOptions)
[17:26:42.654]             if (.Platform$OS.type == "windows") {
[17:26:42.654]                 old_names <- names(...future.oldEnvVars)
[17:26:42.654]                 envs <- base::Sys.getenv()
[17:26:42.654]                 names <- names(envs)
[17:26:42.654]                 common <- intersect(names, old_names)
[17:26:42.654]                 added <- setdiff(names, old_names)
[17:26:42.654]                 removed <- setdiff(old_names, names)
[17:26:42.654]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.654]                   envs[common]]
[17:26:42.654]                 NAMES <- toupper(changed)
[17:26:42.654]                 args <- list()
[17:26:42.654]                 for (kk in seq_along(NAMES)) {
[17:26:42.654]                   name <- changed[[kk]]
[17:26:42.654]                   NAME <- NAMES[[kk]]
[17:26:42.654]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.654]                     next
[17:26:42.654]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.654]                 }
[17:26:42.654]                 NAMES <- toupper(added)
[17:26:42.654]                 for (kk in seq_along(NAMES)) {
[17:26:42.654]                   name <- added[[kk]]
[17:26:42.654]                   NAME <- NAMES[[kk]]
[17:26:42.654]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.654]                     next
[17:26:42.654]                   args[[name]] <- ""
[17:26:42.654]                 }
[17:26:42.654]                 NAMES <- toupper(removed)
[17:26:42.654]                 for (kk in seq_along(NAMES)) {
[17:26:42.654]                   name <- removed[[kk]]
[17:26:42.654]                   NAME <- NAMES[[kk]]
[17:26:42.654]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.654]                     next
[17:26:42.654]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.654]                 }
[17:26:42.654]                 if (length(args) > 0) 
[17:26:42.654]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.654]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.654]             }
[17:26:42.654]             else {
[17:26:42.654]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.654]             }
[17:26:42.654]             {
[17:26:42.654]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.654]                   0L) {
[17:26:42.654]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.654]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.654]                   base::options(opts)
[17:26:42.654]                 }
[17:26:42.654]                 {
[17:26:42.654]                   {
[17:26:42.654]                     NULL
[17:26:42.654]                     RNGkind("Mersenne-Twister")
[17:26:42.654]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.654]                       inherits = FALSE)
[17:26:42.654]                   }
[17:26:42.654]                   options(future.plan = NULL)
[17:26:42.654]                   if (is.na(NA_character_)) 
[17:26:42.654]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.654]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.654]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.654]                     .init = FALSE)
[17:26:42.654]                 }
[17:26:42.654]             }
[17:26:42.654]         }
[17:26:42.654]     })
[17:26:42.654]     if (TRUE) {
[17:26:42.654]         base::sink(type = "output", split = FALSE)
[17:26:42.654]         if (TRUE) {
[17:26:42.654]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.654]         }
[17:26:42.654]         else {
[17:26:42.654]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.654]         }
[17:26:42.654]         base::close(...future.stdout)
[17:26:42.654]         ...future.stdout <- NULL
[17:26:42.654]     }
[17:26:42.654]     ...future.result$conditions <- ...future.conditions
[17:26:42.654]     ...future.result$finished <- base::Sys.time()
[17:26:42.654]     ...future.result
[17:26:42.654] }
[17:26:42.658] plan(): Setting new future strategy stack:
[17:26:42.658] List of future strategies:
[17:26:42.658] 1. sequential:
[17:26:42.658]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.658]    - tweaked: FALSE
[17:26:42.658]    - call: NULL
[17:26:42.660] plan(): nbrOfWorkers() = 1
[17:26:42.661] plan(): Setting new future strategy stack:
[17:26:42.662] List of future strategies:
[17:26:42.662] 1. sequential:
[17:26:42.662]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.662]    - tweaked: FALSE
[17:26:42.662]    - call: plan(strategy)
[17:26:42.662] plan(): nbrOfWorkers() = 1
[17:26:42.663] SequentialFuture started (and completed)
[17:26:42.663] - Launch lazy future ... done
[17:26:42.663] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230cc45298> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230d60c810> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230cc45298> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230d60c810> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 1 6
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
[17:26:42.669] resolved() for 'SequentialFuture' ...
[17:26:42.669] - state: 'finished'
[17:26:42.670] - run: TRUE
[17:26:42.670] - result: 'FutureResult'
[17:26:42.670] resolved() for 'SequentialFuture' ... done
[17:26:42.670] resolved() for 'SequentialFuture' ...
[17:26:42.670] - state: 'finished'
[17:26:42.670] - run: TRUE
[17:26:42.671] - result: 'FutureResult'
[17:26:42.671] resolved() for 'SequentialFuture' ... done
 logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:42.673] resolve() on list ...
[17:26:42.673]  recursive: 0
[17:26:42.674]  length: 6
[17:26:42.674]  elements: 'a', 'b', 'c', '', '', ''
[17:26:42.674] signalConditionsASAP(numeric, pos=1) ...
[17:26:42.674] - nx: 6
[17:26:42.674] - relay: TRUE
[17:26:42.674] - stdout: TRUE
[17:26:42.675] - signal: TRUE
[17:26:42.675] - resignal: FALSE
[17:26:42.675] - force: TRUE
[17:26:42.675] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.675] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.675]  - until=2
[17:26:42.675]  - relaying element #2
[17:26:42.676] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.676] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.676] signalConditionsASAP(NULL, pos=1) ... done
[17:26:42.676]  length: 5 (resolved future 1)
[17:26:42.676] resolved() for 'SequentialFuture' ...
[17:26:42.677] - state: 'finished'
[17:26:42.677] - run: TRUE
[17:26:42.677] - result: 'FutureResult'
[17:26:42.677] resolved() for 'SequentialFuture' ... done
[17:26:42.677] Future #2
[17:26:42.678] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:42.678] - nx: 6
[17:26:42.678] - relay: TRUE
[17:26:42.678] - stdout: TRUE
[17:26:42.678] - signal: TRUE
[17:26:42.678] - resignal: FALSE
[17:26:42.678] - force: TRUE
[17:26:42.679] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.679] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.679]  - until=2
[17:26:42.679]  - relaying element #2
[17:26:42.679] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.680] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.680] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:42.680]  length: 4 (resolved future 2)
[17:26:42.680] resolved() for 'SequentialFuture' ...
[17:26:42.680] - state: 'finished'
[17:26:42.680] - run: TRUE
[17:26:42.681] - result: 'FutureResult'
[17:26:42.681] resolved() for 'SequentialFuture' ... done
[17:26:42.681] Future #3
[17:26:42.681] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:42.681] - nx: 6
[17:26:42.682] - relay: TRUE
[17:26:42.682] - stdout: TRUE
[17:26:42.682] - signal: TRUE
[17:26:42.682] - resignal: FALSE
[17:26:42.682] - force: TRUE
[17:26:42.682] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.683] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.683]  - until=3
[17:26:42.683]  - relaying element #3
[17:26:42.683] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.683] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.683] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:42.684]  length: 3 (resolved future 3)
[17:26:42.684] signalConditionsASAP(NULL, pos=4) ...
[17:26:42.684] - nx: 6
[17:26:42.684] - relay: TRUE
[17:26:42.684] - stdout: TRUE
[17:26:42.684] - signal: TRUE
[17:26:42.685] - resignal: FALSE
[17:26:42.685] - force: TRUE
[17:26:42.685] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.685] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.685]  - until=5
[17:26:42.685]  - relaying element #5
[17:26:42.686] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.686] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.686] signalConditionsASAP(NULL, pos=4) ... done
[17:26:42.686]  length: 2 (resolved future 4)
[17:26:42.686] signalConditionsASAP(NULL, pos=5) ...
[17:26:42.686] - nx: 6
[17:26:42.687] - relay: TRUE
[17:26:42.687] - stdout: TRUE
[17:26:42.687] - signal: TRUE
[17:26:42.687] - resignal: FALSE
[17:26:42.687] - force: TRUE
[17:26:42.687] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.687] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.688]  - until=6
[17:26:42.688]  - relaying element #6
[17:26:42.688] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.688] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.688] signalConditionsASAP(NULL, pos=5) ... done
[17:26:42.689]  length: 1 (resolved future 5)
[17:26:42.689] signalConditionsASAP(numeric, pos=6) ...
[17:26:42.689] - nx: 6
[17:26:42.689] - relay: TRUE
[17:26:42.689] - stdout: TRUE
[17:26:42.689] - signal: TRUE
[17:26:42.690] - resignal: FALSE
[17:26:42.690] - force: TRUE
[17:26:42.690] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.690] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.690]  - until=6
[17:26:42.690] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.691] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.691] signalConditionsASAP(numeric, pos=6) ... done
[17:26:42.691]  length: 0 (resolved future 6)
[17:26:42.691] Relaying remaining futures
[17:26:42.691] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.691] - nx: 6
[17:26:42.692] - relay: TRUE
[17:26:42.692] - stdout: TRUE
[17:26:42.692] - signal: TRUE
[17:26:42.692] - resignal: FALSE
[17:26:42.692] - force: TRUE
[17:26:42.692] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.692] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:42.693] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.693] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.693] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.693] resolve() on list ... DONE
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 1 6
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
Dimensions: c(2, 3)
[17:26:42.698] getGlobalsAndPackages() ...
[17:26:42.699] Searching for globals...
[17:26:42.699] 
[17:26:42.699] Searching for globals ... DONE
[17:26:42.699] - globals: [0] <none>
[17:26:42.699] getGlobalsAndPackages() ... DONE
[17:26:42.700] run() for 'Future' ...
[17:26:42.700] - state: 'created'
[17:26:42.700] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.701] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.701] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.701]   - Field: 'label'
[17:26:42.701]   - Field: 'local'
[17:26:42.701]   - Field: 'owner'
[17:26:42.701]   - Field: 'envir'
[17:26:42.702]   - Field: 'packages'
[17:26:42.702]   - Field: 'gc'
[17:26:42.702]   - Field: 'conditions'
[17:26:42.702]   - Field: 'expr'
[17:26:42.702]   - Field: 'uuid'
[17:26:42.703]   - Field: 'seed'
[17:26:42.703]   - Field: 'version'
[17:26:42.703]   - Field: 'result'
[17:26:42.703]   - Field: 'asynchronous'
[17:26:42.703]   - Field: 'calls'
[17:26:42.703]   - Field: 'globals'
[17:26:42.704]   - Field: 'stdout'
[17:26:42.704]   - Field: 'earlySignal'
[17:26:42.704]   - Field: 'lazy'
[17:26:42.704]   - Field: 'state'
[17:26:42.704] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.705] - Launch lazy future ...
[17:26:42.705] Packages needed by the future expression (n = 0): <none>
[17:26:42.705] Packages needed by future strategies (n = 0): <none>
[17:26:42.706] {
[17:26:42.706]     {
[17:26:42.706]         {
[17:26:42.706]             ...future.startTime <- base::Sys.time()
[17:26:42.706]             {
[17:26:42.706]                 {
[17:26:42.706]                   {
[17:26:42.706]                     base::local({
[17:26:42.706]                       has_future <- base::requireNamespace("future", 
[17:26:42.706]                         quietly = TRUE)
[17:26:42.706]                       if (has_future) {
[17:26:42.706]                         ns <- base::getNamespace("future")
[17:26:42.706]                         version <- ns[[".package"]][["version"]]
[17:26:42.706]                         if (is.null(version)) 
[17:26:42.706]                           version <- utils::packageVersion("future")
[17:26:42.706]                       }
[17:26:42.706]                       else {
[17:26:42.706]                         version <- NULL
[17:26:42.706]                       }
[17:26:42.706]                       if (!has_future || version < "1.8.0") {
[17:26:42.706]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.706]                           "", base::R.version$version.string), 
[17:26:42.706]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.706]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.706]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.706]                             "release", "version")], collapse = " "), 
[17:26:42.706]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.706]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.706]                           info)
[17:26:42.706]                         info <- base::paste(info, collapse = "; ")
[17:26:42.706]                         if (!has_future) {
[17:26:42.706]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.706]                             info)
[17:26:42.706]                         }
[17:26:42.706]                         else {
[17:26:42.706]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.706]                             info, version)
[17:26:42.706]                         }
[17:26:42.706]                         base::stop(msg)
[17:26:42.706]                       }
[17:26:42.706]                     })
[17:26:42.706]                   }
[17:26:42.706]                   ...future.strategy.old <- future::plan("list")
[17:26:42.706]                   options(future.plan = NULL)
[17:26:42.706]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.706]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.706]                 }
[17:26:42.706]                 ...future.workdir <- getwd()
[17:26:42.706]             }
[17:26:42.706]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.706]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.706]         }
[17:26:42.706]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.706]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.706]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.706]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.706]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.706]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.706]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.706]             base::names(...future.oldOptions))
[17:26:42.706]     }
[17:26:42.706]     if (FALSE) {
[17:26:42.706]     }
[17:26:42.706]     else {
[17:26:42.706]         if (TRUE) {
[17:26:42.706]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.706]                 open = "w")
[17:26:42.706]         }
[17:26:42.706]         else {
[17:26:42.706]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.706]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.706]         }
[17:26:42.706]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.706]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.706]             base::sink(type = "output", split = FALSE)
[17:26:42.706]             base::close(...future.stdout)
[17:26:42.706]         }, add = TRUE)
[17:26:42.706]     }
[17:26:42.706]     ...future.frame <- base::sys.nframe()
[17:26:42.706]     ...future.conditions <- base::list()
[17:26:42.706]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.706]     if (FALSE) {
[17:26:42.706]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.706]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.706]     }
[17:26:42.706]     ...future.result <- base::tryCatch({
[17:26:42.706]         base::withCallingHandlers({
[17:26:42.706]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.706]             future::FutureResult(value = ...future.value$value, 
[17:26:42.706]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.706]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.706]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.706]                     ...future.globalenv.names))
[17:26:42.706]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.706]         }, condition = base::local({
[17:26:42.706]             c <- base::c
[17:26:42.706]             inherits <- base::inherits
[17:26:42.706]             invokeRestart <- base::invokeRestart
[17:26:42.706]             length <- base::length
[17:26:42.706]             list <- base::list
[17:26:42.706]             seq.int <- base::seq.int
[17:26:42.706]             signalCondition <- base::signalCondition
[17:26:42.706]             sys.calls <- base::sys.calls
[17:26:42.706]             `[[` <- base::`[[`
[17:26:42.706]             `+` <- base::`+`
[17:26:42.706]             `<<-` <- base::`<<-`
[17:26:42.706]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.706]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.706]                   3L)]
[17:26:42.706]             }
[17:26:42.706]             function(cond) {
[17:26:42.706]                 is_error <- inherits(cond, "error")
[17:26:42.706]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.706]                   NULL)
[17:26:42.706]                 if (is_error) {
[17:26:42.706]                   sessionInformation <- function() {
[17:26:42.706]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.706]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.706]                       search = base::search(), system = base::Sys.info())
[17:26:42.706]                   }
[17:26:42.706]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.706]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.706]                     cond$call), session = sessionInformation(), 
[17:26:42.706]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.706]                   signalCondition(cond)
[17:26:42.706]                 }
[17:26:42.706]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.706]                 "immediateCondition"))) {
[17:26:42.706]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.706]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.706]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.706]                   if (TRUE && !signal) {
[17:26:42.706]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.706]                     {
[17:26:42.706]                       inherits <- base::inherits
[17:26:42.706]                       invokeRestart <- base::invokeRestart
[17:26:42.706]                       is.null <- base::is.null
[17:26:42.706]                       muffled <- FALSE
[17:26:42.706]                       if (inherits(cond, "message")) {
[17:26:42.706]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.706]                         if (muffled) 
[17:26:42.706]                           invokeRestart("muffleMessage")
[17:26:42.706]                       }
[17:26:42.706]                       else if (inherits(cond, "warning")) {
[17:26:42.706]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.706]                         if (muffled) 
[17:26:42.706]                           invokeRestart("muffleWarning")
[17:26:42.706]                       }
[17:26:42.706]                       else if (inherits(cond, "condition")) {
[17:26:42.706]                         if (!is.null(pattern)) {
[17:26:42.706]                           computeRestarts <- base::computeRestarts
[17:26:42.706]                           grepl <- base::grepl
[17:26:42.706]                           restarts <- computeRestarts(cond)
[17:26:42.706]                           for (restart in restarts) {
[17:26:42.706]                             name <- restart$name
[17:26:42.706]                             if (is.null(name)) 
[17:26:42.706]                               next
[17:26:42.706]                             if (!grepl(pattern, name)) 
[17:26:42.706]                               next
[17:26:42.706]                             invokeRestart(restart)
[17:26:42.706]                             muffled <- TRUE
[17:26:42.706]                             break
[17:26:42.706]                           }
[17:26:42.706]                         }
[17:26:42.706]                       }
[17:26:42.706]                       invisible(muffled)
[17:26:42.706]                     }
[17:26:42.706]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.706]                   }
[17:26:42.706]                 }
[17:26:42.706]                 else {
[17:26:42.706]                   if (TRUE) {
[17:26:42.706]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.706]                     {
[17:26:42.706]                       inherits <- base::inherits
[17:26:42.706]                       invokeRestart <- base::invokeRestart
[17:26:42.706]                       is.null <- base::is.null
[17:26:42.706]                       muffled <- FALSE
[17:26:42.706]                       if (inherits(cond, "message")) {
[17:26:42.706]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.706]                         if (muffled) 
[17:26:42.706]                           invokeRestart("muffleMessage")
[17:26:42.706]                       }
[17:26:42.706]                       else if (inherits(cond, "warning")) {
[17:26:42.706]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.706]                         if (muffled) 
[17:26:42.706]                           invokeRestart("muffleWarning")
[17:26:42.706]                       }
[17:26:42.706]                       else if (inherits(cond, "condition")) {
[17:26:42.706]                         if (!is.null(pattern)) {
[17:26:42.706]                           computeRestarts <- base::computeRestarts
[17:26:42.706]                           grepl <- base::grepl
[17:26:42.706]                           restarts <- computeRestarts(cond)
[17:26:42.706]                           for (restart in restarts) {
[17:26:42.706]                             name <- restart$name
[17:26:42.706]                             if (is.null(name)) 
[17:26:42.706]                               next
[17:26:42.706]                             if (!grepl(pattern, name)) 
[17:26:42.706]                               next
[17:26:42.706]                             invokeRestart(restart)
[17:26:42.706]                             muffled <- TRUE
[17:26:42.706]                             break
[17:26:42.706]                           }
[17:26:42.706]                         }
[17:26:42.706]                       }
[17:26:42.706]                       invisible(muffled)
[17:26:42.706]                     }
[17:26:42.706]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.706]                   }
[17:26:42.706]                 }
[17:26:42.706]             }
[17:26:42.706]         }))
[17:26:42.706]     }, error = function(ex) {
[17:26:42.706]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.706]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.706]                 ...future.rng), started = ...future.startTime, 
[17:26:42.706]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.706]             version = "1.8"), class = "FutureResult")
[17:26:42.706]     }, finally = {
[17:26:42.706]         if (!identical(...future.workdir, getwd())) 
[17:26:42.706]             setwd(...future.workdir)
[17:26:42.706]         {
[17:26:42.706]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.706]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.706]             }
[17:26:42.706]             base::options(...future.oldOptions)
[17:26:42.706]             if (.Platform$OS.type == "windows") {
[17:26:42.706]                 old_names <- names(...future.oldEnvVars)
[17:26:42.706]                 envs <- base::Sys.getenv()
[17:26:42.706]                 names <- names(envs)
[17:26:42.706]                 common <- intersect(names, old_names)
[17:26:42.706]                 added <- setdiff(names, old_names)
[17:26:42.706]                 removed <- setdiff(old_names, names)
[17:26:42.706]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.706]                   envs[common]]
[17:26:42.706]                 NAMES <- toupper(changed)
[17:26:42.706]                 args <- list()
[17:26:42.706]                 for (kk in seq_along(NAMES)) {
[17:26:42.706]                   name <- changed[[kk]]
[17:26:42.706]                   NAME <- NAMES[[kk]]
[17:26:42.706]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.706]                     next
[17:26:42.706]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.706]                 }
[17:26:42.706]                 NAMES <- toupper(added)
[17:26:42.706]                 for (kk in seq_along(NAMES)) {
[17:26:42.706]                   name <- added[[kk]]
[17:26:42.706]                   NAME <- NAMES[[kk]]
[17:26:42.706]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.706]                     next
[17:26:42.706]                   args[[name]] <- ""
[17:26:42.706]                 }
[17:26:42.706]                 NAMES <- toupper(removed)
[17:26:42.706]                 for (kk in seq_along(NAMES)) {
[17:26:42.706]                   name <- removed[[kk]]
[17:26:42.706]                   NAME <- NAMES[[kk]]
[17:26:42.706]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.706]                     next
[17:26:42.706]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.706]                 }
[17:26:42.706]                 if (length(args) > 0) 
[17:26:42.706]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.706]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.706]             }
[17:26:42.706]             else {
[17:26:42.706]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.706]             }
[17:26:42.706]             {
[17:26:42.706]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.706]                   0L) {
[17:26:42.706]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.706]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.706]                   base::options(opts)
[17:26:42.706]                 }
[17:26:42.706]                 {
[17:26:42.706]                   {
[17:26:42.706]                     NULL
[17:26:42.706]                     RNGkind("Mersenne-Twister")
[17:26:42.706]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.706]                       inherits = FALSE)
[17:26:42.706]                   }
[17:26:42.706]                   options(future.plan = NULL)
[17:26:42.706]                   if (is.na(NA_character_)) 
[17:26:42.706]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.706]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.706]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.706]                     .init = FALSE)
[17:26:42.706]                 }
[17:26:42.706]             }
[17:26:42.706]         }
[17:26:42.706]     })
[17:26:42.706]     if (TRUE) {
[17:26:42.706]         base::sink(type = "output", split = FALSE)
[17:26:42.706]         if (TRUE) {
[17:26:42.706]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.706]         }
[17:26:42.706]         else {
[17:26:42.706]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.706]         }
[17:26:42.706]         base::close(...future.stdout)
[17:26:42.706]         ...future.stdout <- NULL
[17:26:42.706]     }
[17:26:42.706]     ...future.result$conditions <- ...future.conditions
[17:26:42.706]     ...future.result$finished <- base::Sys.time()
[17:26:42.706]     ...future.result
[17:26:42.706] }
[17:26:42.709] plan(): Setting new future strategy stack:
[17:26:42.710] List of future strategies:
[17:26:42.710] 1. sequential:
[17:26:42.710]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.710]    - tweaked: FALSE
[17:26:42.710]    - call: NULL
[17:26:42.710] plan(): nbrOfWorkers() = 1
[17:26:42.711] plan(): Setting new future strategy stack:
[17:26:42.712] List of future strategies:
[17:26:42.712] 1. sequential:
[17:26:42.712]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.712]    - tweaked: FALSE
[17:26:42.712]    - call: plan(strategy)
[17:26:42.712] plan(): nbrOfWorkers() = 1
[17:26:42.712] SequentialFuture started (and completed)
[17:26:42.713] - Launch lazy future ... done
[17:26:42.713] run() for 'SequentialFuture' ... done
[17:26:42.713] getGlobalsAndPackages() ...
[17:26:42.713] Searching for globals...
[17:26:42.714] 
[17:26:42.714] Searching for globals ... DONE
[17:26:42.714] - globals: [0] <none>
[17:26:42.714] getGlobalsAndPackages() ... DONE
[17:26:42.714] run() for 'Future' ...
[17:26:42.715] - state: 'created'
[17:26:42.715] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.715] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.715] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.716]   - Field: 'label'
[17:26:42.716]   - Field: 'local'
[17:26:42.716]   - Field: 'owner'
[17:26:42.716]   - Field: 'envir'
[17:26:42.716]   - Field: 'packages'
[17:26:42.717]   - Field: 'gc'
[17:26:42.717]   - Field: 'conditions'
[17:26:42.717]   - Field: 'expr'
[17:26:42.717]   - Field: 'uuid'
[17:26:42.717]   - Field: 'seed'
[17:26:42.717]   - Field: 'version'
[17:26:42.718]   - Field: 'result'
[17:26:42.718]   - Field: 'asynchronous'
[17:26:42.718]   - Field: 'calls'
[17:26:42.718]   - Field: 'globals'
[17:26:42.718]   - Field: 'stdout'
[17:26:42.718]   - Field: 'earlySignal'
[17:26:42.719]   - Field: 'lazy'
[17:26:42.719]   - Field: 'state'
[17:26:42.719] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.719] - Launch lazy future ...
[17:26:42.719] Packages needed by the future expression (n = 0): <none>
[17:26:42.720] Packages needed by future strategies (n = 0): <none>
[17:26:42.720] {
[17:26:42.720]     {
[17:26:42.720]         {
[17:26:42.720]             ...future.startTime <- base::Sys.time()
[17:26:42.720]             {
[17:26:42.720]                 {
[17:26:42.720]                   {
[17:26:42.720]                     base::local({
[17:26:42.720]                       has_future <- base::requireNamespace("future", 
[17:26:42.720]                         quietly = TRUE)
[17:26:42.720]                       if (has_future) {
[17:26:42.720]                         ns <- base::getNamespace("future")
[17:26:42.720]                         version <- ns[[".package"]][["version"]]
[17:26:42.720]                         if (is.null(version)) 
[17:26:42.720]                           version <- utils::packageVersion("future")
[17:26:42.720]                       }
[17:26:42.720]                       else {
[17:26:42.720]                         version <- NULL
[17:26:42.720]                       }
[17:26:42.720]                       if (!has_future || version < "1.8.0") {
[17:26:42.720]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.720]                           "", base::R.version$version.string), 
[17:26:42.720]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.720]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.720]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.720]                             "release", "version")], collapse = " "), 
[17:26:42.720]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.720]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.720]                           info)
[17:26:42.720]                         info <- base::paste(info, collapse = "; ")
[17:26:42.720]                         if (!has_future) {
[17:26:42.720]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.720]                             info)
[17:26:42.720]                         }
[17:26:42.720]                         else {
[17:26:42.720]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.720]                             info, version)
[17:26:42.720]                         }
[17:26:42.720]                         base::stop(msg)
[17:26:42.720]                       }
[17:26:42.720]                     })
[17:26:42.720]                   }
[17:26:42.720]                   ...future.strategy.old <- future::plan("list")
[17:26:42.720]                   options(future.plan = NULL)
[17:26:42.720]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.720]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.720]                 }
[17:26:42.720]                 ...future.workdir <- getwd()
[17:26:42.720]             }
[17:26:42.720]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.720]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.720]         }
[17:26:42.720]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.720]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.720]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.720]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.720]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.720]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.720]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.720]             base::names(...future.oldOptions))
[17:26:42.720]     }
[17:26:42.720]     if (FALSE) {
[17:26:42.720]     }
[17:26:42.720]     else {
[17:26:42.720]         if (TRUE) {
[17:26:42.720]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.720]                 open = "w")
[17:26:42.720]         }
[17:26:42.720]         else {
[17:26:42.720]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.720]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.720]         }
[17:26:42.720]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.720]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.720]             base::sink(type = "output", split = FALSE)
[17:26:42.720]             base::close(...future.stdout)
[17:26:42.720]         }, add = TRUE)
[17:26:42.720]     }
[17:26:42.720]     ...future.frame <- base::sys.nframe()
[17:26:42.720]     ...future.conditions <- base::list()
[17:26:42.720]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.720]     if (FALSE) {
[17:26:42.720]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.720]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.720]     }
[17:26:42.720]     ...future.result <- base::tryCatch({
[17:26:42.720]         base::withCallingHandlers({
[17:26:42.720]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.720]             future::FutureResult(value = ...future.value$value, 
[17:26:42.720]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.720]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.720]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.720]                     ...future.globalenv.names))
[17:26:42.720]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.720]         }, condition = base::local({
[17:26:42.720]             c <- base::c
[17:26:42.720]             inherits <- base::inherits
[17:26:42.720]             invokeRestart <- base::invokeRestart
[17:26:42.720]             length <- base::length
[17:26:42.720]             list <- base::list
[17:26:42.720]             seq.int <- base::seq.int
[17:26:42.720]             signalCondition <- base::signalCondition
[17:26:42.720]             sys.calls <- base::sys.calls
[17:26:42.720]             `[[` <- base::`[[`
[17:26:42.720]             `+` <- base::`+`
[17:26:42.720]             `<<-` <- base::`<<-`
[17:26:42.720]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.720]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.720]                   3L)]
[17:26:42.720]             }
[17:26:42.720]             function(cond) {
[17:26:42.720]                 is_error <- inherits(cond, "error")
[17:26:42.720]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.720]                   NULL)
[17:26:42.720]                 if (is_error) {
[17:26:42.720]                   sessionInformation <- function() {
[17:26:42.720]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.720]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.720]                       search = base::search(), system = base::Sys.info())
[17:26:42.720]                   }
[17:26:42.720]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.720]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.720]                     cond$call), session = sessionInformation(), 
[17:26:42.720]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.720]                   signalCondition(cond)
[17:26:42.720]                 }
[17:26:42.720]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.720]                 "immediateCondition"))) {
[17:26:42.720]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.720]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.720]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.720]                   if (TRUE && !signal) {
[17:26:42.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.720]                     {
[17:26:42.720]                       inherits <- base::inherits
[17:26:42.720]                       invokeRestart <- base::invokeRestart
[17:26:42.720]                       is.null <- base::is.null
[17:26:42.720]                       muffled <- FALSE
[17:26:42.720]                       if (inherits(cond, "message")) {
[17:26:42.720]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.720]                         if (muffled) 
[17:26:42.720]                           invokeRestart("muffleMessage")
[17:26:42.720]                       }
[17:26:42.720]                       else if (inherits(cond, "warning")) {
[17:26:42.720]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.720]                         if (muffled) 
[17:26:42.720]                           invokeRestart("muffleWarning")
[17:26:42.720]                       }
[17:26:42.720]                       else if (inherits(cond, "condition")) {
[17:26:42.720]                         if (!is.null(pattern)) {
[17:26:42.720]                           computeRestarts <- base::computeRestarts
[17:26:42.720]                           grepl <- base::grepl
[17:26:42.720]                           restarts <- computeRestarts(cond)
[17:26:42.720]                           for (restart in restarts) {
[17:26:42.720]                             name <- restart$name
[17:26:42.720]                             if (is.null(name)) 
[17:26:42.720]                               next
[17:26:42.720]                             if (!grepl(pattern, name)) 
[17:26:42.720]                               next
[17:26:42.720]                             invokeRestart(restart)
[17:26:42.720]                             muffled <- TRUE
[17:26:42.720]                             break
[17:26:42.720]                           }
[17:26:42.720]                         }
[17:26:42.720]                       }
[17:26:42.720]                       invisible(muffled)
[17:26:42.720]                     }
[17:26:42.720]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.720]                   }
[17:26:42.720]                 }
[17:26:42.720]                 else {
[17:26:42.720]                   if (TRUE) {
[17:26:42.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.720]                     {
[17:26:42.720]                       inherits <- base::inherits
[17:26:42.720]                       invokeRestart <- base::invokeRestart
[17:26:42.720]                       is.null <- base::is.null
[17:26:42.720]                       muffled <- FALSE
[17:26:42.720]                       if (inherits(cond, "message")) {
[17:26:42.720]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.720]                         if (muffled) 
[17:26:42.720]                           invokeRestart("muffleMessage")
[17:26:42.720]                       }
[17:26:42.720]                       else if (inherits(cond, "warning")) {
[17:26:42.720]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.720]                         if (muffled) 
[17:26:42.720]                           invokeRestart("muffleWarning")
[17:26:42.720]                       }
[17:26:42.720]                       else if (inherits(cond, "condition")) {
[17:26:42.720]                         if (!is.null(pattern)) {
[17:26:42.720]                           computeRestarts <- base::computeRestarts
[17:26:42.720]                           grepl <- base::grepl
[17:26:42.720]                           restarts <- computeRestarts(cond)
[17:26:42.720]                           for (restart in restarts) {
[17:26:42.720]                             name <- restart$name
[17:26:42.720]                             if (is.null(name)) 
[17:26:42.720]                               next
[17:26:42.720]                             if (!grepl(pattern, name)) 
[17:26:42.720]                               next
[17:26:42.720]                             invokeRestart(restart)
[17:26:42.720]                             muffled <- TRUE
[17:26:42.720]                             break
[17:26:42.720]                           }
[17:26:42.720]                         }
[17:26:42.720]                       }
[17:26:42.720]                       invisible(muffled)
[17:26:42.720]                     }
[17:26:42.720]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.720]                   }
[17:26:42.720]                 }
[17:26:42.720]             }
[17:26:42.720]         }))
[17:26:42.720]     }, error = function(ex) {
[17:26:42.720]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.720]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.720]                 ...future.rng), started = ...future.startTime, 
[17:26:42.720]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.720]             version = "1.8"), class = "FutureResult")
[17:26:42.720]     }, finally = {
[17:26:42.720]         if (!identical(...future.workdir, getwd())) 
[17:26:42.720]             setwd(...future.workdir)
[17:26:42.720]         {
[17:26:42.720]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.720]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.720]             }
[17:26:42.720]             base::options(...future.oldOptions)
[17:26:42.720]             if (.Platform$OS.type == "windows") {
[17:26:42.720]                 old_names <- names(...future.oldEnvVars)
[17:26:42.720]                 envs <- base::Sys.getenv()
[17:26:42.720]                 names <- names(envs)
[17:26:42.720]                 common <- intersect(names, old_names)
[17:26:42.720]                 added <- setdiff(names, old_names)
[17:26:42.720]                 removed <- setdiff(old_names, names)
[17:26:42.720]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.720]                   envs[common]]
[17:26:42.720]                 NAMES <- toupper(changed)
[17:26:42.720]                 args <- list()
[17:26:42.720]                 for (kk in seq_along(NAMES)) {
[17:26:42.720]                   name <- changed[[kk]]
[17:26:42.720]                   NAME <- NAMES[[kk]]
[17:26:42.720]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.720]                     next
[17:26:42.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.720]                 }
[17:26:42.720]                 NAMES <- toupper(added)
[17:26:42.720]                 for (kk in seq_along(NAMES)) {
[17:26:42.720]                   name <- added[[kk]]
[17:26:42.720]                   NAME <- NAMES[[kk]]
[17:26:42.720]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.720]                     next
[17:26:42.720]                   args[[name]] <- ""
[17:26:42.720]                 }
[17:26:42.720]                 NAMES <- toupper(removed)
[17:26:42.720]                 for (kk in seq_along(NAMES)) {
[17:26:42.720]                   name <- removed[[kk]]
[17:26:42.720]                   NAME <- NAMES[[kk]]
[17:26:42.720]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.720]                     next
[17:26:42.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.720]                 }
[17:26:42.720]                 if (length(args) > 0) 
[17:26:42.720]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.720]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.720]             }
[17:26:42.720]             else {
[17:26:42.720]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.720]             }
[17:26:42.720]             {
[17:26:42.720]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.720]                   0L) {
[17:26:42.720]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.720]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.720]                   base::options(opts)
[17:26:42.720]                 }
[17:26:42.720]                 {
[17:26:42.720]                   {
[17:26:42.720]                     NULL
[17:26:42.720]                     RNGkind("Mersenne-Twister")
[17:26:42.720]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.720]                       inherits = FALSE)
[17:26:42.720]                   }
[17:26:42.720]                   options(future.plan = NULL)
[17:26:42.720]                   if (is.na(NA_character_)) 
[17:26:42.720]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.720]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.720]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.720]                     .init = FALSE)
[17:26:42.720]                 }
[17:26:42.720]             }
[17:26:42.720]         }
[17:26:42.720]     })
[17:26:42.720]     if (TRUE) {
[17:26:42.720]         base::sink(type = "output", split = FALSE)
[17:26:42.720]         if (TRUE) {
[17:26:42.720]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.720]         }
[17:26:42.720]         else {
[17:26:42.720]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.720]         }
[17:26:42.720]         base::close(...future.stdout)
[17:26:42.720]         ...future.stdout <- NULL
[17:26:42.720]     }
[17:26:42.720]     ...future.result$conditions <- ...future.conditions
[17:26:42.720]     ...future.result$finished <- base::Sys.time()
[17:26:42.720]     ...future.result
[17:26:42.720] }
[17:26:42.724] plan(): Setting new future strategy stack:
[17:26:42.724] List of future strategies:
[17:26:42.724] 1. sequential:
[17:26:42.724]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.724]    - tweaked: FALSE
[17:26:42.724]    - call: NULL
[17:26:42.725] plan(): nbrOfWorkers() = 1
[17:26:42.726] plan(): Setting new future strategy stack:
[17:26:42.726] List of future strategies:
[17:26:42.726] 1. sequential:
[17:26:42.726]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.726]    - tweaked: FALSE
[17:26:42.726]    - call: plan(strategy)
[17:26:42.727] plan(): nbrOfWorkers() = 1
[17:26:42.727] SequentialFuture started (and completed)
[17:26:42.727] - Launch lazy future ... done
[17:26:42.728] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230b07f308> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230cc741e8> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230b07f308> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230cc741e8> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 2 3
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
[17:26:42.735] resolved() for 'SequentialFuture' ...
[17:26:42.735] - state: 'finished'
[17:26:42.735] - run: TRUE
[17:26:42.736] - result: 'FutureResult'
[17:26:42.736] resolved() for 'SequentialFuture' ... done
[17:26:42.736] resolved() for 'SequentialFuture' ...
[17:26:42.736] - state: 'finished'
[17:26:42.736] - run: TRUE
[17:26:42.736] - result: 'FutureResult'
[17:26:42.737] resolved() for 'SequentialFuture' ... done
 logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:42.739] resolve() on list ...
[17:26:42.739]  recursive: 0
[17:26:42.739]  length: 6
[17:26:42.739]  elements: 'a', 'b', 'c', '', '', ''
[17:26:42.739] signalConditionsASAP(numeric, pos=1) ...
[17:26:42.739] - nx: 6
[17:26:42.740] - relay: TRUE
[17:26:42.740] - stdout: TRUE
[17:26:42.740] - signal: TRUE
[17:26:42.740] - resignal: FALSE
[17:26:42.740] - force: TRUE
[17:26:42.740] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.740] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.741]  - until=2
[17:26:42.741]  - relaying element #2
[17:26:42.741] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.741] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.741] signalConditionsASAP(NULL, pos=1) ... done
[17:26:42.742]  length: 5 (resolved future 1)
[17:26:42.742] resolved() for 'SequentialFuture' ...
[17:26:42.742] - state: 'finished'
[17:26:42.742] - run: TRUE
[17:26:42.742] - result: 'FutureResult'
[17:26:42.742] resolved() for 'SequentialFuture' ... done
[17:26:42.743] Future #2
[17:26:42.743] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:42.743] - nx: 6
[17:26:42.743] - relay: TRUE
[17:26:42.743] - stdout: TRUE
[17:26:42.743] - signal: TRUE
[17:26:42.744] - resignal: FALSE
[17:26:42.744] - force: TRUE
[17:26:42.744] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.744] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.744]  - until=2
[17:26:42.744]  - relaying element #2
[17:26:42.745] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.745] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.745] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:42.745]  length: 4 (resolved future 2)
[17:26:42.745] resolved() for 'SequentialFuture' ...
[17:26:42.746] - state: 'finished'
[17:26:42.746] - run: TRUE
[17:26:42.746] - result: 'FutureResult'
[17:26:42.746] resolved() for 'SequentialFuture' ... done
[17:26:42.746] Future #3
[17:26:42.747] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:42.747] - nx: 6
[17:26:42.747] - relay: TRUE
[17:26:42.747] - stdout: TRUE
[17:26:42.747] - signal: TRUE
[17:26:42.747] - resignal: FALSE
[17:26:42.747] - force: TRUE
[17:26:42.748] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.748] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.748]  - until=3
[17:26:42.748]  - relaying element #3
[17:26:42.748] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.749] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.749] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:42.749]  length: 3 (resolved future 3)
[17:26:42.749] signalConditionsASAP(NULL, pos=4) ...
[17:26:42.749] - nx: 6
[17:26:42.749] - relay: TRUE
[17:26:42.749] - stdout: TRUE
[17:26:42.750] - signal: TRUE
[17:26:42.750] - resignal: FALSE
[17:26:42.750] - force: TRUE
[17:26:42.750] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.750] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.750]  - until=5
[17:26:42.751]  - relaying element #5
[17:26:42.751] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.751] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.751] signalConditionsASAP(NULL, pos=4) ... done
[17:26:42.751]  length: 2 (resolved future 4)
[17:26:42.751] signalConditionsASAP(NULL, pos=5) ...
[17:26:42.752] - nx: 6
[17:26:42.752] - relay: TRUE
[17:26:42.752] - stdout: TRUE
[17:26:42.752] - signal: TRUE
[17:26:42.752] - resignal: FALSE
[17:26:42.752] - force: TRUE
[17:26:42.752] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.753] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.753]  - until=6
[17:26:42.753]  - relaying element #6
[17:26:42.753] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.753] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.753] signalConditionsASAP(NULL, pos=5) ... done
[17:26:42.754]  length: 1 (resolved future 5)
[17:26:42.754] signalConditionsASAP(numeric, pos=6) ...
[17:26:42.754] - nx: 6
[17:26:42.754] - relay: TRUE
[17:26:42.754] - stdout: TRUE
[17:26:42.754] - signal: TRUE
[17:26:42.755] - resignal: FALSE
[17:26:42.755] - force: TRUE
[17:26:42.755] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.755] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.755]  - until=6
[17:26:42.755] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.755] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.756] signalConditionsASAP(numeric, pos=6) ... done
[17:26:42.756]  length: 0 (resolved future 6)
[17:26:42.756] Relaying remaining futures
[17:26:42.756] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.756] - nx: 6
[17:26:42.756] - relay: TRUE
[17:26:42.757] - stdout: TRUE
[17:26:42.757] - signal: TRUE
[17:26:42.757] - resignal: FALSE
[17:26:42.757] - force: TRUE
[17:26:42.757] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.757] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:42.758] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.758] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.758] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.758] resolve() on list ... DONE
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 2 3
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
Dimensions: c(2, 3, 1)
[17:26:42.762] getGlobalsAndPackages() ...
[17:26:42.762] Searching for globals...
[17:26:42.762] 
[17:26:42.763] Searching for globals ... DONE
[17:26:42.763] - globals: [0] <none>
[17:26:42.763] getGlobalsAndPackages() ... DONE
[17:26:42.763] run() for 'Future' ...
[17:26:42.763] - state: 'created'
[17:26:42.764] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.764] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.764] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.764]   - Field: 'label'
[17:26:42.765]   - Field: 'local'
[17:26:42.765]   - Field: 'owner'
[17:26:42.765]   - Field: 'envir'
[17:26:42.765]   - Field: 'packages'
[17:26:42.765]   - Field: 'gc'
[17:26:42.765]   - Field: 'conditions'
[17:26:42.766]   - Field: 'expr'
[17:26:42.766]   - Field: 'uuid'
[17:26:42.766]   - Field: 'seed'
[17:26:42.766]   - Field: 'version'
[17:26:42.766]   - Field: 'result'
[17:26:42.767]   - Field: 'asynchronous'
[17:26:42.767]   - Field: 'calls'
[17:26:42.768]   - Field: 'globals'
[17:26:42.768]   - Field: 'stdout'
[17:26:42.768]   - Field: 'earlySignal'
[17:26:42.768]   - Field: 'lazy'
[17:26:42.769]   - Field: 'state'
[17:26:42.769] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.769] - Launch lazy future ...
[17:26:42.769] Packages needed by the future expression (n = 0): <none>
[17:26:42.769] Packages needed by future strategies (n = 0): <none>
[17:26:42.770] {
[17:26:42.770]     {
[17:26:42.770]         {
[17:26:42.770]             ...future.startTime <- base::Sys.time()
[17:26:42.770]             {
[17:26:42.770]                 {
[17:26:42.770]                   {
[17:26:42.770]                     base::local({
[17:26:42.770]                       has_future <- base::requireNamespace("future", 
[17:26:42.770]                         quietly = TRUE)
[17:26:42.770]                       if (has_future) {
[17:26:42.770]                         ns <- base::getNamespace("future")
[17:26:42.770]                         version <- ns[[".package"]][["version"]]
[17:26:42.770]                         if (is.null(version)) 
[17:26:42.770]                           version <- utils::packageVersion("future")
[17:26:42.770]                       }
[17:26:42.770]                       else {
[17:26:42.770]                         version <- NULL
[17:26:42.770]                       }
[17:26:42.770]                       if (!has_future || version < "1.8.0") {
[17:26:42.770]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.770]                           "", base::R.version$version.string), 
[17:26:42.770]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.770]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.770]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.770]                             "release", "version")], collapse = " "), 
[17:26:42.770]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.770]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.770]                           info)
[17:26:42.770]                         info <- base::paste(info, collapse = "; ")
[17:26:42.770]                         if (!has_future) {
[17:26:42.770]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.770]                             info)
[17:26:42.770]                         }
[17:26:42.770]                         else {
[17:26:42.770]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.770]                             info, version)
[17:26:42.770]                         }
[17:26:42.770]                         base::stop(msg)
[17:26:42.770]                       }
[17:26:42.770]                     })
[17:26:42.770]                   }
[17:26:42.770]                   ...future.strategy.old <- future::plan("list")
[17:26:42.770]                   options(future.plan = NULL)
[17:26:42.770]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.770]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.770]                 }
[17:26:42.770]                 ...future.workdir <- getwd()
[17:26:42.770]             }
[17:26:42.770]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.770]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.770]         }
[17:26:42.770]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.770]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.770]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.770]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.770]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.770]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.770]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.770]             base::names(...future.oldOptions))
[17:26:42.770]     }
[17:26:42.770]     if (FALSE) {
[17:26:42.770]     }
[17:26:42.770]     else {
[17:26:42.770]         if (TRUE) {
[17:26:42.770]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.770]                 open = "w")
[17:26:42.770]         }
[17:26:42.770]         else {
[17:26:42.770]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.770]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.770]         }
[17:26:42.770]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.770]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.770]             base::sink(type = "output", split = FALSE)
[17:26:42.770]             base::close(...future.stdout)
[17:26:42.770]         }, add = TRUE)
[17:26:42.770]     }
[17:26:42.770]     ...future.frame <- base::sys.nframe()
[17:26:42.770]     ...future.conditions <- base::list()
[17:26:42.770]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.770]     if (FALSE) {
[17:26:42.770]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.770]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.770]     }
[17:26:42.770]     ...future.result <- base::tryCatch({
[17:26:42.770]         base::withCallingHandlers({
[17:26:42.770]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.770]             future::FutureResult(value = ...future.value$value, 
[17:26:42.770]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.770]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.770]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.770]                     ...future.globalenv.names))
[17:26:42.770]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.770]         }, condition = base::local({
[17:26:42.770]             c <- base::c
[17:26:42.770]             inherits <- base::inherits
[17:26:42.770]             invokeRestart <- base::invokeRestart
[17:26:42.770]             length <- base::length
[17:26:42.770]             list <- base::list
[17:26:42.770]             seq.int <- base::seq.int
[17:26:42.770]             signalCondition <- base::signalCondition
[17:26:42.770]             sys.calls <- base::sys.calls
[17:26:42.770]             `[[` <- base::`[[`
[17:26:42.770]             `+` <- base::`+`
[17:26:42.770]             `<<-` <- base::`<<-`
[17:26:42.770]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.770]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.770]                   3L)]
[17:26:42.770]             }
[17:26:42.770]             function(cond) {
[17:26:42.770]                 is_error <- inherits(cond, "error")
[17:26:42.770]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.770]                   NULL)
[17:26:42.770]                 if (is_error) {
[17:26:42.770]                   sessionInformation <- function() {
[17:26:42.770]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.770]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.770]                       search = base::search(), system = base::Sys.info())
[17:26:42.770]                   }
[17:26:42.770]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.770]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.770]                     cond$call), session = sessionInformation(), 
[17:26:42.770]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.770]                   signalCondition(cond)
[17:26:42.770]                 }
[17:26:42.770]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.770]                 "immediateCondition"))) {
[17:26:42.770]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.770]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.770]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.770]                   if (TRUE && !signal) {
[17:26:42.770]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.770]                     {
[17:26:42.770]                       inherits <- base::inherits
[17:26:42.770]                       invokeRestart <- base::invokeRestart
[17:26:42.770]                       is.null <- base::is.null
[17:26:42.770]                       muffled <- FALSE
[17:26:42.770]                       if (inherits(cond, "message")) {
[17:26:42.770]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.770]                         if (muffled) 
[17:26:42.770]                           invokeRestart("muffleMessage")
[17:26:42.770]                       }
[17:26:42.770]                       else if (inherits(cond, "warning")) {
[17:26:42.770]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.770]                         if (muffled) 
[17:26:42.770]                           invokeRestart("muffleWarning")
[17:26:42.770]                       }
[17:26:42.770]                       else if (inherits(cond, "condition")) {
[17:26:42.770]                         if (!is.null(pattern)) {
[17:26:42.770]                           computeRestarts <- base::computeRestarts
[17:26:42.770]                           grepl <- base::grepl
[17:26:42.770]                           restarts <- computeRestarts(cond)
[17:26:42.770]                           for (restart in restarts) {
[17:26:42.770]                             name <- restart$name
[17:26:42.770]                             if (is.null(name)) 
[17:26:42.770]                               next
[17:26:42.770]                             if (!grepl(pattern, name)) 
[17:26:42.770]                               next
[17:26:42.770]                             invokeRestart(restart)
[17:26:42.770]                             muffled <- TRUE
[17:26:42.770]                             break
[17:26:42.770]                           }
[17:26:42.770]                         }
[17:26:42.770]                       }
[17:26:42.770]                       invisible(muffled)
[17:26:42.770]                     }
[17:26:42.770]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.770]                   }
[17:26:42.770]                 }
[17:26:42.770]                 else {
[17:26:42.770]                   if (TRUE) {
[17:26:42.770]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.770]                     {
[17:26:42.770]                       inherits <- base::inherits
[17:26:42.770]                       invokeRestart <- base::invokeRestart
[17:26:42.770]                       is.null <- base::is.null
[17:26:42.770]                       muffled <- FALSE
[17:26:42.770]                       if (inherits(cond, "message")) {
[17:26:42.770]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.770]                         if (muffled) 
[17:26:42.770]                           invokeRestart("muffleMessage")
[17:26:42.770]                       }
[17:26:42.770]                       else if (inherits(cond, "warning")) {
[17:26:42.770]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.770]                         if (muffled) 
[17:26:42.770]                           invokeRestart("muffleWarning")
[17:26:42.770]                       }
[17:26:42.770]                       else if (inherits(cond, "condition")) {
[17:26:42.770]                         if (!is.null(pattern)) {
[17:26:42.770]                           computeRestarts <- base::computeRestarts
[17:26:42.770]                           grepl <- base::grepl
[17:26:42.770]                           restarts <- computeRestarts(cond)
[17:26:42.770]                           for (restart in restarts) {
[17:26:42.770]                             name <- restart$name
[17:26:42.770]                             if (is.null(name)) 
[17:26:42.770]                               next
[17:26:42.770]                             if (!grepl(pattern, name)) 
[17:26:42.770]                               next
[17:26:42.770]                             invokeRestart(restart)
[17:26:42.770]                             muffled <- TRUE
[17:26:42.770]                             break
[17:26:42.770]                           }
[17:26:42.770]                         }
[17:26:42.770]                       }
[17:26:42.770]                       invisible(muffled)
[17:26:42.770]                     }
[17:26:42.770]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.770]                   }
[17:26:42.770]                 }
[17:26:42.770]             }
[17:26:42.770]         }))
[17:26:42.770]     }, error = function(ex) {
[17:26:42.770]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.770]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.770]                 ...future.rng), started = ...future.startTime, 
[17:26:42.770]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.770]             version = "1.8"), class = "FutureResult")
[17:26:42.770]     }, finally = {
[17:26:42.770]         if (!identical(...future.workdir, getwd())) 
[17:26:42.770]             setwd(...future.workdir)
[17:26:42.770]         {
[17:26:42.770]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.770]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.770]             }
[17:26:42.770]             base::options(...future.oldOptions)
[17:26:42.770]             if (.Platform$OS.type == "windows") {
[17:26:42.770]                 old_names <- names(...future.oldEnvVars)
[17:26:42.770]                 envs <- base::Sys.getenv()
[17:26:42.770]                 names <- names(envs)
[17:26:42.770]                 common <- intersect(names, old_names)
[17:26:42.770]                 added <- setdiff(names, old_names)
[17:26:42.770]                 removed <- setdiff(old_names, names)
[17:26:42.770]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.770]                   envs[common]]
[17:26:42.770]                 NAMES <- toupper(changed)
[17:26:42.770]                 args <- list()
[17:26:42.770]                 for (kk in seq_along(NAMES)) {
[17:26:42.770]                   name <- changed[[kk]]
[17:26:42.770]                   NAME <- NAMES[[kk]]
[17:26:42.770]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.770]                     next
[17:26:42.770]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.770]                 }
[17:26:42.770]                 NAMES <- toupper(added)
[17:26:42.770]                 for (kk in seq_along(NAMES)) {
[17:26:42.770]                   name <- added[[kk]]
[17:26:42.770]                   NAME <- NAMES[[kk]]
[17:26:42.770]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.770]                     next
[17:26:42.770]                   args[[name]] <- ""
[17:26:42.770]                 }
[17:26:42.770]                 NAMES <- toupper(removed)
[17:26:42.770]                 for (kk in seq_along(NAMES)) {
[17:26:42.770]                   name <- removed[[kk]]
[17:26:42.770]                   NAME <- NAMES[[kk]]
[17:26:42.770]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.770]                     next
[17:26:42.770]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.770]                 }
[17:26:42.770]                 if (length(args) > 0) 
[17:26:42.770]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.770]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.770]             }
[17:26:42.770]             else {
[17:26:42.770]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.770]             }
[17:26:42.770]             {
[17:26:42.770]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.770]                   0L) {
[17:26:42.770]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.770]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.770]                   base::options(opts)
[17:26:42.770]                 }
[17:26:42.770]                 {
[17:26:42.770]                   {
[17:26:42.770]                     NULL
[17:26:42.770]                     RNGkind("Mersenne-Twister")
[17:26:42.770]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.770]                       inherits = FALSE)
[17:26:42.770]                   }
[17:26:42.770]                   options(future.plan = NULL)
[17:26:42.770]                   if (is.na(NA_character_)) 
[17:26:42.770]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.770]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.770]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.770]                     .init = FALSE)
[17:26:42.770]                 }
[17:26:42.770]             }
[17:26:42.770]         }
[17:26:42.770]     })
[17:26:42.770]     if (TRUE) {
[17:26:42.770]         base::sink(type = "output", split = FALSE)
[17:26:42.770]         if (TRUE) {
[17:26:42.770]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.770]         }
[17:26:42.770]         else {
[17:26:42.770]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.770]         }
[17:26:42.770]         base::close(...future.stdout)
[17:26:42.770]         ...future.stdout <- NULL
[17:26:42.770]     }
[17:26:42.770]     ...future.result$conditions <- ...future.conditions
[17:26:42.770]     ...future.result$finished <- base::Sys.time()
[17:26:42.770]     ...future.result
[17:26:42.770] }
[17:26:42.774] plan(): Setting new future strategy stack:
[17:26:42.774] List of future strategies:
[17:26:42.774] 1. sequential:
[17:26:42.774]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.774]    - tweaked: FALSE
[17:26:42.774]    - call: NULL
[17:26:42.775] plan(): nbrOfWorkers() = 1
[17:26:42.776] plan(): Setting new future strategy stack:
[17:26:42.776] List of future strategies:
[17:26:42.776] 1. sequential:
[17:26:42.776]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.776]    - tweaked: FALSE
[17:26:42.776]    - call: plan(strategy)
[17:26:42.777] plan(): nbrOfWorkers() = 1
[17:26:42.777] SequentialFuture started (and completed)
[17:26:42.777] - Launch lazy future ... done
[17:26:42.777] run() for 'SequentialFuture' ... done
[17:26:42.777] getGlobalsAndPackages() ...
[17:26:42.778] Searching for globals...
[17:26:42.778] 
[17:26:42.778] Searching for globals ... DONE
[17:26:42.778] - globals: [0] <none>
[17:26:42.778] getGlobalsAndPackages() ... DONE
[17:26:42.779] run() for 'Future' ...
[17:26:42.779] - state: 'created'
[17:26:42.779] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.779] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.780] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.780]   - Field: 'label'
[17:26:42.780]   - Field: 'local'
[17:26:42.780]   - Field: 'owner'
[17:26:42.780]   - Field: 'envir'
[17:26:42.781]   - Field: 'packages'
[17:26:42.781]   - Field: 'gc'
[17:26:42.781]   - Field: 'conditions'
[17:26:42.781]   - Field: 'expr'
[17:26:42.781]   - Field: 'uuid'
[17:26:42.781]   - Field: 'seed'
[17:26:42.782]   - Field: 'version'
[17:26:42.782]   - Field: 'result'
[17:26:42.782]   - Field: 'asynchronous'
[17:26:42.782]   - Field: 'calls'
[17:26:42.782]   - Field: 'globals'
[17:26:42.783]   - Field: 'stdout'
[17:26:42.783]   - Field: 'earlySignal'
[17:26:42.783]   - Field: 'lazy'
[17:26:42.783]   - Field: 'state'
[17:26:42.783] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.784] - Launch lazy future ...
[17:26:42.784] Packages needed by the future expression (n = 0): <none>
[17:26:42.784] Packages needed by future strategies (n = 0): <none>
[17:26:42.785] {
[17:26:42.785]     {
[17:26:42.785]         {
[17:26:42.785]             ...future.startTime <- base::Sys.time()
[17:26:42.785]             {
[17:26:42.785]                 {
[17:26:42.785]                   {
[17:26:42.785]                     base::local({
[17:26:42.785]                       has_future <- base::requireNamespace("future", 
[17:26:42.785]                         quietly = TRUE)
[17:26:42.785]                       if (has_future) {
[17:26:42.785]                         ns <- base::getNamespace("future")
[17:26:42.785]                         version <- ns[[".package"]][["version"]]
[17:26:42.785]                         if (is.null(version)) 
[17:26:42.785]                           version <- utils::packageVersion("future")
[17:26:42.785]                       }
[17:26:42.785]                       else {
[17:26:42.785]                         version <- NULL
[17:26:42.785]                       }
[17:26:42.785]                       if (!has_future || version < "1.8.0") {
[17:26:42.785]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.785]                           "", base::R.version$version.string), 
[17:26:42.785]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.785]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.785]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.785]                             "release", "version")], collapse = " "), 
[17:26:42.785]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.785]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.785]                           info)
[17:26:42.785]                         info <- base::paste(info, collapse = "; ")
[17:26:42.785]                         if (!has_future) {
[17:26:42.785]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.785]                             info)
[17:26:42.785]                         }
[17:26:42.785]                         else {
[17:26:42.785]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.785]                             info, version)
[17:26:42.785]                         }
[17:26:42.785]                         base::stop(msg)
[17:26:42.785]                       }
[17:26:42.785]                     })
[17:26:42.785]                   }
[17:26:42.785]                   ...future.strategy.old <- future::plan("list")
[17:26:42.785]                   options(future.plan = NULL)
[17:26:42.785]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.785]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.785]                 }
[17:26:42.785]                 ...future.workdir <- getwd()
[17:26:42.785]             }
[17:26:42.785]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.785]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.785]         }
[17:26:42.785]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.785]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.785]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.785]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.785]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.785]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.785]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.785]             base::names(...future.oldOptions))
[17:26:42.785]     }
[17:26:42.785]     if (FALSE) {
[17:26:42.785]     }
[17:26:42.785]     else {
[17:26:42.785]         if (TRUE) {
[17:26:42.785]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.785]                 open = "w")
[17:26:42.785]         }
[17:26:42.785]         else {
[17:26:42.785]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.785]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.785]         }
[17:26:42.785]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.785]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.785]             base::sink(type = "output", split = FALSE)
[17:26:42.785]             base::close(...future.stdout)
[17:26:42.785]         }, add = TRUE)
[17:26:42.785]     }
[17:26:42.785]     ...future.frame <- base::sys.nframe()
[17:26:42.785]     ...future.conditions <- base::list()
[17:26:42.785]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.785]     if (FALSE) {
[17:26:42.785]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.785]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.785]     }
[17:26:42.785]     ...future.result <- base::tryCatch({
[17:26:42.785]         base::withCallingHandlers({
[17:26:42.785]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.785]             future::FutureResult(value = ...future.value$value, 
[17:26:42.785]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.785]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.785]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.785]                     ...future.globalenv.names))
[17:26:42.785]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.785]         }, condition = base::local({
[17:26:42.785]             c <- base::c
[17:26:42.785]             inherits <- base::inherits
[17:26:42.785]             invokeRestart <- base::invokeRestart
[17:26:42.785]             length <- base::length
[17:26:42.785]             list <- base::list
[17:26:42.785]             seq.int <- base::seq.int
[17:26:42.785]             signalCondition <- base::signalCondition
[17:26:42.785]             sys.calls <- base::sys.calls
[17:26:42.785]             `[[` <- base::`[[`
[17:26:42.785]             `+` <- base::`+`
[17:26:42.785]             `<<-` <- base::`<<-`
[17:26:42.785]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.785]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.785]                   3L)]
[17:26:42.785]             }
[17:26:42.785]             function(cond) {
[17:26:42.785]                 is_error <- inherits(cond, "error")
[17:26:42.785]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.785]                   NULL)
[17:26:42.785]                 if (is_error) {
[17:26:42.785]                   sessionInformation <- function() {
[17:26:42.785]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.785]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.785]                       search = base::search(), system = base::Sys.info())
[17:26:42.785]                   }
[17:26:42.785]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.785]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.785]                     cond$call), session = sessionInformation(), 
[17:26:42.785]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.785]                   signalCondition(cond)
[17:26:42.785]                 }
[17:26:42.785]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.785]                 "immediateCondition"))) {
[17:26:42.785]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.785]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.785]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.785]                   if (TRUE && !signal) {
[17:26:42.785]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.785]                     {
[17:26:42.785]                       inherits <- base::inherits
[17:26:42.785]                       invokeRestart <- base::invokeRestart
[17:26:42.785]                       is.null <- base::is.null
[17:26:42.785]                       muffled <- FALSE
[17:26:42.785]                       if (inherits(cond, "message")) {
[17:26:42.785]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.785]                         if (muffled) 
[17:26:42.785]                           invokeRestart("muffleMessage")
[17:26:42.785]                       }
[17:26:42.785]                       else if (inherits(cond, "warning")) {
[17:26:42.785]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.785]                         if (muffled) 
[17:26:42.785]                           invokeRestart("muffleWarning")
[17:26:42.785]                       }
[17:26:42.785]                       else if (inherits(cond, "condition")) {
[17:26:42.785]                         if (!is.null(pattern)) {
[17:26:42.785]                           computeRestarts <- base::computeRestarts
[17:26:42.785]                           grepl <- base::grepl
[17:26:42.785]                           restarts <- computeRestarts(cond)
[17:26:42.785]                           for (restart in restarts) {
[17:26:42.785]                             name <- restart$name
[17:26:42.785]                             if (is.null(name)) 
[17:26:42.785]                               next
[17:26:42.785]                             if (!grepl(pattern, name)) 
[17:26:42.785]                               next
[17:26:42.785]                             invokeRestart(restart)
[17:26:42.785]                             muffled <- TRUE
[17:26:42.785]                             break
[17:26:42.785]                           }
[17:26:42.785]                         }
[17:26:42.785]                       }
[17:26:42.785]                       invisible(muffled)
[17:26:42.785]                     }
[17:26:42.785]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.785]                   }
[17:26:42.785]                 }
[17:26:42.785]                 else {
[17:26:42.785]                   if (TRUE) {
[17:26:42.785]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.785]                     {
[17:26:42.785]                       inherits <- base::inherits
[17:26:42.785]                       invokeRestart <- base::invokeRestart
[17:26:42.785]                       is.null <- base::is.null
[17:26:42.785]                       muffled <- FALSE
[17:26:42.785]                       if (inherits(cond, "message")) {
[17:26:42.785]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.785]                         if (muffled) 
[17:26:42.785]                           invokeRestart("muffleMessage")
[17:26:42.785]                       }
[17:26:42.785]                       else if (inherits(cond, "warning")) {
[17:26:42.785]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.785]                         if (muffled) 
[17:26:42.785]                           invokeRestart("muffleWarning")
[17:26:42.785]                       }
[17:26:42.785]                       else if (inherits(cond, "condition")) {
[17:26:42.785]                         if (!is.null(pattern)) {
[17:26:42.785]                           computeRestarts <- base::computeRestarts
[17:26:42.785]                           grepl <- base::grepl
[17:26:42.785]                           restarts <- computeRestarts(cond)
[17:26:42.785]                           for (restart in restarts) {
[17:26:42.785]                             name <- restart$name
[17:26:42.785]                             if (is.null(name)) 
[17:26:42.785]                               next
[17:26:42.785]                             if (!grepl(pattern, name)) 
[17:26:42.785]                               next
[17:26:42.785]                             invokeRestart(restart)
[17:26:42.785]                             muffled <- TRUE
[17:26:42.785]                             break
[17:26:42.785]                           }
[17:26:42.785]                         }
[17:26:42.785]                       }
[17:26:42.785]                       invisible(muffled)
[17:26:42.785]                     }
[17:26:42.785]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.785]                   }
[17:26:42.785]                 }
[17:26:42.785]             }
[17:26:42.785]         }))
[17:26:42.785]     }, error = function(ex) {
[17:26:42.785]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.785]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.785]                 ...future.rng), started = ...future.startTime, 
[17:26:42.785]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.785]             version = "1.8"), class = "FutureResult")
[17:26:42.785]     }, finally = {
[17:26:42.785]         if (!identical(...future.workdir, getwd())) 
[17:26:42.785]             setwd(...future.workdir)
[17:26:42.785]         {
[17:26:42.785]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.785]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.785]             }
[17:26:42.785]             base::options(...future.oldOptions)
[17:26:42.785]             if (.Platform$OS.type == "windows") {
[17:26:42.785]                 old_names <- names(...future.oldEnvVars)
[17:26:42.785]                 envs <- base::Sys.getenv()
[17:26:42.785]                 names <- names(envs)
[17:26:42.785]                 common <- intersect(names, old_names)
[17:26:42.785]                 added <- setdiff(names, old_names)
[17:26:42.785]                 removed <- setdiff(old_names, names)
[17:26:42.785]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.785]                   envs[common]]
[17:26:42.785]                 NAMES <- toupper(changed)
[17:26:42.785]                 args <- list()
[17:26:42.785]                 for (kk in seq_along(NAMES)) {
[17:26:42.785]                   name <- changed[[kk]]
[17:26:42.785]                   NAME <- NAMES[[kk]]
[17:26:42.785]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.785]                     next
[17:26:42.785]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.785]                 }
[17:26:42.785]                 NAMES <- toupper(added)
[17:26:42.785]                 for (kk in seq_along(NAMES)) {
[17:26:42.785]                   name <- added[[kk]]
[17:26:42.785]                   NAME <- NAMES[[kk]]
[17:26:42.785]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.785]                     next
[17:26:42.785]                   args[[name]] <- ""
[17:26:42.785]                 }
[17:26:42.785]                 NAMES <- toupper(removed)
[17:26:42.785]                 for (kk in seq_along(NAMES)) {
[17:26:42.785]                   name <- removed[[kk]]
[17:26:42.785]                   NAME <- NAMES[[kk]]
[17:26:42.785]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.785]                     next
[17:26:42.785]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.785]                 }
[17:26:42.785]                 if (length(args) > 0) 
[17:26:42.785]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.785]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.785]             }
[17:26:42.785]             else {
[17:26:42.785]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.785]             }
[17:26:42.785]             {
[17:26:42.785]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.785]                   0L) {
[17:26:42.785]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.785]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.785]                   base::options(opts)
[17:26:42.785]                 }
[17:26:42.785]                 {
[17:26:42.785]                   {
[17:26:42.785]                     NULL
[17:26:42.785]                     RNGkind("Mersenne-Twister")
[17:26:42.785]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.785]                       inherits = FALSE)
[17:26:42.785]                   }
[17:26:42.785]                   options(future.plan = NULL)
[17:26:42.785]                   if (is.na(NA_character_)) 
[17:26:42.785]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.785]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.785]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.785]                     .init = FALSE)
[17:26:42.785]                 }
[17:26:42.785]             }
[17:26:42.785]         }
[17:26:42.785]     })
[17:26:42.785]     if (TRUE) {
[17:26:42.785]         base::sink(type = "output", split = FALSE)
[17:26:42.785]         if (TRUE) {
[17:26:42.785]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.785]         }
[17:26:42.785]         else {
[17:26:42.785]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.785]         }
[17:26:42.785]         base::close(...future.stdout)
[17:26:42.785]         ...future.stdout <- NULL
[17:26:42.785]     }
[17:26:42.785]     ...future.result$conditions <- ...future.conditions
[17:26:42.785]     ...future.result$finished <- base::Sys.time()
[17:26:42.785]     ...future.result
[17:26:42.785] }
[17:26:42.788] plan(): Setting new future strategy stack:
[17:26:42.789] List of future strategies:
[17:26:42.789] 1. sequential:
[17:26:42.789]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.789]    - tweaked: FALSE
[17:26:42.789]    - call: NULL
[17:26:42.789] plan(): nbrOfWorkers() = 1
[17:26:42.790] plan(): Setting new future strategy stack:
[17:26:42.791] List of future strategies:
[17:26:42.791] 1. sequential:
[17:26:42.791]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.791]    - tweaked: FALSE
[17:26:42.791]    - call: plan(strategy)
[17:26:42.791] plan(): nbrOfWorkers() = 1
[17:26:42.791] SequentialFuture started (and completed)
[17:26:42.792] - Launch lazy future ... done
[17:26:42.792] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230d75c290> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000022309d2e6c0> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230d75c290> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000022309d2e6c0> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:3] 2 3 1
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:42.798] resolved() for 'SequentialFuture' ...
[17:26:42.798] - state: 'finished'
[17:26:42.798] - run: TRUE
[17:26:42.799] - result: 'FutureResult'
[17:26:42.799] resolved() for 'SequentialFuture' ... done
[17:26:42.799] resolved() for 'SequentialFuture' ...
[17:26:42.799] - state: 'finished'
[17:26:42.799] - run: TRUE
[17:26:42.799] - result: 'FutureResult'
[17:26:42.800] resolved() for 'SequentialFuture' ... done
 logi [1:2, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:42.802] resolve() on list ...
[17:26:42.802]  recursive: 0
[17:26:42.802]  length: 6
[17:26:42.802]  elements: 'a', 'b', 'c', '', '', ''
[17:26:42.803] signalConditionsASAP(numeric, pos=1) ...
[17:26:42.803] - nx: 6
[17:26:42.803] - relay: TRUE
[17:26:42.803] - stdout: TRUE
[17:26:42.803] - signal: TRUE
[17:26:42.803] - resignal: FALSE
[17:26:42.803] - force: TRUE
[17:26:42.804] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.804] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.804]  - until=2
[17:26:42.804]  - relaying element #2
[17:26:42.804] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.804] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.805] signalConditionsASAP(NULL, pos=1) ... done
[17:26:42.805]  length: 5 (resolved future 1)
[17:26:42.805] resolved() for 'SequentialFuture' ...
[17:26:42.805] - state: 'finished'
[17:26:42.805] - run: TRUE
[17:26:42.806] - result: 'FutureResult'
[17:26:42.807] resolved() for 'SequentialFuture' ... done
[17:26:42.807] Future #2
[17:26:42.807] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:42.807] - nx: 6
[17:26:42.808] - relay: TRUE
[17:26:42.808] - stdout: TRUE
[17:26:42.808] - signal: TRUE
[17:26:42.808] - resignal: FALSE
[17:26:42.808] - force: TRUE
[17:26:42.808] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.809] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.809]  - until=2
[17:26:42.809]  - relaying element #2
[17:26:42.809] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.809] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.810] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:42.810]  length: 4 (resolved future 2)
[17:26:42.810] resolved() for 'SequentialFuture' ...
[17:26:42.810] - state: 'finished'
[17:26:42.810] - run: TRUE
[17:26:42.810] - result: 'FutureResult'
[17:26:42.811] resolved() for 'SequentialFuture' ... done
[17:26:42.811] Future #3
[17:26:42.811] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:42.811] - nx: 6
[17:26:42.811] - relay: TRUE
[17:26:42.812] - stdout: TRUE
[17:26:42.812] - signal: TRUE
[17:26:42.812] - resignal: FALSE
[17:26:42.812] - force: TRUE
[17:26:42.812] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.812] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.812]  - until=3
[17:26:42.813]  - relaying element #3
[17:26:42.813] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.813] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.813] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:42.813]  length: 3 (resolved future 3)
[17:26:42.814] signalConditionsASAP(NULL, pos=4) ...
[17:26:42.814] - nx: 6
[17:26:42.814] - relay: TRUE
[17:26:42.814] - stdout: TRUE
[17:26:42.814] - signal: TRUE
[17:26:42.814] - resignal: FALSE
[17:26:42.814] - force: TRUE
[17:26:42.815] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.815] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.815]  - until=5
[17:26:42.815]  - relaying element #5
[17:26:42.815] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.815] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.816] signalConditionsASAP(NULL, pos=4) ... done
[17:26:42.816]  length: 2 (resolved future 4)
[17:26:42.816] signalConditionsASAP(NULL, pos=5) ...
[17:26:42.816] - nx: 6
[17:26:42.816] - relay: TRUE
[17:26:42.816] - stdout: TRUE
[17:26:42.817] - signal: TRUE
[17:26:42.817] - resignal: FALSE
[17:26:42.817] - force: TRUE
[17:26:42.817] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.817] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.817]  - until=6
[17:26:42.817]  - relaying element #6
[17:26:42.818] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.818] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.818] signalConditionsASAP(NULL, pos=5) ... done
[17:26:42.818]  length: 1 (resolved future 5)
[17:26:42.818] signalConditionsASAP(numeric, pos=6) ...
[17:26:42.818] - nx: 6
[17:26:42.819] - relay: TRUE
[17:26:42.819] - stdout: TRUE
[17:26:42.819] - signal: TRUE
[17:26:42.819] - resignal: FALSE
[17:26:42.819] - force: TRUE
[17:26:42.819] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.819] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.820]  - until=6
[17:26:42.820] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.820] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.820] signalConditionsASAP(numeric, pos=6) ... done
[17:26:42.820]  length: 0 (resolved future 6)
[17:26:42.820] Relaying remaining futures
[17:26:42.821] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.821] - nx: 6
[17:26:42.821] - relay: TRUE
[17:26:42.821] - stdout: TRUE
[17:26:42.821] - signal: TRUE
[17:26:42.821] - resignal: FALSE
[17:26:42.821] - force: TRUE
[17:26:42.822] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.822] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:42.822] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.822] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.822] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.822] resolve() on list ... DONE
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:3] 2 3 1
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
Dimensions: c(2, 1, 3, 1)
[17:26:42.827] getGlobalsAndPackages() ...
[17:26:42.827] Searching for globals...
[17:26:42.827] 
[17:26:42.827] Searching for globals ... DONE
[17:26:42.827] - globals: [0] <none>
[17:26:42.828] getGlobalsAndPackages() ... DONE
[17:26:42.828] run() for 'Future' ...
[17:26:42.828] - state: 'created'
[17:26:42.828] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.829] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.829] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.829]   - Field: 'label'
[17:26:42.829]   - Field: 'local'
[17:26:42.830]   - Field: 'owner'
[17:26:42.830]   - Field: 'envir'
[17:26:42.830]   - Field: 'packages'
[17:26:42.830]   - Field: 'gc'
[17:26:42.830]   - Field: 'conditions'
[17:26:42.830]   - Field: 'expr'
[17:26:42.831]   - Field: 'uuid'
[17:26:42.831]   - Field: 'seed'
[17:26:42.831]   - Field: 'version'
[17:26:42.831]   - Field: 'result'
[17:26:42.831]   - Field: 'asynchronous'
[17:26:42.831]   - Field: 'calls'
[17:26:42.832]   - Field: 'globals'
[17:26:42.832]   - Field: 'stdout'
[17:26:42.832]   - Field: 'earlySignal'
[17:26:42.832]   - Field: 'lazy'
[17:26:42.832]   - Field: 'state'
[17:26:42.832] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.833] - Launch lazy future ...
[17:26:42.833] Packages needed by the future expression (n = 0): <none>
[17:26:42.833] Packages needed by future strategies (n = 0): <none>
[17:26:42.834] {
[17:26:42.834]     {
[17:26:42.834]         {
[17:26:42.834]             ...future.startTime <- base::Sys.time()
[17:26:42.834]             {
[17:26:42.834]                 {
[17:26:42.834]                   {
[17:26:42.834]                     base::local({
[17:26:42.834]                       has_future <- base::requireNamespace("future", 
[17:26:42.834]                         quietly = TRUE)
[17:26:42.834]                       if (has_future) {
[17:26:42.834]                         ns <- base::getNamespace("future")
[17:26:42.834]                         version <- ns[[".package"]][["version"]]
[17:26:42.834]                         if (is.null(version)) 
[17:26:42.834]                           version <- utils::packageVersion("future")
[17:26:42.834]                       }
[17:26:42.834]                       else {
[17:26:42.834]                         version <- NULL
[17:26:42.834]                       }
[17:26:42.834]                       if (!has_future || version < "1.8.0") {
[17:26:42.834]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.834]                           "", base::R.version$version.string), 
[17:26:42.834]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.834]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.834]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.834]                             "release", "version")], collapse = " "), 
[17:26:42.834]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.834]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.834]                           info)
[17:26:42.834]                         info <- base::paste(info, collapse = "; ")
[17:26:42.834]                         if (!has_future) {
[17:26:42.834]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.834]                             info)
[17:26:42.834]                         }
[17:26:42.834]                         else {
[17:26:42.834]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.834]                             info, version)
[17:26:42.834]                         }
[17:26:42.834]                         base::stop(msg)
[17:26:42.834]                       }
[17:26:42.834]                     })
[17:26:42.834]                   }
[17:26:42.834]                   ...future.strategy.old <- future::plan("list")
[17:26:42.834]                   options(future.plan = NULL)
[17:26:42.834]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.834]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.834]                 }
[17:26:42.834]                 ...future.workdir <- getwd()
[17:26:42.834]             }
[17:26:42.834]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.834]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.834]         }
[17:26:42.834]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.834]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.834]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.834]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.834]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.834]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.834]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.834]             base::names(...future.oldOptions))
[17:26:42.834]     }
[17:26:42.834]     if (FALSE) {
[17:26:42.834]     }
[17:26:42.834]     else {
[17:26:42.834]         if (TRUE) {
[17:26:42.834]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.834]                 open = "w")
[17:26:42.834]         }
[17:26:42.834]         else {
[17:26:42.834]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.834]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.834]         }
[17:26:42.834]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.834]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.834]             base::sink(type = "output", split = FALSE)
[17:26:42.834]             base::close(...future.stdout)
[17:26:42.834]         }, add = TRUE)
[17:26:42.834]     }
[17:26:42.834]     ...future.frame <- base::sys.nframe()
[17:26:42.834]     ...future.conditions <- base::list()
[17:26:42.834]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.834]     if (FALSE) {
[17:26:42.834]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.834]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.834]     }
[17:26:42.834]     ...future.result <- base::tryCatch({
[17:26:42.834]         base::withCallingHandlers({
[17:26:42.834]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.834]             future::FutureResult(value = ...future.value$value, 
[17:26:42.834]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.834]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.834]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.834]                     ...future.globalenv.names))
[17:26:42.834]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.834]         }, condition = base::local({
[17:26:42.834]             c <- base::c
[17:26:42.834]             inherits <- base::inherits
[17:26:42.834]             invokeRestart <- base::invokeRestart
[17:26:42.834]             length <- base::length
[17:26:42.834]             list <- base::list
[17:26:42.834]             seq.int <- base::seq.int
[17:26:42.834]             signalCondition <- base::signalCondition
[17:26:42.834]             sys.calls <- base::sys.calls
[17:26:42.834]             `[[` <- base::`[[`
[17:26:42.834]             `+` <- base::`+`
[17:26:42.834]             `<<-` <- base::`<<-`
[17:26:42.834]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.834]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.834]                   3L)]
[17:26:42.834]             }
[17:26:42.834]             function(cond) {
[17:26:42.834]                 is_error <- inherits(cond, "error")
[17:26:42.834]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.834]                   NULL)
[17:26:42.834]                 if (is_error) {
[17:26:42.834]                   sessionInformation <- function() {
[17:26:42.834]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.834]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.834]                       search = base::search(), system = base::Sys.info())
[17:26:42.834]                   }
[17:26:42.834]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.834]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.834]                     cond$call), session = sessionInformation(), 
[17:26:42.834]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.834]                   signalCondition(cond)
[17:26:42.834]                 }
[17:26:42.834]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.834]                 "immediateCondition"))) {
[17:26:42.834]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.834]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.834]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.834]                   if (TRUE && !signal) {
[17:26:42.834]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.834]                     {
[17:26:42.834]                       inherits <- base::inherits
[17:26:42.834]                       invokeRestart <- base::invokeRestart
[17:26:42.834]                       is.null <- base::is.null
[17:26:42.834]                       muffled <- FALSE
[17:26:42.834]                       if (inherits(cond, "message")) {
[17:26:42.834]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.834]                         if (muffled) 
[17:26:42.834]                           invokeRestart("muffleMessage")
[17:26:42.834]                       }
[17:26:42.834]                       else if (inherits(cond, "warning")) {
[17:26:42.834]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.834]                         if (muffled) 
[17:26:42.834]                           invokeRestart("muffleWarning")
[17:26:42.834]                       }
[17:26:42.834]                       else if (inherits(cond, "condition")) {
[17:26:42.834]                         if (!is.null(pattern)) {
[17:26:42.834]                           computeRestarts <- base::computeRestarts
[17:26:42.834]                           grepl <- base::grepl
[17:26:42.834]                           restarts <- computeRestarts(cond)
[17:26:42.834]                           for (restart in restarts) {
[17:26:42.834]                             name <- restart$name
[17:26:42.834]                             if (is.null(name)) 
[17:26:42.834]                               next
[17:26:42.834]                             if (!grepl(pattern, name)) 
[17:26:42.834]                               next
[17:26:42.834]                             invokeRestart(restart)
[17:26:42.834]                             muffled <- TRUE
[17:26:42.834]                             break
[17:26:42.834]                           }
[17:26:42.834]                         }
[17:26:42.834]                       }
[17:26:42.834]                       invisible(muffled)
[17:26:42.834]                     }
[17:26:42.834]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.834]                   }
[17:26:42.834]                 }
[17:26:42.834]                 else {
[17:26:42.834]                   if (TRUE) {
[17:26:42.834]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.834]                     {
[17:26:42.834]                       inherits <- base::inherits
[17:26:42.834]                       invokeRestart <- base::invokeRestart
[17:26:42.834]                       is.null <- base::is.null
[17:26:42.834]                       muffled <- FALSE
[17:26:42.834]                       if (inherits(cond, "message")) {
[17:26:42.834]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.834]                         if (muffled) 
[17:26:42.834]                           invokeRestart("muffleMessage")
[17:26:42.834]                       }
[17:26:42.834]                       else if (inherits(cond, "warning")) {
[17:26:42.834]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.834]                         if (muffled) 
[17:26:42.834]                           invokeRestart("muffleWarning")
[17:26:42.834]                       }
[17:26:42.834]                       else if (inherits(cond, "condition")) {
[17:26:42.834]                         if (!is.null(pattern)) {
[17:26:42.834]                           computeRestarts <- base::computeRestarts
[17:26:42.834]                           grepl <- base::grepl
[17:26:42.834]                           restarts <- computeRestarts(cond)
[17:26:42.834]                           for (restart in restarts) {
[17:26:42.834]                             name <- restart$name
[17:26:42.834]                             if (is.null(name)) 
[17:26:42.834]                               next
[17:26:42.834]                             if (!grepl(pattern, name)) 
[17:26:42.834]                               next
[17:26:42.834]                             invokeRestart(restart)
[17:26:42.834]                             muffled <- TRUE
[17:26:42.834]                             break
[17:26:42.834]                           }
[17:26:42.834]                         }
[17:26:42.834]                       }
[17:26:42.834]                       invisible(muffled)
[17:26:42.834]                     }
[17:26:42.834]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.834]                   }
[17:26:42.834]                 }
[17:26:42.834]             }
[17:26:42.834]         }))
[17:26:42.834]     }, error = function(ex) {
[17:26:42.834]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.834]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.834]                 ...future.rng), started = ...future.startTime, 
[17:26:42.834]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.834]             version = "1.8"), class = "FutureResult")
[17:26:42.834]     }, finally = {
[17:26:42.834]         if (!identical(...future.workdir, getwd())) 
[17:26:42.834]             setwd(...future.workdir)
[17:26:42.834]         {
[17:26:42.834]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.834]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.834]             }
[17:26:42.834]             base::options(...future.oldOptions)
[17:26:42.834]             if (.Platform$OS.type == "windows") {
[17:26:42.834]                 old_names <- names(...future.oldEnvVars)
[17:26:42.834]                 envs <- base::Sys.getenv()
[17:26:42.834]                 names <- names(envs)
[17:26:42.834]                 common <- intersect(names, old_names)
[17:26:42.834]                 added <- setdiff(names, old_names)
[17:26:42.834]                 removed <- setdiff(old_names, names)
[17:26:42.834]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.834]                   envs[common]]
[17:26:42.834]                 NAMES <- toupper(changed)
[17:26:42.834]                 args <- list()
[17:26:42.834]                 for (kk in seq_along(NAMES)) {
[17:26:42.834]                   name <- changed[[kk]]
[17:26:42.834]                   NAME <- NAMES[[kk]]
[17:26:42.834]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.834]                     next
[17:26:42.834]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.834]                 }
[17:26:42.834]                 NAMES <- toupper(added)
[17:26:42.834]                 for (kk in seq_along(NAMES)) {
[17:26:42.834]                   name <- added[[kk]]
[17:26:42.834]                   NAME <- NAMES[[kk]]
[17:26:42.834]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.834]                     next
[17:26:42.834]                   args[[name]] <- ""
[17:26:42.834]                 }
[17:26:42.834]                 NAMES <- toupper(removed)
[17:26:42.834]                 for (kk in seq_along(NAMES)) {
[17:26:42.834]                   name <- removed[[kk]]
[17:26:42.834]                   NAME <- NAMES[[kk]]
[17:26:42.834]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.834]                     next
[17:26:42.834]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.834]                 }
[17:26:42.834]                 if (length(args) > 0) 
[17:26:42.834]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.834]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.834]             }
[17:26:42.834]             else {
[17:26:42.834]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.834]             }
[17:26:42.834]             {
[17:26:42.834]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.834]                   0L) {
[17:26:42.834]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.834]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.834]                   base::options(opts)
[17:26:42.834]                 }
[17:26:42.834]                 {
[17:26:42.834]                   {
[17:26:42.834]                     NULL
[17:26:42.834]                     RNGkind("Mersenne-Twister")
[17:26:42.834]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.834]                       inherits = FALSE)
[17:26:42.834]                   }
[17:26:42.834]                   options(future.plan = NULL)
[17:26:42.834]                   if (is.na(NA_character_)) 
[17:26:42.834]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.834]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.834]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.834]                     .init = FALSE)
[17:26:42.834]                 }
[17:26:42.834]             }
[17:26:42.834]         }
[17:26:42.834]     })
[17:26:42.834]     if (TRUE) {
[17:26:42.834]         base::sink(type = "output", split = FALSE)
[17:26:42.834]         if (TRUE) {
[17:26:42.834]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.834]         }
[17:26:42.834]         else {
[17:26:42.834]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.834]         }
[17:26:42.834]         base::close(...future.stdout)
[17:26:42.834]         ...future.stdout <- NULL
[17:26:42.834]     }
[17:26:42.834]     ...future.result$conditions <- ...future.conditions
[17:26:42.834]     ...future.result$finished <- base::Sys.time()
[17:26:42.834]     ...future.result
[17:26:42.834] }
[17:26:42.838] plan(): Setting new future strategy stack:
[17:26:42.838] List of future strategies:
[17:26:42.838] 1. sequential:
[17:26:42.838]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.838]    - tweaked: FALSE
[17:26:42.838]    - call: NULL
[17:26:42.838] plan(): nbrOfWorkers() = 1
[17:26:42.839] plan(): Setting new future strategy stack:
[17:26:42.840] List of future strategies:
[17:26:42.840] 1. sequential:
[17:26:42.840]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.840]    - tweaked: FALSE
[17:26:42.840]    - call: plan(strategy)
[17:26:42.840] plan(): nbrOfWorkers() = 1
[17:26:42.841] SequentialFuture started (and completed)
[17:26:42.841] - Launch lazy future ... done
[17:26:42.841] run() for 'SequentialFuture' ... done
[17:26:42.841] getGlobalsAndPackages() ...
[17:26:42.841] Searching for globals...
[17:26:42.842] 
[17:26:42.842] Searching for globals ... DONE
[17:26:42.842] - globals: [0] <none>
[17:26:42.842] getGlobalsAndPackages() ... DONE
[17:26:42.843] run() for 'Future' ...
[17:26:42.844] - state: 'created'
[17:26:42.844] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.844] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.844] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.845]   - Field: 'label'
[17:26:42.845]   - Field: 'local'
[17:26:42.845]   - Field: 'owner'
[17:26:42.845]   - Field: 'envir'
[17:26:42.845]   - Field: 'packages'
[17:26:42.845]   - Field: 'gc'
[17:26:42.846]   - Field: 'conditions'
[17:26:42.846]   - Field: 'expr'
[17:26:42.846]   - Field: 'uuid'
[17:26:42.846]   - Field: 'seed'
[17:26:42.846]   - Field: 'version'
[17:26:42.847]   - Field: 'result'
[17:26:42.847]   - Field: 'asynchronous'
[17:26:42.847]   - Field: 'calls'
[17:26:42.847]   - Field: 'globals'
[17:26:42.847]   - Field: 'stdout'
[17:26:42.847]   - Field: 'earlySignal'
[17:26:42.848]   - Field: 'lazy'
[17:26:42.848]   - Field: 'state'
[17:26:42.848] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.848] - Launch lazy future ...
[17:26:42.848] Packages needed by the future expression (n = 0): <none>
[17:26:42.849] Packages needed by future strategies (n = 0): <none>
[17:26:42.849] {
[17:26:42.849]     {
[17:26:42.849]         {
[17:26:42.849]             ...future.startTime <- base::Sys.time()
[17:26:42.849]             {
[17:26:42.849]                 {
[17:26:42.849]                   {
[17:26:42.849]                     base::local({
[17:26:42.849]                       has_future <- base::requireNamespace("future", 
[17:26:42.849]                         quietly = TRUE)
[17:26:42.849]                       if (has_future) {
[17:26:42.849]                         ns <- base::getNamespace("future")
[17:26:42.849]                         version <- ns[[".package"]][["version"]]
[17:26:42.849]                         if (is.null(version)) 
[17:26:42.849]                           version <- utils::packageVersion("future")
[17:26:42.849]                       }
[17:26:42.849]                       else {
[17:26:42.849]                         version <- NULL
[17:26:42.849]                       }
[17:26:42.849]                       if (!has_future || version < "1.8.0") {
[17:26:42.849]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.849]                           "", base::R.version$version.string), 
[17:26:42.849]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.849]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.849]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.849]                             "release", "version")], collapse = " "), 
[17:26:42.849]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.849]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.849]                           info)
[17:26:42.849]                         info <- base::paste(info, collapse = "; ")
[17:26:42.849]                         if (!has_future) {
[17:26:42.849]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.849]                             info)
[17:26:42.849]                         }
[17:26:42.849]                         else {
[17:26:42.849]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.849]                             info, version)
[17:26:42.849]                         }
[17:26:42.849]                         base::stop(msg)
[17:26:42.849]                       }
[17:26:42.849]                     })
[17:26:42.849]                   }
[17:26:42.849]                   ...future.strategy.old <- future::plan("list")
[17:26:42.849]                   options(future.plan = NULL)
[17:26:42.849]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.849]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.849]                 }
[17:26:42.849]                 ...future.workdir <- getwd()
[17:26:42.849]             }
[17:26:42.849]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.849]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.849]         }
[17:26:42.849]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.849]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.849]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.849]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.849]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.849]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.849]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.849]             base::names(...future.oldOptions))
[17:26:42.849]     }
[17:26:42.849]     if (FALSE) {
[17:26:42.849]     }
[17:26:42.849]     else {
[17:26:42.849]         if (TRUE) {
[17:26:42.849]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.849]                 open = "w")
[17:26:42.849]         }
[17:26:42.849]         else {
[17:26:42.849]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.849]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.849]         }
[17:26:42.849]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.849]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.849]             base::sink(type = "output", split = FALSE)
[17:26:42.849]             base::close(...future.stdout)
[17:26:42.849]         }, add = TRUE)
[17:26:42.849]     }
[17:26:42.849]     ...future.frame <- base::sys.nframe()
[17:26:42.849]     ...future.conditions <- base::list()
[17:26:42.849]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.849]     if (FALSE) {
[17:26:42.849]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.849]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.849]     }
[17:26:42.849]     ...future.result <- base::tryCatch({
[17:26:42.849]         base::withCallingHandlers({
[17:26:42.849]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.849]             future::FutureResult(value = ...future.value$value, 
[17:26:42.849]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.849]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.849]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.849]                     ...future.globalenv.names))
[17:26:42.849]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.849]         }, condition = base::local({
[17:26:42.849]             c <- base::c
[17:26:42.849]             inherits <- base::inherits
[17:26:42.849]             invokeRestart <- base::invokeRestart
[17:26:42.849]             length <- base::length
[17:26:42.849]             list <- base::list
[17:26:42.849]             seq.int <- base::seq.int
[17:26:42.849]             signalCondition <- base::signalCondition
[17:26:42.849]             sys.calls <- base::sys.calls
[17:26:42.849]             `[[` <- base::`[[`
[17:26:42.849]             `+` <- base::`+`
[17:26:42.849]             `<<-` <- base::`<<-`
[17:26:42.849]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.849]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.849]                   3L)]
[17:26:42.849]             }
[17:26:42.849]             function(cond) {
[17:26:42.849]                 is_error <- inherits(cond, "error")
[17:26:42.849]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.849]                   NULL)
[17:26:42.849]                 if (is_error) {
[17:26:42.849]                   sessionInformation <- function() {
[17:26:42.849]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.849]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.849]                       search = base::search(), system = base::Sys.info())
[17:26:42.849]                   }
[17:26:42.849]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.849]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.849]                     cond$call), session = sessionInformation(), 
[17:26:42.849]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.849]                   signalCondition(cond)
[17:26:42.849]                 }
[17:26:42.849]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.849]                 "immediateCondition"))) {
[17:26:42.849]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.849]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.849]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.849]                   if (TRUE && !signal) {
[17:26:42.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.849]                     {
[17:26:42.849]                       inherits <- base::inherits
[17:26:42.849]                       invokeRestart <- base::invokeRestart
[17:26:42.849]                       is.null <- base::is.null
[17:26:42.849]                       muffled <- FALSE
[17:26:42.849]                       if (inherits(cond, "message")) {
[17:26:42.849]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.849]                         if (muffled) 
[17:26:42.849]                           invokeRestart("muffleMessage")
[17:26:42.849]                       }
[17:26:42.849]                       else if (inherits(cond, "warning")) {
[17:26:42.849]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.849]                         if (muffled) 
[17:26:42.849]                           invokeRestart("muffleWarning")
[17:26:42.849]                       }
[17:26:42.849]                       else if (inherits(cond, "condition")) {
[17:26:42.849]                         if (!is.null(pattern)) {
[17:26:42.849]                           computeRestarts <- base::computeRestarts
[17:26:42.849]                           grepl <- base::grepl
[17:26:42.849]                           restarts <- computeRestarts(cond)
[17:26:42.849]                           for (restart in restarts) {
[17:26:42.849]                             name <- restart$name
[17:26:42.849]                             if (is.null(name)) 
[17:26:42.849]                               next
[17:26:42.849]                             if (!grepl(pattern, name)) 
[17:26:42.849]                               next
[17:26:42.849]                             invokeRestart(restart)
[17:26:42.849]                             muffled <- TRUE
[17:26:42.849]                             break
[17:26:42.849]                           }
[17:26:42.849]                         }
[17:26:42.849]                       }
[17:26:42.849]                       invisible(muffled)
[17:26:42.849]                     }
[17:26:42.849]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.849]                   }
[17:26:42.849]                 }
[17:26:42.849]                 else {
[17:26:42.849]                   if (TRUE) {
[17:26:42.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.849]                     {
[17:26:42.849]                       inherits <- base::inherits
[17:26:42.849]                       invokeRestart <- base::invokeRestart
[17:26:42.849]                       is.null <- base::is.null
[17:26:42.849]                       muffled <- FALSE
[17:26:42.849]                       if (inherits(cond, "message")) {
[17:26:42.849]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.849]                         if (muffled) 
[17:26:42.849]                           invokeRestart("muffleMessage")
[17:26:42.849]                       }
[17:26:42.849]                       else if (inherits(cond, "warning")) {
[17:26:42.849]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.849]                         if (muffled) 
[17:26:42.849]                           invokeRestart("muffleWarning")
[17:26:42.849]                       }
[17:26:42.849]                       else if (inherits(cond, "condition")) {
[17:26:42.849]                         if (!is.null(pattern)) {
[17:26:42.849]                           computeRestarts <- base::computeRestarts
[17:26:42.849]                           grepl <- base::grepl
[17:26:42.849]                           restarts <- computeRestarts(cond)
[17:26:42.849]                           for (restart in restarts) {
[17:26:42.849]                             name <- restart$name
[17:26:42.849]                             if (is.null(name)) 
[17:26:42.849]                               next
[17:26:42.849]                             if (!grepl(pattern, name)) 
[17:26:42.849]                               next
[17:26:42.849]                             invokeRestart(restart)
[17:26:42.849]                             muffled <- TRUE
[17:26:42.849]                             break
[17:26:42.849]                           }
[17:26:42.849]                         }
[17:26:42.849]                       }
[17:26:42.849]                       invisible(muffled)
[17:26:42.849]                     }
[17:26:42.849]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.849]                   }
[17:26:42.849]                 }
[17:26:42.849]             }
[17:26:42.849]         }))
[17:26:42.849]     }, error = function(ex) {
[17:26:42.849]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.849]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.849]                 ...future.rng), started = ...future.startTime, 
[17:26:42.849]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.849]             version = "1.8"), class = "FutureResult")
[17:26:42.849]     }, finally = {
[17:26:42.849]         if (!identical(...future.workdir, getwd())) 
[17:26:42.849]             setwd(...future.workdir)
[17:26:42.849]         {
[17:26:42.849]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.849]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.849]             }
[17:26:42.849]             base::options(...future.oldOptions)
[17:26:42.849]             if (.Platform$OS.type == "windows") {
[17:26:42.849]                 old_names <- names(...future.oldEnvVars)
[17:26:42.849]                 envs <- base::Sys.getenv()
[17:26:42.849]                 names <- names(envs)
[17:26:42.849]                 common <- intersect(names, old_names)
[17:26:42.849]                 added <- setdiff(names, old_names)
[17:26:42.849]                 removed <- setdiff(old_names, names)
[17:26:42.849]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.849]                   envs[common]]
[17:26:42.849]                 NAMES <- toupper(changed)
[17:26:42.849]                 args <- list()
[17:26:42.849]                 for (kk in seq_along(NAMES)) {
[17:26:42.849]                   name <- changed[[kk]]
[17:26:42.849]                   NAME <- NAMES[[kk]]
[17:26:42.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.849]                     next
[17:26:42.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.849]                 }
[17:26:42.849]                 NAMES <- toupper(added)
[17:26:42.849]                 for (kk in seq_along(NAMES)) {
[17:26:42.849]                   name <- added[[kk]]
[17:26:42.849]                   NAME <- NAMES[[kk]]
[17:26:42.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.849]                     next
[17:26:42.849]                   args[[name]] <- ""
[17:26:42.849]                 }
[17:26:42.849]                 NAMES <- toupper(removed)
[17:26:42.849]                 for (kk in seq_along(NAMES)) {
[17:26:42.849]                   name <- removed[[kk]]
[17:26:42.849]                   NAME <- NAMES[[kk]]
[17:26:42.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.849]                     next
[17:26:42.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.849]                 }
[17:26:42.849]                 if (length(args) > 0) 
[17:26:42.849]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.849]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.849]             }
[17:26:42.849]             else {
[17:26:42.849]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.849]             }
[17:26:42.849]             {
[17:26:42.849]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.849]                   0L) {
[17:26:42.849]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.849]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.849]                   base::options(opts)
[17:26:42.849]                 }
[17:26:42.849]                 {
[17:26:42.849]                   {
[17:26:42.849]                     NULL
[17:26:42.849]                     RNGkind("Mersenne-Twister")
[17:26:42.849]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.849]                       inherits = FALSE)
[17:26:42.849]                   }
[17:26:42.849]                   options(future.plan = NULL)
[17:26:42.849]                   if (is.na(NA_character_)) 
[17:26:42.849]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.849]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.849]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.849]                     .init = FALSE)
[17:26:42.849]                 }
[17:26:42.849]             }
[17:26:42.849]         }
[17:26:42.849]     })
[17:26:42.849]     if (TRUE) {
[17:26:42.849]         base::sink(type = "output", split = FALSE)
[17:26:42.849]         if (TRUE) {
[17:26:42.849]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.849]         }
[17:26:42.849]         else {
[17:26:42.849]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.849]         }
[17:26:42.849]         base::close(...future.stdout)
[17:26:42.849]         ...future.stdout <- NULL
[17:26:42.849]     }
[17:26:42.849]     ...future.result$conditions <- ...future.conditions
[17:26:42.849]     ...future.result$finished <- base::Sys.time()
[17:26:42.849]     ...future.result
[17:26:42.849] }
[17:26:42.853] plan(): Setting new future strategy stack:
[17:26:42.853] List of future strategies:
[17:26:42.853] 1. sequential:
[17:26:42.853]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.853]    - tweaked: FALSE
[17:26:42.853]    - call: NULL
[17:26:42.854] plan(): nbrOfWorkers() = 1
[17:26:42.855] plan(): Setting new future strategy stack:
[17:26:42.855] List of future strategies:
[17:26:42.855] 1. sequential:
[17:26:42.855]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.855]    - tweaked: FALSE
[17:26:42.855]    - call: plan(strategy)
[17:26:42.856] plan(): nbrOfWorkers() = 1
[17:26:42.856] SequentialFuture started (and completed)
[17:26:42.856] - Launch lazy future ... done
[17:26:42.856] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230d40b648> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230bd59f48> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230d40b648> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002230bd59f48> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:4] 2 1 3 1
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:42.863] resolved() for 'SequentialFuture' ...
[17:26:42.863] - state: 'finished'
[17:26:42.863] - run: TRUE
[17:26:42.863] - result: 'FutureResult'
[17:26:42.863] resolved() for 'SequentialFuture' ... done
[17:26:42.864] resolved() for 'SequentialFuture' ...
[17:26:42.864] - state: 'finished'
[17:26:42.864] - run: TRUE
[17:26:42.864] - result: 'FutureResult'
[17:26:42.864] resolved() for 'SequentialFuture' ... done
 logi [1:2, 1, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:42.867] resolve() on list ...
[17:26:42.867]  recursive: 0
[17:26:42.867]  length: 6
[17:26:42.867]  elements: 'a', 'b', 'c', '', '', ''
[17:26:42.867] signalConditionsASAP(numeric, pos=1) ...
[17:26:42.868] - nx: 6
[17:26:42.868] - relay: TRUE
[17:26:42.868] - stdout: TRUE
[17:26:42.868] - signal: TRUE
[17:26:42.868] - resignal: FALSE
[17:26:42.868] - force: TRUE
[17:26:42.868] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.869] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.869]  - until=2
[17:26:42.869]  - relaying element #2
[17:26:42.869] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.869] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.869] signalConditionsASAP(NULL, pos=1) ... done
[17:26:42.870]  length: 5 (resolved future 1)
[17:26:42.870] resolved() for 'SequentialFuture' ...
[17:26:42.870] - state: 'finished'
[17:26:42.870] - run: TRUE
[17:26:42.870] - result: 'FutureResult'
[17:26:42.871] resolved() for 'SequentialFuture' ... done
[17:26:42.871] Future #2
[17:26:42.871] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:42.871] - nx: 6
[17:26:42.871] - relay: TRUE
[17:26:42.871] - stdout: TRUE
[17:26:42.872] - signal: TRUE
[17:26:42.872] - resignal: FALSE
[17:26:42.872] - force: TRUE
[17:26:42.872] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.872] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:42.872]  - until=2
[17:26:42.873]  - relaying element #2
[17:26:42.873] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.873] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.873] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:42.873]  length: 4 (resolved future 2)
[17:26:42.873] resolved() for 'SequentialFuture' ...
[17:26:42.874] - state: 'finished'
[17:26:42.874] - run: TRUE
[17:26:42.874] - result: 'FutureResult'
[17:26:42.874] resolved() for 'SequentialFuture' ... done
[17:26:42.874] Future #3
[17:26:42.875] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:42.875] - nx: 6
[17:26:42.875] - relay: TRUE
[17:26:42.875] - stdout: TRUE
[17:26:42.875] - signal: TRUE
[17:26:42.875] - resignal: FALSE
[17:26:42.876] - force: TRUE
[17:26:42.876] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.876] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:42.876]  - until=3
[17:26:42.876]  - relaying element #3
[17:26:42.876] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.877] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.878] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:42.878]  length: 3 (resolved future 3)
[17:26:42.878] signalConditionsASAP(NULL, pos=4) ...
[17:26:42.878] - nx: 6
[17:26:42.878] - relay: TRUE
[17:26:42.879] - stdout: TRUE
[17:26:42.879] - signal: TRUE
[17:26:42.879] - resignal: FALSE
[17:26:42.879] - force: TRUE
[17:26:42.879] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.879] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.880]  - until=5
[17:26:42.880]  - relaying element #5
[17:26:42.880] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.880] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.880] signalConditionsASAP(NULL, pos=4) ... done
[17:26:42.880]  length: 2 (resolved future 4)
[17:26:42.880] signalConditionsASAP(NULL, pos=5) ...
[17:26:42.881] - nx: 6
[17:26:42.881] - relay: TRUE
[17:26:42.881] - stdout: TRUE
[17:26:42.881] - signal: TRUE
[17:26:42.881] - resignal: FALSE
[17:26:42.881] - force: TRUE
[17:26:42.882] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:42.882] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.882]  - until=6
[17:26:42.882]  - relaying element #6
[17:26:42.882] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.882] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.882] signalConditionsASAP(NULL, pos=5) ... done
[17:26:42.883]  length: 1 (resolved future 5)
[17:26:42.883] signalConditionsASAP(numeric, pos=6) ...
[17:26:42.883] - nx: 6
[17:26:42.883] - relay: TRUE
[17:26:42.883] - stdout: TRUE
[17:26:42.883] - signal: TRUE
[17:26:42.884] - resignal: FALSE
[17:26:42.884] - force: TRUE
[17:26:42.884] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:42.884] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.884]  - until=6
[17:26:42.884] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.884] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.885] signalConditionsASAP(numeric, pos=6) ... done
[17:26:42.885]  length: 0 (resolved future 6)
[17:26:42.885] Relaying remaining futures
[17:26:42.885] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.885] - nx: 6
[17:26:42.885] - relay: TRUE
[17:26:42.886] - stdout: TRUE
[17:26:42.886] - signal: TRUE
[17:26:42.886] - resignal: FALSE
[17:26:42.886] - force: TRUE
[17:26:42.886] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.886] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:42.887] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:42.887] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:42.887] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.887] resolve() on list ... DONE
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:4] 2 1 3 1
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
*** futures() - list ... DONE
Type of object: environment
Type of future: sequential
[17:26:42.897] plan(): Setting new future strategy stack:
[17:26:42.898] List of future strategies:
[17:26:42.898] 1. sequential:
[17:26:42.898]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.898]    - tweaked: FALSE
[17:26:42.898]    - call: plan(strategy)
[17:26:42.898] plan(): nbrOfWorkers() = 1
Dimensions: NULL
[17:26:42.899] getGlobalsAndPackages() ...
[17:26:42.899] Searching for globals...
[17:26:42.899] 
[17:26:42.899] Searching for globals ... DONE
[17:26:42.899] - globals: [0] <none>
[17:26:42.900] getGlobalsAndPackages() ... DONE
[17:26:42.900] run() for 'Future' ...
[17:26:42.900] - state: 'created'
[17:26:42.900] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.901] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.901] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.901]   - Field: 'label'
[17:26:42.901]   - Field: 'local'
[17:26:42.901]   - Field: 'owner'
[17:26:42.902]   - Field: 'envir'
[17:26:42.902]   - Field: 'packages'
[17:26:42.902]   - Field: 'gc'
[17:26:42.902]   - Field: 'conditions'
[17:26:42.902]   - Field: 'expr'
[17:26:42.902]   - Field: 'uuid'
[17:26:42.903]   - Field: 'seed'
[17:26:42.903]   - Field: 'version'
[17:26:42.903]   - Field: 'result'
[17:26:42.903]   - Field: 'asynchronous'
[17:26:42.903]   - Field: 'calls'
[17:26:42.903]   - Field: 'globals'
[17:26:42.904]   - Field: 'stdout'
[17:26:42.904]   - Field: 'earlySignal'
[17:26:42.904]   - Field: 'lazy'
[17:26:42.904]   - Field: 'state'
[17:26:42.905] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.905] - Launch lazy future ...
[17:26:42.906] Packages needed by the future expression (n = 0): <none>
[17:26:42.906] Packages needed by future strategies (n = 0): <none>
[17:26:42.906] {
[17:26:42.906]     {
[17:26:42.906]         {
[17:26:42.906]             ...future.startTime <- base::Sys.time()
[17:26:42.906]             {
[17:26:42.906]                 {
[17:26:42.906]                   {
[17:26:42.906]                     base::local({
[17:26:42.906]                       has_future <- base::requireNamespace("future", 
[17:26:42.906]                         quietly = TRUE)
[17:26:42.906]                       if (has_future) {
[17:26:42.906]                         ns <- base::getNamespace("future")
[17:26:42.906]                         version <- ns[[".package"]][["version"]]
[17:26:42.906]                         if (is.null(version)) 
[17:26:42.906]                           version <- utils::packageVersion("future")
[17:26:42.906]                       }
[17:26:42.906]                       else {
[17:26:42.906]                         version <- NULL
[17:26:42.906]                       }
[17:26:42.906]                       if (!has_future || version < "1.8.0") {
[17:26:42.906]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.906]                           "", base::R.version$version.string), 
[17:26:42.906]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.906]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.906]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.906]                             "release", "version")], collapse = " "), 
[17:26:42.906]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.906]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.906]                           info)
[17:26:42.906]                         info <- base::paste(info, collapse = "; ")
[17:26:42.906]                         if (!has_future) {
[17:26:42.906]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.906]                             info)
[17:26:42.906]                         }
[17:26:42.906]                         else {
[17:26:42.906]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.906]                             info, version)
[17:26:42.906]                         }
[17:26:42.906]                         base::stop(msg)
[17:26:42.906]                       }
[17:26:42.906]                     })
[17:26:42.906]                   }
[17:26:42.906]                   ...future.strategy.old <- future::plan("list")
[17:26:42.906]                   options(future.plan = NULL)
[17:26:42.906]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.906]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.906]                 }
[17:26:42.906]                 ...future.workdir <- getwd()
[17:26:42.906]             }
[17:26:42.906]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.906]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.906]         }
[17:26:42.906]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.906]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.906]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.906]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.906]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.906]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.906]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.906]             base::names(...future.oldOptions))
[17:26:42.906]     }
[17:26:42.906]     if (FALSE) {
[17:26:42.906]     }
[17:26:42.906]     else {
[17:26:42.906]         if (TRUE) {
[17:26:42.906]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.906]                 open = "w")
[17:26:42.906]         }
[17:26:42.906]         else {
[17:26:42.906]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.906]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.906]         }
[17:26:42.906]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.906]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.906]             base::sink(type = "output", split = FALSE)
[17:26:42.906]             base::close(...future.stdout)
[17:26:42.906]         }, add = TRUE)
[17:26:42.906]     }
[17:26:42.906]     ...future.frame <- base::sys.nframe()
[17:26:42.906]     ...future.conditions <- base::list()
[17:26:42.906]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.906]     if (FALSE) {
[17:26:42.906]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.906]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.906]     }
[17:26:42.906]     ...future.result <- base::tryCatch({
[17:26:42.906]         base::withCallingHandlers({
[17:26:42.906]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.906]             future::FutureResult(value = ...future.value$value, 
[17:26:42.906]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.906]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.906]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.906]                     ...future.globalenv.names))
[17:26:42.906]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.906]         }, condition = base::local({
[17:26:42.906]             c <- base::c
[17:26:42.906]             inherits <- base::inherits
[17:26:42.906]             invokeRestart <- base::invokeRestart
[17:26:42.906]             length <- base::length
[17:26:42.906]             list <- base::list
[17:26:42.906]             seq.int <- base::seq.int
[17:26:42.906]             signalCondition <- base::signalCondition
[17:26:42.906]             sys.calls <- base::sys.calls
[17:26:42.906]             `[[` <- base::`[[`
[17:26:42.906]             `+` <- base::`+`
[17:26:42.906]             `<<-` <- base::`<<-`
[17:26:42.906]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.906]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.906]                   3L)]
[17:26:42.906]             }
[17:26:42.906]             function(cond) {
[17:26:42.906]                 is_error <- inherits(cond, "error")
[17:26:42.906]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.906]                   NULL)
[17:26:42.906]                 if (is_error) {
[17:26:42.906]                   sessionInformation <- function() {
[17:26:42.906]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.906]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.906]                       search = base::search(), system = base::Sys.info())
[17:26:42.906]                   }
[17:26:42.906]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.906]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.906]                     cond$call), session = sessionInformation(), 
[17:26:42.906]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.906]                   signalCondition(cond)
[17:26:42.906]                 }
[17:26:42.906]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.906]                 "immediateCondition"))) {
[17:26:42.906]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.906]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.906]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.906]                   if (TRUE && !signal) {
[17:26:42.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.906]                     {
[17:26:42.906]                       inherits <- base::inherits
[17:26:42.906]                       invokeRestart <- base::invokeRestart
[17:26:42.906]                       is.null <- base::is.null
[17:26:42.906]                       muffled <- FALSE
[17:26:42.906]                       if (inherits(cond, "message")) {
[17:26:42.906]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.906]                         if (muffled) 
[17:26:42.906]                           invokeRestart("muffleMessage")
[17:26:42.906]                       }
[17:26:42.906]                       else if (inherits(cond, "warning")) {
[17:26:42.906]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.906]                         if (muffled) 
[17:26:42.906]                           invokeRestart("muffleWarning")
[17:26:42.906]                       }
[17:26:42.906]                       else if (inherits(cond, "condition")) {
[17:26:42.906]                         if (!is.null(pattern)) {
[17:26:42.906]                           computeRestarts <- base::computeRestarts
[17:26:42.906]                           grepl <- base::grepl
[17:26:42.906]                           restarts <- computeRestarts(cond)
[17:26:42.906]                           for (restart in restarts) {
[17:26:42.906]                             name <- restart$name
[17:26:42.906]                             if (is.null(name)) 
[17:26:42.906]                               next
[17:26:42.906]                             if (!grepl(pattern, name)) 
[17:26:42.906]                               next
[17:26:42.906]                             invokeRestart(restart)
[17:26:42.906]                             muffled <- TRUE
[17:26:42.906]                             break
[17:26:42.906]                           }
[17:26:42.906]                         }
[17:26:42.906]                       }
[17:26:42.906]                       invisible(muffled)
[17:26:42.906]                     }
[17:26:42.906]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.906]                   }
[17:26:42.906]                 }
[17:26:42.906]                 else {
[17:26:42.906]                   if (TRUE) {
[17:26:42.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.906]                     {
[17:26:42.906]                       inherits <- base::inherits
[17:26:42.906]                       invokeRestart <- base::invokeRestart
[17:26:42.906]                       is.null <- base::is.null
[17:26:42.906]                       muffled <- FALSE
[17:26:42.906]                       if (inherits(cond, "message")) {
[17:26:42.906]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.906]                         if (muffled) 
[17:26:42.906]                           invokeRestart("muffleMessage")
[17:26:42.906]                       }
[17:26:42.906]                       else if (inherits(cond, "warning")) {
[17:26:42.906]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.906]                         if (muffled) 
[17:26:42.906]                           invokeRestart("muffleWarning")
[17:26:42.906]                       }
[17:26:42.906]                       else if (inherits(cond, "condition")) {
[17:26:42.906]                         if (!is.null(pattern)) {
[17:26:42.906]                           computeRestarts <- base::computeRestarts
[17:26:42.906]                           grepl <- base::grepl
[17:26:42.906]                           restarts <- computeRestarts(cond)
[17:26:42.906]                           for (restart in restarts) {
[17:26:42.906]                             name <- restart$name
[17:26:42.906]                             if (is.null(name)) 
[17:26:42.906]                               next
[17:26:42.906]                             if (!grepl(pattern, name)) 
[17:26:42.906]                               next
[17:26:42.906]                             invokeRestart(restart)
[17:26:42.906]                             muffled <- TRUE
[17:26:42.906]                             break
[17:26:42.906]                           }
[17:26:42.906]                         }
[17:26:42.906]                       }
[17:26:42.906]                       invisible(muffled)
[17:26:42.906]                     }
[17:26:42.906]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.906]                   }
[17:26:42.906]                 }
[17:26:42.906]             }
[17:26:42.906]         }))
[17:26:42.906]     }, error = function(ex) {
[17:26:42.906]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.906]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.906]                 ...future.rng), started = ...future.startTime, 
[17:26:42.906]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.906]             version = "1.8"), class = "FutureResult")
[17:26:42.906]     }, finally = {
[17:26:42.906]         if (!identical(...future.workdir, getwd())) 
[17:26:42.906]             setwd(...future.workdir)
[17:26:42.906]         {
[17:26:42.906]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.906]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.906]             }
[17:26:42.906]             base::options(...future.oldOptions)
[17:26:42.906]             if (.Platform$OS.type == "windows") {
[17:26:42.906]                 old_names <- names(...future.oldEnvVars)
[17:26:42.906]                 envs <- base::Sys.getenv()
[17:26:42.906]                 names <- names(envs)
[17:26:42.906]                 common <- intersect(names, old_names)
[17:26:42.906]                 added <- setdiff(names, old_names)
[17:26:42.906]                 removed <- setdiff(old_names, names)
[17:26:42.906]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.906]                   envs[common]]
[17:26:42.906]                 NAMES <- toupper(changed)
[17:26:42.906]                 args <- list()
[17:26:42.906]                 for (kk in seq_along(NAMES)) {
[17:26:42.906]                   name <- changed[[kk]]
[17:26:42.906]                   NAME <- NAMES[[kk]]
[17:26:42.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.906]                     next
[17:26:42.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.906]                 }
[17:26:42.906]                 NAMES <- toupper(added)
[17:26:42.906]                 for (kk in seq_along(NAMES)) {
[17:26:42.906]                   name <- added[[kk]]
[17:26:42.906]                   NAME <- NAMES[[kk]]
[17:26:42.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.906]                     next
[17:26:42.906]                   args[[name]] <- ""
[17:26:42.906]                 }
[17:26:42.906]                 NAMES <- toupper(removed)
[17:26:42.906]                 for (kk in seq_along(NAMES)) {
[17:26:42.906]                   name <- removed[[kk]]
[17:26:42.906]                   NAME <- NAMES[[kk]]
[17:26:42.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.906]                     next
[17:26:42.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.906]                 }
[17:26:42.906]                 if (length(args) > 0) 
[17:26:42.906]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.906]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.906]             }
[17:26:42.906]             else {
[17:26:42.906]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.906]             }
[17:26:42.906]             {
[17:26:42.906]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.906]                   0L) {
[17:26:42.906]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.906]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.906]                   base::options(opts)
[17:26:42.906]                 }
[17:26:42.906]                 {
[17:26:42.906]                   {
[17:26:42.906]                     NULL
[17:26:42.906]                     RNGkind("Mersenne-Twister")
[17:26:42.906]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.906]                       inherits = FALSE)
[17:26:42.906]                   }
[17:26:42.906]                   options(future.plan = NULL)
[17:26:42.906]                   if (is.na(NA_character_)) 
[17:26:42.906]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.906]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.906]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.906]                     .init = FALSE)
[17:26:42.906]                 }
[17:26:42.906]             }
[17:26:42.906]         }
[17:26:42.906]     })
[17:26:42.906]     if (TRUE) {
[17:26:42.906]         base::sink(type = "output", split = FALSE)
[17:26:42.906]         if (TRUE) {
[17:26:42.906]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.906]         }
[17:26:42.906]         else {
[17:26:42.906]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.906]         }
[17:26:42.906]         base::close(...future.stdout)
[17:26:42.906]         ...future.stdout <- NULL
[17:26:42.906]     }
[17:26:42.906]     ...future.result$conditions <- ...future.conditions
[17:26:42.906]     ...future.result$finished <- base::Sys.time()
[17:26:42.906]     ...future.result
[17:26:42.906] }
[17:26:42.910] plan(): Setting new future strategy stack:
[17:26:42.911] List of future strategies:
[17:26:42.911] 1. sequential:
[17:26:42.911]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.911]    - tweaked: FALSE
[17:26:42.911]    - call: NULL
[17:26:42.911] plan(): nbrOfWorkers() = 1
[17:26:42.912] plan(): Setting new future strategy stack:
[17:26:42.912] List of future strategies:
[17:26:42.912] 1. sequential:
[17:26:42.912]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.912]    - tweaked: FALSE
[17:26:42.912]    - call: plan(strategy)
[17:26:42.913] plan(): nbrOfWorkers() = 1
[17:26:42.913] SequentialFuture started (and completed)
[17:26:42.914] - Launch lazy future ... done
[17:26:42.914] run() for 'SequentialFuture' ... done
[17:26:42.914] getGlobalsAndPackages() ...
[17:26:42.914] Searching for globals...
[17:26:42.914] 
[17:26:42.915] Searching for globals ... DONE
[17:26:42.915] - globals: [0] <none>
[17:26:42.915] getGlobalsAndPackages() ... DONE
[17:26:42.915] run() for 'Future' ...
[17:26:42.915] - state: 'created'
[17:26:42.916] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.916] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.916] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.916]   - Field: 'label'
[17:26:42.917]   - Field: 'local'
[17:26:42.917]   - Field: 'owner'
[17:26:42.917]   - Field: 'envir'
[17:26:42.917]   - Field: 'packages'
[17:26:42.917]   - Field: 'gc'
[17:26:42.917]   - Field: 'conditions'
[17:26:42.918]   - Field: 'expr'
[17:26:42.918]   - Field: 'uuid'
[17:26:42.918]   - Field: 'seed'
[17:26:42.918]   - Field: 'version'
[17:26:42.918]   - Field: 'result'
[17:26:42.918]   - Field: 'asynchronous'
[17:26:42.919]   - Field: 'calls'
[17:26:42.919]   - Field: 'globals'
[17:26:42.919]   - Field: 'stdout'
[17:26:42.919]   - Field: 'earlySignal'
[17:26:42.919]   - Field: 'lazy'
[17:26:42.920]   - Field: 'state'
[17:26:42.920] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.920] - Launch lazy future ...
[17:26:42.920] Packages needed by the future expression (n = 0): <none>
[17:26:42.920] Packages needed by future strategies (n = 0): <none>
[17:26:42.921] {
[17:26:42.921]     {
[17:26:42.921]         {
[17:26:42.921]             ...future.startTime <- base::Sys.time()
[17:26:42.921]             {
[17:26:42.921]                 {
[17:26:42.921]                   {
[17:26:42.921]                     base::local({
[17:26:42.921]                       has_future <- base::requireNamespace("future", 
[17:26:42.921]                         quietly = TRUE)
[17:26:42.921]                       if (has_future) {
[17:26:42.921]                         ns <- base::getNamespace("future")
[17:26:42.921]                         version <- ns[[".package"]][["version"]]
[17:26:42.921]                         if (is.null(version)) 
[17:26:42.921]                           version <- utils::packageVersion("future")
[17:26:42.921]                       }
[17:26:42.921]                       else {
[17:26:42.921]                         version <- NULL
[17:26:42.921]                       }
[17:26:42.921]                       if (!has_future || version < "1.8.0") {
[17:26:42.921]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.921]                           "", base::R.version$version.string), 
[17:26:42.921]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.921]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.921]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.921]                             "release", "version")], collapse = " "), 
[17:26:42.921]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.921]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.921]                           info)
[17:26:42.921]                         info <- base::paste(info, collapse = "; ")
[17:26:42.921]                         if (!has_future) {
[17:26:42.921]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.921]                             info)
[17:26:42.921]                         }
[17:26:42.921]                         else {
[17:26:42.921]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.921]                             info, version)
[17:26:42.921]                         }
[17:26:42.921]                         base::stop(msg)
[17:26:42.921]                       }
[17:26:42.921]                     })
[17:26:42.921]                   }
[17:26:42.921]                   ...future.strategy.old <- future::plan("list")
[17:26:42.921]                   options(future.plan = NULL)
[17:26:42.921]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.921]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.921]                 }
[17:26:42.921]                 ...future.workdir <- getwd()
[17:26:42.921]             }
[17:26:42.921]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.921]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.921]         }
[17:26:42.921]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.921]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.921]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.921]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.921]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.921]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.921]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.921]             base::names(...future.oldOptions))
[17:26:42.921]     }
[17:26:42.921]     if (FALSE) {
[17:26:42.921]     }
[17:26:42.921]     else {
[17:26:42.921]         if (TRUE) {
[17:26:42.921]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.921]                 open = "w")
[17:26:42.921]         }
[17:26:42.921]         else {
[17:26:42.921]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.921]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.921]         }
[17:26:42.921]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.921]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.921]             base::sink(type = "output", split = FALSE)
[17:26:42.921]             base::close(...future.stdout)
[17:26:42.921]         }, add = TRUE)
[17:26:42.921]     }
[17:26:42.921]     ...future.frame <- base::sys.nframe()
[17:26:42.921]     ...future.conditions <- base::list()
[17:26:42.921]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.921]     if (FALSE) {
[17:26:42.921]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.921]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.921]     }
[17:26:42.921]     ...future.result <- base::tryCatch({
[17:26:42.921]         base::withCallingHandlers({
[17:26:42.921]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.921]             future::FutureResult(value = ...future.value$value, 
[17:26:42.921]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.921]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.921]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.921]                     ...future.globalenv.names))
[17:26:42.921]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.921]         }, condition = base::local({
[17:26:42.921]             c <- base::c
[17:26:42.921]             inherits <- base::inherits
[17:26:42.921]             invokeRestart <- base::invokeRestart
[17:26:42.921]             length <- base::length
[17:26:42.921]             list <- base::list
[17:26:42.921]             seq.int <- base::seq.int
[17:26:42.921]             signalCondition <- base::signalCondition
[17:26:42.921]             sys.calls <- base::sys.calls
[17:26:42.921]             `[[` <- base::`[[`
[17:26:42.921]             `+` <- base::`+`
[17:26:42.921]             `<<-` <- base::`<<-`
[17:26:42.921]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.921]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.921]                   3L)]
[17:26:42.921]             }
[17:26:42.921]             function(cond) {
[17:26:42.921]                 is_error <- inherits(cond, "error")
[17:26:42.921]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.921]                   NULL)
[17:26:42.921]                 if (is_error) {
[17:26:42.921]                   sessionInformation <- function() {
[17:26:42.921]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.921]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.921]                       search = base::search(), system = base::Sys.info())
[17:26:42.921]                   }
[17:26:42.921]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.921]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.921]                     cond$call), session = sessionInformation(), 
[17:26:42.921]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.921]                   signalCondition(cond)
[17:26:42.921]                 }
[17:26:42.921]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.921]                 "immediateCondition"))) {
[17:26:42.921]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.921]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.921]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.921]                   if (TRUE && !signal) {
[17:26:42.921]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.921]                     {
[17:26:42.921]                       inherits <- base::inherits
[17:26:42.921]                       invokeRestart <- base::invokeRestart
[17:26:42.921]                       is.null <- base::is.null
[17:26:42.921]                       muffled <- FALSE
[17:26:42.921]                       if (inherits(cond, "message")) {
[17:26:42.921]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.921]                         if (muffled) 
[17:26:42.921]                           invokeRestart("muffleMessage")
[17:26:42.921]                       }
[17:26:42.921]                       else if (inherits(cond, "warning")) {
[17:26:42.921]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.921]                         if (muffled) 
[17:26:42.921]                           invokeRestart("muffleWarning")
[17:26:42.921]                       }
[17:26:42.921]                       else if (inherits(cond, "condition")) {
[17:26:42.921]                         if (!is.null(pattern)) {
[17:26:42.921]                           computeRestarts <- base::computeRestarts
[17:26:42.921]                           grepl <- base::grepl
[17:26:42.921]                           restarts <- computeRestarts(cond)
[17:26:42.921]                           for (restart in restarts) {
[17:26:42.921]                             name <- restart$name
[17:26:42.921]                             if (is.null(name)) 
[17:26:42.921]                               next
[17:26:42.921]                             if (!grepl(pattern, name)) 
[17:26:42.921]                               next
[17:26:42.921]                             invokeRestart(restart)
[17:26:42.921]                             muffled <- TRUE
[17:26:42.921]                             break
[17:26:42.921]                           }
[17:26:42.921]                         }
[17:26:42.921]                       }
[17:26:42.921]                       invisible(muffled)
[17:26:42.921]                     }
[17:26:42.921]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.921]                   }
[17:26:42.921]                 }
[17:26:42.921]                 else {
[17:26:42.921]                   if (TRUE) {
[17:26:42.921]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.921]                     {
[17:26:42.921]                       inherits <- base::inherits
[17:26:42.921]                       invokeRestart <- base::invokeRestart
[17:26:42.921]                       is.null <- base::is.null
[17:26:42.921]                       muffled <- FALSE
[17:26:42.921]                       if (inherits(cond, "message")) {
[17:26:42.921]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.921]                         if (muffled) 
[17:26:42.921]                           invokeRestart("muffleMessage")
[17:26:42.921]                       }
[17:26:42.921]                       else if (inherits(cond, "warning")) {
[17:26:42.921]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.921]                         if (muffled) 
[17:26:42.921]                           invokeRestart("muffleWarning")
[17:26:42.921]                       }
[17:26:42.921]                       else if (inherits(cond, "condition")) {
[17:26:42.921]                         if (!is.null(pattern)) {
[17:26:42.921]                           computeRestarts <- base::computeRestarts
[17:26:42.921]                           grepl <- base::grepl
[17:26:42.921]                           restarts <- computeRestarts(cond)
[17:26:42.921]                           for (restart in restarts) {
[17:26:42.921]                             name <- restart$name
[17:26:42.921]                             if (is.null(name)) 
[17:26:42.921]                               next
[17:26:42.921]                             if (!grepl(pattern, name)) 
[17:26:42.921]                               next
[17:26:42.921]                             invokeRestart(restart)
[17:26:42.921]                             muffled <- TRUE
[17:26:42.921]                             break
[17:26:42.921]                           }
[17:26:42.921]                         }
[17:26:42.921]                       }
[17:26:42.921]                       invisible(muffled)
[17:26:42.921]                     }
[17:26:42.921]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.921]                   }
[17:26:42.921]                 }
[17:26:42.921]             }
[17:26:42.921]         }))
[17:26:42.921]     }, error = function(ex) {
[17:26:42.921]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.921]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.921]                 ...future.rng), started = ...future.startTime, 
[17:26:42.921]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.921]             version = "1.8"), class = "FutureResult")
[17:26:42.921]     }, finally = {
[17:26:42.921]         if (!identical(...future.workdir, getwd())) 
[17:26:42.921]             setwd(...future.workdir)
[17:26:42.921]         {
[17:26:42.921]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.921]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.921]             }
[17:26:42.921]             base::options(...future.oldOptions)
[17:26:42.921]             if (.Platform$OS.type == "windows") {
[17:26:42.921]                 old_names <- names(...future.oldEnvVars)
[17:26:42.921]                 envs <- base::Sys.getenv()
[17:26:42.921]                 names <- names(envs)
[17:26:42.921]                 common <- intersect(names, old_names)
[17:26:42.921]                 added <- setdiff(names, old_names)
[17:26:42.921]                 removed <- setdiff(old_names, names)
[17:26:42.921]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.921]                   envs[common]]
[17:26:42.921]                 NAMES <- toupper(changed)
[17:26:42.921]                 args <- list()
[17:26:42.921]                 for (kk in seq_along(NAMES)) {
[17:26:42.921]                   name <- changed[[kk]]
[17:26:42.921]                   NAME <- NAMES[[kk]]
[17:26:42.921]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.921]                     next
[17:26:42.921]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.921]                 }
[17:26:42.921]                 NAMES <- toupper(added)
[17:26:42.921]                 for (kk in seq_along(NAMES)) {
[17:26:42.921]                   name <- added[[kk]]
[17:26:42.921]                   NAME <- NAMES[[kk]]
[17:26:42.921]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.921]                     next
[17:26:42.921]                   args[[name]] <- ""
[17:26:42.921]                 }
[17:26:42.921]                 NAMES <- toupper(removed)
[17:26:42.921]                 for (kk in seq_along(NAMES)) {
[17:26:42.921]                   name <- removed[[kk]]
[17:26:42.921]                   NAME <- NAMES[[kk]]
[17:26:42.921]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.921]                     next
[17:26:42.921]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.921]                 }
[17:26:42.921]                 if (length(args) > 0) 
[17:26:42.921]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.921]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.921]             }
[17:26:42.921]             else {
[17:26:42.921]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.921]             }
[17:26:42.921]             {
[17:26:42.921]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.921]                   0L) {
[17:26:42.921]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.921]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.921]                   base::options(opts)
[17:26:42.921]                 }
[17:26:42.921]                 {
[17:26:42.921]                   {
[17:26:42.921]                     NULL
[17:26:42.921]                     RNGkind("Mersenne-Twister")
[17:26:42.921]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.921]                       inherits = FALSE)
[17:26:42.921]                   }
[17:26:42.921]                   options(future.plan = NULL)
[17:26:42.921]                   if (is.na(NA_character_)) 
[17:26:42.921]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.921]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.921]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.921]                     .init = FALSE)
[17:26:42.921]                 }
[17:26:42.921]             }
[17:26:42.921]         }
[17:26:42.921]     })
[17:26:42.921]     if (TRUE) {
[17:26:42.921]         base::sink(type = "output", split = FALSE)
[17:26:42.921]         if (TRUE) {
[17:26:42.921]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.921]         }
[17:26:42.921]         else {
[17:26:42.921]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.921]         }
[17:26:42.921]         base::close(...future.stdout)
[17:26:42.921]         ...future.stdout <- NULL
[17:26:42.921]     }
[17:26:42.921]     ...future.result$conditions <- ...future.conditions
[17:26:42.921]     ...future.result$finished <- base::Sys.time()
[17:26:42.921]     ...future.result
[17:26:42.921] }
[17:26:42.925] plan(): Setting new future strategy stack:
[17:26:42.925] List of future strategies:
[17:26:42.925] 1. sequential:
[17:26:42.925]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.925]    - tweaked: FALSE
[17:26:42.925]    - call: NULL
[17:26:42.926] plan(): nbrOfWorkers() = 1
[17:26:42.927] plan(): Setting new future strategy stack:
[17:26:42.927] List of future strategies:
[17:26:42.927] 1. sequential:
[17:26:42.927]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.927]    - tweaked: FALSE
[17:26:42.927]    - call: plan(strategy)
[17:26:42.927] plan(): nbrOfWorkers() = 1
[17:26:42.928] SequentialFuture started (and completed)
[17:26:42.928] - Launch lazy future ... done
[17:26:42.928] run() for 'SequentialFuture' ... done
[17:26:42.929] getGlobalsAndPackages() ...
[17:26:42.930] Searching for globals...
[17:26:42.931] - globals found: [1] '{'
[17:26:42.931] Searching for globals ... DONE
[17:26:42.931] Resolving globals: FALSE
[17:26:42.932] 
[17:26:42.932] 
[17:26:42.932] getGlobalsAndPackages() ... DONE
[17:26:42.933] run() for 'Future' ...
[17:26:42.933] - state: 'created'
[17:26:42.933] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.933] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.934] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.934]   - Field: 'label'
[17:26:42.934]   - Field: 'local'
[17:26:42.934]   - Field: 'owner'
[17:26:42.934]   - Field: 'envir'
[17:26:42.934]   - Field: 'packages'
[17:26:42.935]   - Field: 'gc'
[17:26:42.935]   - Field: 'conditions'
[17:26:42.935]   - Field: 'expr'
[17:26:42.935]   - Field: 'uuid'
[17:26:42.935]   - Field: 'seed'
[17:26:42.935]   - Field: 'version'
[17:26:42.936]   - Field: 'result'
[17:26:42.936]   - Field: 'asynchronous'
[17:26:42.936]   - Field: 'calls'
[17:26:42.936]   - Field: 'globals'
[17:26:42.936]   - Field: 'stdout'
[17:26:42.937]   - Field: 'earlySignal'
[17:26:42.937]   - Field: 'lazy'
[17:26:42.937]   - Field: 'state'
[17:26:42.937] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.937] - Launch lazy future ...
[17:26:42.938] Packages needed by the future expression (n = 0): <none>
[17:26:42.938] Packages needed by future strategies (n = 0): <none>
[17:26:42.938] {
[17:26:42.938]     {
[17:26:42.938]         {
[17:26:42.938]             ...future.startTime <- base::Sys.time()
[17:26:42.938]             {
[17:26:42.938]                 {
[17:26:42.938]                   {
[17:26:42.938]                     base::local({
[17:26:42.938]                       has_future <- base::requireNamespace("future", 
[17:26:42.938]                         quietly = TRUE)
[17:26:42.938]                       if (has_future) {
[17:26:42.938]                         ns <- base::getNamespace("future")
[17:26:42.938]                         version <- ns[[".package"]][["version"]]
[17:26:42.938]                         if (is.null(version)) 
[17:26:42.938]                           version <- utils::packageVersion("future")
[17:26:42.938]                       }
[17:26:42.938]                       else {
[17:26:42.938]                         version <- NULL
[17:26:42.938]                       }
[17:26:42.938]                       if (!has_future || version < "1.8.0") {
[17:26:42.938]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.938]                           "", base::R.version$version.string), 
[17:26:42.938]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.938]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.938]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.938]                             "release", "version")], collapse = " "), 
[17:26:42.938]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.938]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.938]                           info)
[17:26:42.938]                         info <- base::paste(info, collapse = "; ")
[17:26:42.938]                         if (!has_future) {
[17:26:42.938]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.938]                             info)
[17:26:42.938]                         }
[17:26:42.938]                         else {
[17:26:42.938]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.938]                             info, version)
[17:26:42.938]                         }
[17:26:42.938]                         base::stop(msg)
[17:26:42.938]                       }
[17:26:42.938]                     })
[17:26:42.938]                   }
[17:26:42.938]                   ...future.strategy.old <- future::plan("list")
[17:26:42.938]                   options(future.plan = NULL)
[17:26:42.938]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.938]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.938]                 }
[17:26:42.938]                 ...future.workdir <- getwd()
[17:26:42.938]             }
[17:26:42.938]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.938]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.938]         }
[17:26:42.938]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.938]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.938]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.938]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.938]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.938]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.938]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.938]             base::names(...future.oldOptions))
[17:26:42.938]     }
[17:26:42.938]     if (FALSE) {
[17:26:42.938]     }
[17:26:42.938]     else {
[17:26:42.938]         if (TRUE) {
[17:26:42.938]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.938]                 open = "w")
[17:26:42.938]         }
[17:26:42.938]         else {
[17:26:42.938]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.938]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.938]         }
[17:26:42.938]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.938]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.938]             base::sink(type = "output", split = FALSE)
[17:26:42.938]             base::close(...future.stdout)
[17:26:42.938]         }, add = TRUE)
[17:26:42.938]     }
[17:26:42.938]     ...future.frame <- base::sys.nframe()
[17:26:42.938]     ...future.conditions <- base::list()
[17:26:42.938]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.938]     if (FALSE) {
[17:26:42.938]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.938]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.938]     }
[17:26:42.938]     ...future.result <- base::tryCatch({
[17:26:42.938]         base::withCallingHandlers({
[17:26:42.938]             ...future.value <- base::withVisible(base::local({
[17:26:42.938]                 4
[17:26:42.938]             }))
[17:26:42.938]             future::FutureResult(value = ...future.value$value, 
[17:26:42.938]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.938]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.938]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.938]                     ...future.globalenv.names))
[17:26:42.938]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.938]         }, condition = base::local({
[17:26:42.938]             c <- base::c
[17:26:42.938]             inherits <- base::inherits
[17:26:42.938]             invokeRestart <- base::invokeRestart
[17:26:42.938]             length <- base::length
[17:26:42.938]             list <- base::list
[17:26:42.938]             seq.int <- base::seq.int
[17:26:42.938]             signalCondition <- base::signalCondition
[17:26:42.938]             sys.calls <- base::sys.calls
[17:26:42.938]             `[[` <- base::`[[`
[17:26:42.938]             `+` <- base::`+`
[17:26:42.938]             `<<-` <- base::`<<-`
[17:26:42.938]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.938]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.938]                   3L)]
[17:26:42.938]             }
[17:26:42.938]             function(cond) {
[17:26:42.938]                 is_error <- inherits(cond, "error")
[17:26:42.938]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.938]                   NULL)
[17:26:42.938]                 if (is_error) {
[17:26:42.938]                   sessionInformation <- function() {
[17:26:42.938]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.938]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.938]                       search = base::search(), system = base::Sys.info())
[17:26:42.938]                   }
[17:26:42.938]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.938]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.938]                     cond$call), session = sessionInformation(), 
[17:26:42.938]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.938]                   signalCondition(cond)
[17:26:42.938]                 }
[17:26:42.938]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.938]                 "immediateCondition"))) {
[17:26:42.938]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.938]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.938]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.938]                   if (TRUE && !signal) {
[17:26:42.938]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.938]                     {
[17:26:42.938]                       inherits <- base::inherits
[17:26:42.938]                       invokeRestart <- base::invokeRestart
[17:26:42.938]                       is.null <- base::is.null
[17:26:42.938]                       muffled <- FALSE
[17:26:42.938]                       if (inherits(cond, "message")) {
[17:26:42.938]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.938]                         if (muffled) 
[17:26:42.938]                           invokeRestart("muffleMessage")
[17:26:42.938]                       }
[17:26:42.938]                       else if (inherits(cond, "warning")) {
[17:26:42.938]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.938]                         if (muffled) 
[17:26:42.938]                           invokeRestart("muffleWarning")
[17:26:42.938]                       }
[17:26:42.938]                       else if (inherits(cond, "condition")) {
[17:26:42.938]                         if (!is.null(pattern)) {
[17:26:42.938]                           computeRestarts <- base::computeRestarts
[17:26:42.938]                           grepl <- base::grepl
[17:26:42.938]                           restarts <- computeRestarts(cond)
[17:26:42.938]                           for (restart in restarts) {
[17:26:42.938]                             name <- restart$name
[17:26:42.938]                             if (is.null(name)) 
[17:26:42.938]                               next
[17:26:42.938]                             if (!grepl(pattern, name)) 
[17:26:42.938]                               next
[17:26:42.938]                             invokeRestart(restart)
[17:26:42.938]                             muffled <- TRUE
[17:26:42.938]                             break
[17:26:42.938]                           }
[17:26:42.938]                         }
[17:26:42.938]                       }
[17:26:42.938]                       invisible(muffled)
[17:26:42.938]                     }
[17:26:42.938]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.938]                   }
[17:26:42.938]                 }
[17:26:42.938]                 else {
[17:26:42.938]                   if (TRUE) {
[17:26:42.938]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.938]                     {
[17:26:42.938]                       inherits <- base::inherits
[17:26:42.938]                       invokeRestart <- base::invokeRestart
[17:26:42.938]                       is.null <- base::is.null
[17:26:42.938]                       muffled <- FALSE
[17:26:42.938]                       if (inherits(cond, "message")) {
[17:26:42.938]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.938]                         if (muffled) 
[17:26:42.938]                           invokeRestart("muffleMessage")
[17:26:42.938]                       }
[17:26:42.938]                       else if (inherits(cond, "warning")) {
[17:26:42.938]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.938]                         if (muffled) 
[17:26:42.938]                           invokeRestart("muffleWarning")
[17:26:42.938]                       }
[17:26:42.938]                       else if (inherits(cond, "condition")) {
[17:26:42.938]                         if (!is.null(pattern)) {
[17:26:42.938]                           computeRestarts <- base::computeRestarts
[17:26:42.938]                           grepl <- base::grepl
[17:26:42.938]                           restarts <- computeRestarts(cond)
[17:26:42.938]                           for (restart in restarts) {
[17:26:42.938]                             name <- restart$name
[17:26:42.938]                             if (is.null(name)) 
[17:26:42.938]                               next
[17:26:42.938]                             if (!grepl(pattern, name)) 
[17:26:42.938]                               next
[17:26:42.938]                             invokeRestart(restart)
[17:26:42.938]                             muffled <- TRUE
[17:26:42.938]                             break
[17:26:42.938]                           }
[17:26:42.938]                         }
[17:26:42.938]                       }
[17:26:42.938]                       invisible(muffled)
[17:26:42.938]                     }
[17:26:42.938]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.938]                   }
[17:26:42.938]                 }
[17:26:42.938]             }
[17:26:42.938]         }))
[17:26:42.938]     }, error = function(ex) {
[17:26:42.938]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.938]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.938]                 ...future.rng), started = ...future.startTime, 
[17:26:42.938]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.938]             version = "1.8"), class = "FutureResult")
[17:26:42.938]     }, finally = {
[17:26:42.938]         if (!identical(...future.workdir, getwd())) 
[17:26:42.938]             setwd(...future.workdir)
[17:26:42.938]         {
[17:26:42.938]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.938]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.938]             }
[17:26:42.938]             base::options(...future.oldOptions)
[17:26:42.938]             if (.Platform$OS.type == "windows") {
[17:26:42.938]                 old_names <- names(...future.oldEnvVars)
[17:26:42.938]                 envs <- base::Sys.getenv()
[17:26:42.938]                 names <- names(envs)
[17:26:42.938]                 common <- intersect(names, old_names)
[17:26:42.938]                 added <- setdiff(names, old_names)
[17:26:42.938]                 removed <- setdiff(old_names, names)
[17:26:42.938]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.938]                   envs[common]]
[17:26:42.938]                 NAMES <- toupper(changed)
[17:26:42.938]                 args <- list()
[17:26:42.938]                 for (kk in seq_along(NAMES)) {
[17:26:42.938]                   name <- changed[[kk]]
[17:26:42.938]                   NAME <- NAMES[[kk]]
[17:26:42.938]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.938]                     next
[17:26:42.938]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.938]                 }
[17:26:42.938]                 NAMES <- toupper(added)
[17:26:42.938]                 for (kk in seq_along(NAMES)) {
[17:26:42.938]                   name <- added[[kk]]
[17:26:42.938]                   NAME <- NAMES[[kk]]
[17:26:42.938]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.938]                     next
[17:26:42.938]                   args[[name]] <- ""
[17:26:42.938]                 }
[17:26:42.938]                 NAMES <- toupper(removed)
[17:26:42.938]                 for (kk in seq_along(NAMES)) {
[17:26:42.938]                   name <- removed[[kk]]
[17:26:42.938]                   NAME <- NAMES[[kk]]
[17:26:42.938]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.938]                     next
[17:26:42.938]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.938]                 }
[17:26:42.938]                 if (length(args) > 0) 
[17:26:42.938]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.938]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.938]             }
[17:26:42.938]             else {
[17:26:42.938]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.938]             }
[17:26:42.938]             {
[17:26:42.938]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.938]                   0L) {
[17:26:42.938]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.938]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.938]                   base::options(opts)
[17:26:42.938]                 }
[17:26:42.938]                 {
[17:26:42.938]                   {
[17:26:42.938]                     NULL
[17:26:42.938]                     RNGkind("Mersenne-Twister")
[17:26:42.938]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.938]                       inherits = FALSE)
[17:26:42.938]                   }
[17:26:42.938]                   options(future.plan = NULL)
[17:26:42.938]                   if (is.na(NA_character_)) 
[17:26:42.938]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.938]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.938]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.938]                     .init = FALSE)
[17:26:42.938]                 }
[17:26:42.938]             }
[17:26:42.938]         }
[17:26:42.938]     })
[17:26:42.938]     if (TRUE) {
[17:26:42.938]         base::sink(type = "output", split = FALSE)
[17:26:42.938]         if (TRUE) {
[17:26:42.938]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.938]         }
[17:26:42.938]         else {
[17:26:42.938]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.938]         }
[17:26:42.938]         base::close(...future.stdout)
[17:26:42.938]         ...future.stdout <- NULL
[17:26:42.938]     }
[17:26:42.938]     ...future.result$conditions <- ...future.conditions
[17:26:42.938]     ...future.result$finished <- base::Sys.time()
[17:26:42.938]     ...future.result
[17:26:42.938] }
[17:26:42.942] plan(): Setting new future strategy stack:
[17:26:42.942] List of future strategies:
[17:26:42.942] 1. sequential:
[17:26:42.942]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.942]    - tweaked: FALSE
[17:26:42.942]    - call: NULL
[17:26:42.943] plan(): nbrOfWorkers() = 1
[17:26:42.944] plan(): Setting new future strategy stack:
[17:26:42.944] List of future strategies:
[17:26:42.944] 1. sequential:
[17:26:42.944]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.944]    - tweaked: FALSE
[17:26:42.944]    - call: plan(strategy)
[17:26:42.945] plan(): nbrOfWorkers() = 1
[17:26:42.945] SequentialFuture started (and completed)
[17:26:42.945] - Launch lazy future ... done
[17:26:42.946] run() for 'SequentialFuture' ... done
<environment: 0x000002230d66c798> 
<environment: 0x000002230d77f8b8> 
[17:26:42.947] resolved() for 'SequentialFuture' ...
[17:26:42.948] - state: 'finished'
[17:26:42.949] - run: TRUE
[17:26:42.949] - result: 'FutureResult'
[17:26:42.950] resolved() for 'SequentialFuture' ... done
[17:26:42.950] resolved() for 'SequentialFuture' ...
[17:26:42.950] - state: 'finished'
[17:26:42.950] - run: TRUE
[17:26:42.950] - result: 'FutureResult'
[17:26:42.950] resolved() for 'SequentialFuture' ... done
[17:26:42.951] resolved() for 'SequentialFuture' ...
[17:26:42.951] - state: 'finished'
[17:26:42.951] - run: TRUE
[17:26:42.951] - result: 'FutureResult'
[17:26:42.951] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:42.953] resolve() on environment ...
[17:26:42.953]  recursive: 0
[17:26:42.954]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:42.954] signalConditionsASAP(numeric, pos=1) ...
[17:26:42.954] - nx: 4
[17:26:42.954] - relay: TRUE
[17:26:42.955] - stdout: TRUE
[17:26:42.955] - signal: TRUE
[17:26:42.955] - resignal: FALSE
[17:26:42.955] - force: TRUE
[17:26:42.955] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:42.955] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:42.956]  - until=2
[17:26:42.956]  - relaying element #2
[17:26:42.956] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:42.956] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:42.956] signalConditionsASAP(NULL, pos=1) ... done
[17:26:42.956]  length: 3 (resolved future 1)
[17:26:42.956] resolved() for 'SequentialFuture' ...
[17:26:42.957] - state: 'finished'
[17:26:42.957] - run: TRUE
[17:26:42.957] - result: 'FutureResult'
[17:26:42.957] resolved() for 'SequentialFuture' ... done
[17:26:42.957] Future #2
[17:26:42.958] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:42.958] - nx: 4
[17:26:42.958] - relay: TRUE
[17:26:42.958] - stdout: TRUE
[17:26:42.958] - signal: TRUE
[17:26:42.958] - resignal: FALSE
[17:26:42.959] - force: TRUE
[17:26:42.959] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:42.959] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:42.959]  - until=2
[17:26:42.959]  - relaying element #2
[17:26:42.959] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:42.960] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:42.960] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:42.960]  length: 2 (resolved future 2)
[17:26:42.960] resolved() for 'SequentialFuture' ...
[17:26:42.960] - state: 'finished'
[17:26:42.961] - run: TRUE
[17:26:42.961] - result: 'FutureResult'
[17:26:42.961] resolved() for 'SequentialFuture' ... done
[17:26:42.961] Future #3
[17:26:42.961] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:42.961] - nx: 4
[17:26:42.962] - relay: TRUE
[17:26:42.962] - stdout: TRUE
[17:26:42.962] - signal: TRUE
[17:26:42.962] - resignal: FALSE
[17:26:42.962] - force: TRUE
[17:26:42.962] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:42.962] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:42.963]  - until=3
[17:26:42.963]  - relaying element #3
[17:26:42.963] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:42.963] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:42.963] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:42.964]  length: 1 (resolved future 3)
[17:26:42.964] resolved() for 'SequentialFuture' ...
[17:26:42.964] - state: 'finished'
[17:26:42.964] - run: TRUE
[17:26:42.964] - result: 'FutureResult'
[17:26:42.964] resolved() for 'SequentialFuture' ... done
[17:26:42.965] Future #4
[17:26:42.965] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:42.965] - nx: 4
[17:26:42.965] - relay: TRUE
[17:26:42.965] - stdout: TRUE
[17:26:42.966] - signal: TRUE
[17:26:42.966] - resignal: FALSE
[17:26:42.966] - force: TRUE
[17:26:42.966] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:42.966] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:42.966]  - until=4
[17:26:42.966]  - relaying element #4
[17:26:42.967] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:42.967] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:42.967] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:42.967]  length: 0 (resolved future 4)
[17:26:42.967] Relaying remaining futures
[17:26:42.968] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.968] - nx: 4
[17:26:42.968] - relay: TRUE
[17:26:42.968] - stdout: TRUE
[17:26:42.968] - signal: TRUE
[17:26:42.968] - resignal: FALSE
[17:26:42.968] - force: TRUE
[17:26:42.969] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:42.969] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:42.969] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:42.969] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:42.969] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.969] resolve() on environment ... DONE
<environment: 0x000002230b243960> 
Dimensions: c(1, 6)
[17:26:42.970] getGlobalsAndPackages() ...
[17:26:42.970] Searching for globals...
[17:26:42.971] 
[17:26:42.971] Searching for globals ... DONE
[17:26:42.971] - globals: [0] <none>
[17:26:42.971] getGlobalsAndPackages() ... DONE
[17:26:42.971] run() for 'Future' ...
[17:26:42.972] - state: 'created'
[17:26:42.972] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.972] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.972] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.973]   - Field: 'label'
[17:26:42.973]   - Field: 'local'
[17:26:42.973]   - Field: 'owner'
[17:26:42.973]   - Field: 'envir'
[17:26:42.973]   - Field: 'packages'
[17:26:42.973]   - Field: 'gc'
[17:26:42.974]   - Field: 'conditions'
[17:26:42.974]   - Field: 'expr'
[17:26:42.974]   - Field: 'uuid'
[17:26:42.974]   - Field: 'seed'
[17:26:42.974]   - Field: 'version'
[17:26:42.975]   - Field: 'result'
[17:26:42.975]   - Field: 'asynchronous'
[17:26:42.975]   - Field: 'calls'
[17:26:42.975]   - Field: 'globals'
[17:26:42.975]   - Field: 'stdout'
[17:26:42.975]   - Field: 'earlySignal'
[17:26:42.976]   - Field: 'lazy'
[17:26:42.976]   - Field: 'state'
[17:26:42.976] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.976] - Launch lazy future ...
[17:26:42.976] Packages needed by the future expression (n = 0): <none>
[17:26:42.977] Packages needed by future strategies (n = 0): <none>
[17:26:42.977] {
[17:26:42.977]     {
[17:26:42.977]         {
[17:26:42.977]             ...future.startTime <- base::Sys.time()
[17:26:42.977]             {
[17:26:42.977]                 {
[17:26:42.977]                   {
[17:26:42.977]                     base::local({
[17:26:42.977]                       has_future <- base::requireNamespace("future", 
[17:26:42.977]                         quietly = TRUE)
[17:26:42.977]                       if (has_future) {
[17:26:42.977]                         ns <- base::getNamespace("future")
[17:26:42.977]                         version <- ns[[".package"]][["version"]]
[17:26:42.977]                         if (is.null(version)) 
[17:26:42.977]                           version <- utils::packageVersion("future")
[17:26:42.977]                       }
[17:26:42.977]                       else {
[17:26:42.977]                         version <- NULL
[17:26:42.977]                       }
[17:26:42.977]                       if (!has_future || version < "1.8.0") {
[17:26:42.977]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.977]                           "", base::R.version$version.string), 
[17:26:42.977]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.977]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.977]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.977]                             "release", "version")], collapse = " "), 
[17:26:42.977]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.977]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.977]                           info)
[17:26:42.977]                         info <- base::paste(info, collapse = "; ")
[17:26:42.977]                         if (!has_future) {
[17:26:42.977]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.977]                             info)
[17:26:42.977]                         }
[17:26:42.977]                         else {
[17:26:42.977]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.977]                             info, version)
[17:26:42.977]                         }
[17:26:42.977]                         base::stop(msg)
[17:26:42.977]                       }
[17:26:42.977]                     })
[17:26:42.977]                   }
[17:26:42.977]                   ...future.strategy.old <- future::plan("list")
[17:26:42.977]                   options(future.plan = NULL)
[17:26:42.977]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.977]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.977]                 }
[17:26:42.977]                 ...future.workdir <- getwd()
[17:26:42.977]             }
[17:26:42.977]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.977]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.977]         }
[17:26:42.977]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.977]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.977]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.977]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.977]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.977]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.977]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.977]             base::names(...future.oldOptions))
[17:26:42.977]     }
[17:26:42.977]     if (FALSE) {
[17:26:42.977]     }
[17:26:42.977]     else {
[17:26:42.977]         if (TRUE) {
[17:26:42.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.977]                 open = "w")
[17:26:42.977]         }
[17:26:42.977]         else {
[17:26:42.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.977]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.977]         }
[17:26:42.977]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.977]             base::sink(type = "output", split = FALSE)
[17:26:42.977]             base::close(...future.stdout)
[17:26:42.977]         }, add = TRUE)
[17:26:42.977]     }
[17:26:42.977]     ...future.frame <- base::sys.nframe()
[17:26:42.977]     ...future.conditions <- base::list()
[17:26:42.977]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.977]     if (FALSE) {
[17:26:42.977]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.977]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.977]     }
[17:26:42.977]     ...future.result <- base::tryCatch({
[17:26:42.977]         base::withCallingHandlers({
[17:26:42.977]             ...future.value <- base::withVisible(base::local(2))
[17:26:42.977]             future::FutureResult(value = ...future.value$value, 
[17:26:42.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.977]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.977]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.977]                     ...future.globalenv.names))
[17:26:42.977]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.977]         }, condition = base::local({
[17:26:42.977]             c <- base::c
[17:26:42.977]             inherits <- base::inherits
[17:26:42.977]             invokeRestart <- base::invokeRestart
[17:26:42.977]             length <- base::length
[17:26:42.977]             list <- base::list
[17:26:42.977]             seq.int <- base::seq.int
[17:26:42.977]             signalCondition <- base::signalCondition
[17:26:42.977]             sys.calls <- base::sys.calls
[17:26:42.977]             `[[` <- base::`[[`
[17:26:42.977]             `+` <- base::`+`
[17:26:42.977]             `<<-` <- base::`<<-`
[17:26:42.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.977]                   3L)]
[17:26:42.977]             }
[17:26:42.977]             function(cond) {
[17:26:42.977]                 is_error <- inherits(cond, "error")
[17:26:42.977]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.977]                   NULL)
[17:26:42.977]                 if (is_error) {
[17:26:42.977]                   sessionInformation <- function() {
[17:26:42.977]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.977]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.977]                       search = base::search(), system = base::Sys.info())
[17:26:42.977]                   }
[17:26:42.977]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.977]                     cond$call), session = sessionInformation(), 
[17:26:42.977]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.977]                   signalCondition(cond)
[17:26:42.977]                 }
[17:26:42.977]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.977]                 "immediateCondition"))) {
[17:26:42.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.977]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.977]                   if (TRUE && !signal) {
[17:26:42.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.977]                     {
[17:26:42.977]                       inherits <- base::inherits
[17:26:42.977]                       invokeRestart <- base::invokeRestart
[17:26:42.977]                       is.null <- base::is.null
[17:26:42.977]                       muffled <- FALSE
[17:26:42.977]                       if (inherits(cond, "message")) {
[17:26:42.977]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.977]                         if (muffled) 
[17:26:42.977]                           invokeRestart("muffleMessage")
[17:26:42.977]                       }
[17:26:42.977]                       else if (inherits(cond, "warning")) {
[17:26:42.977]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.977]                         if (muffled) 
[17:26:42.977]                           invokeRestart("muffleWarning")
[17:26:42.977]                       }
[17:26:42.977]                       else if (inherits(cond, "condition")) {
[17:26:42.977]                         if (!is.null(pattern)) {
[17:26:42.977]                           computeRestarts <- base::computeRestarts
[17:26:42.977]                           grepl <- base::grepl
[17:26:42.977]                           restarts <- computeRestarts(cond)
[17:26:42.977]                           for (restart in restarts) {
[17:26:42.977]                             name <- restart$name
[17:26:42.977]                             if (is.null(name)) 
[17:26:42.977]                               next
[17:26:42.977]                             if (!grepl(pattern, name)) 
[17:26:42.977]                               next
[17:26:42.977]                             invokeRestart(restart)
[17:26:42.977]                             muffled <- TRUE
[17:26:42.977]                             break
[17:26:42.977]                           }
[17:26:42.977]                         }
[17:26:42.977]                       }
[17:26:42.977]                       invisible(muffled)
[17:26:42.977]                     }
[17:26:42.977]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.977]                   }
[17:26:42.977]                 }
[17:26:42.977]                 else {
[17:26:42.977]                   if (TRUE) {
[17:26:42.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.977]                     {
[17:26:42.977]                       inherits <- base::inherits
[17:26:42.977]                       invokeRestart <- base::invokeRestart
[17:26:42.977]                       is.null <- base::is.null
[17:26:42.977]                       muffled <- FALSE
[17:26:42.977]                       if (inherits(cond, "message")) {
[17:26:42.977]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.977]                         if (muffled) 
[17:26:42.977]                           invokeRestart("muffleMessage")
[17:26:42.977]                       }
[17:26:42.977]                       else if (inherits(cond, "warning")) {
[17:26:42.977]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.977]                         if (muffled) 
[17:26:42.977]                           invokeRestart("muffleWarning")
[17:26:42.977]                       }
[17:26:42.977]                       else if (inherits(cond, "condition")) {
[17:26:42.977]                         if (!is.null(pattern)) {
[17:26:42.977]                           computeRestarts <- base::computeRestarts
[17:26:42.977]                           grepl <- base::grepl
[17:26:42.977]                           restarts <- computeRestarts(cond)
[17:26:42.977]                           for (restart in restarts) {
[17:26:42.977]                             name <- restart$name
[17:26:42.977]                             if (is.null(name)) 
[17:26:42.977]                               next
[17:26:42.977]                             if (!grepl(pattern, name)) 
[17:26:42.977]                               next
[17:26:42.977]                             invokeRestart(restart)
[17:26:42.977]                             muffled <- TRUE
[17:26:42.977]                             break
[17:26:42.977]                           }
[17:26:42.977]                         }
[17:26:42.977]                       }
[17:26:42.977]                       invisible(muffled)
[17:26:42.977]                     }
[17:26:42.977]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.977]                   }
[17:26:42.977]                 }
[17:26:42.977]             }
[17:26:42.977]         }))
[17:26:42.977]     }, error = function(ex) {
[17:26:42.977]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.977]                 ...future.rng), started = ...future.startTime, 
[17:26:42.977]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.977]             version = "1.8"), class = "FutureResult")
[17:26:42.977]     }, finally = {
[17:26:42.977]         if (!identical(...future.workdir, getwd())) 
[17:26:42.977]             setwd(...future.workdir)
[17:26:42.977]         {
[17:26:42.977]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.977]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.977]             }
[17:26:42.977]             base::options(...future.oldOptions)
[17:26:42.977]             if (.Platform$OS.type == "windows") {
[17:26:42.977]                 old_names <- names(...future.oldEnvVars)
[17:26:42.977]                 envs <- base::Sys.getenv()
[17:26:42.977]                 names <- names(envs)
[17:26:42.977]                 common <- intersect(names, old_names)
[17:26:42.977]                 added <- setdiff(names, old_names)
[17:26:42.977]                 removed <- setdiff(old_names, names)
[17:26:42.977]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.977]                   envs[common]]
[17:26:42.977]                 NAMES <- toupper(changed)
[17:26:42.977]                 args <- list()
[17:26:42.977]                 for (kk in seq_along(NAMES)) {
[17:26:42.977]                   name <- changed[[kk]]
[17:26:42.977]                   NAME <- NAMES[[kk]]
[17:26:42.977]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.977]                     next
[17:26:42.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.977]                 }
[17:26:42.977]                 NAMES <- toupper(added)
[17:26:42.977]                 for (kk in seq_along(NAMES)) {
[17:26:42.977]                   name <- added[[kk]]
[17:26:42.977]                   NAME <- NAMES[[kk]]
[17:26:42.977]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.977]                     next
[17:26:42.977]                   args[[name]] <- ""
[17:26:42.977]                 }
[17:26:42.977]                 NAMES <- toupper(removed)
[17:26:42.977]                 for (kk in seq_along(NAMES)) {
[17:26:42.977]                   name <- removed[[kk]]
[17:26:42.977]                   NAME <- NAMES[[kk]]
[17:26:42.977]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.977]                     next
[17:26:42.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.977]                 }
[17:26:42.977]                 if (length(args) > 0) 
[17:26:42.977]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.977]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.977]             }
[17:26:42.977]             else {
[17:26:42.977]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.977]             }
[17:26:42.977]             {
[17:26:42.977]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.977]                   0L) {
[17:26:42.977]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.977]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.977]                   base::options(opts)
[17:26:42.977]                 }
[17:26:42.977]                 {
[17:26:42.977]                   {
[17:26:42.977]                     NULL
[17:26:42.977]                     RNGkind("Mersenne-Twister")
[17:26:42.977]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.977]                       inherits = FALSE)
[17:26:42.977]                   }
[17:26:42.977]                   options(future.plan = NULL)
[17:26:42.977]                   if (is.na(NA_character_)) 
[17:26:42.977]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.977]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.977]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.977]                     .init = FALSE)
[17:26:42.977]                 }
[17:26:42.977]             }
[17:26:42.977]         }
[17:26:42.977]     })
[17:26:42.977]     if (TRUE) {
[17:26:42.977]         base::sink(type = "output", split = FALSE)
[17:26:42.977]         if (TRUE) {
[17:26:42.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.977]         }
[17:26:42.977]         else {
[17:26:42.977]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.977]         }
[17:26:42.977]         base::close(...future.stdout)
[17:26:42.977]         ...future.stdout <- NULL
[17:26:42.977]     }
[17:26:42.977]     ...future.result$conditions <- ...future.conditions
[17:26:42.977]     ...future.result$finished <- base::Sys.time()
[17:26:42.977]     ...future.result
[17:26:42.977] }
[17:26:42.981] plan(): Setting new future strategy stack:
[17:26:42.981] List of future strategies:
[17:26:42.981] 1. sequential:
[17:26:42.981]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.981]    - tweaked: FALSE
[17:26:42.981]    - call: NULL
[17:26:42.982] plan(): nbrOfWorkers() = 1
[17:26:42.983] plan(): Setting new future strategy stack:
[17:26:42.983] List of future strategies:
[17:26:42.983] 1. sequential:
[17:26:42.983]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.983]    - tweaked: FALSE
[17:26:42.983]    - call: plan(strategy)
[17:26:42.985] plan(): nbrOfWorkers() = 1
[17:26:42.985] SequentialFuture started (and completed)
[17:26:42.985] - Launch lazy future ... done
[17:26:42.986] run() for 'SequentialFuture' ... done
[17:26:42.986] getGlobalsAndPackages() ...
[17:26:42.986] Searching for globals...
[17:26:42.986] 
[17:26:42.986] Searching for globals ... DONE
[17:26:42.987] - globals: [0] <none>
[17:26:42.987] getGlobalsAndPackages() ... DONE
[17:26:42.987] run() for 'Future' ...
[17:26:42.987] - state: 'created'
[17:26:42.988] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:42.988] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:42.988] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:42.988]   - Field: 'label'
[17:26:42.988]   - Field: 'local'
[17:26:42.989]   - Field: 'owner'
[17:26:42.989]   - Field: 'envir'
[17:26:42.989]   - Field: 'packages'
[17:26:42.989]   - Field: 'gc'
[17:26:42.989]   - Field: 'conditions'
[17:26:42.989]   - Field: 'expr'
[17:26:42.990]   - Field: 'uuid'
[17:26:42.990]   - Field: 'seed'
[17:26:42.990]   - Field: 'version'
[17:26:42.990]   - Field: 'result'
[17:26:42.990]   - Field: 'asynchronous'
[17:26:42.991]   - Field: 'calls'
[17:26:42.991]   - Field: 'globals'
[17:26:42.991]   - Field: 'stdout'
[17:26:42.991]   - Field: 'earlySignal'
[17:26:42.991]   - Field: 'lazy'
[17:26:42.991]   - Field: 'state'
[17:26:42.992] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:42.992] - Launch lazy future ...
[17:26:42.992] Packages needed by the future expression (n = 0): <none>
[17:26:42.992] Packages needed by future strategies (n = 0): <none>
[17:26:42.993] {
[17:26:42.993]     {
[17:26:42.993]         {
[17:26:42.993]             ...future.startTime <- base::Sys.time()
[17:26:42.993]             {
[17:26:42.993]                 {
[17:26:42.993]                   {
[17:26:42.993]                     base::local({
[17:26:42.993]                       has_future <- base::requireNamespace("future", 
[17:26:42.993]                         quietly = TRUE)
[17:26:42.993]                       if (has_future) {
[17:26:42.993]                         ns <- base::getNamespace("future")
[17:26:42.993]                         version <- ns[[".package"]][["version"]]
[17:26:42.993]                         if (is.null(version)) 
[17:26:42.993]                           version <- utils::packageVersion("future")
[17:26:42.993]                       }
[17:26:42.993]                       else {
[17:26:42.993]                         version <- NULL
[17:26:42.993]                       }
[17:26:42.993]                       if (!has_future || version < "1.8.0") {
[17:26:42.993]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:42.993]                           "", base::R.version$version.string), 
[17:26:42.993]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:42.993]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:42.993]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:42.993]                             "release", "version")], collapse = " "), 
[17:26:42.993]                           hostname = base::Sys.info()[["nodename"]])
[17:26:42.993]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:42.993]                           info)
[17:26:42.993]                         info <- base::paste(info, collapse = "; ")
[17:26:42.993]                         if (!has_future) {
[17:26:42.993]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:42.993]                             info)
[17:26:42.993]                         }
[17:26:42.993]                         else {
[17:26:42.993]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:42.993]                             info, version)
[17:26:42.993]                         }
[17:26:42.993]                         base::stop(msg)
[17:26:42.993]                       }
[17:26:42.993]                     })
[17:26:42.993]                   }
[17:26:42.993]                   ...future.strategy.old <- future::plan("list")
[17:26:42.993]                   options(future.plan = NULL)
[17:26:42.993]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.993]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:42.993]                 }
[17:26:42.993]                 ...future.workdir <- getwd()
[17:26:42.993]             }
[17:26:42.993]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:42.993]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:42.993]         }
[17:26:42.993]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:42.993]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:42.993]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:42.993]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:42.993]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:42.993]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:42.993]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:42.993]             base::names(...future.oldOptions))
[17:26:42.993]     }
[17:26:42.993]     if (FALSE) {
[17:26:42.993]     }
[17:26:42.993]     else {
[17:26:42.993]         if (TRUE) {
[17:26:42.993]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:42.993]                 open = "w")
[17:26:42.993]         }
[17:26:42.993]         else {
[17:26:42.993]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:42.993]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:42.993]         }
[17:26:42.993]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:42.993]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:42.993]             base::sink(type = "output", split = FALSE)
[17:26:42.993]             base::close(...future.stdout)
[17:26:42.993]         }, add = TRUE)
[17:26:42.993]     }
[17:26:42.993]     ...future.frame <- base::sys.nframe()
[17:26:42.993]     ...future.conditions <- base::list()
[17:26:42.993]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:42.993]     if (FALSE) {
[17:26:42.993]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:42.993]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:42.993]     }
[17:26:42.993]     ...future.result <- base::tryCatch({
[17:26:42.993]         base::withCallingHandlers({
[17:26:42.993]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:42.993]             future::FutureResult(value = ...future.value$value, 
[17:26:42.993]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.993]                   ...future.rng), globalenv = if (FALSE) 
[17:26:42.993]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:42.993]                     ...future.globalenv.names))
[17:26:42.993]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:42.993]         }, condition = base::local({
[17:26:42.993]             c <- base::c
[17:26:42.993]             inherits <- base::inherits
[17:26:42.993]             invokeRestart <- base::invokeRestart
[17:26:42.993]             length <- base::length
[17:26:42.993]             list <- base::list
[17:26:42.993]             seq.int <- base::seq.int
[17:26:42.993]             signalCondition <- base::signalCondition
[17:26:42.993]             sys.calls <- base::sys.calls
[17:26:42.993]             `[[` <- base::`[[`
[17:26:42.993]             `+` <- base::`+`
[17:26:42.993]             `<<-` <- base::`<<-`
[17:26:42.993]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:42.993]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:42.993]                   3L)]
[17:26:42.993]             }
[17:26:42.993]             function(cond) {
[17:26:42.993]                 is_error <- inherits(cond, "error")
[17:26:42.993]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:42.993]                   NULL)
[17:26:42.993]                 if (is_error) {
[17:26:42.993]                   sessionInformation <- function() {
[17:26:42.993]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:42.993]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:42.993]                       search = base::search(), system = base::Sys.info())
[17:26:42.993]                   }
[17:26:42.993]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.993]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:42.993]                     cond$call), session = sessionInformation(), 
[17:26:42.993]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:42.993]                   signalCondition(cond)
[17:26:42.993]                 }
[17:26:42.993]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:42.993]                 "immediateCondition"))) {
[17:26:42.993]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:42.993]                   ...future.conditions[[length(...future.conditions) + 
[17:26:42.993]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:42.993]                   if (TRUE && !signal) {
[17:26:42.993]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.993]                     {
[17:26:42.993]                       inherits <- base::inherits
[17:26:42.993]                       invokeRestart <- base::invokeRestart
[17:26:42.993]                       is.null <- base::is.null
[17:26:42.993]                       muffled <- FALSE
[17:26:42.993]                       if (inherits(cond, "message")) {
[17:26:42.993]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.993]                         if (muffled) 
[17:26:42.993]                           invokeRestart("muffleMessage")
[17:26:42.993]                       }
[17:26:42.993]                       else if (inherits(cond, "warning")) {
[17:26:42.993]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.993]                         if (muffled) 
[17:26:42.993]                           invokeRestart("muffleWarning")
[17:26:42.993]                       }
[17:26:42.993]                       else if (inherits(cond, "condition")) {
[17:26:42.993]                         if (!is.null(pattern)) {
[17:26:42.993]                           computeRestarts <- base::computeRestarts
[17:26:42.993]                           grepl <- base::grepl
[17:26:42.993]                           restarts <- computeRestarts(cond)
[17:26:42.993]                           for (restart in restarts) {
[17:26:42.993]                             name <- restart$name
[17:26:42.993]                             if (is.null(name)) 
[17:26:42.993]                               next
[17:26:42.993]                             if (!grepl(pattern, name)) 
[17:26:42.993]                               next
[17:26:42.993]                             invokeRestart(restart)
[17:26:42.993]                             muffled <- TRUE
[17:26:42.993]                             break
[17:26:42.993]                           }
[17:26:42.993]                         }
[17:26:42.993]                       }
[17:26:42.993]                       invisible(muffled)
[17:26:42.993]                     }
[17:26:42.993]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.993]                   }
[17:26:42.993]                 }
[17:26:42.993]                 else {
[17:26:42.993]                   if (TRUE) {
[17:26:42.993]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:42.993]                     {
[17:26:42.993]                       inherits <- base::inherits
[17:26:42.993]                       invokeRestart <- base::invokeRestart
[17:26:42.993]                       is.null <- base::is.null
[17:26:42.993]                       muffled <- FALSE
[17:26:42.993]                       if (inherits(cond, "message")) {
[17:26:42.993]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:42.993]                         if (muffled) 
[17:26:42.993]                           invokeRestart("muffleMessage")
[17:26:42.993]                       }
[17:26:42.993]                       else if (inherits(cond, "warning")) {
[17:26:42.993]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:42.993]                         if (muffled) 
[17:26:42.993]                           invokeRestart("muffleWarning")
[17:26:42.993]                       }
[17:26:42.993]                       else if (inherits(cond, "condition")) {
[17:26:42.993]                         if (!is.null(pattern)) {
[17:26:42.993]                           computeRestarts <- base::computeRestarts
[17:26:42.993]                           grepl <- base::grepl
[17:26:42.993]                           restarts <- computeRestarts(cond)
[17:26:42.993]                           for (restart in restarts) {
[17:26:42.993]                             name <- restart$name
[17:26:42.993]                             if (is.null(name)) 
[17:26:42.993]                               next
[17:26:42.993]                             if (!grepl(pattern, name)) 
[17:26:42.993]                               next
[17:26:42.993]                             invokeRestart(restart)
[17:26:42.993]                             muffled <- TRUE
[17:26:42.993]                             break
[17:26:42.993]                           }
[17:26:42.993]                         }
[17:26:42.993]                       }
[17:26:42.993]                       invisible(muffled)
[17:26:42.993]                     }
[17:26:42.993]                     muffleCondition(cond, pattern = "^muffle")
[17:26:42.993]                   }
[17:26:42.993]                 }
[17:26:42.993]             }
[17:26:42.993]         }))
[17:26:42.993]     }, error = function(ex) {
[17:26:42.993]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:42.993]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:42.993]                 ...future.rng), started = ...future.startTime, 
[17:26:42.993]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:42.993]             version = "1.8"), class = "FutureResult")
[17:26:42.993]     }, finally = {
[17:26:42.993]         if (!identical(...future.workdir, getwd())) 
[17:26:42.993]             setwd(...future.workdir)
[17:26:42.993]         {
[17:26:42.993]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:42.993]                 ...future.oldOptions$nwarnings <- NULL
[17:26:42.993]             }
[17:26:42.993]             base::options(...future.oldOptions)
[17:26:42.993]             if (.Platform$OS.type == "windows") {
[17:26:42.993]                 old_names <- names(...future.oldEnvVars)
[17:26:42.993]                 envs <- base::Sys.getenv()
[17:26:42.993]                 names <- names(envs)
[17:26:42.993]                 common <- intersect(names, old_names)
[17:26:42.993]                 added <- setdiff(names, old_names)
[17:26:42.993]                 removed <- setdiff(old_names, names)
[17:26:42.993]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:42.993]                   envs[common]]
[17:26:42.993]                 NAMES <- toupper(changed)
[17:26:42.993]                 args <- list()
[17:26:42.993]                 for (kk in seq_along(NAMES)) {
[17:26:42.993]                   name <- changed[[kk]]
[17:26:42.993]                   NAME <- NAMES[[kk]]
[17:26:42.993]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.993]                     next
[17:26:42.993]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.993]                 }
[17:26:42.993]                 NAMES <- toupper(added)
[17:26:42.993]                 for (kk in seq_along(NAMES)) {
[17:26:42.993]                   name <- added[[kk]]
[17:26:42.993]                   NAME <- NAMES[[kk]]
[17:26:42.993]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.993]                     next
[17:26:42.993]                   args[[name]] <- ""
[17:26:42.993]                 }
[17:26:42.993]                 NAMES <- toupper(removed)
[17:26:42.993]                 for (kk in seq_along(NAMES)) {
[17:26:42.993]                   name <- removed[[kk]]
[17:26:42.993]                   NAME <- NAMES[[kk]]
[17:26:42.993]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:42.993]                     next
[17:26:42.993]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:42.993]                 }
[17:26:42.993]                 if (length(args) > 0) 
[17:26:42.993]                   base::do.call(base::Sys.setenv, args = args)
[17:26:42.993]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:42.993]             }
[17:26:42.993]             else {
[17:26:42.993]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:42.993]             }
[17:26:42.993]             {
[17:26:42.993]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:42.993]                   0L) {
[17:26:42.993]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:42.993]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:42.993]                   base::options(opts)
[17:26:42.993]                 }
[17:26:42.993]                 {
[17:26:42.993]                   {
[17:26:42.993]                     NULL
[17:26:42.993]                     RNGkind("Mersenne-Twister")
[17:26:42.993]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:42.993]                       inherits = FALSE)
[17:26:42.993]                   }
[17:26:42.993]                   options(future.plan = NULL)
[17:26:42.993]                   if (is.na(NA_character_)) 
[17:26:42.993]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:42.993]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:42.993]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:42.993]                     .init = FALSE)
[17:26:42.993]                 }
[17:26:42.993]             }
[17:26:42.993]         }
[17:26:42.993]     })
[17:26:42.993]     if (TRUE) {
[17:26:42.993]         base::sink(type = "output", split = FALSE)
[17:26:42.993]         if (TRUE) {
[17:26:42.993]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:42.993]         }
[17:26:42.993]         else {
[17:26:42.993]             ...future.result["stdout"] <- base::list(NULL)
[17:26:42.993]         }
[17:26:42.993]         base::close(...future.stdout)
[17:26:42.993]         ...future.stdout <- NULL
[17:26:42.993]     }
[17:26:42.993]     ...future.result$conditions <- ...future.conditions
[17:26:42.993]     ...future.result$finished <- base::Sys.time()
[17:26:42.993]     ...future.result
[17:26:42.993] }
[17:26:42.997] plan(): Setting new future strategy stack:
[17:26:42.997] List of future strategies:
[17:26:42.997] 1. sequential:
[17:26:42.997]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.997]    - tweaked: FALSE
[17:26:42.997]    - call: NULL
[17:26:42.997] plan(): nbrOfWorkers() = 1
[17:26:42.998] plan(): Setting new future strategy stack:
[17:26:42.999] List of future strategies:
[17:26:42.999] 1. sequential:
[17:26:42.999]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.999]    - tweaked: FALSE
[17:26:42.999]    - call: plan(strategy)
[17:26:42.999] plan(): nbrOfWorkers() = 1
[17:26:42.999] SequentialFuture started (and completed)
[17:26:43.000] - Launch lazy future ... done
[17:26:43.000] run() for 'SequentialFuture' ... done
[17:26:43.000] getGlobalsAndPackages() ...
[17:26:43.000] Searching for globals...
[17:26:43.001] - globals found: [1] '{'
[17:26:43.001] Searching for globals ... DONE
[17:26:43.002] Resolving globals: FALSE
[17:26:43.002] 
[17:26:43.002] 
[17:26:43.002] getGlobalsAndPackages() ... DONE
[17:26:43.002] run() for 'Future' ...
[17:26:43.003] - state: 'created'
[17:26:43.003] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.003] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.003] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.004]   - Field: 'label'
[17:26:43.004]   - Field: 'local'
[17:26:43.004]   - Field: 'owner'
[17:26:43.004]   - Field: 'envir'
[17:26:43.004]   - Field: 'packages'
[17:26:43.004]   - Field: 'gc'
[17:26:43.005]   - Field: 'conditions'
[17:26:43.005]   - Field: 'expr'
[17:26:43.005]   - Field: 'uuid'
[17:26:43.005]   - Field: 'seed'
[17:26:43.005]   - Field: 'version'
[17:26:43.006]   - Field: 'result'
[17:26:43.006]   - Field: 'asynchronous'
[17:26:43.006]   - Field: 'calls'
[17:26:43.006]   - Field: 'globals'
[17:26:43.006]   - Field: 'stdout'
[17:26:43.006]   - Field: 'earlySignal'
[17:26:43.007]   - Field: 'lazy'
[17:26:43.007]   - Field: 'state'
[17:26:43.007] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.007] - Launch lazy future ...
[17:26:43.007] Packages needed by the future expression (n = 0): <none>
[17:26:43.007] Packages needed by future strategies (n = 0): <none>
[17:26:43.008] {
[17:26:43.008]     {
[17:26:43.008]         {
[17:26:43.008]             ...future.startTime <- base::Sys.time()
[17:26:43.008]             {
[17:26:43.008]                 {
[17:26:43.008]                   {
[17:26:43.008]                     base::local({
[17:26:43.008]                       has_future <- base::requireNamespace("future", 
[17:26:43.008]                         quietly = TRUE)
[17:26:43.008]                       if (has_future) {
[17:26:43.008]                         ns <- base::getNamespace("future")
[17:26:43.008]                         version <- ns[[".package"]][["version"]]
[17:26:43.008]                         if (is.null(version)) 
[17:26:43.008]                           version <- utils::packageVersion("future")
[17:26:43.008]                       }
[17:26:43.008]                       else {
[17:26:43.008]                         version <- NULL
[17:26:43.008]                       }
[17:26:43.008]                       if (!has_future || version < "1.8.0") {
[17:26:43.008]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.008]                           "", base::R.version$version.string), 
[17:26:43.008]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.008]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.008]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.008]                             "release", "version")], collapse = " "), 
[17:26:43.008]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.008]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.008]                           info)
[17:26:43.008]                         info <- base::paste(info, collapse = "; ")
[17:26:43.008]                         if (!has_future) {
[17:26:43.008]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.008]                             info)
[17:26:43.008]                         }
[17:26:43.008]                         else {
[17:26:43.008]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.008]                             info, version)
[17:26:43.008]                         }
[17:26:43.008]                         base::stop(msg)
[17:26:43.008]                       }
[17:26:43.008]                     })
[17:26:43.008]                   }
[17:26:43.008]                   ...future.strategy.old <- future::plan("list")
[17:26:43.008]                   options(future.plan = NULL)
[17:26:43.008]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.008]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.008]                 }
[17:26:43.008]                 ...future.workdir <- getwd()
[17:26:43.008]             }
[17:26:43.008]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.008]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.008]         }
[17:26:43.008]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.008]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.008]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.008]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.008]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.008]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.008]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.008]             base::names(...future.oldOptions))
[17:26:43.008]     }
[17:26:43.008]     if (FALSE) {
[17:26:43.008]     }
[17:26:43.008]     else {
[17:26:43.008]         if (TRUE) {
[17:26:43.008]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.008]                 open = "w")
[17:26:43.008]         }
[17:26:43.008]         else {
[17:26:43.008]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.008]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.008]         }
[17:26:43.008]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.008]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.008]             base::sink(type = "output", split = FALSE)
[17:26:43.008]             base::close(...future.stdout)
[17:26:43.008]         }, add = TRUE)
[17:26:43.008]     }
[17:26:43.008]     ...future.frame <- base::sys.nframe()
[17:26:43.008]     ...future.conditions <- base::list()
[17:26:43.008]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.008]     if (FALSE) {
[17:26:43.008]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.008]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.008]     }
[17:26:43.008]     ...future.result <- base::tryCatch({
[17:26:43.008]         base::withCallingHandlers({
[17:26:43.008]             ...future.value <- base::withVisible(base::local({
[17:26:43.008]                 4
[17:26:43.008]             }))
[17:26:43.008]             future::FutureResult(value = ...future.value$value, 
[17:26:43.008]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.008]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.008]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.008]                     ...future.globalenv.names))
[17:26:43.008]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.008]         }, condition = base::local({
[17:26:43.008]             c <- base::c
[17:26:43.008]             inherits <- base::inherits
[17:26:43.008]             invokeRestart <- base::invokeRestart
[17:26:43.008]             length <- base::length
[17:26:43.008]             list <- base::list
[17:26:43.008]             seq.int <- base::seq.int
[17:26:43.008]             signalCondition <- base::signalCondition
[17:26:43.008]             sys.calls <- base::sys.calls
[17:26:43.008]             `[[` <- base::`[[`
[17:26:43.008]             `+` <- base::`+`
[17:26:43.008]             `<<-` <- base::`<<-`
[17:26:43.008]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.008]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.008]                   3L)]
[17:26:43.008]             }
[17:26:43.008]             function(cond) {
[17:26:43.008]                 is_error <- inherits(cond, "error")
[17:26:43.008]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.008]                   NULL)
[17:26:43.008]                 if (is_error) {
[17:26:43.008]                   sessionInformation <- function() {
[17:26:43.008]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.008]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.008]                       search = base::search(), system = base::Sys.info())
[17:26:43.008]                   }
[17:26:43.008]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.008]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.008]                     cond$call), session = sessionInformation(), 
[17:26:43.008]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.008]                   signalCondition(cond)
[17:26:43.008]                 }
[17:26:43.008]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.008]                 "immediateCondition"))) {
[17:26:43.008]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.008]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.008]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.008]                   if (TRUE && !signal) {
[17:26:43.008]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.008]                     {
[17:26:43.008]                       inherits <- base::inherits
[17:26:43.008]                       invokeRestart <- base::invokeRestart
[17:26:43.008]                       is.null <- base::is.null
[17:26:43.008]                       muffled <- FALSE
[17:26:43.008]                       if (inherits(cond, "message")) {
[17:26:43.008]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.008]                         if (muffled) 
[17:26:43.008]                           invokeRestart("muffleMessage")
[17:26:43.008]                       }
[17:26:43.008]                       else if (inherits(cond, "warning")) {
[17:26:43.008]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.008]                         if (muffled) 
[17:26:43.008]                           invokeRestart("muffleWarning")
[17:26:43.008]                       }
[17:26:43.008]                       else if (inherits(cond, "condition")) {
[17:26:43.008]                         if (!is.null(pattern)) {
[17:26:43.008]                           computeRestarts <- base::computeRestarts
[17:26:43.008]                           grepl <- base::grepl
[17:26:43.008]                           restarts <- computeRestarts(cond)
[17:26:43.008]                           for (restart in restarts) {
[17:26:43.008]                             name <- restart$name
[17:26:43.008]                             if (is.null(name)) 
[17:26:43.008]                               next
[17:26:43.008]                             if (!grepl(pattern, name)) 
[17:26:43.008]                               next
[17:26:43.008]                             invokeRestart(restart)
[17:26:43.008]                             muffled <- TRUE
[17:26:43.008]                             break
[17:26:43.008]                           }
[17:26:43.008]                         }
[17:26:43.008]                       }
[17:26:43.008]                       invisible(muffled)
[17:26:43.008]                     }
[17:26:43.008]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.008]                   }
[17:26:43.008]                 }
[17:26:43.008]                 else {
[17:26:43.008]                   if (TRUE) {
[17:26:43.008]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.008]                     {
[17:26:43.008]                       inherits <- base::inherits
[17:26:43.008]                       invokeRestart <- base::invokeRestart
[17:26:43.008]                       is.null <- base::is.null
[17:26:43.008]                       muffled <- FALSE
[17:26:43.008]                       if (inherits(cond, "message")) {
[17:26:43.008]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.008]                         if (muffled) 
[17:26:43.008]                           invokeRestart("muffleMessage")
[17:26:43.008]                       }
[17:26:43.008]                       else if (inherits(cond, "warning")) {
[17:26:43.008]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.008]                         if (muffled) 
[17:26:43.008]                           invokeRestart("muffleWarning")
[17:26:43.008]                       }
[17:26:43.008]                       else if (inherits(cond, "condition")) {
[17:26:43.008]                         if (!is.null(pattern)) {
[17:26:43.008]                           computeRestarts <- base::computeRestarts
[17:26:43.008]                           grepl <- base::grepl
[17:26:43.008]                           restarts <- computeRestarts(cond)
[17:26:43.008]                           for (restart in restarts) {
[17:26:43.008]                             name <- restart$name
[17:26:43.008]                             if (is.null(name)) 
[17:26:43.008]                               next
[17:26:43.008]                             if (!grepl(pattern, name)) 
[17:26:43.008]                               next
[17:26:43.008]                             invokeRestart(restart)
[17:26:43.008]                             muffled <- TRUE
[17:26:43.008]                             break
[17:26:43.008]                           }
[17:26:43.008]                         }
[17:26:43.008]                       }
[17:26:43.008]                       invisible(muffled)
[17:26:43.008]                     }
[17:26:43.008]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.008]                   }
[17:26:43.008]                 }
[17:26:43.008]             }
[17:26:43.008]         }))
[17:26:43.008]     }, error = function(ex) {
[17:26:43.008]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.008]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.008]                 ...future.rng), started = ...future.startTime, 
[17:26:43.008]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.008]             version = "1.8"), class = "FutureResult")
[17:26:43.008]     }, finally = {
[17:26:43.008]         if (!identical(...future.workdir, getwd())) 
[17:26:43.008]             setwd(...future.workdir)
[17:26:43.008]         {
[17:26:43.008]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.008]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.008]             }
[17:26:43.008]             base::options(...future.oldOptions)
[17:26:43.008]             if (.Platform$OS.type == "windows") {
[17:26:43.008]                 old_names <- names(...future.oldEnvVars)
[17:26:43.008]                 envs <- base::Sys.getenv()
[17:26:43.008]                 names <- names(envs)
[17:26:43.008]                 common <- intersect(names, old_names)
[17:26:43.008]                 added <- setdiff(names, old_names)
[17:26:43.008]                 removed <- setdiff(old_names, names)
[17:26:43.008]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.008]                   envs[common]]
[17:26:43.008]                 NAMES <- toupper(changed)
[17:26:43.008]                 args <- list()
[17:26:43.008]                 for (kk in seq_along(NAMES)) {
[17:26:43.008]                   name <- changed[[kk]]
[17:26:43.008]                   NAME <- NAMES[[kk]]
[17:26:43.008]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.008]                     next
[17:26:43.008]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.008]                 }
[17:26:43.008]                 NAMES <- toupper(added)
[17:26:43.008]                 for (kk in seq_along(NAMES)) {
[17:26:43.008]                   name <- added[[kk]]
[17:26:43.008]                   NAME <- NAMES[[kk]]
[17:26:43.008]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.008]                     next
[17:26:43.008]                   args[[name]] <- ""
[17:26:43.008]                 }
[17:26:43.008]                 NAMES <- toupper(removed)
[17:26:43.008]                 for (kk in seq_along(NAMES)) {
[17:26:43.008]                   name <- removed[[kk]]
[17:26:43.008]                   NAME <- NAMES[[kk]]
[17:26:43.008]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.008]                     next
[17:26:43.008]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.008]                 }
[17:26:43.008]                 if (length(args) > 0) 
[17:26:43.008]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.008]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.008]             }
[17:26:43.008]             else {
[17:26:43.008]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.008]             }
[17:26:43.008]             {
[17:26:43.008]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.008]                   0L) {
[17:26:43.008]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.008]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.008]                   base::options(opts)
[17:26:43.008]                 }
[17:26:43.008]                 {
[17:26:43.008]                   {
[17:26:43.008]                     NULL
[17:26:43.008]                     RNGkind("Mersenne-Twister")
[17:26:43.008]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.008]                       inherits = FALSE)
[17:26:43.008]                   }
[17:26:43.008]                   options(future.plan = NULL)
[17:26:43.008]                   if (is.na(NA_character_)) 
[17:26:43.008]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.008]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.008]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.008]                     .init = FALSE)
[17:26:43.008]                 }
[17:26:43.008]             }
[17:26:43.008]         }
[17:26:43.008]     })
[17:26:43.008]     if (TRUE) {
[17:26:43.008]         base::sink(type = "output", split = FALSE)
[17:26:43.008]         if (TRUE) {
[17:26:43.008]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.008]         }
[17:26:43.008]         else {
[17:26:43.008]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.008]         }
[17:26:43.008]         base::close(...future.stdout)
[17:26:43.008]         ...future.stdout <- NULL
[17:26:43.008]     }
[17:26:43.008]     ...future.result$conditions <- ...future.conditions
[17:26:43.008]     ...future.result$finished <- base::Sys.time()
[17:26:43.008]     ...future.result
[17:26:43.008] }
[17:26:43.012] plan(): Setting new future strategy stack:
[17:26:43.012] List of future strategies:
[17:26:43.012] 1. sequential:
[17:26:43.012]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.012]    - tweaked: FALSE
[17:26:43.012]    - call: NULL
[17:26:43.013] plan(): nbrOfWorkers() = 1
[17:26:43.014] plan(): Setting new future strategy stack:
[17:26:43.014] List of future strategies:
[17:26:43.014] 1. sequential:
[17:26:43.014]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.014]    - tweaked: FALSE
[17:26:43.014]    - call: plan(strategy)
[17:26:43.015] plan(): nbrOfWorkers() = 1
[17:26:43.015] SequentialFuture started (and completed)
[17:26:43.015] - Launch lazy future ... done
[17:26:43.015] run() for 'SequentialFuture' ... done
<environment: 0x000002230d3bca40> 
<environment: 0x000002230d5a5648> 
[17:26:43.017] resolved() for 'SequentialFuture' ...
[17:26:43.017] - state: 'finished'
[17:26:43.017] - run: TRUE
[17:26:43.017] - result: 'FutureResult'
[17:26:43.018] resolved() for 'SequentialFuture' ... done
[17:26:43.018] resolved() for 'SequentialFuture' ...
[17:26:43.018] - state: 'finished'
[17:26:43.018] - run: TRUE
[17:26:43.018] - result: 'FutureResult'
[17:26:43.018] resolved() for 'SequentialFuture' ... done
[17:26:43.019] resolved() for 'SequentialFuture' ...
[17:26:43.019] - state: 'finished'
[17:26:43.019] - run: TRUE
[17:26:43.019] - result: 'FutureResult'
[17:26:43.019] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:43.022] resolve() on environment ...
[17:26:43.022]  recursive: 0
[17:26:43.023]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:43.023] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.023] - nx: 4
[17:26:43.023] - relay: TRUE
[17:26:43.023] - stdout: TRUE
[17:26:43.023] - signal: TRUE
[17:26:43.024] - resignal: FALSE
[17:26:43.024] - force: TRUE
[17:26:43.024] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.024] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.024]  - until=2
[17:26:43.024]  - relaying element #2
[17:26:43.025] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.025] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.025] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.025]  length: 3 (resolved future 1)
[17:26:43.025] resolved() for 'SequentialFuture' ...
[17:26:43.025] - state: 'finished'
[17:26:43.026] - run: TRUE
[17:26:43.026] - result: 'FutureResult'
[17:26:43.026] resolved() for 'SequentialFuture' ... done
[17:26:43.026] Future #2
[17:26:43.026] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.026] - nx: 4
[17:26:43.027] - relay: TRUE
[17:26:43.027] - stdout: TRUE
[17:26:43.027] - signal: TRUE
[17:26:43.027] - resignal: FALSE
[17:26:43.027] - force: TRUE
[17:26:43.027] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.028] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.028]  - until=2
[17:26:43.028]  - relaying element #2
[17:26:43.028] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.028] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.028] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.029]  length: 2 (resolved future 2)
[17:26:43.029] resolved() for 'SequentialFuture' ...
[17:26:43.029] - state: 'finished'
[17:26:43.029] - run: TRUE
[17:26:43.029] - result: 'FutureResult'
[17:26:43.030] resolved() for 'SequentialFuture' ... done
[17:26:43.030] Future #3
[17:26:43.030] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.030] - nx: 4
[17:26:43.030] - relay: TRUE
[17:26:43.030] - stdout: TRUE
[17:26:43.031] - signal: TRUE
[17:26:43.031] - resignal: FALSE
[17:26:43.031] - force: TRUE
[17:26:43.031] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.031] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.031]  - until=3
[17:26:43.031]  - relaying element #3
[17:26:43.032] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.032] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.032] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.032]  length: 1 (resolved future 3)
[17:26:43.033] resolved() for 'SequentialFuture' ...
[17:26:43.033] - state: 'finished'
[17:26:43.033] - run: TRUE
[17:26:43.033] - result: 'FutureResult'
[17:26:43.033] resolved() for 'SequentialFuture' ... done
[17:26:43.033] Future #4
[17:26:43.034] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.034] - nx: 4
[17:26:43.034] - relay: TRUE
[17:26:43.034] - stdout: TRUE
[17:26:43.034] - signal: TRUE
[17:26:43.034] - resignal: FALSE
[17:26:43.035] - force: TRUE
[17:26:43.035] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.035] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.035]  - until=4
[17:26:43.035]  - relaying element #4
[17:26:43.035] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.036] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.036] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.036]  length: 0 (resolved future 4)
[17:26:43.036] Relaying remaining futures
[17:26:43.036] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.036] - nx: 4
[17:26:43.037] - relay: TRUE
[17:26:43.037] - stdout: TRUE
[17:26:43.037] - signal: TRUE
[17:26:43.037] - resignal: FALSE
[17:26:43.037] - force: TRUE
[17:26:43.037] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.037] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:43.038] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.038] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.038] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.038] resolve() on environment ... DONE
<environment: 0x000002230d8394c0> 
Dimensions: c(2, 3)
[17:26:43.039] getGlobalsAndPackages() ...
[17:26:43.039] Searching for globals...
[17:26:43.039] 
[17:26:43.040] Searching for globals ... DONE
[17:26:43.040] - globals: [0] <none>
[17:26:43.040] getGlobalsAndPackages() ... DONE
[17:26:43.040] run() for 'Future' ...
[17:26:43.040] - state: 'created'
[17:26:43.041] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.041] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.041] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.041]   - Field: 'label'
[17:26:43.042]   - Field: 'local'
[17:26:43.042]   - Field: 'owner'
[17:26:43.042]   - Field: 'envir'
[17:26:43.042]   - Field: 'packages'
[17:26:43.042]   - Field: 'gc'
[17:26:43.042]   - Field: 'conditions'
[17:26:43.043]   - Field: 'expr'
[17:26:43.043]   - Field: 'uuid'
[17:26:43.043]   - Field: 'seed'
[17:26:43.043]   - Field: 'version'
[17:26:43.043]   - Field: 'result'
[17:26:43.043]   - Field: 'asynchronous'
[17:26:43.044]   - Field: 'calls'
[17:26:43.044]   - Field: 'globals'
[17:26:43.044]   - Field: 'stdout'
[17:26:43.044]   - Field: 'earlySignal'
[17:26:43.044]   - Field: 'lazy'
[17:26:43.044]   - Field: 'state'
[17:26:43.045] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.045] - Launch lazy future ...
[17:26:43.045] Packages needed by the future expression (n = 0): <none>
[17:26:43.045] Packages needed by future strategies (n = 0): <none>
[17:26:43.046] {
[17:26:43.046]     {
[17:26:43.046]         {
[17:26:43.046]             ...future.startTime <- base::Sys.time()
[17:26:43.046]             {
[17:26:43.046]                 {
[17:26:43.046]                   {
[17:26:43.046]                     base::local({
[17:26:43.046]                       has_future <- base::requireNamespace("future", 
[17:26:43.046]                         quietly = TRUE)
[17:26:43.046]                       if (has_future) {
[17:26:43.046]                         ns <- base::getNamespace("future")
[17:26:43.046]                         version <- ns[[".package"]][["version"]]
[17:26:43.046]                         if (is.null(version)) 
[17:26:43.046]                           version <- utils::packageVersion("future")
[17:26:43.046]                       }
[17:26:43.046]                       else {
[17:26:43.046]                         version <- NULL
[17:26:43.046]                       }
[17:26:43.046]                       if (!has_future || version < "1.8.0") {
[17:26:43.046]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.046]                           "", base::R.version$version.string), 
[17:26:43.046]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.046]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.046]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.046]                             "release", "version")], collapse = " "), 
[17:26:43.046]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.046]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.046]                           info)
[17:26:43.046]                         info <- base::paste(info, collapse = "; ")
[17:26:43.046]                         if (!has_future) {
[17:26:43.046]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.046]                             info)
[17:26:43.046]                         }
[17:26:43.046]                         else {
[17:26:43.046]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.046]                             info, version)
[17:26:43.046]                         }
[17:26:43.046]                         base::stop(msg)
[17:26:43.046]                       }
[17:26:43.046]                     })
[17:26:43.046]                   }
[17:26:43.046]                   ...future.strategy.old <- future::plan("list")
[17:26:43.046]                   options(future.plan = NULL)
[17:26:43.046]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.046]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.046]                 }
[17:26:43.046]                 ...future.workdir <- getwd()
[17:26:43.046]             }
[17:26:43.046]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.046]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.046]         }
[17:26:43.046]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.046]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.046]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.046]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.046]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.046]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.046]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.046]             base::names(...future.oldOptions))
[17:26:43.046]     }
[17:26:43.046]     if (FALSE) {
[17:26:43.046]     }
[17:26:43.046]     else {
[17:26:43.046]         if (TRUE) {
[17:26:43.046]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.046]                 open = "w")
[17:26:43.046]         }
[17:26:43.046]         else {
[17:26:43.046]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.046]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.046]         }
[17:26:43.046]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.046]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.046]             base::sink(type = "output", split = FALSE)
[17:26:43.046]             base::close(...future.stdout)
[17:26:43.046]         }, add = TRUE)
[17:26:43.046]     }
[17:26:43.046]     ...future.frame <- base::sys.nframe()
[17:26:43.046]     ...future.conditions <- base::list()
[17:26:43.046]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.046]     if (FALSE) {
[17:26:43.046]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.046]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.046]     }
[17:26:43.046]     ...future.result <- base::tryCatch({
[17:26:43.046]         base::withCallingHandlers({
[17:26:43.046]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.046]             future::FutureResult(value = ...future.value$value, 
[17:26:43.046]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.046]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.046]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.046]                     ...future.globalenv.names))
[17:26:43.046]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.046]         }, condition = base::local({
[17:26:43.046]             c <- base::c
[17:26:43.046]             inherits <- base::inherits
[17:26:43.046]             invokeRestart <- base::invokeRestart
[17:26:43.046]             length <- base::length
[17:26:43.046]             list <- base::list
[17:26:43.046]             seq.int <- base::seq.int
[17:26:43.046]             signalCondition <- base::signalCondition
[17:26:43.046]             sys.calls <- base::sys.calls
[17:26:43.046]             `[[` <- base::`[[`
[17:26:43.046]             `+` <- base::`+`
[17:26:43.046]             `<<-` <- base::`<<-`
[17:26:43.046]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.046]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.046]                   3L)]
[17:26:43.046]             }
[17:26:43.046]             function(cond) {
[17:26:43.046]                 is_error <- inherits(cond, "error")
[17:26:43.046]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.046]                   NULL)
[17:26:43.046]                 if (is_error) {
[17:26:43.046]                   sessionInformation <- function() {
[17:26:43.046]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.046]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.046]                       search = base::search(), system = base::Sys.info())
[17:26:43.046]                   }
[17:26:43.046]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.046]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.046]                     cond$call), session = sessionInformation(), 
[17:26:43.046]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.046]                   signalCondition(cond)
[17:26:43.046]                 }
[17:26:43.046]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.046]                 "immediateCondition"))) {
[17:26:43.046]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.046]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.046]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.046]                   if (TRUE && !signal) {
[17:26:43.046]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.046]                     {
[17:26:43.046]                       inherits <- base::inherits
[17:26:43.046]                       invokeRestart <- base::invokeRestart
[17:26:43.046]                       is.null <- base::is.null
[17:26:43.046]                       muffled <- FALSE
[17:26:43.046]                       if (inherits(cond, "message")) {
[17:26:43.046]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.046]                         if (muffled) 
[17:26:43.046]                           invokeRestart("muffleMessage")
[17:26:43.046]                       }
[17:26:43.046]                       else if (inherits(cond, "warning")) {
[17:26:43.046]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.046]                         if (muffled) 
[17:26:43.046]                           invokeRestart("muffleWarning")
[17:26:43.046]                       }
[17:26:43.046]                       else if (inherits(cond, "condition")) {
[17:26:43.046]                         if (!is.null(pattern)) {
[17:26:43.046]                           computeRestarts <- base::computeRestarts
[17:26:43.046]                           grepl <- base::grepl
[17:26:43.046]                           restarts <- computeRestarts(cond)
[17:26:43.046]                           for (restart in restarts) {
[17:26:43.046]                             name <- restart$name
[17:26:43.046]                             if (is.null(name)) 
[17:26:43.046]                               next
[17:26:43.046]                             if (!grepl(pattern, name)) 
[17:26:43.046]                               next
[17:26:43.046]                             invokeRestart(restart)
[17:26:43.046]                             muffled <- TRUE
[17:26:43.046]                             break
[17:26:43.046]                           }
[17:26:43.046]                         }
[17:26:43.046]                       }
[17:26:43.046]                       invisible(muffled)
[17:26:43.046]                     }
[17:26:43.046]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.046]                   }
[17:26:43.046]                 }
[17:26:43.046]                 else {
[17:26:43.046]                   if (TRUE) {
[17:26:43.046]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.046]                     {
[17:26:43.046]                       inherits <- base::inherits
[17:26:43.046]                       invokeRestart <- base::invokeRestart
[17:26:43.046]                       is.null <- base::is.null
[17:26:43.046]                       muffled <- FALSE
[17:26:43.046]                       if (inherits(cond, "message")) {
[17:26:43.046]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.046]                         if (muffled) 
[17:26:43.046]                           invokeRestart("muffleMessage")
[17:26:43.046]                       }
[17:26:43.046]                       else if (inherits(cond, "warning")) {
[17:26:43.046]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.046]                         if (muffled) 
[17:26:43.046]                           invokeRestart("muffleWarning")
[17:26:43.046]                       }
[17:26:43.046]                       else if (inherits(cond, "condition")) {
[17:26:43.046]                         if (!is.null(pattern)) {
[17:26:43.046]                           computeRestarts <- base::computeRestarts
[17:26:43.046]                           grepl <- base::grepl
[17:26:43.046]                           restarts <- computeRestarts(cond)
[17:26:43.046]                           for (restart in restarts) {
[17:26:43.046]                             name <- restart$name
[17:26:43.046]                             if (is.null(name)) 
[17:26:43.046]                               next
[17:26:43.046]                             if (!grepl(pattern, name)) 
[17:26:43.046]                               next
[17:26:43.046]                             invokeRestart(restart)
[17:26:43.046]                             muffled <- TRUE
[17:26:43.046]                             break
[17:26:43.046]                           }
[17:26:43.046]                         }
[17:26:43.046]                       }
[17:26:43.046]                       invisible(muffled)
[17:26:43.046]                     }
[17:26:43.046]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.046]                   }
[17:26:43.046]                 }
[17:26:43.046]             }
[17:26:43.046]         }))
[17:26:43.046]     }, error = function(ex) {
[17:26:43.046]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.046]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.046]                 ...future.rng), started = ...future.startTime, 
[17:26:43.046]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.046]             version = "1.8"), class = "FutureResult")
[17:26:43.046]     }, finally = {
[17:26:43.046]         if (!identical(...future.workdir, getwd())) 
[17:26:43.046]             setwd(...future.workdir)
[17:26:43.046]         {
[17:26:43.046]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.046]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.046]             }
[17:26:43.046]             base::options(...future.oldOptions)
[17:26:43.046]             if (.Platform$OS.type == "windows") {
[17:26:43.046]                 old_names <- names(...future.oldEnvVars)
[17:26:43.046]                 envs <- base::Sys.getenv()
[17:26:43.046]                 names <- names(envs)
[17:26:43.046]                 common <- intersect(names, old_names)
[17:26:43.046]                 added <- setdiff(names, old_names)
[17:26:43.046]                 removed <- setdiff(old_names, names)
[17:26:43.046]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.046]                   envs[common]]
[17:26:43.046]                 NAMES <- toupper(changed)
[17:26:43.046]                 args <- list()
[17:26:43.046]                 for (kk in seq_along(NAMES)) {
[17:26:43.046]                   name <- changed[[kk]]
[17:26:43.046]                   NAME <- NAMES[[kk]]
[17:26:43.046]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.046]                     next
[17:26:43.046]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.046]                 }
[17:26:43.046]                 NAMES <- toupper(added)
[17:26:43.046]                 for (kk in seq_along(NAMES)) {
[17:26:43.046]                   name <- added[[kk]]
[17:26:43.046]                   NAME <- NAMES[[kk]]
[17:26:43.046]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.046]                     next
[17:26:43.046]                   args[[name]] <- ""
[17:26:43.046]                 }
[17:26:43.046]                 NAMES <- toupper(removed)
[17:26:43.046]                 for (kk in seq_along(NAMES)) {
[17:26:43.046]                   name <- removed[[kk]]
[17:26:43.046]                   NAME <- NAMES[[kk]]
[17:26:43.046]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.046]                     next
[17:26:43.046]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.046]                 }
[17:26:43.046]                 if (length(args) > 0) 
[17:26:43.046]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.046]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.046]             }
[17:26:43.046]             else {
[17:26:43.046]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.046]             }
[17:26:43.046]             {
[17:26:43.046]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.046]                   0L) {
[17:26:43.046]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.046]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.046]                   base::options(opts)
[17:26:43.046]                 }
[17:26:43.046]                 {
[17:26:43.046]                   {
[17:26:43.046]                     NULL
[17:26:43.046]                     RNGkind("Mersenne-Twister")
[17:26:43.046]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.046]                       inherits = FALSE)
[17:26:43.046]                   }
[17:26:43.046]                   options(future.plan = NULL)
[17:26:43.046]                   if (is.na(NA_character_)) 
[17:26:43.046]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.046]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.046]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.046]                     .init = FALSE)
[17:26:43.046]                 }
[17:26:43.046]             }
[17:26:43.046]         }
[17:26:43.046]     })
[17:26:43.046]     if (TRUE) {
[17:26:43.046]         base::sink(type = "output", split = FALSE)
[17:26:43.046]         if (TRUE) {
[17:26:43.046]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.046]         }
[17:26:43.046]         else {
[17:26:43.046]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.046]         }
[17:26:43.046]         base::close(...future.stdout)
[17:26:43.046]         ...future.stdout <- NULL
[17:26:43.046]     }
[17:26:43.046]     ...future.result$conditions <- ...future.conditions
[17:26:43.046]     ...future.result$finished <- base::Sys.time()
[17:26:43.046]     ...future.result
[17:26:43.046] }
[17:26:43.050] plan(): Setting new future strategy stack:
[17:26:43.050] List of future strategies:
[17:26:43.050] 1. sequential:
[17:26:43.050]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.050]    - tweaked: FALSE
[17:26:43.050]    - call: NULL
[17:26:43.051] plan(): nbrOfWorkers() = 1
[17:26:43.052] plan(): Setting new future strategy stack:
[17:26:43.052] List of future strategies:
[17:26:43.052] 1. sequential:
[17:26:43.052]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.052]    - tweaked: FALSE
[17:26:43.052]    - call: plan(strategy)
[17:26:43.052] plan(): nbrOfWorkers() = 1
[17:26:43.053] SequentialFuture started (and completed)
[17:26:43.053] - Launch lazy future ... done
[17:26:43.053] run() for 'SequentialFuture' ... done
[17:26:43.053] getGlobalsAndPackages() ...
[17:26:43.053] Searching for globals...
[17:26:43.054] 
[17:26:43.054] Searching for globals ... DONE
[17:26:43.054] - globals: [0] <none>
[17:26:43.054] getGlobalsAndPackages() ... DONE
[17:26:43.055] run() for 'Future' ...
[17:26:43.055] - state: 'created'
[17:26:43.055] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.056] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.057] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.057]   - Field: 'label'
[17:26:43.057]   - Field: 'local'
[17:26:43.057]   - Field: 'owner'
[17:26:43.057]   - Field: 'envir'
[17:26:43.057]   - Field: 'packages'
[17:26:43.058]   - Field: 'gc'
[17:26:43.058]   - Field: 'conditions'
[17:26:43.058]   - Field: 'expr'
[17:26:43.058]   - Field: 'uuid'
[17:26:43.058]   - Field: 'seed'
[17:26:43.058]   - Field: 'version'
[17:26:43.059]   - Field: 'result'
[17:26:43.059]   - Field: 'asynchronous'
[17:26:43.059]   - Field: 'calls'
[17:26:43.059]   - Field: 'globals'
[17:26:43.059]   - Field: 'stdout'
[17:26:43.060]   - Field: 'earlySignal'
[17:26:43.060]   - Field: 'lazy'
[17:26:43.060]   - Field: 'state'
[17:26:43.060] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.060] - Launch lazy future ...
[17:26:43.060] Packages needed by the future expression (n = 0): <none>
[17:26:43.061] Packages needed by future strategies (n = 0): <none>
[17:26:43.061] {
[17:26:43.061]     {
[17:26:43.061]         {
[17:26:43.061]             ...future.startTime <- base::Sys.time()
[17:26:43.061]             {
[17:26:43.061]                 {
[17:26:43.061]                   {
[17:26:43.061]                     base::local({
[17:26:43.061]                       has_future <- base::requireNamespace("future", 
[17:26:43.061]                         quietly = TRUE)
[17:26:43.061]                       if (has_future) {
[17:26:43.061]                         ns <- base::getNamespace("future")
[17:26:43.061]                         version <- ns[[".package"]][["version"]]
[17:26:43.061]                         if (is.null(version)) 
[17:26:43.061]                           version <- utils::packageVersion("future")
[17:26:43.061]                       }
[17:26:43.061]                       else {
[17:26:43.061]                         version <- NULL
[17:26:43.061]                       }
[17:26:43.061]                       if (!has_future || version < "1.8.0") {
[17:26:43.061]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.061]                           "", base::R.version$version.string), 
[17:26:43.061]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.061]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.061]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.061]                             "release", "version")], collapse = " "), 
[17:26:43.061]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.061]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.061]                           info)
[17:26:43.061]                         info <- base::paste(info, collapse = "; ")
[17:26:43.061]                         if (!has_future) {
[17:26:43.061]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.061]                             info)
[17:26:43.061]                         }
[17:26:43.061]                         else {
[17:26:43.061]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.061]                             info, version)
[17:26:43.061]                         }
[17:26:43.061]                         base::stop(msg)
[17:26:43.061]                       }
[17:26:43.061]                     })
[17:26:43.061]                   }
[17:26:43.061]                   ...future.strategy.old <- future::plan("list")
[17:26:43.061]                   options(future.plan = NULL)
[17:26:43.061]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.061]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.061]                 }
[17:26:43.061]                 ...future.workdir <- getwd()
[17:26:43.061]             }
[17:26:43.061]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.061]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.061]         }
[17:26:43.061]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.061]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.061]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.061]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.061]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.061]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.061]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.061]             base::names(...future.oldOptions))
[17:26:43.061]     }
[17:26:43.061]     if (FALSE) {
[17:26:43.061]     }
[17:26:43.061]     else {
[17:26:43.061]         if (TRUE) {
[17:26:43.061]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.061]                 open = "w")
[17:26:43.061]         }
[17:26:43.061]         else {
[17:26:43.061]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.061]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.061]         }
[17:26:43.061]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.061]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.061]             base::sink(type = "output", split = FALSE)
[17:26:43.061]             base::close(...future.stdout)
[17:26:43.061]         }, add = TRUE)
[17:26:43.061]     }
[17:26:43.061]     ...future.frame <- base::sys.nframe()
[17:26:43.061]     ...future.conditions <- base::list()
[17:26:43.061]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.061]     if (FALSE) {
[17:26:43.061]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.061]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.061]     }
[17:26:43.061]     ...future.result <- base::tryCatch({
[17:26:43.061]         base::withCallingHandlers({
[17:26:43.061]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.061]             future::FutureResult(value = ...future.value$value, 
[17:26:43.061]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.061]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.061]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.061]                     ...future.globalenv.names))
[17:26:43.061]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.061]         }, condition = base::local({
[17:26:43.061]             c <- base::c
[17:26:43.061]             inherits <- base::inherits
[17:26:43.061]             invokeRestart <- base::invokeRestart
[17:26:43.061]             length <- base::length
[17:26:43.061]             list <- base::list
[17:26:43.061]             seq.int <- base::seq.int
[17:26:43.061]             signalCondition <- base::signalCondition
[17:26:43.061]             sys.calls <- base::sys.calls
[17:26:43.061]             `[[` <- base::`[[`
[17:26:43.061]             `+` <- base::`+`
[17:26:43.061]             `<<-` <- base::`<<-`
[17:26:43.061]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.061]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.061]                   3L)]
[17:26:43.061]             }
[17:26:43.061]             function(cond) {
[17:26:43.061]                 is_error <- inherits(cond, "error")
[17:26:43.061]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.061]                   NULL)
[17:26:43.061]                 if (is_error) {
[17:26:43.061]                   sessionInformation <- function() {
[17:26:43.061]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.061]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.061]                       search = base::search(), system = base::Sys.info())
[17:26:43.061]                   }
[17:26:43.061]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.061]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.061]                     cond$call), session = sessionInformation(), 
[17:26:43.061]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.061]                   signalCondition(cond)
[17:26:43.061]                 }
[17:26:43.061]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.061]                 "immediateCondition"))) {
[17:26:43.061]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.061]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.061]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.061]                   if (TRUE && !signal) {
[17:26:43.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.061]                     {
[17:26:43.061]                       inherits <- base::inherits
[17:26:43.061]                       invokeRestart <- base::invokeRestart
[17:26:43.061]                       is.null <- base::is.null
[17:26:43.061]                       muffled <- FALSE
[17:26:43.061]                       if (inherits(cond, "message")) {
[17:26:43.061]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.061]                         if (muffled) 
[17:26:43.061]                           invokeRestart("muffleMessage")
[17:26:43.061]                       }
[17:26:43.061]                       else if (inherits(cond, "warning")) {
[17:26:43.061]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.061]                         if (muffled) 
[17:26:43.061]                           invokeRestart("muffleWarning")
[17:26:43.061]                       }
[17:26:43.061]                       else if (inherits(cond, "condition")) {
[17:26:43.061]                         if (!is.null(pattern)) {
[17:26:43.061]                           computeRestarts <- base::computeRestarts
[17:26:43.061]                           grepl <- base::grepl
[17:26:43.061]                           restarts <- computeRestarts(cond)
[17:26:43.061]                           for (restart in restarts) {
[17:26:43.061]                             name <- restart$name
[17:26:43.061]                             if (is.null(name)) 
[17:26:43.061]                               next
[17:26:43.061]                             if (!grepl(pattern, name)) 
[17:26:43.061]                               next
[17:26:43.061]                             invokeRestart(restart)
[17:26:43.061]                             muffled <- TRUE
[17:26:43.061]                             break
[17:26:43.061]                           }
[17:26:43.061]                         }
[17:26:43.061]                       }
[17:26:43.061]                       invisible(muffled)
[17:26:43.061]                     }
[17:26:43.061]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.061]                   }
[17:26:43.061]                 }
[17:26:43.061]                 else {
[17:26:43.061]                   if (TRUE) {
[17:26:43.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.061]                     {
[17:26:43.061]                       inherits <- base::inherits
[17:26:43.061]                       invokeRestart <- base::invokeRestart
[17:26:43.061]                       is.null <- base::is.null
[17:26:43.061]                       muffled <- FALSE
[17:26:43.061]                       if (inherits(cond, "message")) {
[17:26:43.061]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.061]                         if (muffled) 
[17:26:43.061]                           invokeRestart("muffleMessage")
[17:26:43.061]                       }
[17:26:43.061]                       else if (inherits(cond, "warning")) {
[17:26:43.061]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.061]                         if (muffled) 
[17:26:43.061]                           invokeRestart("muffleWarning")
[17:26:43.061]                       }
[17:26:43.061]                       else if (inherits(cond, "condition")) {
[17:26:43.061]                         if (!is.null(pattern)) {
[17:26:43.061]                           computeRestarts <- base::computeRestarts
[17:26:43.061]                           grepl <- base::grepl
[17:26:43.061]                           restarts <- computeRestarts(cond)
[17:26:43.061]                           for (restart in restarts) {
[17:26:43.061]                             name <- restart$name
[17:26:43.061]                             if (is.null(name)) 
[17:26:43.061]                               next
[17:26:43.061]                             if (!grepl(pattern, name)) 
[17:26:43.061]                               next
[17:26:43.061]                             invokeRestart(restart)
[17:26:43.061]                             muffled <- TRUE
[17:26:43.061]                             break
[17:26:43.061]                           }
[17:26:43.061]                         }
[17:26:43.061]                       }
[17:26:43.061]                       invisible(muffled)
[17:26:43.061]                     }
[17:26:43.061]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.061]                   }
[17:26:43.061]                 }
[17:26:43.061]             }
[17:26:43.061]         }))
[17:26:43.061]     }, error = function(ex) {
[17:26:43.061]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.061]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.061]                 ...future.rng), started = ...future.startTime, 
[17:26:43.061]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.061]             version = "1.8"), class = "FutureResult")
[17:26:43.061]     }, finally = {
[17:26:43.061]         if (!identical(...future.workdir, getwd())) 
[17:26:43.061]             setwd(...future.workdir)
[17:26:43.061]         {
[17:26:43.061]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.061]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.061]             }
[17:26:43.061]             base::options(...future.oldOptions)
[17:26:43.061]             if (.Platform$OS.type == "windows") {
[17:26:43.061]                 old_names <- names(...future.oldEnvVars)
[17:26:43.061]                 envs <- base::Sys.getenv()
[17:26:43.061]                 names <- names(envs)
[17:26:43.061]                 common <- intersect(names, old_names)
[17:26:43.061]                 added <- setdiff(names, old_names)
[17:26:43.061]                 removed <- setdiff(old_names, names)
[17:26:43.061]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.061]                   envs[common]]
[17:26:43.061]                 NAMES <- toupper(changed)
[17:26:43.061]                 args <- list()
[17:26:43.061]                 for (kk in seq_along(NAMES)) {
[17:26:43.061]                   name <- changed[[kk]]
[17:26:43.061]                   NAME <- NAMES[[kk]]
[17:26:43.061]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.061]                     next
[17:26:43.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.061]                 }
[17:26:43.061]                 NAMES <- toupper(added)
[17:26:43.061]                 for (kk in seq_along(NAMES)) {
[17:26:43.061]                   name <- added[[kk]]
[17:26:43.061]                   NAME <- NAMES[[kk]]
[17:26:43.061]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.061]                     next
[17:26:43.061]                   args[[name]] <- ""
[17:26:43.061]                 }
[17:26:43.061]                 NAMES <- toupper(removed)
[17:26:43.061]                 for (kk in seq_along(NAMES)) {
[17:26:43.061]                   name <- removed[[kk]]
[17:26:43.061]                   NAME <- NAMES[[kk]]
[17:26:43.061]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.061]                     next
[17:26:43.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.061]                 }
[17:26:43.061]                 if (length(args) > 0) 
[17:26:43.061]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.061]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.061]             }
[17:26:43.061]             else {
[17:26:43.061]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.061]             }
[17:26:43.061]             {
[17:26:43.061]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.061]                   0L) {
[17:26:43.061]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.061]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.061]                   base::options(opts)
[17:26:43.061]                 }
[17:26:43.061]                 {
[17:26:43.061]                   {
[17:26:43.061]                     NULL
[17:26:43.061]                     RNGkind("Mersenne-Twister")
[17:26:43.061]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.061]                       inherits = FALSE)
[17:26:43.061]                   }
[17:26:43.061]                   options(future.plan = NULL)
[17:26:43.061]                   if (is.na(NA_character_)) 
[17:26:43.061]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.061]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.061]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.061]                     .init = FALSE)
[17:26:43.061]                 }
[17:26:43.061]             }
[17:26:43.061]         }
[17:26:43.061]     })
[17:26:43.061]     if (TRUE) {
[17:26:43.061]         base::sink(type = "output", split = FALSE)
[17:26:43.061]         if (TRUE) {
[17:26:43.061]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.061]         }
[17:26:43.061]         else {
[17:26:43.061]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.061]         }
[17:26:43.061]         base::close(...future.stdout)
[17:26:43.061]         ...future.stdout <- NULL
[17:26:43.061]     }
[17:26:43.061]     ...future.result$conditions <- ...future.conditions
[17:26:43.061]     ...future.result$finished <- base::Sys.time()
[17:26:43.061]     ...future.result
[17:26:43.061] }
[17:26:43.065] plan(): Setting new future strategy stack:
[17:26:43.065] List of future strategies:
[17:26:43.065] 1. sequential:
[17:26:43.065]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.065]    - tweaked: FALSE
[17:26:43.065]    - call: NULL
[17:26:43.066] plan(): nbrOfWorkers() = 1
[17:26:43.067] plan(): Setting new future strategy stack:
[17:26:43.067] List of future strategies:
[17:26:43.067] 1. sequential:
[17:26:43.067]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.067]    - tweaked: FALSE
[17:26:43.067]    - call: plan(strategy)
[17:26:43.068] plan(): nbrOfWorkers() = 1
[17:26:43.068] SequentialFuture started (and completed)
[17:26:43.068] - Launch lazy future ... done
[17:26:43.068] run() for 'SequentialFuture' ... done
[17:26:43.069] getGlobalsAndPackages() ...
[17:26:43.069] Searching for globals...
[17:26:43.070] - globals found: [1] '{'
[17:26:43.070] Searching for globals ... DONE
[17:26:43.070] Resolving globals: FALSE
[17:26:43.070] 
[17:26:43.070] 
[17:26:43.071] getGlobalsAndPackages() ... DONE
[17:26:43.071] run() for 'Future' ...
[17:26:43.071] - state: 'created'
[17:26:43.071] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.072] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.072] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.072]   - Field: 'label'
[17:26:43.072]   - Field: 'local'
[17:26:43.072]   - Field: 'owner'
[17:26:43.073]   - Field: 'envir'
[17:26:43.073]   - Field: 'packages'
[17:26:43.073]   - Field: 'gc'
[17:26:43.073]   - Field: 'conditions'
[17:26:43.073]   - Field: 'expr'
[17:26:43.073]   - Field: 'uuid'
[17:26:43.074]   - Field: 'seed'
[17:26:43.074]   - Field: 'version'
[17:26:43.074]   - Field: 'result'
[17:26:43.074]   - Field: 'asynchronous'
[17:26:43.074]   - Field: 'calls'
[17:26:43.074]   - Field: 'globals'
[17:26:43.075]   - Field: 'stdout'
[17:26:43.075]   - Field: 'earlySignal'
[17:26:43.075]   - Field: 'lazy'
[17:26:43.075]   - Field: 'state'
[17:26:43.075] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.076] - Launch lazy future ...
[17:26:43.076] Packages needed by the future expression (n = 0): <none>
[17:26:43.076] Packages needed by future strategies (n = 0): <none>
[17:26:43.076] {
[17:26:43.076]     {
[17:26:43.076]         {
[17:26:43.076]             ...future.startTime <- base::Sys.time()
[17:26:43.076]             {
[17:26:43.076]                 {
[17:26:43.076]                   {
[17:26:43.076]                     base::local({
[17:26:43.076]                       has_future <- base::requireNamespace("future", 
[17:26:43.076]                         quietly = TRUE)
[17:26:43.076]                       if (has_future) {
[17:26:43.076]                         ns <- base::getNamespace("future")
[17:26:43.076]                         version <- ns[[".package"]][["version"]]
[17:26:43.076]                         if (is.null(version)) 
[17:26:43.076]                           version <- utils::packageVersion("future")
[17:26:43.076]                       }
[17:26:43.076]                       else {
[17:26:43.076]                         version <- NULL
[17:26:43.076]                       }
[17:26:43.076]                       if (!has_future || version < "1.8.0") {
[17:26:43.076]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.076]                           "", base::R.version$version.string), 
[17:26:43.076]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.076]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.076]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.076]                             "release", "version")], collapse = " "), 
[17:26:43.076]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.076]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.076]                           info)
[17:26:43.076]                         info <- base::paste(info, collapse = "; ")
[17:26:43.076]                         if (!has_future) {
[17:26:43.076]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.076]                             info)
[17:26:43.076]                         }
[17:26:43.076]                         else {
[17:26:43.076]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.076]                             info, version)
[17:26:43.076]                         }
[17:26:43.076]                         base::stop(msg)
[17:26:43.076]                       }
[17:26:43.076]                     })
[17:26:43.076]                   }
[17:26:43.076]                   ...future.strategy.old <- future::plan("list")
[17:26:43.076]                   options(future.plan = NULL)
[17:26:43.076]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.076]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.076]                 }
[17:26:43.076]                 ...future.workdir <- getwd()
[17:26:43.076]             }
[17:26:43.076]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.076]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.076]         }
[17:26:43.076]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.076]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.076]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.076]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.076]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.076]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.076]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.076]             base::names(...future.oldOptions))
[17:26:43.076]     }
[17:26:43.076]     if (FALSE) {
[17:26:43.076]     }
[17:26:43.076]     else {
[17:26:43.076]         if (TRUE) {
[17:26:43.076]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.076]                 open = "w")
[17:26:43.076]         }
[17:26:43.076]         else {
[17:26:43.076]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.076]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.076]         }
[17:26:43.076]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.076]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.076]             base::sink(type = "output", split = FALSE)
[17:26:43.076]             base::close(...future.stdout)
[17:26:43.076]         }, add = TRUE)
[17:26:43.076]     }
[17:26:43.076]     ...future.frame <- base::sys.nframe()
[17:26:43.076]     ...future.conditions <- base::list()
[17:26:43.076]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.076]     if (FALSE) {
[17:26:43.076]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.076]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.076]     }
[17:26:43.076]     ...future.result <- base::tryCatch({
[17:26:43.076]         base::withCallingHandlers({
[17:26:43.076]             ...future.value <- base::withVisible(base::local({
[17:26:43.076]                 4
[17:26:43.076]             }))
[17:26:43.076]             future::FutureResult(value = ...future.value$value, 
[17:26:43.076]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.076]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.076]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.076]                     ...future.globalenv.names))
[17:26:43.076]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.076]         }, condition = base::local({
[17:26:43.076]             c <- base::c
[17:26:43.076]             inherits <- base::inherits
[17:26:43.076]             invokeRestart <- base::invokeRestart
[17:26:43.076]             length <- base::length
[17:26:43.076]             list <- base::list
[17:26:43.076]             seq.int <- base::seq.int
[17:26:43.076]             signalCondition <- base::signalCondition
[17:26:43.076]             sys.calls <- base::sys.calls
[17:26:43.076]             `[[` <- base::`[[`
[17:26:43.076]             `+` <- base::`+`
[17:26:43.076]             `<<-` <- base::`<<-`
[17:26:43.076]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.076]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.076]                   3L)]
[17:26:43.076]             }
[17:26:43.076]             function(cond) {
[17:26:43.076]                 is_error <- inherits(cond, "error")
[17:26:43.076]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.076]                   NULL)
[17:26:43.076]                 if (is_error) {
[17:26:43.076]                   sessionInformation <- function() {
[17:26:43.076]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.076]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.076]                       search = base::search(), system = base::Sys.info())
[17:26:43.076]                   }
[17:26:43.076]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.076]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.076]                     cond$call), session = sessionInformation(), 
[17:26:43.076]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.076]                   signalCondition(cond)
[17:26:43.076]                 }
[17:26:43.076]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.076]                 "immediateCondition"))) {
[17:26:43.076]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.076]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.076]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.076]                   if (TRUE && !signal) {
[17:26:43.076]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.076]                     {
[17:26:43.076]                       inherits <- base::inherits
[17:26:43.076]                       invokeRestart <- base::invokeRestart
[17:26:43.076]                       is.null <- base::is.null
[17:26:43.076]                       muffled <- FALSE
[17:26:43.076]                       if (inherits(cond, "message")) {
[17:26:43.076]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.076]                         if (muffled) 
[17:26:43.076]                           invokeRestart("muffleMessage")
[17:26:43.076]                       }
[17:26:43.076]                       else if (inherits(cond, "warning")) {
[17:26:43.076]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.076]                         if (muffled) 
[17:26:43.076]                           invokeRestart("muffleWarning")
[17:26:43.076]                       }
[17:26:43.076]                       else if (inherits(cond, "condition")) {
[17:26:43.076]                         if (!is.null(pattern)) {
[17:26:43.076]                           computeRestarts <- base::computeRestarts
[17:26:43.076]                           grepl <- base::grepl
[17:26:43.076]                           restarts <- computeRestarts(cond)
[17:26:43.076]                           for (restart in restarts) {
[17:26:43.076]                             name <- restart$name
[17:26:43.076]                             if (is.null(name)) 
[17:26:43.076]                               next
[17:26:43.076]                             if (!grepl(pattern, name)) 
[17:26:43.076]                               next
[17:26:43.076]                             invokeRestart(restart)
[17:26:43.076]                             muffled <- TRUE
[17:26:43.076]                             break
[17:26:43.076]                           }
[17:26:43.076]                         }
[17:26:43.076]                       }
[17:26:43.076]                       invisible(muffled)
[17:26:43.076]                     }
[17:26:43.076]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.076]                   }
[17:26:43.076]                 }
[17:26:43.076]                 else {
[17:26:43.076]                   if (TRUE) {
[17:26:43.076]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.076]                     {
[17:26:43.076]                       inherits <- base::inherits
[17:26:43.076]                       invokeRestart <- base::invokeRestart
[17:26:43.076]                       is.null <- base::is.null
[17:26:43.076]                       muffled <- FALSE
[17:26:43.076]                       if (inherits(cond, "message")) {
[17:26:43.076]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.076]                         if (muffled) 
[17:26:43.076]                           invokeRestart("muffleMessage")
[17:26:43.076]                       }
[17:26:43.076]                       else if (inherits(cond, "warning")) {
[17:26:43.076]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.076]                         if (muffled) 
[17:26:43.076]                           invokeRestart("muffleWarning")
[17:26:43.076]                       }
[17:26:43.076]                       else if (inherits(cond, "condition")) {
[17:26:43.076]                         if (!is.null(pattern)) {
[17:26:43.076]                           computeRestarts <- base::computeRestarts
[17:26:43.076]                           grepl <- base::grepl
[17:26:43.076]                           restarts <- computeRestarts(cond)
[17:26:43.076]                           for (restart in restarts) {
[17:26:43.076]                             name <- restart$name
[17:26:43.076]                             if (is.null(name)) 
[17:26:43.076]                               next
[17:26:43.076]                             if (!grepl(pattern, name)) 
[17:26:43.076]                               next
[17:26:43.076]                             invokeRestart(restart)
[17:26:43.076]                             muffled <- TRUE
[17:26:43.076]                             break
[17:26:43.076]                           }
[17:26:43.076]                         }
[17:26:43.076]                       }
[17:26:43.076]                       invisible(muffled)
[17:26:43.076]                     }
[17:26:43.076]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.076]                   }
[17:26:43.076]                 }
[17:26:43.076]             }
[17:26:43.076]         }))
[17:26:43.076]     }, error = function(ex) {
[17:26:43.076]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.076]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.076]                 ...future.rng), started = ...future.startTime, 
[17:26:43.076]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.076]             version = "1.8"), class = "FutureResult")
[17:26:43.076]     }, finally = {
[17:26:43.076]         if (!identical(...future.workdir, getwd())) 
[17:26:43.076]             setwd(...future.workdir)
[17:26:43.076]         {
[17:26:43.076]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.076]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.076]             }
[17:26:43.076]             base::options(...future.oldOptions)
[17:26:43.076]             if (.Platform$OS.type == "windows") {
[17:26:43.076]                 old_names <- names(...future.oldEnvVars)
[17:26:43.076]                 envs <- base::Sys.getenv()
[17:26:43.076]                 names <- names(envs)
[17:26:43.076]                 common <- intersect(names, old_names)
[17:26:43.076]                 added <- setdiff(names, old_names)
[17:26:43.076]                 removed <- setdiff(old_names, names)
[17:26:43.076]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.076]                   envs[common]]
[17:26:43.076]                 NAMES <- toupper(changed)
[17:26:43.076]                 args <- list()
[17:26:43.076]                 for (kk in seq_along(NAMES)) {
[17:26:43.076]                   name <- changed[[kk]]
[17:26:43.076]                   NAME <- NAMES[[kk]]
[17:26:43.076]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.076]                     next
[17:26:43.076]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.076]                 }
[17:26:43.076]                 NAMES <- toupper(added)
[17:26:43.076]                 for (kk in seq_along(NAMES)) {
[17:26:43.076]                   name <- added[[kk]]
[17:26:43.076]                   NAME <- NAMES[[kk]]
[17:26:43.076]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.076]                     next
[17:26:43.076]                   args[[name]] <- ""
[17:26:43.076]                 }
[17:26:43.076]                 NAMES <- toupper(removed)
[17:26:43.076]                 for (kk in seq_along(NAMES)) {
[17:26:43.076]                   name <- removed[[kk]]
[17:26:43.076]                   NAME <- NAMES[[kk]]
[17:26:43.076]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.076]                     next
[17:26:43.076]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.076]                 }
[17:26:43.076]                 if (length(args) > 0) 
[17:26:43.076]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.076]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.076]             }
[17:26:43.076]             else {
[17:26:43.076]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.076]             }
[17:26:43.076]             {
[17:26:43.076]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.076]                   0L) {
[17:26:43.076]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.076]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.076]                   base::options(opts)
[17:26:43.076]                 }
[17:26:43.076]                 {
[17:26:43.076]                   {
[17:26:43.076]                     NULL
[17:26:43.076]                     RNGkind("Mersenne-Twister")
[17:26:43.076]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.076]                       inherits = FALSE)
[17:26:43.076]                   }
[17:26:43.076]                   options(future.plan = NULL)
[17:26:43.076]                   if (is.na(NA_character_)) 
[17:26:43.076]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.076]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.076]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.076]                     .init = FALSE)
[17:26:43.076]                 }
[17:26:43.076]             }
[17:26:43.076]         }
[17:26:43.076]     })
[17:26:43.076]     if (TRUE) {
[17:26:43.076]         base::sink(type = "output", split = FALSE)
[17:26:43.076]         if (TRUE) {
[17:26:43.076]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.076]         }
[17:26:43.076]         else {
[17:26:43.076]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.076]         }
[17:26:43.076]         base::close(...future.stdout)
[17:26:43.076]         ...future.stdout <- NULL
[17:26:43.076]     }
[17:26:43.076]     ...future.result$conditions <- ...future.conditions
[17:26:43.076]     ...future.result$finished <- base::Sys.time()
[17:26:43.076]     ...future.result
[17:26:43.076] }
[17:26:43.080] plan(): Setting new future strategy stack:
[17:26:43.081] List of future strategies:
[17:26:43.081] 1. sequential:
[17:26:43.081]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.081]    - tweaked: FALSE
[17:26:43.081]    - call: NULL
[17:26:43.081] plan(): nbrOfWorkers() = 1
[17:26:43.082] plan(): Setting new future strategy stack:
[17:26:43.083] List of future strategies:
[17:26:43.083] 1. sequential:
[17:26:43.083]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.083]    - tweaked: FALSE
[17:26:43.083]    - call: plan(strategy)
[17:26:43.083] plan(): nbrOfWorkers() = 1
[17:26:43.083] SequentialFuture started (and completed)
[17:26:43.084] - Launch lazy future ... done
[17:26:43.084] run() for 'SequentialFuture' ... done
<environment: 0x000002230ce35bf8> 
<environment: 0x000002230d474610> 
[17:26:43.085] resolved() for 'SequentialFuture' ...
[17:26:43.085] - state: 'finished'
[17:26:43.086] - run: TRUE
[17:26:43.086] - result: 'FutureResult'
[17:26:43.086] resolved() for 'SequentialFuture' ... done
[17:26:43.086] resolved() for 'SequentialFuture' ...
[17:26:43.086] - state: 'finished'
[17:26:43.087] - run: TRUE
[17:26:43.087] - result: 'FutureResult'
[17:26:43.087] resolved() for 'SequentialFuture' ... done
[17:26:43.087] resolved() for 'SequentialFuture' ...
[17:26:43.087] - state: 'finished'
[17:26:43.087] - run: TRUE
[17:26:43.088] - result: 'FutureResult'
[17:26:43.088] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:43.089] resolve() on environment ...
[17:26:43.089]  recursive: 0
[17:26:43.090]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:43.090] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.090] - nx: 4
[17:26:43.091] - relay: TRUE
[17:26:43.091] - stdout: TRUE
[17:26:43.091] - signal: TRUE
[17:26:43.091] - resignal: FALSE
[17:26:43.091] - force: TRUE
[17:26:43.091] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.091] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.092]  - until=2
[17:26:43.093]  - relaying element #2
[17:26:43.093] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.093] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.093] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.093]  length: 3 (resolved future 1)
[17:26:43.094] resolved() for 'SequentialFuture' ...
[17:26:43.094] - state: 'finished'
[17:26:43.094] - run: TRUE
[17:26:43.094] - result: 'FutureResult'
[17:26:43.094] resolved() for 'SequentialFuture' ... done
[17:26:43.095] Future #2
[17:26:43.095] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.095] - nx: 4
[17:26:43.095] - relay: TRUE
[17:26:43.095] - stdout: TRUE
[17:26:43.095] - signal: TRUE
[17:26:43.096] - resignal: FALSE
[17:26:43.096] - force: TRUE
[17:26:43.096] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.096] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.096]  - until=2
[17:26:43.096]  - relaying element #2
[17:26:43.097] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.097] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.097] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.097]  length: 2 (resolved future 2)
[17:26:43.097] resolved() for 'SequentialFuture' ...
[17:26:43.098] - state: 'finished'
[17:26:43.098] - run: TRUE
[17:26:43.098] - result: 'FutureResult'
[17:26:43.098] resolved() for 'SequentialFuture' ... done
[17:26:43.098] Future #3
[17:26:43.098] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.099] - nx: 4
[17:26:43.099] - relay: TRUE
[17:26:43.099] - stdout: TRUE
[17:26:43.099] - signal: TRUE
[17:26:43.099] - resignal: FALSE
[17:26:43.099] - force: TRUE
[17:26:43.099] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.100] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.100]  - until=3
[17:26:43.100]  - relaying element #3
[17:26:43.100] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.100] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.101] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.101]  length: 1 (resolved future 3)
[17:26:43.101] resolved() for 'SequentialFuture' ...
[17:26:43.101] - state: 'finished'
[17:26:43.101] - run: TRUE
[17:26:43.101] - result: 'FutureResult'
[17:26:43.102] resolved() for 'SequentialFuture' ... done
[17:26:43.102] Future #4
[17:26:43.102] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.102] - nx: 4
[17:26:43.102] - relay: TRUE
[17:26:43.102] - stdout: TRUE
[17:26:43.103] - signal: TRUE
[17:26:43.103] - resignal: FALSE
[17:26:43.103] - force: TRUE
[17:26:43.103] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.103] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.103]  - until=4
[17:26:43.104]  - relaying element #4
[17:26:43.104] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.104] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.104] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.104]  length: 0 (resolved future 4)
[17:26:43.104] Relaying remaining futures
[17:26:43.105] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.105] - nx: 4
[17:26:43.105] - relay: TRUE
[17:26:43.105] - stdout: TRUE
[17:26:43.105] - signal: TRUE
[17:26:43.105] - resignal: FALSE
[17:26:43.106] - force: TRUE
[17:26:43.106] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.106] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:43.106] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.106] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.106] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.107] resolve() on environment ... DONE
<environment: 0x000002230d691e60> 
Dimensions: c(2, 3, 1)
[17:26:43.107] getGlobalsAndPackages() ...
[17:26:43.107] Searching for globals...
[17:26:43.108] 
[17:26:43.108] Searching for globals ... DONE
[17:26:43.108] - globals: [0] <none>
[17:26:43.108] getGlobalsAndPackages() ... DONE
[17:26:43.109] run() for 'Future' ...
[17:26:43.109] - state: 'created'
[17:26:43.109] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.109] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.110] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.110]   - Field: 'label'
[17:26:43.110]   - Field: 'local'
[17:26:43.110]   - Field: 'owner'
[17:26:43.110]   - Field: 'envir'
[17:26:43.110]   - Field: 'packages'
[17:26:43.111]   - Field: 'gc'
[17:26:43.111]   - Field: 'conditions'
[17:26:43.111]   - Field: 'expr'
[17:26:43.111]   - Field: 'uuid'
[17:26:43.111]   - Field: 'seed'
[17:26:43.111]   - Field: 'version'
[17:26:43.112]   - Field: 'result'
[17:26:43.112]   - Field: 'asynchronous'
[17:26:43.112]   - Field: 'calls'
[17:26:43.112]   - Field: 'globals'
[17:26:43.112]   - Field: 'stdout'
[17:26:43.112]   - Field: 'earlySignal'
[17:26:43.113]   - Field: 'lazy'
[17:26:43.113]   - Field: 'state'
[17:26:43.113] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.113] - Launch lazy future ...
[17:26:43.113] Packages needed by the future expression (n = 0): <none>
[17:26:43.114] Packages needed by future strategies (n = 0): <none>
[17:26:43.114] {
[17:26:43.114]     {
[17:26:43.114]         {
[17:26:43.114]             ...future.startTime <- base::Sys.time()
[17:26:43.114]             {
[17:26:43.114]                 {
[17:26:43.114]                   {
[17:26:43.114]                     base::local({
[17:26:43.114]                       has_future <- base::requireNamespace("future", 
[17:26:43.114]                         quietly = TRUE)
[17:26:43.114]                       if (has_future) {
[17:26:43.114]                         ns <- base::getNamespace("future")
[17:26:43.114]                         version <- ns[[".package"]][["version"]]
[17:26:43.114]                         if (is.null(version)) 
[17:26:43.114]                           version <- utils::packageVersion("future")
[17:26:43.114]                       }
[17:26:43.114]                       else {
[17:26:43.114]                         version <- NULL
[17:26:43.114]                       }
[17:26:43.114]                       if (!has_future || version < "1.8.0") {
[17:26:43.114]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.114]                           "", base::R.version$version.string), 
[17:26:43.114]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.114]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.114]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.114]                             "release", "version")], collapse = " "), 
[17:26:43.114]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.114]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.114]                           info)
[17:26:43.114]                         info <- base::paste(info, collapse = "; ")
[17:26:43.114]                         if (!has_future) {
[17:26:43.114]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.114]                             info)
[17:26:43.114]                         }
[17:26:43.114]                         else {
[17:26:43.114]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.114]                             info, version)
[17:26:43.114]                         }
[17:26:43.114]                         base::stop(msg)
[17:26:43.114]                       }
[17:26:43.114]                     })
[17:26:43.114]                   }
[17:26:43.114]                   ...future.strategy.old <- future::plan("list")
[17:26:43.114]                   options(future.plan = NULL)
[17:26:43.114]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.114]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.114]                 }
[17:26:43.114]                 ...future.workdir <- getwd()
[17:26:43.114]             }
[17:26:43.114]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.114]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.114]         }
[17:26:43.114]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.114]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.114]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.114]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.114]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.114]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.114]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.114]             base::names(...future.oldOptions))
[17:26:43.114]     }
[17:26:43.114]     if (FALSE) {
[17:26:43.114]     }
[17:26:43.114]     else {
[17:26:43.114]         if (TRUE) {
[17:26:43.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.114]                 open = "w")
[17:26:43.114]         }
[17:26:43.114]         else {
[17:26:43.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.114]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.114]         }
[17:26:43.114]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.114]             base::sink(type = "output", split = FALSE)
[17:26:43.114]             base::close(...future.stdout)
[17:26:43.114]         }, add = TRUE)
[17:26:43.114]     }
[17:26:43.114]     ...future.frame <- base::sys.nframe()
[17:26:43.114]     ...future.conditions <- base::list()
[17:26:43.114]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.114]     if (FALSE) {
[17:26:43.114]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.114]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.114]     }
[17:26:43.114]     ...future.result <- base::tryCatch({
[17:26:43.114]         base::withCallingHandlers({
[17:26:43.114]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.114]             future::FutureResult(value = ...future.value$value, 
[17:26:43.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.114]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.114]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.114]                     ...future.globalenv.names))
[17:26:43.114]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.114]         }, condition = base::local({
[17:26:43.114]             c <- base::c
[17:26:43.114]             inherits <- base::inherits
[17:26:43.114]             invokeRestart <- base::invokeRestart
[17:26:43.114]             length <- base::length
[17:26:43.114]             list <- base::list
[17:26:43.114]             seq.int <- base::seq.int
[17:26:43.114]             signalCondition <- base::signalCondition
[17:26:43.114]             sys.calls <- base::sys.calls
[17:26:43.114]             `[[` <- base::`[[`
[17:26:43.114]             `+` <- base::`+`
[17:26:43.114]             `<<-` <- base::`<<-`
[17:26:43.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.114]                   3L)]
[17:26:43.114]             }
[17:26:43.114]             function(cond) {
[17:26:43.114]                 is_error <- inherits(cond, "error")
[17:26:43.114]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.114]                   NULL)
[17:26:43.114]                 if (is_error) {
[17:26:43.114]                   sessionInformation <- function() {
[17:26:43.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.114]                       search = base::search(), system = base::Sys.info())
[17:26:43.114]                   }
[17:26:43.114]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.114]                     cond$call), session = sessionInformation(), 
[17:26:43.114]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.114]                   signalCondition(cond)
[17:26:43.114]                 }
[17:26:43.114]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.114]                 "immediateCondition"))) {
[17:26:43.114]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.114]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.114]                   if (TRUE && !signal) {
[17:26:43.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.114]                     {
[17:26:43.114]                       inherits <- base::inherits
[17:26:43.114]                       invokeRestart <- base::invokeRestart
[17:26:43.114]                       is.null <- base::is.null
[17:26:43.114]                       muffled <- FALSE
[17:26:43.114]                       if (inherits(cond, "message")) {
[17:26:43.114]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.114]                         if (muffled) 
[17:26:43.114]                           invokeRestart("muffleMessage")
[17:26:43.114]                       }
[17:26:43.114]                       else if (inherits(cond, "warning")) {
[17:26:43.114]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.114]                         if (muffled) 
[17:26:43.114]                           invokeRestart("muffleWarning")
[17:26:43.114]                       }
[17:26:43.114]                       else if (inherits(cond, "condition")) {
[17:26:43.114]                         if (!is.null(pattern)) {
[17:26:43.114]                           computeRestarts <- base::computeRestarts
[17:26:43.114]                           grepl <- base::grepl
[17:26:43.114]                           restarts <- computeRestarts(cond)
[17:26:43.114]                           for (restart in restarts) {
[17:26:43.114]                             name <- restart$name
[17:26:43.114]                             if (is.null(name)) 
[17:26:43.114]                               next
[17:26:43.114]                             if (!grepl(pattern, name)) 
[17:26:43.114]                               next
[17:26:43.114]                             invokeRestart(restart)
[17:26:43.114]                             muffled <- TRUE
[17:26:43.114]                             break
[17:26:43.114]                           }
[17:26:43.114]                         }
[17:26:43.114]                       }
[17:26:43.114]                       invisible(muffled)
[17:26:43.114]                     }
[17:26:43.114]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.114]                   }
[17:26:43.114]                 }
[17:26:43.114]                 else {
[17:26:43.114]                   if (TRUE) {
[17:26:43.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.114]                     {
[17:26:43.114]                       inherits <- base::inherits
[17:26:43.114]                       invokeRestart <- base::invokeRestart
[17:26:43.114]                       is.null <- base::is.null
[17:26:43.114]                       muffled <- FALSE
[17:26:43.114]                       if (inherits(cond, "message")) {
[17:26:43.114]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.114]                         if (muffled) 
[17:26:43.114]                           invokeRestart("muffleMessage")
[17:26:43.114]                       }
[17:26:43.114]                       else if (inherits(cond, "warning")) {
[17:26:43.114]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.114]                         if (muffled) 
[17:26:43.114]                           invokeRestart("muffleWarning")
[17:26:43.114]                       }
[17:26:43.114]                       else if (inherits(cond, "condition")) {
[17:26:43.114]                         if (!is.null(pattern)) {
[17:26:43.114]                           computeRestarts <- base::computeRestarts
[17:26:43.114]                           grepl <- base::grepl
[17:26:43.114]                           restarts <- computeRestarts(cond)
[17:26:43.114]                           for (restart in restarts) {
[17:26:43.114]                             name <- restart$name
[17:26:43.114]                             if (is.null(name)) 
[17:26:43.114]                               next
[17:26:43.114]                             if (!grepl(pattern, name)) 
[17:26:43.114]                               next
[17:26:43.114]                             invokeRestart(restart)
[17:26:43.114]                             muffled <- TRUE
[17:26:43.114]                             break
[17:26:43.114]                           }
[17:26:43.114]                         }
[17:26:43.114]                       }
[17:26:43.114]                       invisible(muffled)
[17:26:43.114]                     }
[17:26:43.114]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.114]                   }
[17:26:43.114]                 }
[17:26:43.114]             }
[17:26:43.114]         }))
[17:26:43.114]     }, error = function(ex) {
[17:26:43.114]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.114]                 ...future.rng), started = ...future.startTime, 
[17:26:43.114]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.114]             version = "1.8"), class = "FutureResult")
[17:26:43.114]     }, finally = {
[17:26:43.114]         if (!identical(...future.workdir, getwd())) 
[17:26:43.114]             setwd(...future.workdir)
[17:26:43.114]         {
[17:26:43.114]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.114]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.114]             }
[17:26:43.114]             base::options(...future.oldOptions)
[17:26:43.114]             if (.Platform$OS.type == "windows") {
[17:26:43.114]                 old_names <- names(...future.oldEnvVars)
[17:26:43.114]                 envs <- base::Sys.getenv()
[17:26:43.114]                 names <- names(envs)
[17:26:43.114]                 common <- intersect(names, old_names)
[17:26:43.114]                 added <- setdiff(names, old_names)
[17:26:43.114]                 removed <- setdiff(old_names, names)
[17:26:43.114]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.114]                   envs[common]]
[17:26:43.114]                 NAMES <- toupper(changed)
[17:26:43.114]                 args <- list()
[17:26:43.114]                 for (kk in seq_along(NAMES)) {
[17:26:43.114]                   name <- changed[[kk]]
[17:26:43.114]                   NAME <- NAMES[[kk]]
[17:26:43.114]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.114]                     next
[17:26:43.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.114]                 }
[17:26:43.114]                 NAMES <- toupper(added)
[17:26:43.114]                 for (kk in seq_along(NAMES)) {
[17:26:43.114]                   name <- added[[kk]]
[17:26:43.114]                   NAME <- NAMES[[kk]]
[17:26:43.114]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.114]                     next
[17:26:43.114]                   args[[name]] <- ""
[17:26:43.114]                 }
[17:26:43.114]                 NAMES <- toupper(removed)
[17:26:43.114]                 for (kk in seq_along(NAMES)) {
[17:26:43.114]                   name <- removed[[kk]]
[17:26:43.114]                   NAME <- NAMES[[kk]]
[17:26:43.114]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.114]                     next
[17:26:43.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.114]                 }
[17:26:43.114]                 if (length(args) > 0) 
[17:26:43.114]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.114]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.114]             }
[17:26:43.114]             else {
[17:26:43.114]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.114]             }
[17:26:43.114]             {
[17:26:43.114]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.114]                   0L) {
[17:26:43.114]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.114]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.114]                   base::options(opts)
[17:26:43.114]                 }
[17:26:43.114]                 {
[17:26:43.114]                   {
[17:26:43.114]                     NULL
[17:26:43.114]                     RNGkind("Mersenne-Twister")
[17:26:43.114]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.114]                       inherits = FALSE)
[17:26:43.114]                   }
[17:26:43.114]                   options(future.plan = NULL)
[17:26:43.114]                   if (is.na(NA_character_)) 
[17:26:43.114]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.114]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.114]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.114]                     .init = FALSE)
[17:26:43.114]                 }
[17:26:43.114]             }
[17:26:43.114]         }
[17:26:43.114]     })
[17:26:43.114]     if (TRUE) {
[17:26:43.114]         base::sink(type = "output", split = FALSE)
[17:26:43.114]         if (TRUE) {
[17:26:43.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.114]         }
[17:26:43.114]         else {
[17:26:43.114]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.114]         }
[17:26:43.114]         base::close(...future.stdout)
[17:26:43.114]         ...future.stdout <- NULL
[17:26:43.114]     }
[17:26:43.114]     ...future.result$conditions <- ...future.conditions
[17:26:43.114]     ...future.result$finished <- base::Sys.time()
[17:26:43.114]     ...future.result
[17:26:43.114] }
[17:26:43.118] plan(): Setting new future strategy stack:
[17:26:43.118] List of future strategies:
[17:26:43.118] 1. sequential:
[17:26:43.118]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.118]    - tweaked: FALSE
[17:26:43.118]    - call: NULL
[17:26:43.119] plan(): nbrOfWorkers() = 1
[17:26:43.120] plan(): Setting new future strategy stack:
[17:26:43.120] List of future strategies:
[17:26:43.120] 1. sequential:
[17:26:43.120]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.120]    - tweaked: FALSE
[17:26:43.120]    - call: plan(strategy)
[17:26:43.121] plan(): nbrOfWorkers() = 1
[17:26:43.121] SequentialFuture started (and completed)
[17:26:43.121] - Launch lazy future ... done
[17:26:43.121] run() for 'SequentialFuture' ... done
[17:26:43.122] getGlobalsAndPackages() ...
[17:26:43.122] Searching for globals...
[17:26:43.122] 
[17:26:43.122] Searching for globals ... DONE
[17:26:43.122] - globals: [0] <none>
[17:26:43.123] getGlobalsAndPackages() ... DONE
[17:26:43.123] run() for 'Future' ...
[17:26:43.123] - state: 'created'
[17:26:43.123] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.124] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.124] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.124]   - Field: 'label'
[17:26:43.124]   - Field: 'local'
[17:26:43.124]   - Field: 'owner'
[17:26:43.125]   - Field: 'envir'
[17:26:43.125]   - Field: 'packages'
[17:26:43.125]   - Field: 'gc'
[17:26:43.125]   - Field: 'conditions'
[17:26:43.125]   - Field: 'expr'
[17:26:43.125]   - Field: 'uuid'
[17:26:43.126]   - Field: 'seed'
[17:26:43.126]   - Field: 'version'
[17:26:43.127]   - Field: 'result'
[17:26:43.127]   - Field: 'asynchronous'
[17:26:43.127]   - Field: 'calls'
[17:26:43.127]   - Field: 'globals'
[17:26:43.128]   - Field: 'stdout'
[17:26:43.128]   - Field: 'earlySignal'
[17:26:43.128]   - Field: 'lazy'
[17:26:43.128]   - Field: 'state'
[17:26:43.128] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.128] - Launch lazy future ...
[17:26:43.129] Packages needed by the future expression (n = 0): <none>
[17:26:43.129] Packages needed by future strategies (n = 0): <none>
[17:26:43.129] {
[17:26:43.129]     {
[17:26:43.129]         {
[17:26:43.129]             ...future.startTime <- base::Sys.time()
[17:26:43.129]             {
[17:26:43.129]                 {
[17:26:43.129]                   {
[17:26:43.129]                     base::local({
[17:26:43.129]                       has_future <- base::requireNamespace("future", 
[17:26:43.129]                         quietly = TRUE)
[17:26:43.129]                       if (has_future) {
[17:26:43.129]                         ns <- base::getNamespace("future")
[17:26:43.129]                         version <- ns[[".package"]][["version"]]
[17:26:43.129]                         if (is.null(version)) 
[17:26:43.129]                           version <- utils::packageVersion("future")
[17:26:43.129]                       }
[17:26:43.129]                       else {
[17:26:43.129]                         version <- NULL
[17:26:43.129]                       }
[17:26:43.129]                       if (!has_future || version < "1.8.0") {
[17:26:43.129]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.129]                           "", base::R.version$version.string), 
[17:26:43.129]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.129]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.129]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.129]                             "release", "version")], collapse = " "), 
[17:26:43.129]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.129]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.129]                           info)
[17:26:43.129]                         info <- base::paste(info, collapse = "; ")
[17:26:43.129]                         if (!has_future) {
[17:26:43.129]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.129]                             info)
[17:26:43.129]                         }
[17:26:43.129]                         else {
[17:26:43.129]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.129]                             info, version)
[17:26:43.129]                         }
[17:26:43.129]                         base::stop(msg)
[17:26:43.129]                       }
[17:26:43.129]                     })
[17:26:43.129]                   }
[17:26:43.129]                   ...future.strategy.old <- future::plan("list")
[17:26:43.129]                   options(future.plan = NULL)
[17:26:43.129]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.129]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.129]                 }
[17:26:43.129]                 ...future.workdir <- getwd()
[17:26:43.129]             }
[17:26:43.129]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.129]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.129]         }
[17:26:43.129]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.129]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.129]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.129]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.129]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.129]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.129]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.129]             base::names(...future.oldOptions))
[17:26:43.129]     }
[17:26:43.129]     if (FALSE) {
[17:26:43.129]     }
[17:26:43.129]     else {
[17:26:43.129]         if (TRUE) {
[17:26:43.129]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.129]                 open = "w")
[17:26:43.129]         }
[17:26:43.129]         else {
[17:26:43.129]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.129]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.129]         }
[17:26:43.129]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.129]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.129]             base::sink(type = "output", split = FALSE)
[17:26:43.129]             base::close(...future.stdout)
[17:26:43.129]         }, add = TRUE)
[17:26:43.129]     }
[17:26:43.129]     ...future.frame <- base::sys.nframe()
[17:26:43.129]     ...future.conditions <- base::list()
[17:26:43.129]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.129]     if (FALSE) {
[17:26:43.129]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.129]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.129]     }
[17:26:43.129]     ...future.result <- base::tryCatch({
[17:26:43.129]         base::withCallingHandlers({
[17:26:43.129]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.129]             future::FutureResult(value = ...future.value$value, 
[17:26:43.129]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.129]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.129]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.129]                     ...future.globalenv.names))
[17:26:43.129]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.129]         }, condition = base::local({
[17:26:43.129]             c <- base::c
[17:26:43.129]             inherits <- base::inherits
[17:26:43.129]             invokeRestart <- base::invokeRestart
[17:26:43.129]             length <- base::length
[17:26:43.129]             list <- base::list
[17:26:43.129]             seq.int <- base::seq.int
[17:26:43.129]             signalCondition <- base::signalCondition
[17:26:43.129]             sys.calls <- base::sys.calls
[17:26:43.129]             `[[` <- base::`[[`
[17:26:43.129]             `+` <- base::`+`
[17:26:43.129]             `<<-` <- base::`<<-`
[17:26:43.129]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.129]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.129]                   3L)]
[17:26:43.129]             }
[17:26:43.129]             function(cond) {
[17:26:43.129]                 is_error <- inherits(cond, "error")
[17:26:43.129]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.129]                   NULL)
[17:26:43.129]                 if (is_error) {
[17:26:43.129]                   sessionInformation <- function() {
[17:26:43.129]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.129]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.129]                       search = base::search(), system = base::Sys.info())
[17:26:43.129]                   }
[17:26:43.129]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.129]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.129]                     cond$call), session = sessionInformation(), 
[17:26:43.129]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.129]                   signalCondition(cond)
[17:26:43.129]                 }
[17:26:43.129]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.129]                 "immediateCondition"))) {
[17:26:43.129]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.129]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.129]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.129]                   if (TRUE && !signal) {
[17:26:43.129]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.129]                     {
[17:26:43.129]                       inherits <- base::inherits
[17:26:43.129]                       invokeRestart <- base::invokeRestart
[17:26:43.129]                       is.null <- base::is.null
[17:26:43.129]                       muffled <- FALSE
[17:26:43.129]                       if (inherits(cond, "message")) {
[17:26:43.129]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.129]                         if (muffled) 
[17:26:43.129]                           invokeRestart("muffleMessage")
[17:26:43.129]                       }
[17:26:43.129]                       else if (inherits(cond, "warning")) {
[17:26:43.129]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.129]                         if (muffled) 
[17:26:43.129]                           invokeRestart("muffleWarning")
[17:26:43.129]                       }
[17:26:43.129]                       else if (inherits(cond, "condition")) {
[17:26:43.129]                         if (!is.null(pattern)) {
[17:26:43.129]                           computeRestarts <- base::computeRestarts
[17:26:43.129]                           grepl <- base::grepl
[17:26:43.129]                           restarts <- computeRestarts(cond)
[17:26:43.129]                           for (restart in restarts) {
[17:26:43.129]                             name <- restart$name
[17:26:43.129]                             if (is.null(name)) 
[17:26:43.129]                               next
[17:26:43.129]                             if (!grepl(pattern, name)) 
[17:26:43.129]                               next
[17:26:43.129]                             invokeRestart(restart)
[17:26:43.129]                             muffled <- TRUE
[17:26:43.129]                             break
[17:26:43.129]                           }
[17:26:43.129]                         }
[17:26:43.129]                       }
[17:26:43.129]                       invisible(muffled)
[17:26:43.129]                     }
[17:26:43.129]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.129]                   }
[17:26:43.129]                 }
[17:26:43.129]                 else {
[17:26:43.129]                   if (TRUE) {
[17:26:43.129]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.129]                     {
[17:26:43.129]                       inherits <- base::inherits
[17:26:43.129]                       invokeRestart <- base::invokeRestart
[17:26:43.129]                       is.null <- base::is.null
[17:26:43.129]                       muffled <- FALSE
[17:26:43.129]                       if (inherits(cond, "message")) {
[17:26:43.129]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.129]                         if (muffled) 
[17:26:43.129]                           invokeRestart("muffleMessage")
[17:26:43.129]                       }
[17:26:43.129]                       else if (inherits(cond, "warning")) {
[17:26:43.129]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.129]                         if (muffled) 
[17:26:43.129]                           invokeRestart("muffleWarning")
[17:26:43.129]                       }
[17:26:43.129]                       else if (inherits(cond, "condition")) {
[17:26:43.129]                         if (!is.null(pattern)) {
[17:26:43.129]                           computeRestarts <- base::computeRestarts
[17:26:43.129]                           grepl <- base::grepl
[17:26:43.129]                           restarts <- computeRestarts(cond)
[17:26:43.129]                           for (restart in restarts) {
[17:26:43.129]                             name <- restart$name
[17:26:43.129]                             if (is.null(name)) 
[17:26:43.129]                               next
[17:26:43.129]                             if (!grepl(pattern, name)) 
[17:26:43.129]                               next
[17:26:43.129]                             invokeRestart(restart)
[17:26:43.129]                             muffled <- TRUE
[17:26:43.129]                             break
[17:26:43.129]                           }
[17:26:43.129]                         }
[17:26:43.129]                       }
[17:26:43.129]                       invisible(muffled)
[17:26:43.129]                     }
[17:26:43.129]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.129]                   }
[17:26:43.129]                 }
[17:26:43.129]             }
[17:26:43.129]         }))
[17:26:43.129]     }, error = function(ex) {
[17:26:43.129]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.129]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.129]                 ...future.rng), started = ...future.startTime, 
[17:26:43.129]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.129]             version = "1.8"), class = "FutureResult")
[17:26:43.129]     }, finally = {
[17:26:43.129]         if (!identical(...future.workdir, getwd())) 
[17:26:43.129]             setwd(...future.workdir)
[17:26:43.129]         {
[17:26:43.129]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.129]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.129]             }
[17:26:43.129]             base::options(...future.oldOptions)
[17:26:43.129]             if (.Platform$OS.type == "windows") {
[17:26:43.129]                 old_names <- names(...future.oldEnvVars)
[17:26:43.129]                 envs <- base::Sys.getenv()
[17:26:43.129]                 names <- names(envs)
[17:26:43.129]                 common <- intersect(names, old_names)
[17:26:43.129]                 added <- setdiff(names, old_names)
[17:26:43.129]                 removed <- setdiff(old_names, names)
[17:26:43.129]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.129]                   envs[common]]
[17:26:43.129]                 NAMES <- toupper(changed)
[17:26:43.129]                 args <- list()
[17:26:43.129]                 for (kk in seq_along(NAMES)) {
[17:26:43.129]                   name <- changed[[kk]]
[17:26:43.129]                   NAME <- NAMES[[kk]]
[17:26:43.129]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.129]                     next
[17:26:43.129]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.129]                 }
[17:26:43.129]                 NAMES <- toupper(added)
[17:26:43.129]                 for (kk in seq_along(NAMES)) {
[17:26:43.129]                   name <- added[[kk]]
[17:26:43.129]                   NAME <- NAMES[[kk]]
[17:26:43.129]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.129]                     next
[17:26:43.129]                   args[[name]] <- ""
[17:26:43.129]                 }
[17:26:43.129]                 NAMES <- toupper(removed)
[17:26:43.129]                 for (kk in seq_along(NAMES)) {
[17:26:43.129]                   name <- removed[[kk]]
[17:26:43.129]                   NAME <- NAMES[[kk]]
[17:26:43.129]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.129]                     next
[17:26:43.129]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.129]                 }
[17:26:43.129]                 if (length(args) > 0) 
[17:26:43.129]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.129]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.129]             }
[17:26:43.129]             else {
[17:26:43.129]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.129]             }
[17:26:43.129]             {
[17:26:43.129]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.129]                   0L) {
[17:26:43.129]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.129]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.129]                   base::options(opts)
[17:26:43.129]                 }
[17:26:43.129]                 {
[17:26:43.129]                   {
[17:26:43.129]                     NULL
[17:26:43.129]                     RNGkind("Mersenne-Twister")
[17:26:43.129]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.129]                       inherits = FALSE)
[17:26:43.129]                   }
[17:26:43.129]                   options(future.plan = NULL)
[17:26:43.129]                   if (is.na(NA_character_)) 
[17:26:43.129]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.129]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.129]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.129]                     .init = FALSE)
[17:26:43.129]                 }
[17:26:43.129]             }
[17:26:43.129]         }
[17:26:43.129]     })
[17:26:43.129]     if (TRUE) {
[17:26:43.129]         base::sink(type = "output", split = FALSE)
[17:26:43.129]         if (TRUE) {
[17:26:43.129]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.129]         }
[17:26:43.129]         else {
[17:26:43.129]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.129]         }
[17:26:43.129]         base::close(...future.stdout)
[17:26:43.129]         ...future.stdout <- NULL
[17:26:43.129]     }
[17:26:43.129]     ...future.result$conditions <- ...future.conditions
[17:26:43.129]     ...future.result$finished <- base::Sys.time()
[17:26:43.129]     ...future.result
[17:26:43.129] }
[17:26:43.133] plan(): Setting new future strategy stack:
[17:26:43.134] List of future strategies:
[17:26:43.134] 1. sequential:
[17:26:43.134]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.134]    - tweaked: FALSE
[17:26:43.134]    - call: NULL
[17:26:43.134] plan(): nbrOfWorkers() = 1
[17:26:43.135] plan(): Setting new future strategy stack:
[17:26:43.135] List of future strategies:
[17:26:43.135] 1. sequential:
[17:26:43.135]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.135]    - tweaked: FALSE
[17:26:43.135]    - call: plan(strategy)
[17:26:43.136] plan(): nbrOfWorkers() = 1
[17:26:43.136] SequentialFuture started (and completed)
[17:26:43.136] - Launch lazy future ... done
[17:26:43.137] run() for 'SequentialFuture' ... done
[17:26:43.137] getGlobalsAndPackages() ...
[17:26:43.137] Searching for globals...
[17:26:43.138] - globals found: [1] '{'
[17:26:43.138] Searching for globals ... DONE
[17:26:43.138] Resolving globals: FALSE
[17:26:43.139] 
[17:26:43.139] 
[17:26:43.139] getGlobalsAndPackages() ... DONE
[17:26:43.139] run() for 'Future' ...
[17:26:43.139] - state: 'created'
[17:26:43.140] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.140] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.140] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.140]   - Field: 'label'
[17:26:43.141]   - Field: 'local'
[17:26:43.141]   - Field: 'owner'
[17:26:43.141]   - Field: 'envir'
[17:26:43.141]   - Field: 'packages'
[17:26:43.141]   - Field: 'gc'
[17:26:43.142]   - Field: 'conditions'
[17:26:43.142]   - Field: 'expr'
[17:26:43.142]   - Field: 'uuid'
[17:26:43.142]   - Field: 'seed'
[17:26:43.142]   - Field: 'version'
[17:26:43.142]   - Field: 'result'
[17:26:43.143]   - Field: 'asynchronous'
[17:26:43.143]   - Field: 'calls'
[17:26:43.143]   - Field: 'globals'
[17:26:43.143]   - Field: 'stdout'
[17:26:43.143]   - Field: 'earlySignal'
[17:26:43.144]   - Field: 'lazy'
[17:26:43.144]   - Field: 'state'
[17:26:43.144] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.144] - Launch lazy future ...
[17:26:43.144] Packages needed by the future expression (n = 0): <none>
[17:26:43.144] Packages needed by future strategies (n = 0): <none>
[17:26:43.145] {
[17:26:43.145]     {
[17:26:43.145]         {
[17:26:43.145]             ...future.startTime <- base::Sys.time()
[17:26:43.145]             {
[17:26:43.145]                 {
[17:26:43.145]                   {
[17:26:43.145]                     base::local({
[17:26:43.145]                       has_future <- base::requireNamespace("future", 
[17:26:43.145]                         quietly = TRUE)
[17:26:43.145]                       if (has_future) {
[17:26:43.145]                         ns <- base::getNamespace("future")
[17:26:43.145]                         version <- ns[[".package"]][["version"]]
[17:26:43.145]                         if (is.null(version)) 
[17:26:43.145]                           version <- utils::packageVersion("future")
[17:26:43.145]                       }
[17:26:43.145]                       else {
[17:26:43.145]                         version <- NULL
[17:26:43.145]                       }
[17:26:43.145]                       if (!has_future || version < "1.8.0") {
[17:26:43.145]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.145]                           "", base::R.version$version.string), 
[17:26:43.145]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.145]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.145]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.145]                             "release", "version")], collapse = " "), 
[17:26:43.145]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.145]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.145]                           info)
[17:26:43.145]                         info <- base::paste(info, collapse = "; ")
[17:26:43.145]                         if (!has_future) {
[17:26:43.145]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.145]                             info)
[17:26:43.145]                         }
[17:26:43.145]                         else {
[17:26:43.145]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.145]                             info, version)
[17:26:43.145]                         }
[17:26:43.145]                         base::stop(msg)
[17:26:43.145]                       }
[17:26:43.145]                     })
[17:26:43.145]                   }
[17:26:43.145]                   ...future.strategy.old <- future::plan("list")
[17:26:43.145]                   options(future.plan = NULL)
[17:26:43.145]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.145]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.145]                 }
[17:26:43.145]                 ...future.workdir <- getwd()
[17:26:43.145]             }
[17:26:43.145]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.145]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.145]         }
[17:26:43.145]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.145]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.145]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.145]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.145]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.145]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.145]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.145]             base::names(...future.oldOptions))
[17:26:43.145]     }
[17:26:43.145]     if (FALSE) {
[17:26:43.145]     }
[17:26:43.145]     else {
[17:26:43.145]         if (TRUE) {
[17:26:43.145]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.145]                 open = "w")
[17:26:43.145]         }
[17:26:43.145]         else {
[17:26:43.145]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.145]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.145]         }
[17:26:43.145]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.145]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.145]             base::sink(type = "output", split = FALSE)
[17:26:43.145]             base::close(...future.stdout)
[17:26:43.145]         }, add = TRUE)
[17:26:43.145]     }
[17:26:43.145]     ...future.frame <- base::sys.nframe()
[17:26:43.145]     ...future.conditions <- base::list()
[17:26:43.145]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.145]     if (FALSE) {
[17:26:43.145]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.145]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.145]     }
[17:26:43.145]     ...future.result <- base::tryCatch({
[17:26:43.145]         base::withCallingHandlers({
[17:26:43.145]             ...future.value <- base::withVisible(base::local({
[17:26:43.145]                 4
[17:26:43.145]             }))
[17:26:43.145]             future::FutureResult(value = ...future.value$value, 
[17:26:43.145]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.145]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.145]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.145]                     ...future.globalenv.names))
[17:26:43.145]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.145]         }, condition = base::local({
[17:26:43.145]             c <- base::c
[17:26:43.145]             inherits <- base::inherits
[17:26:43.145]             invokeRestart <- base::invokeRestart
[17:26:43.145]             length <- base::length
[17:26:43.145]             list <- base::list
[17:26:43.145]             seq.int <- base::seq.int
[17:26:43.145]             signalCondition <- base::signalCondition
[17:26:43.145]             sys.calls <- base::sys.calls
[17:26:43.145]             `[[` <- base::`[[`
[17:26:43.145]             `+` <- base::`+`
[17:26:43.145]             `<<-` <- base::`<<-`
[17:26:43.145]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.145]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.145]                   3L)]
[17:26:43.145]             }
[17:26:43.145]             function(cond) {
[17:26:43.145]                 is_error <- inherits(cond, "error")
[17:26:43.145]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.145]                   NULL)
[17:26:43.145]                 if (is_error) {
[17:26:43.145]                   sessionInformation <- function() {
[17:26:43.145]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.145]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.145]                       search = base::search(), system = base::Sys.info())
[17:26:43.145]                   }
[17:26:43.145]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.145]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.145]                     cond$call), session = sessionInformation(), 
[17:26:43.145]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.145]                   signalCondition(cond)
[17:26:43.145]                 }
[17:26:43.145]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.145]                 "immediateCondition"))) {
[17:26:43.145]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.145]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.145]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.145]                   if (TRUE && !signal) {
[17:26:43.145]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.145]                     {
[17:26:43.145]                       inherits <- base::inherits
[17:26:43.145]                       invokeRestart <- base::invokeRestart
[17:26:43.145]                       is.null <- base::is.null
[17:26:43.145]                       muffled <- FALSE
[17:26:43.145]                       if (inherits(cond, "message")) {
[17:26:43.145]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.145]                         if (muffled) 
[17:26:43.145]                           invokeRestart("muffleMessage")
[17:26:43.145]                       }
[17:26:43.145]                       else if (inherits(cond, "warning")) {
[17:26:43.145]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.145]                         if (muffled) 
[17:26:43.145]                           invokeRestart("muffleWarning")
[17:26:43.145]                       }
[17:26:43.145]                       else if (inherits(cond, "condition")) {
[17:26:43.145]                         if (!is.null(pattern)) {
[17:26:43.145]                           computeRestarts <- base::computeRestarts
[17:26:43.145]                           grepl <- base::grepl
[17:26:43.145]                           restarts <- computeRestarts(cond)
[17:26:43.145]                           for (restart in restarts) {
[17:26:43.145]                             name <- restart$name
[17:26:43.145]                             if (is.null(name)) 
[17:26:43.145]                               next
[17:26:43.145]                             if (!grepl(pattern, name)) 
[17:26:43.145]                               next
[17:26:43.145]                             invokeRestart(restart)
[17:26:43.145]                             muffled <- TRUE
[17:26:43.145]                             break
[17:26:43.145]                           }
[17:26:43.145]                         }
[17:26:43.145]                       }
[17:26:43.145]                       invisible(muffled)
[17:26:43.145]                     }
[17:26:43.145]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.145]                   }
[17:26:43.145]                 }
[17:26:43.145]                 else {
[17:26:43.145]                   if (TRUE) {
[17:26:43.145]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.145]                     {
[17:26:43.145]                       inherits <- base::inherits
[17:26:43.145]                       invokeRestart <- base::invokeRestart
[17:26:43.145]                       is.null <- base::is.null
[17:26:43.145]                       muffled <- FALSE
[17:26:43.145]                       if (inherits(cond, "message")) {
[17:26:43.145]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.145]                         if (muffled) 
[17:26:43.145]                           invokeRestart("muffleMessage")
[17:26:43.145]                       }
[17:26:43.145]                       else if (inherits(cond, "warning")) {
[17:26:43.145]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.145]                         if (muffled) 
[17:26:43.145]                           invokeRestart("muffleWarning")
[17:26:43.145]                       }
[17:26:43.145]                       else if (inherits(cond, "condition")) {
[17:26:43.145]                         if (!is.null(pattern)) {
[17:26:43.145]                           computeRestarts <- base::computeRestarts
[17:26:43.145]                           grepl <- base::grepl
[17:26:43.145]                           restarts <- computeRestarts(cond)
[17:26:43.145]                           for (restart in restarts) {
[17:26:43.145]                             name <- restart$name
[17:26:43.145]                             if (is.null(name)) 
[17:26:43.145]                               next
[17:26:43.145]                             if (!grepl(pattern, name)) 
[17:26:43.145]                               next
[17:26:43.145]                             invokeRestart(restart)
[17:26:43.145]                             muffled <- TRUE
[17:26:43.145]                             break
[17:26:43.145]                           }
[17:26:43.145]                         }
[17:26:43.145]                       }
[17:26:43.145]                       invisible(muffled)
[17:26:43.145]                     }
[17:26:43.145]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.145]                   }
[17:26:43.145]                 }
[17:26:43.145]             }
[17:26:43.145]         }))
[17:26:43.145]     }, error = function(ex) {
[17:26:43.145]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.145]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.145]                 ...future.rng), started = ...future.startTime, 
[17:26:43.145]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.145]             version = "1.8"), class = "FutureResult")
[17:26:43.145]     }, finally = {
[17:26:43.145]         if (!identical(...future.workdir, getwd())) 
[17:26:43.145]             setwd(...future.workdir)
[17:26:43.145]         {
[17:26:43.145]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.145]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.145]             }
[17:26:43.145]             base::options(...future.oldOptions)
[17:26:43.145]             if (.Platform$OS.type == "windows") {
[17:26:43.145]                 old_names <- names(...future.oldEnvVars)
[17:26:43.145]                 envs <- base::Sys.getenv()
[17:26:43.145]                 names <- names(envs)
[17:26:43.145]                 common <- intersect(names, old_names)
[17:26:43.145]                 added <- setdiff(names, old_names)
[17:26:43.145]                 removed <- setdiff(old_names, names)
[17:26:43.145]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.145]                   envs[common]]
[17:26:43.145]                 NAMES <- toupper(changed)
[17:26:43.145]                 args <- list()
[17:26:43.145]                 for (kk in seq_along(NAMES)) {
[17:26:43.145]                   name <- changed[[kk]]
[17:26:43.145]                   NAME <- NAMES[[kk]]
[17:26:43.145]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.145]                     next
[17:26:43.145]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.145]                 }
[17:26:43.145]                 NAMES <- toupper(added)
[17:26:43.145]                 for (kk in seq_along(NAMES)) {
[17:26:43.145]                   name <- added[[kk]]
[17:26:43.145]                   NAME <- NAMES[[kk]]
[17:26:43.145]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.145]                     next
[17:26:43.145]                   args[[name]] <- ""
[17:26:43.145]                 }
[17:26:43.145]                 NAMES <- toupper(removed)
[17:26:43.145]                 for (kk in seq_along(NAMES)) {
[17:26:43.145]                   name <- removed[[kk]]
[17:26:43.145]                   NAME <- NAMES[[kk]]
[17:26:43.145]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.145]                     next
[17:26:43.145]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.145]                 }
[17:26:43.145]                 if (length(args) > 0) 
[17:26:43.145]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.145]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.145]             }
[17:26:43.145]             else {
[17:26:43.145]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.145]             }
[17:26:43.145]             {
[17:26:43.145]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.145]                   0L) {
[17:26:43.145]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.145]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.145]                   base::options(opts)
[17:26:43.145]                 }
[17:26:43.145]                 {
[17:26:43.145]                   {
[17:26:43.145]                     NULL
[17:26:43.145]                     RNGkind("Mersenne-Twister")
[17:26:43.145]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.145]                       inherits = FALSE)
[17:26:43.145]                   }
[17:26:43.145]                   options(future.plan = NULL)
[17:26:43.145]                   if (is.na(NA_character_)) 
[17:26:43.145]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.145]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.145]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.145]                     .init = FALSE)
[17:26:43.145]                 }
[17:26:43.145]             }
[17:26:43.145]         }
[17:26:43.145]     })
[17:26:43.145]     if (TRUE) {
[17:26:43.145]         base::sink(type = "output", split = FALSE)
[17:26:43.145]         if (TRUE) {
[17:26:43.145]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.145]         }
[17:26:43.145]         else {
[17:26:43.145]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.145]         }
[17:26:43.145]         base::close(...future.stdout)
[17:26:43.145]         ...future.stdout <- NULL
[17:26:43.145]     }
[17:26:43.145]     ...future.result$conditions <- ...future.conditions
[17:26:43.145]     ...future.result$finished <- base::Sys.time()
[17:26:43.145]     ...future.result
[17:26:43.145] }
[17:26:43.149] plan(): Setting new future strategy stack:
[17:26:43.149] List of future strategies:
[17:26:43.149] 1. sequential:
[17:26:43.149]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.149]    - tweaked: FALSE
[17:26:43.149]    - call: NULL
[17:26:43.150] plan(): nbrOfWorkers() = 1
[17:26:43.151] plan(): Setting new future strategy stack:
[17:26:43.151] List of future strategies:
[17:26:43.151] 1. sequential:
[17:26:43.151]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.151]    - tweaked: FALSE
[17:26:43.151]    - call: plan(strategy)
[17:26:43.152] plan(): nbrOfWorkers() = 1
[17:26:43.152] SequentialFuture started (and completed)
[17:26:43.152] - Launch lazy future ... done
[17:26:43.152] run() for 'SequentialFuture' ... done
<environment: 0x000002230caba7d8> 
<environment: 0x000002230d3531b8> 
[17:26:43.154] resolved() for 'SequentialFuture' ...
[17:26:43.154] - state: 'finished'
[17:26:43.154] - run: TRUE
[17:26:43.154] - result: 'FutureResult'
[17:26:43.155] resolved() for 'SequentialFuture' ... done
[17:26:43.155] resolved() for 'SequentialFuture' ...
[17:26:43.155] - state: 'finished'
[17:26:43.155] - run: TRUE
[17:26:43.155] - result: 'FutureResult'
[17:26:43.156] resolved() for 'SequentialFuture' ... done
[17:26:43.156] resolved() for 'SequentialFuture' ...
[17:26:43.156] - state: 'finished'
[17:26:43.156] - run: TRUE
[17:26:43.156] - result: 'FutureResult'
[17:26:43.156] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:43.158] resolve() on environment ...
[17:26:43.158]  recursive: 0
[17:26:43.159]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:43.159] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.159] - nx: 4
[17:26:43.159] - relay: TRUE
[17:26:43.159] - stdout: TRUE
[17:26:43.159] - signal: TRUE
[17:26:43.160] - resignal: FALSE
[17:26:43.160] - force: TRUE
[17:26:43.160] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.160] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.160]  - until=2
[17:26:43.160]  - relaying element #2
[17:26:43.161] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.161] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.161] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.161]  length: 3 (resolved future 1)
[17:26:43.161] resolved() for 'SequentialFuture' ...
[17:26:43.161] - state: 'finished'
[17:26:43.162] - run: TRUE
[17:26:43.162] - result: 'FutureResult'
[17:26:43.162] resolved() for 'SequentialFuture' ... done
[17:26:43.162] Future #2
[17:26:43.226] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.227] - nx: 4
[17:26:43.227] - relay: TRUE
[17:26:43.227] - stdout: TRUE
[17:26:43.227] - signal: TRUE
[17:26:43.227] - resignal: FALSE
[17:26:43.228] - force: TRUE
[17:26:43.228] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.228] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.228]  - until=2
[17:26:43.228]  - relaying element #2
[17:26:43.229] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.229] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.229] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.229]  length: 2 (resolved future 2)
[17:26:43.230] resolved() for 'SequentialFuture' ...
[17:26:43.230] - state: 'finished'
[17:26:43.230] - run: TRUE
[17:26:43.230] - result: 'FutureResult'
[17:26:43.231] resolved() for 'SequentialFuture' ... done
[17:26:43.231] Future #3
[17:26:43.231] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.231] - nx: 4
[17:26:43.231] - relay: TRUE
[17:26:43.232] - stdout: TRUE
[17:26:43.232] - signal: TRUE
[17:26:43.232] - resignal: FALSE
[17:26:43.232] - force: TRUE
[17:26:43.232] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.233] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.233]  - until=3
[17:26:43.233]  - relaying element #3
[17:26:43.233] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.234] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.234] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.234]  length: 1 (resolved future 3)
[17:26:43.234] resolved() for 'SequentialFuture' ...
[17:26:43.234] - state: 'finished'
[17:26:43.235] - run: TRUE
[17:26:43.235] - result: 'FutureResult'
[17:26:43.235] resolved() for 'SequentialFuture' ... done
[17:26:43.235] Future #4
[17:26:43.236] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.236] - nx: 4
[17:26:43.236] - relay: TRUE
[17:26:43.236] - stdout: TRUE
[17:26:43.236] - signal: TRUE
[17:26:43.237] - resignal: FALSE
[17:26:43.237] - force: TRUE
[17:26:43.237] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.237] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.237]  - until=4
[17:26:43.238]  - relaying element #4
[17:26:43.238] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.238] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.238] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.239]  length: 0 (resolved future 4)
[17:26:43.239] Relaying remaining futures
[17:26:43.239] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.239] - nx: 4
[17:26:43.239] - relay: TRUE
[17:26:43.240] - stdout: TRUE
[17:26:43.240] - signal: TRUE
[17:26:43.240] - resignal: FALSE
[17:26:43.240] - force: TRUE
[17:26:43.240] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.240] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:43.241] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.241] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.241] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.241] resolve() on environment ... DONE
<environment: 0x000002230d585300> 
Dimensions: c(2, 1, 3, 1)
[17:26:43.242] getGlobalsAndPackages() ...
[17:26:43.242] Searching for globals...
[17:26:43.243] 
[17:26:43.243] Searching for globals ... DONE
[17:26:43.243] - globals: [0] <none>
[17:26:43.244] getGlobalsAndPackages() ... DONE
[17:26:43.244] run() for 'Future' ...
[17:26:43.244] - state: 'created'
[17:26:43.244] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.245] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.245] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.245]   - Field: 'label'
[17:26:43.245]   - Field: 'local'
[17:26:43.245]   - Field: 'owner'
[17:26:43.246]   - Field: 'envir'
[17:26:43.246]   - Field: 'packages'
[17:26:43.246]   - Field: 'gc'
[17:26:43.246]   - Field: 'conditions'
[17:26:43.246]   - Field: 'expr'
[17:26:43.247]   - Field: 'uuid'
[17:26:43.247]   - Field: 'seed'
[17:26:43.247]   - Field: 'version'
[17:26:43.247]   - Field: 'result'
[17:26:43.247]   - Field: 'asynchronous'
[17:26:43.248]   - Field: 'calls'
[17:26:43.248]   - Field: 'globals'
[17:26:43.248]   - Field: 'stdout'
[17:26:43.248]   - Field: 'earlySignal'
[17:26:43.248]   - Field: 'lazy'
[17:26:43.248]   - Field: 'state'
[17:26:43.249] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.249] - Launch lazy future ...
[17:26:43.249] Packages needed by the future expression (n = 0): <none>
[17:26:43.249] Packages needed by future strategies (n = 0): <none>
[17:26:43.250] {
[17:26:43.250]     {
[17:26:43.250]         {
[17:26:43.250]             ...future.startTime <- base::Sys.time()
[17:26:43.250]             {
[17:26:43.250]                 {
[17:26:43.250]                   {
[17:26:43.250]                     base::local({
[17:26:43.250]                       has_future <- base::requireNamespace("future", 
[17:26:43.250]                         quietly = TRUE)
[17:26:43.250]                       if (has_future) {
[17:26:43.250]                         ns <- base::getNamespace("future")
[17:26:43.250]                         version <- ns[[".package"]][["version"]]
[17:26:43.250]                         if (is.null(version)) 
[17:26:43.250]                           version <- utils::packageVersion("future")
[17:26:43.250]                       }
[17:26:43.250]                       else {
[17:26:43.250]                         version <- NULL
[17:26:43.250]                       }
[17:26:43.250]                       if (!has_future || version < "1.8.0") {
[17:26:43.250]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.250]                           "", base::R.version$version.string), 
[17:26:43.250]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.250]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.250]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.250]                             "release", "version")], collapse = " "), 
[17:26:43.250]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.250]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.250]                           info)
[17:26:43.250]                         info <- base::paste(info, collapse = "; ")
[17:26:43.250]                         if (!has_future) {
[17:26:43.250]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.250]                             info)
[17:26:43.250]                         }
[17:26:43.250]                         else {
[17:26:43.250]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.250]                             info, version)
[17:26:43.250]                         }
[17:26:43.250]                         base::stop(msg)
[17:26:43.250]                       }
[17:26:43.250]                     })
[17:26:43.250]                   }
[17:26:43.250]                   ...future.strategy.old <- future::plan("list")
[17:26:43.250]                   options(future.plan = NULL)
[17:26:43.250]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.250]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.250]                 }
[17:26:43.250]                 ...future.workdir <- getwd()
[17:26:43.250]             }
[17:26:43.250]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.250]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.250]         }
[17:26:43.250]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.250]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.250]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.250]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.250]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.250]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.250]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.250]             base::names(...future.oldOptions))
[17:26:43.250]     }
[17:26:43.250]     if (FALSE) {
[17:26:43.250]     }
[17:26:43.250]     else {
[17:26:43.250]         if (TRUE) {
[17:26:43.250]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.250]                 open = "w")
[17:26:43.250]         }
[17:26:43.250]         else {
[17:26:43.250]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.250]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.250]         }
[17:26:43.250]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.250]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.250]             base::sink(type = "output", split = FALSE)
[17:26:43.250]             base::close(...future.stdout)
[17:26:43.250]         }, add = TRUE)
[17:26:43.250]     }
[17:26:43.250]     ...future.frame <- base::sys.nframe()
[17:26:43.250]     ...future.conditions <- base::list()
[17:26:43.250]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.250]     if (FALSE) {
[17:26:43.250]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.250]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.250]     }
[17:26:43.250]     ...future.result <- base::tryCatch({
[17:26:43.250]         base::withCallingHandlers({
[17:26:43.250]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.250]             future::FutureResult(value = ...future.value$value, 
[17:26:43.250]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.250]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.250]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.250]                     ...future.globalenv.names))
[17:26:43.250]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.250]         }, condition = base::local({
[17:26:43.250]             c <- base::c
[17:26:43.250]             inherits <- base::inherits
[17:26:43.250]             invokeRestart <- base::invokeRestart
[17:26:43.250]             length <- base::length
[17:26:43.250]             list <- base::list
[17:26:43.250]             seq.int <- base::seq.int
[17:26:43.250]             signalCondition <- base::signalCondition
[17:26:43.250]             sys.calls <- base::sys.calls
[17:26:43.250]             `[[` <- base::`[[`
[17:26:43.250]             `+` <- base::`+`
[17:26:43.250]             `<<-` <- base::`<<-`
[17:26:43.250]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.250]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.250]                   3L)]
[17:26:43.250]             }
[17:26:43.250]             function(cond) {
[17:26:43.250]                 is_error <- inherits(cond, "error")
[17:26:43.250]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.250]                   NULL)
[17:26:43.250]                 if (is_error) {
[17:26:43.250]                   sessionInformation <- function() {
[17:26:43.250]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.250]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.250]                       search = base::search(), system = base::Sys.info())
[17:26:43.250]                   }
[17:26:43.250]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.250]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.250]                     cond$call), session = sessionInformation(), 
[17:26:43.250]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.250]                   signalCondition(cond)
[17:26:43.250]                 }
[17:26:43.250]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.250]                 "immediateCondition"))) {
[17:26:43.250]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.250]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.250]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.250]                   if (TRUE && !signal) {
[17:26:43.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.250]                     {
[17:26:43.250]                       inherits <- base::inherits
[17:26:43.250]                       invokeRestart <- base::invokeRestart
[17:26:43.250]                       is.null <- base::is.null
[17:26:43.250]                       muffled <- FALSE
[17:26:43.250]                       if (inherits(cond, "message")) {
[17:26:43.250]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.250]                         if (muffled) 
[17:26:43.250]                           invokeRestart("muffleMessage")
[17:26:43.250]                       }
[17:26:43.250]                       else if (inherits(cond, "warning")) {
[17:26:43.250]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.250]                         if (muffled) 
[17:26:43.250]                           invokeRestart("muffleWarning")
[17:26:43.250]                       }
[17:26:43.250]                       else if (inherits(cond, "condition")) {
[17:26:43.250]                         if (!is.null(pattern)) {
[17:26:43.250]                           computeRestarts <- base::computeRestarts
[17:26:43.250]                           grepl <- base::grepl
[17:26:43.250]                           restarts <- computeRestarts(cond)
[17:26:43.250]                           for (restart in restarts) {
[17:26:43.250]                             name <- restart$name
[17:26:43.250]                             if (is.null(name)) 
[17:26:43.250]                               next
[17:26:43.250]                             if (!grepl(pattern, name)) 
[17:26:43.250]                               next
[17:26:43.250]                             invokeRestart(restart)
[17:26:43.250]                             muffled <- TRUE
[17:26:43.250]                             break
[17:26:43.250]                           }
[17:26:43.250]                         }
[17:26:43.250]                       }
[17:26:43.250]                       invisible(muffled)
[17:26:43.250]                     }
[17:26:43.250]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.250]                   }
[17:26:43.250]                 }
[17:26:43.250]                 else {
[17:26:43.250]                   if (TRUE) {
[17:26:43.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.250]                     {
[17:26:43.250]                       inherits <- base::inherits
[17:26:43.250]                       invokeRestart <- base::invokeRestart
[17:26:43.250]                       is.null <- base::is.null
[17:26:43.250]                       muffled <- FALSE
[17:26:43.250]                       if (inherits(cond, "message")) {
[17:26:43.250]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.250]                         if (muffled) 
[17:26:43.250]                           invokeRestart("muffleMessage")
[17:26:43.250]                       }
[17:26:43.250]                       else if (inherits(cond, "warning")) {
[17:26:43.250]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.250]                         if (muffled) 
[17:26:43.250]                           invokeRestart("muffleWarning")
[17:26:43.250]                       }
[17:26:43.250]                       else if (inherits(cond, "condition")) {
[17:26:43.250]                         if (!is.null(pattern)) {
[17:26:43.250]                           computeRestarts <- base::computeRestarts
[17:26:43.250]                           grepl <- base::grepl
[17:26:43.250]                           restarts <- computeRestarts(cond)
[17:26:43.250]                           for (restart in restarts) {
[17:26:43.250]                             name <- restart$name
[17:26:43.250]                             if (is.null(name)) 
[17:26:43.250]                               next
[17:26:43.250]                             if (!grepl(pattern, name)) 
[17:26:43.250]                               next
[17:26:43.250]                             invokeRestart(restart)
[17:26:43.250]                             muffled <- TRUE
[17:26:43.250]                             break
[17:26:43.250]                           }
[17:26:43.250]                         }
[17:26:43.250]                       }
[17:26:43.250]                       invisible(muffled)
[17:26:43.250]                     }
[17:26:43.250]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.250]                   }
[17:26:43.250]                 }
[17:26:43.250]             }
[17:26:43.250]         }))
[17:26:43.250]     }, error = function(ex) {
[17:26:43.250]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.250]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.250]                 ...future.rng), started = ...future.startTime, 
[17:26:43.250]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.250]             version = "1.8"), class = "FutureResult")
[17:26:43.250]     }, finally = {
[17:26:43.250]         if (!identical(...future.workdir, getwd())) 
[17:26:43.250]             setwd(...future.workdir)
[17:26:43.250]         {
[17:26:43.250]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.250]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.250]             }
[17:26:43.250]             base::options(...future.oldOptions)
[17:26:43.250]             if (.Platform$OS.type == "windows") {
[17:26:43.250]                 old_names <- names(...future.oldEnvVars)
[17:26:43.250]                 envs <- base::Sys.getenv()
[17:26:43.250]                 names <- names(envs)
[17:26:43.250]                 common <- intersect(names, old_names)
[17:26:43.250]                 added <- setdiff(names, old_names)
[17:26:43.250]                 removed <- setdiff(old_names, names)
[17:26:43.250]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.250]                   envs[common]]
[17:26:43.250]                 NAMES <- toupper(changed)
[17:26:43.250]                 args <- list()
[17:26:43.250]                 for (kk in seq_along(NAMES)) {
[17:26:43.250]                   name <- changed[[kk]]
[17:26:43.250]                   NAME <- NAMES[[kk]]
[17:26:43.250]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.250]                     next
[17:26:43.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.250]                 }
[17:26:43.250]                 NAMES <- toupper(added)
[17:26:43.250]                 for (kk in seq_along(NAMES)) {
[17:26:43.250]                   name <- added[[kk]]
[17:26:43.250]                   NAME <- NAMES[[kk]]
[17:26:43.250]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.250]                     next
[17:26:43.250]                   args[[name]] <- ""
[17:26:43.250]                 }
[17:26:43.250]                 NAMES <- toupper(removed)
[17:26:43.250]                 for (kk in seq_along(NAMES)) {
[17:26:43.250]                   name <- removed[[kk]]
[17:26:43.250]                   NAME <- NAMES[[kk]]
[17:26:43.250]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.250]                     next
[17:26:43.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.250]                 }
[17:26:43.250]                 if (length(args) > 0) 
[17:26:43.250]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.250]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.250]             }
[17:26:43.250]             else {
[17:26:43.250]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.250]             }
[17:26:43.250]             {
[17:26:43.250]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.250]                   0L) {
[17:26:43.250]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.250]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.250]                   base::options(opts)
[17:26:43.250]                 }
[17:26:43.250]                 {
[17:26:43.250]                   {
[17:26:43.250]                     NULL
[17:26:43.250]                     RNGkind("Mersenne-Twister")
[17:26:43.250]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.250]                       inherits = FALSE)
[17:26:43.250]                   }
[17:26:43.250]                   options(future.plan = NULL)
[17:26:43.250]                   if (is.na(NA_character_)) 
[17:26:43.250]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.250]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.250]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.250]                     .init = FALSE)
[17:26:43.250]                 }
[17:26:43.250]             }
[17:26:43.250]         }
[17:26:43.250]     })
[17:26:43.250]     if (TRUE) {
[17:26:43.250]         base::sink(type = "output", split = FALSE)
[17:26:43.250]         if (TRUE) {
[17:26:43.250]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.250]         }
[17:26:43.250]         else {
[17:26:43.250]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.250]         }
[17:26:43.250]         base::close(...future.stdout)
[17:26:43.250]         ...future.stdout <- NULL
[17:26:43.250]     }
[17:26:43.250]     ...future.result$conditions <- ...future.conditions
[17:26:43.250]     ...future.result$finished <- base::Sys.time()
[17:26:43.250]     ...future.result
[17:26:43.250] }
[17:26:43.254] plan(): Setting new future strategy stack:
[17:26:43.254] List of future strategies:
[17:26:43.254] 1. sequential:
[17:26:43.254]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.254]    - tweaked: FALSE
[17:26:43.254]    - call: NULL
[17:26:43.255] plan(): nbrOfWorkers() = 1
[17:26:43.257] plan(): Setting new future strategy stack:
[17:26:43.257] List of future strategies:
[17:26:43.257] 1. sequential:
[17:26:43.257]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.257]    - tweaked: FALSE
[17:26:43.257]    - call: plan(strategy)
[17:26:43.257] plan(): nbrOfWorkers() = 1
[17:26:43.258] SequentialFuture started (and completed)
[17:26:43.258] - Launch lazy future ... done
[17:26:43.258] run() for 'SequentialFuture' ... done
[17:26:43.258] getGlobalsAndPackages() ...
[17:26:43.259] Searching for globals...
[17:26:43.259] 
[17:26:43.259] Searching for globals ... DONE
[17:26:43.259] - globals: [0] <none>
[17:26:43.260] getGlobalsAndPackages() ... DONE
[17:26:43.260] run() for 'Future' ...
[17:26:43.260] - state: 'created'
[17:26:43.260] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.261] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.261] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.261]   - Field: 'label'
[17:26:43.261]   - Field: 'local'
[17:26:43.262]   - Field: 'owner'
[17:26:43.262]   - Field: 'envir'
[17:26:43.262]   - Field: 'packages'
[17:26:43.262]   - Field: 'gc'
[17:26:43.262]   - Field: 'conditions'
[17:26:43.263]   - Field: 'expr'
[17:26:43.263]   - Field: 'uuid'
[17:26:43.263]   - Field: 'seed'
[17:26:43.263]   - Field: 'version'
[17:26:43.263]   - Field: 'result'
[17:26:43.264]   - Field: 'asynchronous'
[17:26:43.264]   - Field: 'calls'
[17:26:43.264]   - Field: 'globals'
[17:26:43.264]   - Field: 'stdout'
[17:26:43.264]   - Field: 'earlySignal'
[17:26:43.265]   - Field: 'lazy'
[17:26:43.265]   - Field: 'state'
[17:26:43.265] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.265] - Launch lazy future ...
[17:26:43.266] Packages needed by the future expression (n = 0): <none>
[17:26:43.266] Packages needed by future strategies (n = 0): <none>
[17:26:43.266] {
[17:26:43.266]     {
[17:26:43.266]         {
[17:26:43.266]             ...future.startTime <- base::Sys.time()
[17:26:43.266]             {
[17:26:43.266]                 {
[17:26:43.266]                   {
[17:26:43.266]                     base::local({
[17:26:43.266]                       has_future <- base::requireNamespace("future", 
[17:26:43.266]                         quietly = TRUE)
[17:26:43.266]                       if (has_future) {
[17:26:43.266]                         ns <- base::getNamespace("future")
[17:26:43.266]                         version <- ns[[".package"]][["version"]]
[17:26:43.266]                         if (is.null(version)) 
[17:26:43.266]                           version <- utils::packageVersion("future")
[17:26:43.266]                       }
[17:26:43.266]                       else {
[17:26:43.266]                         version <- NULL
[17:26:43.266]                       }
[17:26:43.266]                       if (!has_future || version < "1.8.0") {
[17:26:43.266]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.266]                           "", base::R.version$version.string), 
[17:26:43.266]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.266]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.266]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.266]                             "release", "version")], collapse = " "), 
[17:26:43.266]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.266]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.266]                           info)
[17:26:43.266]                         info <- base::paste(info, collapse = "; ")
[17:26:43.266]                         if (!has_future) {
[17:26:43.266]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.266]                             info)
[17:26:43.266]                         }
[17:26:43.266]                         else {
[17:26:43.266]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.266]                             info, version)
[17:26:43.266]                         }
[17:26:43.266]                         base::stop(msg)
[17:26:43.266]                       }
[17:26:43.266]                     })
[17:26:43.266]                   }
[17:26:43.266]                   ...future.strategy.old <- future::plan("list")
[17:26:43.266]                   options(future.plan = NULL)
[17:26:43.266]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.266]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.266]                 }
[17:26:43.266]                 ...future.workdir <- getwd()
[17:26:43.266]             }
[17:26:43.266]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.266]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.266]         }
[17:26:43.266]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.266]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.266]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.266]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.266]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.266]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.266]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.266]             base::names(...future.oldOptions))
[17:26:43.266]     }
[17:26:43.266]     if (FALSE) {
[17:26:43.266]     }
[17:26:43.266]     else {
[17:26:43.266]         if (TRUE) {
[17:26:43.266]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.266]                 open = "w")
[17:26:43.266]         }
[17:26:43.266]         else {
[17:26:43.266]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.266]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.266]         }
[17:26:43.266]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.266]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.266]             base::sink(type = "output", split = FALSE)
[17:26:43.266]             base::close(...future.stdout)
[17:26:43.266]         }, add = TRUE)
[17:26:43.266]     }
[17:26:43.266]     ...future.frame <- base::sys.nframe()
[17:26:43.266]     ...future.conditions <- base::list()
[17:26:43.266]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.266]     if (FALSE) {
[17:26:43.266]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.266]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.266]     }
[17:26:43.266]     ...future.result <- base::tryCatch({
[17:26:43.266]         base::withCallingHandlers({
[17:26:43.266]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.266]             future::FutureResult(value = ...future.value$value, 
[17:26:43.266]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.266]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.266]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.266]                     ...future.globalenv.names))
[17:26:43.266]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.266]         }, condition = base::local({
[17:26:43.266]             c <- base::c
[17:26:43.266]             inherits <- base::inherits
[17:26:43.266]             invokeRestart <- base::invokeRestart
[17:26:43.266]             length <- base::length
[17:26:43.266]             list <- base::list
[17:26:43.266]             seq.int <- base::seq.int
[17:26:43.266]             signalCondition <- base::signalCondition
[17:26:43.266]             sys.calls <- base::sys.calls
[17:26:43.266]             `[[` <- base::`[[`
[17:26:43.266]             `+` <- base::`+`
[17:26:43.266]             `<<-` <- base::`<<-`
[17:26:43.266]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.266]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.266]                   3L)]
[17:26:43.266]             }
[17:26:43.266]             function(cond) {
[17:26:43.266]                 is_error <- inherits(cond, "error")
[17:26:43.266]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.266]                   NULL)
[17:26:43.266]                 if (is_error) {
[17:26:43.266]                   sessionInformation <- function() {
[17:26:43.266]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.266]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.266]                       search = base::search(), system = base::Sys.info())
[17:26:43.266]                   }
[17:26:43.266]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.266]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.266]                     cond$call), session = sessionInformation(), 
[17:26:43.266]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.266]                   signalCondition(cond)
[17:26:43.266]                 }
[17:26:43.266]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.266]                 "immediateCondition"))) {
[17:26:43.266]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.266]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.266]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.266]                   if (TRUE && !signal) {
[17:26:43.266]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.266]                     {
[17:26:43.266]                       inherits <- base::inherits
[17:26:43.266]                       invokeRestart <- base::invokeRestart
[17:26:43.266]                       is.null <- base::is.null
[17:26:43.266]                       muffled <- FALSE
[17:26:43.266]                       if (inherits(cond, "message")) {
[17:26:43.266]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.266]                         if (muffled) 
[17:26:43.266]                           invokeRestart("muffleMessage")
[17:26:43.266]                       }
[17:26:43.266]                       else if (inherits(cond, "warning")) {
[17:26:43.266]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.266]                         if (muffled) 
[17:26:43.266]                           invokeRestart("muffleWarning")
[17:26:43.266]                       }
[17:26:43.266]                       else if (inherits(cond, "condition")) {
[17:26:43.266]                         if (!is.null(pattern)) {
[17:26:43.266]                           computeRestarts <- base::computeRestarts
[17:26:43.266]                           grepl <- base::grepl
[17:26:43.266]                           restarts <- computeRestarts(cond)
[17:26:43.266]                           for (restart in restarts) {
[17:26:43.266]                             name <- restart$name
[17:26:43.266]                             if (is.null(name)) 
[17:26:43.266]                               next
[17:26:43.266]                             if (!grepl(pattern, name)) 
[17:26:43.266]                               next
[17:26:43.266]                             invokeRestart(restart)
[17:26:43.266]                             muffled <- TRUE
[17:26:43.266]                             break
[17:26:43.266]                           }
[17:26:43.266]                         }
[17:26:43.266]                       }
[17:26:43.266]                       invisible(muffled)
[17:26:43.266]                     }
[17:26:43.266]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.266]                   }
[17:26:43.266]                 }
[17:26:43.266]                 else {
[17:26:43.266]                   if (TRUE) {
[17:26:43.266]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.266]                     {
[17:26:43.266]                       inherits <- base::inherits
[17:26:43.266]                       invokeRestart <- base::invokeRestart
[17:26:43.266]                       is.null <- base::is.null
[17:26:43.266]                       muffled <- FALSE
[17:26:43.266]                       if (inherits(cond, "message")) {
[17:26:43.266]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.266]                         if (muffled) 
[17:26:43.266]                           invokeRestart("muffleMessage")
[17:26:43.266]                       }
[17:26:43.266]                       else if (inherits(cond, "warning")) {
[17:26:43.266]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.266]                         if (muffled) 
[17:26:43.266]                           invokeRestart("muffleWarning")
[17:26:43.266]                       }
[17:26:43.266]                       else if (inherits(cond, "condition")) {
[17:26:43.266]                         if (!is.null(pattern)) {
[17:26:43.266]                           computeRestarts <- base::computeRestarts
[17:26:43.266]                           grepl <- base::grepl
[17:26:43.266]                           restarts <- computeRestarts(cond)
[17:26:43.266]                           for (restart in restarts) {
[17:26:43.266]                             name <- restart$name
[17:26:43.266]                             if (is.null(name)) 
[17:26:43.266]                               next
[17:26:43.266]                             if (!grepl(pattern, name)) 
[17:26:43.266]                               next
[17:26:43.266]                             invokeRestart(restart)
[17:26:43.266]                             muffled <- TRUE
[17:26:43.266]                             break
[17:26:43.266]                           }
[17:26:43.266]                         }
[17:26:43.266]                       }
[17:26:43.266]                       invisible(muffled)
[17:26:43.266]                     }
[17:26:43.266]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.266]                   }
[17:26:43.266]                 }
[17:26:43.266]             }
[17:26:43.266]         }))
[17:26:43.266]     }, error = function(ex) {
[17:26:43.266]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.266]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.266]                 ...future.rng), started = ...future.startTime, 
[17:26:43.266]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.266]             version = "1.8"), class = "FutureResult")
[17:26:43.266]     }, finally = {
[17:26:43.266]         if (!identical(...future.workdir, getwd())) 
[17:26:43.266]             setwd(...future.workdir)
[17:26:43.266]         {
[17:26:43.266]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.266]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.266]             }
[17:26:43.266]             base::options(...future.oldOptions)
[17:26:43.266]             if (.Platform$OS.type == "windows") {
[17:26:43.266]                 old_names <- names(...future.oldEnvVars)
[17:26:43.266]                 envs <- base::Sys.getenv()
[17:26:43.266]                 names <- names(envs)
[17:26:43.266]                 common <- intersect(names, old_names)
[17:26:43.266]                 added <- setdiff(names, old_names)
[17:26:43.266]                 removed <- setdiff(old_names, names)
[17:26:43.266]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.266]                   envs[common]]
[17:26:43.266]                 NAMES <- toupper(changed)
[17:26:43.266]                 args <- list()
[17:26:43.266]                 for (kk in seq_along(NAMES)) {
[17:26:43.266]                   name <- changed[[kk]]
[17:26:43.266]                   NAME <- NAMES[[kk]]
[17:26:43.266]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.266]                     next
[17:26:43.266]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.266]                 }
[17:26:43.266]                 NAMES <- toupper(added)
[17:26:43.266]                 for (kk in seq_along(NAMES)) {
[17:26:43.266]                   name <- added[[kk]]
[17:26:43.266]                   NAME <- NAMES[[kk]]
[17:26:43.266]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.266]                     next
[17:26:43.266]                   args[[name]] <- ""
[17:26:43.266]                 }
[17:26:43.266]                 NAMES <- toupper(removed)
[17:26:43.266]                 for (kk in seq_along(NAMES)) {
[17:26:43.266]                   name <- removed[[kk]]
[17:26:43.266]                   NAME <- NAMES[[kk]]
[17:26:43.266]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.266]                     next
[17:26:43.266]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.266]                 }
[17:26:43.266]                 if (length(args) > 0) 
[17:26:43.266]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.266]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.266]             }
[17:26:43.266]             else {
[17:26:43.266]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.266]             }
[17:26:43.266]             {
[17:26:43.266]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.266]                   0L) {
[17:26:43.266]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.266]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.266]                   base::options(opts)
[17:26:43.266]                 }
[17:26:43.266]                 {
[17:26:43.266]                   {
[17:26:43.266]                     NULL
[17:26:43.266]                     RNGkind("Mersenne-Twister")
[17:26:43.266]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.266]                       inherits = FALSE)
[17:26:43.266]                   }
[17:26:43.266]                   options(future.plan = NULL)
[17:26:43.266]                   if (is.na(NA_character_)) 
[17:26:43.266]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.266]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.266]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.266]                     .init = FALSE)
[17:26:43.266]                 }
[17:26:43.266]             }
[17:26:43.266]         }
[17:26:43.266]     })
[17:26:43.266]     if (TRUE) {
[17:26:43.266]         base::sink(type = "output", split = FALSE)
[17:26:43.266]         if (TRUE) {
[17:26:43.266]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.266]         }
[17:26:43.266]         else {
[17:26:43.266]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.266]         }
[17:26:43.266]         base::close(...future.stdout)
[17:26:43.266]         ...future.stdout <- NULL
[17:26:43.266]     }
[17:26:43.266]     ...future.result$conditions <- ...future.conditions
[17:26:43.266]     ...future.result$finished <- base::Sys.time()
[17:26:43.266]     ...future.result
[17:26:43.266] }
[17:26:43.271] plan(): Setting new future strategy stack:
[17:26:43.271] List of future strategies:
[17:26:43.271] 1. sequential:
[17:26:43.271]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.271]    - tweaked: FALSE
[17:26:43.271]    - call: NULL
[17:26:43.271] plan(): nbrOfWorkers() = 1
[17:26:43.273] plan(): Setting new future strategy stack:
[17:26:43.273] List of future strategies:
[17:26:43.273] 1. sequential:
[17:26:43.273]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.273]    - tweaked: FALSE
[17:26:43.273]    - call: plan(strategy)
[17:26:43.274] plan(): nbrOfWorkers() = 1
[17:26:43.275] SequentialFuture started (and completed)
[17:26:43.275] - Launch lazy future ... done
[17:26:43.275] run() for 'SequentialFuture' ... done
[17:26:43.276] getGlobalsAndPackages() ...
[17:26:43.276] Searching for globals...
[17:26:43.277] - globals found: [1] '{'
[17:26:43.277] Searching for globals ... DONE
[17:26:43.277] Resolving globals: FALSE
[17:26:43.277] 
[17:26:43.278] 
[17:26:43.278] getGlobalsAndPackages() ... DONE
[17:26:43.278] run() for 'Future' ...
[17:26:43.278] - state: 'created'
[17:26:43.278] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.279] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.279] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.279]   - Field: 'label'
[17:26:43.279]   - Field: 'local'
[17:26:43.280]   - Field: 'owner'
[17:26:43.280]   - Field: 'envir'
[17:26:43.280]   - Field: 'packages'
[17:26:43.280]   - Field: 'gc'
[17:26:43.280]   - Field: 'conditions'
[17:26:43.280]   - Field: 'expr'
[17:26:43.281]   - Field: 'uuid'
[17:26:43.281]   - Field: 'seed'
[17:26:43.281]   - Field: 'version'
[17:26:43.281]   - Field: 'result'
[17:26:43.281]   - Field: 'asynchronous'
[17:26:43.281]   - Field: 'calls'
[17:26:43.282]   - Field: 'globals'
[17:26:43.282]   - Field: 'stdout'
[17:26:43.282]   - Field: 'earlySignal'
[17:26:43.282]   - Field: 'lazy'
[17:26:43.283]   - Field: 'state'
[17:26:43.283] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.283] - Launch lazy future ...
[17:26:43.283] Packages needed by the future expression (n = 0): <none>
[17:26:43.283] Packages needed by future strategies (n = 0): <none>
[17:26:43.284] {
[17:26:43.284]     {
[17:26:43.284]         {
[17:26:43.284]             ...future.startTime <- base::Sys.time()
[17:26:43.284]             {
[17:26:43.284]                 {
[17:26:43.284]                   {
[17:26:43.284]                     base::local({
[17:26:43.284]                       has_future <- base::requireNamespace("future", 
[17:26:43.284]                         quietly = TRUE)
[17:26:43.284]                       if (has_future) {
[17:26:43.284]                         ns <- base::getNamespace("future")
[17:26:43.284]                         version <- ns[[".package"]][["version"]]
[17:26:43.284]                         if (is.null(version)) 
[17:26:43.284]                           version <- utils::packageVersion("future")
[17:26:43.284]                       }
[17:26:43.284]                       else {
[17:26:43.284]                         version <- NULL
[17:26:43.284]                       }
[17:26:43.284]                       if (!has_future || version < "1.8.0") {
[17:26:43.284]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.284]                           "", base::R.version$version.string), 
[17:26:43.284]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.284]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.284]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.284]                             "release", "version")], collapse = " "), 
[17:26:43.284]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.284]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.284]                           info)
[17:26:43.284]                         info <- base::paste(info, collapse = "; ")
[17:26:43.284]                         if (!has_future) {
[17:26:43.284]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.284]                             info)
[17:26:43.284]                         }
[17:26:43.284]                         else {
[17:26:43.284]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.284]                             info, version)
[17:26:43.284]                         }
[17:26:43.284]                         base::stop(msg)
[17:26:43.284]                       }
[17:26:43.284]                     })
[17:26:43.284]                   }
[17:26:43.284]                   ...future.strategy.old <- future::plan("list")
[17:26:43.284]                   options(future.plan = NULL)
[17:26:43.284]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.284]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.284]                 }
[17:26:43.284]                 ...future.workdir <- getwd()
[17:26:43.284]             }
[17:26:43.284]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.284]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.284]         }
[17:26:43.284]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.284]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.284]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.284]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.284]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.284]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.284]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.284]             base::names(...future.oldOptions))
[17:26:43.284]     }
[17:26:43.284]     if (FALSE) {
[17:26:43.284]     }
[17:26:43.284]     else {
[17:26:43.284]         if (TRUE) {
[17:26:43.284]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.284]                 open = "w")
[17:26:43.284]         }
[17:26:43.284]         else {
[17:26:43.284]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.284]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.284]         }
[17:26:43.284]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.284]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.284]             base::sink(type = "output", split = FALSE)
[17:26:43.284]             base::close(...future.stdout)
[17:26:43.284]         }, add = TRUE)
[17:26:43.284]     }
[17:26:43.284]     ...future.frame <- base::sys.nframe()
[17:26:43.284]     ...future.conditions <- base::list()
[17:26:43.284]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.284]     if (FALSE) {
[17:26:43.284]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.284]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.284]     }
[17:26:43.284]     ...future.result <- base::tryCatch({
[17:26:43.284]         base::withCallingHandlers({
[17:26:43.284]             ...future.value <- base::withVisible(base::local({
[17:26:43.284]                 4
[17:26:43.284]             }))
[17:26:43.284]             future::FutureResult(value = ...future.value$value, 
[17:26:43.284]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.284]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.284]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.284]                     ...future.globalenv.names))
[17:26:43.284]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.284]         }, condition = base::local({
[17:26:43.284]             c <- base::c
[17:26:43.284]             inherits <- base::inherits
[17:26:43.284]             invokeRestart <- base::invokeRestart
[17:26:43.284]             length <- base::length
[17:26:43.284]             list <- base::list
[17:26:43.284]             seq.int <- base::seq.int
[17:26:43.284]             signalCondition <- base::signalCondition
[17:26:43.284]             sys.calls <- base::sys.calls
[17:26:43.284]             `[[` <- base::`[[`
[17:26:43.284]             `+` <- base::`+`
[17:26:43.284]             `<<-` <- base::`<<-`
[17:26:43.284]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.284]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.284]                   3L)]
[17:26:43.284]             }
[17:26:43.284]             function(cond) {
[17:26:43.284]                 is_error <- inherits(cond, "error")
[17:26:43.284]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.284]                   NULL)
[17:26:43.284]                 if (is_error) {
[17:26:43.284]                   sessionInformation <- function() {
[17:26:43.284]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.284]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.284]                       search = base::search(), system = base::Sys.info())
[17:26:43.284]                   }
[17:26:43.284]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.284]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.284]                     cond$call), session = sessionInformation(), 
[17:26:43.284]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.284]                   signalCondition(cond)
[17:26:43.284]                 }
[17:26:43.284]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.284]                 "immediateCondition"))) {
[17:26:43.284]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.284]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.284]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.284]                   if (TRUE && !signal) {
[17:26:43.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.284]                     {
[17:26:43.284]                       inherits <- base::inherits
[17:26:43.284]                       invokeRestart <- base::invokeRestart
[17:26:43.284]                       is.null <- base::is.null
[17:26:43.284]                       muffled <- FALSE
[17:26:43.284]                       if (inherits(cond, "message")) {
[17:26:43.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.284]                         if (muffled) 
[17:26:43.284]                           invokeRestart("muffleMessage")
[17:26:43.284]                       }
[17:26:43.284]                       else if (inherits(cond, "warning")) {
[17:26:43.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.284]                         if (muffled) 
[17:26:43.284]                           invokeRestart("muffleWarning")
[17:26:43.284]                       }
[17:26:43.284]                       else if (inherits(cond, "condition")) {
[17:26:43.284]                         if (!is.null(pattern)) {
[17:26:43.284]                           computeRestarts <- base::computeRestarts
[17:26:43.284]                           grepl <- base::grepl
[17:26:43.284]                           restarts <- computeRestarts(cond)
[17:26:43.284]                           for (restart in restarts) {
[17:26:43.284]                             name <- restart$name
[17:26:43.284]                             if (is.null(name)) 
[17:26:43.284]                               next
[17:26:43.284]                             if (!grepl(pattern, name)) 
[17:26:43.284]                               next
[17:26:43.284]                             invokeRestart(restart)
[17:26:43.284]                             muffled <- TRUE
[17:26:43.284]                             break
[17:26:43.284]                           }
[17:26:43.284]                         }
[17:26:43.284]                       }
[17:26:43.284]                       invisible(muffled)
[17:26:43.284]                     }
[17:26:43.284]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.284]                   }
[17:26:43.284]                 }
[17:26:43.284]                 else {
[17:26:43.284]                   if (TRUE) {
[17:26:43.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.284]                     {
[17:26:43.284]                       inherits <- base::inherits
[17:26:43.284]                       invokeRestart <- base::invokeRestart
[17:26:43.284]                       is.null <- base::is.null
[17:26:43.284]                       muffled <- FALSE
[17:26:43.284]                       if (inherits(cond, "message")) {
[17:26:43.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.284]                         if (muffled) 
[17:26:43.284]                           invokeRestart("muffleMessage")
[17:26:43.284]                       }
[17:26:43.284]                       else if (inherits(cond, "warning")) {
[17:26:43.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.284]                         if (muffled) 
[17:26:43.284]                           invokeRestart("muffleWarning")
[17:26:43.284]                       }
[17:26:43.284]                       else if (inherits(cond, "condition")) {
[17:26:43.284]                         if (!is.null(pattern)) {
[17:26:43.284]                           computeRestarts <- base::computeRestarts
[17:26:43.284]                           grepl <- base::grepl
[17:26:43.284]                           restarts <- computeRestarts(cond)
[17:26:43.284]                           for (restart in restarts) {
[17:26:43.284]                             name <- restart$name
[17:26:43.284]                             if (is.null(name)) 
[17:26:43.284]                               next
[17:26:43.284]                             if (!grepl(pattern, name)) 
[17:26:43.284]                               next
[17:26:43.284]                             invokeRestart(restart)
[17:26:43.284]                             muffled <- TRUE
[17:26:43.284]                             break
[17:26:43.284]                           }
[17:26:43.284]                         }
[17:26:43.284]                       }
[17:26:43.284]                       invisible(muffled)
[17:26:43.284]                     }
[17:26:43.284]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.284]                   }
[17:26:43.284]                 }
[17:26:43.284]             }
[17:26:43.284]         }))
[17:26:43.284]     }, error = function(ex) {
[17:26:43.284]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.284]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.284]                 ...future.rng), started = ...future.startTime, 
[17:26:43.284]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.284]             version = "1.8"), class = "FutureResult")
[17:26:43.284]     }, finally = {
[17:26:43.284]         if (!identical(...future.workdir, getwd())) 
[17:26:43.284]             setwd(...future.workdir)
[17:26:43.284]         {
[17:26:43.284]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.284]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.284]             }
[17:26:43.284]             base::options(...future.oldOptions)
[17:26:43.284]             if (.Platform$OS.type == "windows") {
[17:26:43.284]                 old_names <- names(...future.oldEnvVars)
[17:26:43.284]                 envs <- base::Sys.getenv()
[17:26:43.284]                 names <- names(envs)
[17:26:43.284]                 common <- intersect(names, old_names)
[17:26:43.284]                 added <- setdiff(names, old_names)
[17:26:43.284]                 removed <- setdiff(old_names, names)
[17:26:43.284]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.284]                   envs[common]]
[17:26:43.284]                 NAMES <- toupper(changed)
[17:26:43.284]                 args <- list()
[17:26:43.284]                 for (kk in seq_along(NAMES)) {
[17:26:43.284]                   name <- changed[[kk]]
[17:26:43.284]                   NAME <- NAMES[[kk]]
[17:26:43.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.284]                     next
[17:26:43.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.284]                 }
[17:26:43.284]                 NAMES <- toupper(added)
[17:26:43.284]                 for (kk in seq_along(NAMES)) {
[17:26:43.284]                   name <- added[[kk]]
[17:26:43.284]                   NAME <- NAMES[[kk]]
[17:26:43.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.284]                     next
[17:26:43.284]                   args[[name]] <- ""
[17:26:43.284]                 }
[17:26:43.284]                 NAMES <- toupper(removed)
[17:26:43.284]                 for (kk in seq_along(NAMES)) {
[17:26:43.284]                   name <- removed[[kk]]
[17:26:43.284]                   NAME <- NAMES[[kk]]
[17:26:43.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.284]                     next
[17:26:43.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.284]                 }
[17:26:43.284]                 if (length(args) > 0) 
[17:26:43.284]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.284]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.284]             }
[17:26:43.284]             else {
[17:26:43.284]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.284]             }
[17:26:43.284]             {
[17:26:43.284]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.284]                   0L) {
[17:26:43.284]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.284]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.284]                   base::options(opts)
[17:26:43.284]                 }
[17:26:43.284]                 {
[17:26:43.284]                   {
[17:26:43.284]                     NULL
[17:26:43.284]                     RNGkind("Mersenne-Twister")
[17:26:43.284]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.284]                       inherits = FALSE)
[17:26:43.284]                   }
[17:26:43.284]                   options(future.plan = NULL)
[17:26:43.284]                   if (is.na(NA_character_)) 
[17:26:43.284]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.284]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.284]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.284]                     .init = FALSE)
[17:26:43.284]                 }
[17:26:43.284]             }
[17:26:43.284]         }
[17:26:43.284]     })
[17:26:43.284]     if (TRUE) {
[17:26:43.284]         base::sink(type = "output", split = FALSE)
[17:26:43.284]         if (TRUE) {
[17:26:43.284]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.284]         }
[17:26:43.284]         else {
[17:26:43.284]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.284]         }
[17:26:43.284]         base::close(...future.stdout)
[17:26:43.284]         ...future.stdout <- NULL
[17:26:43.284]     }
[17:26:43.284]     ...future.result$conditions <- ...future.conditions
[17:26:43.284]     ...future.result$finished <- base::Sys.time()
[17:26:43.284]     ...future.result
[17:26:43.284] }
[17:26:43.288] plan(): Setting new future strategy stack:
[17:26:43.288] List of future strategies:
[17:26:43.288] 1. sequential:
[17:26:43.288]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.288]    - tweaked: FALSE
[17:26:43.288]    - call: NULL
[17:26:43.289] plan(): nbrOfWorkers() = 1
[17:26:43.290] plan(): Setting new future strategy stack:
[17:26:43.290] List of future strategies:
[17:26:43.290] 1. sequential:
[17:26:43.290]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.290]    - tweaked: FALSE
[17:26:43.290]    - call: plan(strategy)
[17:26:43.291] plan(): nbrOfWorkers() = 1
[17:26:43.291] SequentialFuture started (and completed)
[17:26:43.291] - Launch lazy future ... done
[17:26:43.291] run() for 'SequentialFuture' ... done
<environment: 0x000002230c45a450> 
<environment: 0x0000022309e14df0> 
[17:26:43.293] resolved() for 'SequentialFuture' ...
[17:26:43.293] - state: 'finished'
[17:26:43.294] - run: TRUE
[17:26:43.294] - result: 'FutureResult'
[17:26:43.294] resolved() for 'SequentialFuture' ... done
[17:26:43.294] resolved() for 'SequentialFuture' ...
[17:26:43.294] - state: 'finished'
[17:26:43.295] - run: TRUE
[17:26:43.295] - result: 'FutureResult'
[17:26:43.295] resolved() for 'SequentialFuture' ... done
[17:26:43.295] resolved() for 'SequentialFuture' ...
[17:26:43.295] - state: 'finished'
[17:26:43.295] - run: TRUE
[17:26:43.296] - result: 'FutureResult'
[17:26:43.296] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:43.297] resolve() on environment ...
[17:26:43.297]  recursive: 0
[17:26:43.298]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:43.298] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.299] - nx: 4
[17:26:43.299] - relay: TRUE
[17:26:43.299] - stdout: TRUE
[17:26:43.299] - signal: TRUE
[17:26:43.299] - resignal: FALSE
[17:26:43.299] - force: TRUE
[17:26:43.300] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.300] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.300]  - until=2
[17:26:43.300]  - relaying element #2
[17:26:43.300] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.301] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.301] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.301]  length: 3 (resolved future 1)
[17:26:43.301] resolved() for 'SequentialFuture' ...
[17:26:43.301] - state: 'finished'
[17:26:43.302] - run: TRUE
[17:26:43.302] - result: 'FutureResult'
[17:26:43.302] resolved() for 'SequentialFuture' ... done
[17:26:43.302] Future #2
[17:26:43.302] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.303] - nx: 4
[17:26:43.303] - relay: TRUE
[17:26:43.303] - stdout: TRUE
[17:26:43.303] - signal: TRUE
[17:26:43.303] - resignal: FALSE
[17:26:43.304] - force: TRUE
[17:26:43.304] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:43.304] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:43.304]  - until=2
[17:26:43.304]  - relaying element #2
[17:26:43.305] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.305] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.305] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.305]  length: 2 (resolved future 2)
[17:26:43.305] resolved() for 'SequentialFuture' ...
[17:26:43.306] - state: 'finished'
[17:26:43.306] - run: TRUE
[17:26:43.306] - result: 'FutureResult'
[17:26:43.306] resolved() for 'SequentialFuture' ... done
[17:26:43.306] Future #3
[17:26:43.307] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.307] - nx: 4
[17:26:43.307] - relay: TRUE
[17:26:43.307] - stdout: TRUE
[17:26:43.307] - signal: TRUE
[17:26:43.307] - resignal: FALSE
[17:26:43.308] - force: TRUE
[17:26:43.308] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:43.308] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:43.308]  - until=3
[17:26:43.308]  - relaying element #3
[17:26:43.309] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.309] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.309] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.309]  length: 1 (resolved future 3)
[17:26:43.309] resolved() for 'SequentialFuture' ...
[17:26:43.310] - state: 'finished'
[17:26:43.310] - run: TRUE
[17:26:43.310] - result: 'FutureResult'
[17:26:43.310] resolved() for 'SequentialFuture' ... done
[17:26:43.310] Future #4
[17:26:43.311] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.311] - nx: 4
[17:26:43.311] - relay: TRUE
[17:26:43.311] - stdout: TRUE
[17:26:43.311] - signal: TRUE
[17:26:43.311] - resignal: FALSE
[17:26:43.312] - force: TRUE
[17:26:43.312] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:43.312] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:43.312]  - until=4
[17:26:43.312]  - relaying element #4
[17:26:43.312] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.313] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.313] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.313]  length: 0 (resolved future 4)
[17:26:43.313] Relaying remaining futures
[17:26:43.313] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.314] - nx: 4
[17:26:43.314] - relay: TRUE
[17:26:43.314] - stdout: TRUE
[17:26:43.315] - signal: TRUE
[17:26:43.315] - resignal: FALSE
[17:26:43.315] - force: TRUE
[17:26:43.315] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.315] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:43.315] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:43.316] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:43.316] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.316] resolve() on environment ... DONE
<environment: 0x000002230ccc05e0> 
*** futures() - environment ... DONE
Type of object: listenv
Type of future: sequential
[17:26:43.317] plan(): Setting new future strategy stack:
[17:26:43.317] List of future strategies:
[17:26:43.317] 1. sequential:
[17:26:43.317]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.317]    - tweaked: FALSE
[17:26:43.317]    - call: plan(strategy)
[17:26:43.318] plan(): nbrOfWorkers() = 1
Dimensions: NULL
[17:26:43.318] getGlobalsAndPackages() ...
[17:26:43.318] Searching for globals...
[17:26:43.319] 
[17:26:43.319] Searching for globals ... DONE
[17:26:43.319] - globals: [0] <none>
[17:26:43.319] getGlobalsAndPackages() ... DONE
[17:26:43.320] run() for 'Future' ...
[17:26:43.320] - state: 'created'
[17:26:43.320] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.320] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.321] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.321]   - Field: 'label'
[17:26:43.321]   - Field: 'local'
[17:26:43.321]   - Field: 'owner'
[17:26:43.321]   - Field: 'envir'
[17:26:43.322]   - Field: 'packages'
[17:26:43.322]   - Field: 'gc'
[17:26:43.322]   - Field: 'conditions'
[17:26:43.322]   - Field: 'expr'
[17:26:43.322]   - Field: 'uuid'
[17:26:43.322]   - Field: 'seed'
[17:26:43.323]   - Field: 'version'
[17:26:43.323]   - Field: 'result'
[17:26:43.323]   - Field: 'asynchronous'
[17:26:43.323]   - Field: 'calls'
[17:26:43.323]   - Field: 'globals'
[17:26:43.324]   - Field: 'stdout'
[17:26:43.324]   - Field: 'earlySignal'
[17:26:43.324]   - Field: 'lazy'
[17:26:43.324]   - Field: 'state'
[17:26:43.324] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.324] - Launch lazy future ...
[17:26:43.325] Packages needed by the future expression (n = 0): <none>
[17:26:43.325] Packages needed by future strategies (n = 0): <none>
[17:26:43.326] {
[17:26:43.326]     {
[17:26:43.326]         {
[17:26:43.326]             ...future.startTime <- base::Sys.time()
[17:26:43.326]             {
[17:26:43.326]                 {
[17:26:43.326]                   {
[17:26:43.326]                     base::local({
[17:26:43.326]                       has_future <- base::requireNamespace("future", 
[17:26:43.326]                         quietly = TRUE)
[17:26:43.326]                       if (has_future) {
[17:26:43.326]                         ns <- base::getNamespace("future")
[17:26:43.326]                         version <- ns[[".package"]][["version"]]
[17:26:43.326]                         if (is.null(version)) 
[17:26:43.326]                           version <- utils::packageVersion("future")
[17:26:43.326]                       }
[17:26:43.326]                       else {
[17:26:43.326]                         version <- NULL
[17:26:43.326]                       }
[17:26:43.326]                       if (!has_future || version < "1.8.0") {
[17:26:43.326]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.326]                           "", base::R.version$version.string), 
[17:26:43.326]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.326]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.326]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.326]                             "release", "version")], collapse = " "), 
[17:26:43.326]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.326]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.326]                           info)
[17:26:43.326]                         info <- base::paste(info, collapse = "; ")
[17:26:43.326]                         if (!has_future) {
[17:26:43.326]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.326]                             info)
[17:26:43.326]                         }
[17:26:43.326]                         else {
[17:26:43.326]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.326]                             info, version)
[17:26:43.326]                         }
[17:26:43.326]                         base::stop(msg)
[17:26:43.326]                       }
[17:26:43.326]                     })
[17:26:43.326]                   }
[17:26:43.326]                   ...future.strategy.old <- future::plan("list")
[17:26:43.326]                   options(future.plan = NULL)
[17:26:43.326]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.326]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.326]                 }
[17:26:43.326]                 ...future.workdir <- getwd()
[17:26:43.326]             }
[17:26:43.326]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.326]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.326]         }
[17:26:43.326]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.326]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.326]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.326]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.326]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.326]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.326]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.326]             base::names(...future.oldOptions))
[17:26:43.326]     }
[17:26:43.326]     if (FALSE) {
[17:26:43.326]     }
[17:26:43.326]     else {
[17:26:43.326]         if (TRUE) {
[17:26:43.326]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.326]                 open = "w")
[17:26:43.326]         }
[17:26:43.326]         else {
[17:26:43.326]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.326]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.326]         }
[17:26:43.326]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.326]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.326]             base::sink(type = "output", split = FALSE)
[17:26:43.326]             base::close(...future.stdout)
[17:26:43.326]         }, add = TRUE)
[17:26:43.326]     }
[17:26:43.326]     ...future.frame <- base::sys.nframe()
[17:26:43.326]     ...future.conditions <- base::list()
[17:26:43.326]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.326]     if (FALSE) {
[17:26:43.326]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.326]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.326]     }
[17:26:43.326]     ...future.result <- base::tryCatch({
[17:26:43.326]         base::withCallingHandlers({
[17:26:43.326]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.326]             future::FutureResult(value = ...future.value$value, 
[17:26:43.326]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.326]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.326]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.326]                     ...future.globalenv.names))
[17:26:43.326]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.326]         }, condition = base::local({
[17:26:43.326]             c <- base::c
[17:26:43.326]             inherits <- base::inherits
[17:26:43.326]             invokeRestart <- base::invokeRestart
[17:26:43.326]             length <- base::length
[17:26:43.326]             list <- base::list
[17:26:43.326]             seq.int <- base::seq.int
[17:26:43.326]             signalCondition <- base::signalCondition
[17:26:43.326]             sys.calls <- base::sys.calls
[17:26:43.326]             `[[` <- base::`[[`
[17:26:43.326]             `+` <- base::`+`
[17:26:43.326]             `<<-` <- base::`<<-`
[17:26:43.326]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.326]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.326]                   3L)]
[17:26:43.326]             }
[17:26:43.326]             function(cond) {
[17:26:43.326]                 is_error <- inherits(cond, "error")
[17:26:43.326]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.326]                   NULL)
[17:26:43.326]                 if (is_error) {
[17:26:43.326]                   sessionInformation <- function() {
[17:26:43.326]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.326]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.326]                       search = base::search(), system = base::Sys.info())
[17:26:43.326]                   }
[17:26:43.326]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.326]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.326]                     cond$call), session = sessionInformation(), 
[17:26:43.326]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.326]                   signalCondition(cond)
[17:26:43.326]                 }
[17:26:43.326]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.326]                 "immediateCondition"))) {
[17:26:43.326]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.326]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.326]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.326]                   if (TRUE && !signal) {
[17:26:43.326]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.326]                     {
[17:26:43.326]                       inherits <- base::inherits
[17:26:43.326]                       invokeRestart <- base::invokeRestart
[17:26:43.326]                       is.null <- base::is.null
[17:26:43.326]                       muffled <- FALSE
[17:26:43.326]                       if (inherits(cond, "message")) {
[17:26:43.326]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.326]                         if (muffled) 
[17:26:43.326]                           invokeRestart("muffleMessage")
[17:26:43.326]                       }
[17:26:43.326]                       else if (inherits(cond, "warning")) {
[17:26:43.326]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.326]                         if (muffled) 
[17:26:43.326]                           invokeRestart("muffleWarning")
[17:26:43.326]                       }
[17:26:43.326]                       else if (inherits(cond, "condition")) {
[17:26:43.326]                         if (!is.null(pattern)) {
[17:26:43.326]                           computeRestarts <- base::computeRestarts
[17:26:43.326]                           grepl <- base::grepl
[17:26:43.326]                           restarts <- computeRestarts(cond)
[17:26:43.326]                           for (restart in restarts) {
[17:26:43.326]                             name <- restart$name
[17:26:43.326]                             if (is.null(name)) 
[17:26:43.326]                               next
[17:26:43.326]                             if (!grepl(pattern, name)) 
[17:26:43.326]                               next
[17:26:43.326]                             invokeRestart(restart)
[17:26:43.326]                             muffled <- TRUE
[17:26:43.326]                             break
[17:26:43.326]                           }
[17:26:43.326]                         }
[17:26:43.326]                       }
[17:26:43.326]                       invisible(muffled)
[17:26:43.326]                     }
[17:26:43.326]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.326]                   }
[17:26:43.326]                 }
[17:26:43.326]                 else {
[17:26:43.326]                   if (TRUE) {
[17:26:43.326]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.326]                     {
[17:26:43.326]                       inherits <- base::inherits
[17:26:43.326]                       invokeRestart <- base::invokeRestart
[17:26:43.326]                       is.null <- base::is.null
[17:26:43.326]                       muffled <- FALSE
[17:26:43.326]                       if (inherits(cond, "message")) {
[17:26:43.326]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.326]                         if (muffled) 
[17:26:43.326]                           invokeRestart("muffleMessage")
[17:26:43.326]                       }
[17:26:43.326]                       else if (inherits(cond, "warning")) {
[17:26:43.326]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.326]                         if (muffled) 
[17:26:43.326]                           invokeRestart("muffleWarning")
[17:26:43.326]                       }
[17:26:43.326]                       else if (inherits(cond, "condition")) {
[17:26:43.326]                         if (!is.null(pattern)) {
[17:26:43.326]                           computeRestarts <- base::computeRestarts
[17:26:43.326]                           grepl <- base::grepl
[17:26:43.326]                           restarts <- computeRestarts(cond)
[17:26:43.326]                           for (restart in restarts) {
[17:26:43.326]                             name <- restart$name
[17:26:43.326]                             if (is.null(name)) 
[17:26:43.326]                               next
[17:26:43.326]                             if (!grepl(pattern, name)) 
[17:26:43.326]                               next
[17:26:43.326]                             invokeRestart(restart)
[17:26:43.326]                             muffled <- TRUE
[17:26:43.326]                             break
[17:26:43.326]                           }
[17:26:43.326]                         }
[17:26:43.326]                       }
[17:26:43.326]                       invisible(muffled)
[17:26:43.326]                     }
[17:26:43.326]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.326]                   }
[17:26:43.326]                 }
[17:26:43.326]             }
[17:26:43.326]         }))
[17:26:43.326]     }, error = function(ex) {
[17:26:43.326]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.326]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.326]                 ...future.rng), started = ...future.startTime, 
[17:26:43.326]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.326]             version = "1.8"), class = "FutureResult")
[17:26:43.326]     }, finally = {
[17:26:43.326]         if (!identical(...future.workdir, getwd())) 
[17:26:43.326]             setwd(...future.workdir)
[17:26:43.326]         {
[17:26:43.326]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.326]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.326]             }
[17:26:43.326]             base::options(...future.oldOptions)
[17:26:43.326]             if (.Platform$OS.type == "windows") {
[17:26:43.326]                 old_names <- names(...future.oldEnvVars)
[17:26:43.326]                 envs <- base::Sys.getenv()
[17:26:43.326]                 names <- names(envs)
[17:26:43.326]                 common <- intersect(names, old_names)
[17:26:43.326]                 added <- setdiff(names, old_names)
[17:26:43.326]                 removed <- setdiff(old_names, names)
[17:26:43.326]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.326]                   envs[common]]
[17:26:43.326]                 NAMES <- toupper(changed)
[17:26:43.326]                 args <- list()
[17:26:43.326]                 for (kk in seq_along(NAMES)) {
[17:26:43.326]                   name <- changed[[kk]]
[17:26:43.326]                   NAME <- NAMES[[kk]]
[17:26:43.326]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.326]                     next
[17:26:43.326]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.326]                 }
[17:26:43.326]                 NAMES <- toupper(added)
[17:26:43.326]                 for (kk in seq_along(NAMES)) {
[17:26:43.326]                   name <- added[[kk]]
[17:26:43.326]                   NAME <- NAMES[[kk]]
[17:26:43.326]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.326]                     next
[17:26:43.326]                   args[[name]] <- ""
[17:26:43.326]                 }
[17:26:43.326]                 NAMES <- toupper(removed)
[17:26:43.326]                 for (kk in seq_along(NAMES)) {
[17:26:43.326]                   name <- removed[[kk]]
[17:26:43.326]                   NAME <- NAMES[[kk]]
[17:26:43.326]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.326]                     next
[17:26:43.326]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.326]                 }
[17:26:43.326]                 if (length(args) > 0) 
[17:26:43.326]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.326]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.326]             }
[17:26:43.326]             else {
[17:26:43.326]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.326]             }
[17:26:43.326]             {
[17:26:43.326]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.326]                   0L) {
[17:26:43.326]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.326]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.326]                   base::options(opts)
[17:26:43.326]                 }
[17:26:43.326]                 {
[17:26:43.326]                   {
[17:26:43.326]                     NULL
[17:26:43.326]                     RNGkind("Mersenne-Twister")
[17:26:43.326]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.326]                       inherits = FALSE)
[17:26:43.326]                   }
[17:26:43.326]                   options(future.plan = NULL)
[17:26:43.326]                   if (is.na(NA_character_)) 
[17:26:43.326]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.326]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.326]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.326]                     .init = FALSE)
[17:26:43.326]                 }
[17:26:43.326]             }
[17:26:43.326]         }
[17:26:43.326]     })
[17:26:43.326]     if (TRUE) {
[17:26:43.326]         base::sink(type = "output", split = FALSE)
[17:26:43.326]         if (TRUE) {
[17:26:43.326]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.326]         }
[17:26:43.326]         else {
[17:26:43.326]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.326]         }
[17:26:43.326]         base::close(...future.stdout)
[17:26:43.326]         ...future.stdout <- NULL
[17:26:43.326]     }
[17:26:43.326]     ...future.result$conditions <- ...future.conditions
[17:26:43.326]     ...future.result$finished <- base::Sys.time()
[17:26:43.326]     ...future.result
[17:26:43.326] }
[17:26:43.330] plan(): Setting new future strategy stack:
[17:26:43.330] List of future strategies:
[17:26:43.330] 1. sequential:
[17:26:43.330]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.330]    - tweaked: FALSE
[17:26:43.330]    - call: NULL
[17:26:43.330] plan(): nbrOfWorkers() = 1
[17:26:43.332] plan(): Setting new future strategy stack:
[17:26:43.332] List of future strategies:
[17:26:43.332] 1. sequential:
[17:26:43.332]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.332]    - tweaked: FALSE
[17:26:43.332]    - call: plan(strategy)
[17:26:43.332] plan(): nbrOfWorkers() = 1
[17:26:43.333] SequentialFuture started (and completed)
[17:26:43.333] - Launch lazy future ... done
[17:26:43.333] run() for 'SequentialFuture' ... done
[17:26:43.333] getGlobalsAndPackages() ...
[17:26:43.334] Searching for globals...
[17:26:43.334] 
[17:26:43.334] Searching for globals ... DONE
[17:26:43.334] - globals: [0] <none>
[17:26:43.334] getGlobalsAndPackages() ... DONE
[17:26:43.335] run() for 'Future' ...
[17:26:43.335] - state: 'created'
[17:26:43.335] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.336] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.336] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.336]   - Field: 'label'
[17:26:43.336]   - Field: 'local'
[17:26:43.336]   - Field: 'owner'
[17:26:43.337]   - Field: 'envir'
[17:26:43.337]   - Field: 'packages'
[17:26:43.337]   - Field: 'gc'
[17:26:43.337]   - Field: 'conditions'
[17:26:43.337]   - Field: 'expr'
[17:26:43.337]   - Field: 'uuid'
[17:26:43.338]   - Field: 'seed'
[17:26:43.338]   - Field: 'version'
[17:26:43.338]   - Field: 'result'
[17:26:43.338]   - Field: 'asynchronous'
[17:26:43.338]   - Field: 'calls'
[17:26:43.339]   - Field: 'globals'
[17:26:43.339]   - Field: 'stdout'
[17:26:43.339]   - Field: 'earlySignal'
[17:26:43.339]   - Field: 'lazy'
[17:26:43.339]   - Field: 'state'
[17:26:43.340] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.340] - Launch lazy future ...
[17:26:43.340] Packages needed by the future expression (n = 0): <none>
[17:26:43.340] Packages needed by future strategies (n = 0): <none>
[17:26:43.341] {
[17:26:43.341]     {
[17:26:43.341]         {
[17:26:43.341]             ...future.startTime <- base::Sys.time()
[17:26:43.341]             {
[17:26:43.341]                 {
[17:26:43.341]                   {
[17:26:43.341]                     base::local({
[17:26:43.341]                       has_future <- base::requireNamespace("future", 
[17:26:43.341]                         quietly = TRUE)
[17:26:43.341]                       if (has_future) {
[17:26:43.341]                         ns <- base::getNamespace("future")
[17:26:43.341]                         version <- ns[[".package"]][["version"]]
[17:26:43.341]                         if (is.null(version)) 
[17:26:43.341]                           version <- utils::packageVersion("future")
[17:26:43.341]                       }
[17:26:43.341]                       else {
[17:26:43.341]                         version <- NULL
[17:26:43.341]                       }
[17:26:43.341]                       if (!has_future || version < "1.8.0") {
[17:26:43.341]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.341]                           "", base::R.version$version.string), 
[17:26:43.341]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.341]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.341]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.341]                             "release", "version")], collapse = " "), 
[17:26:43.341]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.341]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.341]                           info)
[17:26:43.341]                         info <- base::paste(info, collapse = "; ")
[17:26:43.341]                         if (!has_future) {
[17:26:43.341]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.341]                             info)
[17:26:43.341]                         }
[17:26:43.341]                         else {
[17:26:43.341]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.341]                             info, version)
[17:26:43.341]                         }
[17:26:43.341]                         base::stop(msg)
[17:26:43.341]                       }
[17:26:43.341]                     })
[17:26:43.341]                   }
[17:26:43.341]                   ...future.strategy.old <- future::plan("list")
[17:26:43.341]                   options(future.plan = NULL)
[17:26:43.341]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.341]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.341]                 }
[17:26:43.341]                 ...future.workdir <- getwd()
[17:26:43.341]             }
[17:26:43.341]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.341]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.341]         }
[17:26:43.341]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.341]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.341]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.341]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.341]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.341]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.341]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.341]             base::names(...future.oldOptions))
[17:26:43.341]     }
[17:26:43.341]     if (FALSE) {
[17:26:43.341]     }
[17:26:43.341]     else {
[17:26:43.341]         if (TRUE) {
[17:26:43.341]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.341]                 open = "w")
[17:26:43.341]         }
[17:26:43.341]         else {
[17:26:43.341]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.341]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.341]         }
[17:26:43.341]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.341]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.341]             base::sink(type = "output", split = FALSE)
[17:26:43.341]             base::close(...future.stdout)
[17:26:43.341]         }, add = TRUE)
[17:26:43.341]     }
[17:26:43.341]     ...future.frame <- base::sys.nframe()
[17:26:43.341]     ...future.conditions <- base::list()
[17:26:43.341]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.341]     if (FALSE) {
[17:26:43.341]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.341]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.341]     }
[17:26:43.341]     ...future.result <- base::tryCatch({
[17:26:43.341]         base::withCallingHandlers({
[17:26:43.341]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.341]             future::FutureResult(value = ...future.value$value, 
[17:26:43.341]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.341]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.341]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.341]                     ...future.globalenv.names))
[17:26:43.341]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.341]         }, condition = base::local({
[17:26:43.341]             c <- base::c
[17:26:43.341]             inherits <- base::inherits
[17:26:43.341]             invokeRestart <- base::invokeRestart
[17:26:43.341]             length <- base::length
[17:26:43.341]             list <- base::list
[17:26:43.341]             seq.int <- base::seq.int
[17:26:43.341]             signalCondition <- base::signalCondition
[17:26:43.341]             sys.calls <- base::sys.calls
[17:26:43.341]             `[[` <- base::`[[`
[17:26:43.341]             `+` <- base::`+`
[17:26:43.341]             `<<-` <- base::`<<-`
[17:26:43.341]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.341]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.341]                   3L)]
[17:26:43.341]             }
[17:26:43.341]             function(cond) {
[17:26:43.341]                 is_error <- inherits(cond, "error")
[17:26:43.341]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.341]                   NULL)
[17:26:43.341]                 if (is_error) {
[17:26:43.341]                   sessionInformation <- function() {
[17:26:43.341]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.341]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.341]                       search = base::search(), system = base::Sys.info())
[17:26:43.341]                   }
[17:26:43.341]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.341]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.341]                     cond$call), session = sessionInformation(), 
[17:26:43.341]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.341]                   signalCondition(cond)
[17:26:43.341]                 }
[17:26:43.341]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.341]                 "immediateCondition"))) {
[17:26:43.341]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.341]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.341]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.341]                   if (TRUE && !signal) {
[17:26:43.341]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.341]                     {
[17:26:43.341]                       inherits <- base::inherits
[17:26:43.341]                       invokeRestart <- base::invokeRestart
[17:26:43.341]                       is.null <- base::is.null
[17:26:43.341]                       muffled <- FALSE
[17:26:43.341]                       if (inherits(cond, "message")) {
[17:26:43.341]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.341]                         if (muffled) 
[17:26:43.341]                           invokeRestart("muffleMessage")
[17:26:43.341]                       }
[17:26:43.341]                       else if (inherits(cond, "warning")) {
[17:26:43.341]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.341]                         if (muffled) 
[17:26:43.341]                           invokeRestart("muffleWarning")
[17:26:43.341]                       }
[17:26:43.341]                       else if (inherits(cond, "condition")) {
[17:26:43.341]                         if (!is.null(pattern)) {
[17:26:43.341]                           computeRestarts <- base::computeRestarts
[17:26:43.341]                           grepl <- base::grepl
[17:26:43.341]                           restarts <- computeRestarts(cond)
[17:26:43.341]                           for (restart in restarts) {
[17:26:43.341]                             name <- restart$name
[17:26:43.341]                             if (is.null(name)) 
[17:26:43.341]                               next
[17:26:43.341]                             if (!grepl(pattern, name)) 
[17:26:43.341]                               next
[17:26:43.341]                             invokeRestart(restart)
[17:26:43.341]                             muffled <- TRUE
[17:26:43.341]                             break
[17:26:43.341]                           }
[17:26:43.341]                         }
[17:26:43.341]                       }
[17:26:43.341]                       invisible(muffled)
[17:26:43.341]                     }
[17:26:43.341]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.341]                   }
[17:26:43.341]                 }
[17:26:43.341]                 else {
[17:26:43.341]                   if (TRUE) {
[17:26:43.341]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.341]                     {
[17:26:43.341]                       inherits <- base::inherits
[17:26:43.341]                       invokeRestart <- base::invokeRestart
[17:26:43.341]                       is.null <- base::is.null
[17:26:43.341]                       muffled <- FALSE
[17:26:43.341]                       if (inherits(cond, "message")) {
[17:26:43.341]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.341]                         if (muffled) 
[17:26:43.341]                           invokeRestart("muffleMessage")
[17:26:43.341]                       }
[17:26:43.341]                       else if (inherits(cond, "warning")) {
[17:26:43.341]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.341]                         if (muffled) 
[17:26:43.341]                           invokeRestart("muffleWarning")
[17:26:43.341]                       }
[17:26:43.341]                       else if (inherits(cond, "condition")) {
[17:26:43.341]                         if (!is.null(pattern)) {
[17:26:43.341]                           computeRestarts <- base::computeRestarts
[17:26:43.341]                           grepl <- base::grepl
[17:26:43.341]                           restarts <- computeRestarts(cond)
[17:26:43.341]                           for (restart in restarts) {
[17:26:43.341]                             name <- restart$name
[17:26:43.341]                             if (is.null(name)) 
[17:26:43.341]                               next
[17:26:43.341]                             if (!grepl(pattern, name)) 
[17:26:43.341]                               next
[17:26:43.341]                             invokeRestart(restart)
[17:26:43.341]                             muffled <- TRUE
[17:26:43.341]                             break
[17:26:43.341]                           }
[17:26:43.341]                         }
[17:26:43.341]                       }
[17:26:43.341]                       invisible(muffled)
[17:26:43.341]                     }
[17:26:43.341]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.341]                   }
[17:26:43.341]                 }
[17:26:43.341]             }
[17:26:43.341]         }))
[17:26:43.341]     }, error = function(ex) {
[17:26:43.341]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.341]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.341]                 ...future.rng), started = ...future.startTime, 
[17:26:43.341]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.341]             version = "1.8"), class = "FutureResult")
[17:26:43.341]     }, finally = {
[17:26:43.341]         if (!identical(...future.workdir, getwd())) 
[17:26:43.341]             setwd(...future.workdir)
[17:26:43.341]         {
[17:26:43.341]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.341]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.341]             }
[17:26:43.341]             base::options(...future.oldOptions)
[17:26:43.341]             if (.Platform$OS.type == "windows") {
[17:26:43.341]                 old_names <- names(...future.oldEnvVars)
[17:26:43.341]                 envs <- base::Sys.getenv()
[17:26:43.341]                 names <- names(envs)
[17:26:43.341]                 common <- intersect(names, old_names)
[17:26:43.341]                 added <- setdiff(names, old_names)
[17:26:43.341]                 removed <- setdiff(old_names, names)
[17:26:43.341]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.341]                   envs[common]]
[17:26:43.341]                 NAMES <- toupper(changed)
[17:26:43.341]                 args <- list()
[17:26:43.341]                 for (kk in seq_along(NAMES)) {
[17:26:43.341]                   name <- changed[[kk]]
[17:26:43.341]                   NAME <- NAMES[[kk]]
[17:26:43.341]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.341]                     next
[17:26:43.341]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.341]                 }
[17:26:43.341]                 NAMES <- toupper(added)
[17:26:43.341]                 for (kk in seq_along(NAMES)) {
[17:26:43.341]                   name <- added[[kk]]
[17:26:43.341]                   NAME <- NAMES[[kk]]
[17:26:43.341]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.341]                     next
[17:26:43.341]                   args[[name]] <- ""
[17:26:43.341]                 }
[17:26:43.341]                 NAMES <- toupper(removed)
[17:26:43.341]                 for (kk in seq_along(NAMES)) {
[17:26:43.341]                   name <- removed[[kk]]
[17:26:43.341]                   NAME <- NAMES[[kk]]
[17:26:43.341]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.341]                     next
[17:26:43.341]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.341]                 }
[17:26:43.341]                 if (length(args) > 0) 
[17:26:43.341]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.341]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.341]             }
[17:26:43.341]             else {
[17:26:43.341]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.341]             }
[17:26:43.341]             {
[17:26:43.341]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.341]                   0L) {
[17:26:43.341]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.341]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.341]                   base::options(opts)
[17:26:43.341]                 }
[17:26:43.341]                 {
[17:26:43.341]                   {
[17:26:43.341]                     NULL
[17:26:43.341]                     RNGkind("Mersenne-Twister")
[17:26:43.341]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.341]                       inherits = FALSE)
[17:26:43.341]                   }
[17:26:43.341]                   options(future.plan = NULL)
[17:26:43.341]                   if (is.na(NA_character_)) 
[17:26:43.341]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.341]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.341]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.341]                     .init = FALSE)
[17:26:43.341]                 }
[17:26:43.341]             }
[17:26:43.341]         }
[17:26:43.341]     })
[17:26:43.341]     if (TRUE) {
[17:26:43.341]         base::sink(type = "output", split = FALSE)
[17:26:43.341]         if (TRUE) {
[17:26:43.341]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.341]         }
[17:26:43.341]         else {
[17:26:43.341]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.341]         }
[17:26:43.341]         base::close(...future.stdout)
[17:26:43.341]         ...future.stdout <- NULL
[17:26:43.341]     }
[17:26:43.341]     ...future.result$conditions <- ...future.conditions
[17:26:43.341]     ...future.result$finished <- base::Sys.time()
[17:26:43.341]     ...future.result
[17:26:43.341] }
[17:26:43.345] plan(): Setting new future strategy stack:
[17:26:43.345] List of future strategies:
[17:26:43.345] 1. sequential:
[17:26:43.345]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.345]    - tweaked: FALSE
[17:26:43.345]    - call: NULL
[17:26:43.346] plan(): nbrOfWorkers() = 1
[17:26:43.347] plan(): Setting new future strategy stack:
[17:26:43.347] List of future strategies:
[17:26:43.347] 1. sequential:
[17:26:43.347]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.347]    - tweaked: FALSE
[17:26:43.347]    - call: plan(strategy)
[17:26:43.348] plan(): nbrOfWorkers() = 1
[17:26:43.348] SequentialFuture started (and completed)
[17:26:43.348] - Launch lazy future ... done
[17:26:43.348] run() for 'SequentialFuture' ... done
[17:26:43.349] getGlobalsAndPackages() ...
[17:26:43.349] Searching for globals...
[17:26:43.350] - globals found: [1] '{'
[17:26:43.350] Searching for globals ... DONE
[17:26:43.351] Resolving globals: FALSE
[17:26:43.351] 
[17:26:43.351] 
[17:26:43.351] getGlobalsAndPackages() ... DONE
[17:26:43.352] run() for 'Future' ...
[17:26:43.352] - state: 'created'
[17:26:43.352] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.353] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.353] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.353]   - Field: 'label'
[17:26:43.353]   - Field: 'local'
[17:26:43.353]   - Field: 'owner'
[17:26:43.354]   - Field: 'envir'
[17:26:43.354]   - Field: 'packages'
[17:26:43.354]   - Field: 'gc'
[17:26:43.354]   - Field: 'conditions'
[17:26:43.354]   - Field: 'expr'
[17:26:43.354]   - Field: 'uuid'
[17:26:43.355]   - Field: 'seed'
[17:26:43.355]   - Field: 'version'
[17:26:43.355]   - Field: 'result'
[17:26:43.355]   - Field: 'asynchronous'
[17:26:43.355]   - Field: 'calls'
[17:26:43.355]   - Field: 'globals'
[17:26:43.356]   - Field: 'stdout'
[17:26:43.356]   - Field: 'earlySignal'
[17:26:43.357]   - Field: 'lazy'
[17:26:43.357]   - Field: 'state'
[17:26:43.357] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.357] - Launch lazy future ...
[17:26:43.358] Packages needed by the future expression (n = 0): <none>
[17:26:43.358] Packages needed by future strategies (n = 0): <none>
[17:26:43.358] {
[17:26:43.358]     {
[17:26:43.358]         {
[17:26:43.358]             ...future.startTime <- base::Sys.time()
[17:26:43.358]             {
[17:26:43.358]                 {
[17:26:43.358]                   {
[17:26:43.358]                     base::local({
[17:26:43.358]                       has_future <- base::requireNamespace("future", 
[17:26:43.358]                         quietly = TRUE)
[17:26:43.358]                       if (has_future) {
[17:26:43.358]                         ns <- base::getNamespace("future")
[17:26:43.358]                         version <- ns[[".package"]][["version"]]
[17:26:43.358]                         if (is.null(version)) 
[17:26:43.358]                           version <- utils::packageVersion("future")
[17:26:43.358]                       }
[17:26:43.358]                       else {
[17:26:43.358]                         version <- NULL
[17:26:43.358]                       }
[17:26:43.358]                       if (!has_future || version < "1.8.0") {
[17:26:43.358]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.358]                           "", base::R.version$version.string), 
[17:26:43.358]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.358]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.358]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.358]                             "release", "version")], collapse = " "), 
[17:26:43.358]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.358]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.358]                           info)
[17:26:43.358]                         info <- base::paste(info, collapse = "; ")
[17:26:43.358]                         if (!has_future) {
[17:26:43.358]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.358]                             info)
[17:26:43.358]                         }
[17:26:43.358]                         else {
[17:26:43.358]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.358]                             info, version)
[17:26:43.358]                         }
[17:26:43.358]                         base::stop(msg)
[17:26:43.358]                       }
[17:26:43.358]                     })
[17:26:43.358]                   }
[17:26:43.358]                   ...future.strategy.old <- future::plan("list")
[17:26:43.358]                   options(future.plan = NULL)
[17:26:43.358]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.358]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.358]                 }
[17:26:43.358]                 ...future.workdir <- getwd()
[17:26:43.358]             }
[17:26:43.358]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.358]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.358]         }
[17:26:43.358]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.358]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.358]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.358]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.358]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.358]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.358]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.358]             base::names(...future.oldOptions))
[17:26:43.358]     }
[17:26:43.358]     if (FALSE) {
[17:26:43.358]     }
[17:26:43.358]     else {
[17:26:43.358]         if (TRUE) {
[17:26:43.358]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.358]                 open = "w")
[17:26:43.358]         }
[17:26:43.358]         else {
[17:26:43.358]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.358]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.358]         }
[17:26:43.358]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.358]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.358]             base::sink(type = "output", split = FALSE)
[17:26:43.358]             base::close(...future.stdout)
[17:26:43.358]         }, add = TRUE)
[17:26:43.358]     }
[17:26:43.358]     ...future.frame <- base::sys.nframe()
[17:26:43.358]     ...future.conditions <- base::list()
[17:26:43.358]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.358]     if (FALSE) {
[17:26:43.358]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.358]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.358]     }
[17:26:43.358]     ...future.result <- base::tryCatch({
[17:26:43.358]         base::withCallingHandlers({
[17:26:43.358]             ...future.value <- base::withVisible(base::local({
[17:26:43.358]                 4
[17:26:43.358]             }))
[17:26:43.358]             future::FutureResult(value = ...future.value$value, 
[17:26:43.358]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.358]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.358]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.358]                     ...future.globalenv.names))
[17:26:43.358]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.358]         }, condition = base::local({
[17:26:43.358]             c <- base::c
[17:26:43.358]             inherits <- base::inherits
[17:26:43.358]             invokeRestart <- base::invokeRestart
[17:26:43.358]             length <- base::length
[17:26:43.358]             list <- base::list
[17:26:43.358]             seq.int <- base::seq.int
[17:26:43.358]             signalCondition <- base::signalCondition
[17:26:43.358]             sys.calls <- base::sys.calls
[17:26:43.358]             `[[` <- base::`[[`
[17:26:43.358]             `+` <- base::`+`
[17:26:43.358]             `<<-` <- base::`<<-`
[17:26:43.358]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.358]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.358]                   3L)]
[17:26:43.358]             }
[17:26:43.358]             function(cond) {
[17:26:43.358]                 is_error <- inherits(cond, "error")
[17:26:43.358]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.358]                   NULL)
[17:26:43.358]                 if (is_error) {
[17:26:43.358]                   sessionInformation <- function() {
[17:26:43.358]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.358]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.358]                       search = base::search(), system = base::Sys.info())
[17:26:43.358]                   }
[17:26:43.358]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.358]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.358]                     cond$call), session = sessionInformation(), 
[17:26:43.358]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.358]                   signalCondition(cond)
[17:26:43.358]                 }
[17:26:43.358]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.358]                 "immediateCondition"))) {
[17:26:43.358]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.358]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.358]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.358]                   if (TRUE && !signal) {
[17:26:43.358]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.358]                     {
[17:26:43.358]                       inherits <- base::inherits
[17:26:43.358]                       invokeRestart <- base::invokeRestart
[17:26:43.358]                       is.null <- base::is.null
[17:26:43.358]                       muffled <- FALSE
[17:26:43.358]                       if (inherits(cond, "message")) {
[17:26:43.358]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.358]                         if (muffled) 
[17:26:43.358]                           invokeRestart("muffleMessage")
[17:26:43.358]                       }
[17:26:43.358]                       else if (inherits(cond, "warning")) {
[17:26:43.358]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.358]                         if (muffled) 
[17:26:43.358]                           invokeRestart("muffleWarning")
[17:26:43.358]                       }
[17:26:43.358]                       else if (inherits(cond, "condition")) {
[17:26:43.358]                         if (!is.null(pattern)) {
[17:26:43.358]                           computeRestarts <- base::computeRestarts
[17:26:43.358]                           grepl <- base::grepl
[17:26:43.358]                           restarts <- computeRestarts(cond)
[17:26:43.358]                           for (restart in restarts) {
[17:26:43.358]                             name <- restart$name
[17:26:43.358]                             if (is.null(name)) 
[17:26:43.358]                               next
[17:26:43.358]                             if (!grepl(pattern, name)) 
[17:26:43.358]                               next
[17:26:43.358]                             invokeRestart(restart)
[17:26:43.358]                             muffled <- TRUE
[17:26:43.358]                             break
[17:26:43.358]                           }
[17:26:43.358]                         }
[17:26:43.358]                       }
[17:26:43.358]                       invisible(muffled)
[17:26:43.358]                     }
[17:26:43.358]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.358]                   }
[17:26:43.358]                 }
[17:26:43.358]                 else {
[17:26:43.358]                   if (TRUE) {
[17:26:43.358]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.358]                     {
[17:26:43.358]                       inherits <- base::inherits
[17:26:43.358]                       invokeRestart <- base::invokeRestart
[17:26:43.358]                       is.null <- base::is.null
[17:26:43.358]                       muffled <- FALSE
[17:26:43.358]                       if (inherits(cond, "message")) {
[17:26:43.358]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.358]                         if (muffled) 
[17:26:43.358]                           invokeRestart("muffleMessage")
[17:26:43.358]                       }
[17:26:43.358]                       else if (inherits(cond, "warning")) {
[17:26:43.358]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.358]                         if (muffled) 
[17:26:43.358]                           invokeRestart("muffleWarning")
[17:26:43.358]                       }
[17:26:43.358]                       else if (inherits(cond, "condition")) {
[17:26:43.358]                         if (!is.null(pattern)) {
[17:26:43.358]                           computeRestarts <- base::computeRestarts
[17:26:43.358]                           grepl <- base::grepl
[17:26:43.358]                           restarts <- computeRestarts(cond)
[17:26:43.358]                           for (restart in restarts) {
[17:26:43.358]                             name <- restart$name
[17:26:43.358]                             if (is.null(name)) 
[17:26:43.358]                               next
[17:26:43.358]                             if (!grepl(pattern, name)) 
[17:26:43.358]                               next
[17:26:43.358]                             invokeRestart(restart)
[17:26:43.358]                             muffled <- TRUE
[17:26:43.358]                             break
[17:26:43.358]                           }
[17:26:43.358]                         }
[17:26:43.358]                       }
[17:26:43.358]                       invisible(muffled)
[17:26:43.358]                     }
[17:26:43.358]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.358]                   }
[17:26:43.358]                 }
[17:26:43.358]             }
[17:26:43.358]         }))
[17:26:43.358]     }, error = function(ex) {
[17:26:43.358]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.358]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.358]                 ...future.rng), started = ...future.startTime, 
[17:26:43.358]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.358]             version = "1.8"), class = "FutureResult")
[17:26:43.358]     }, finally = {
[17:26:43.358]         if (!identical(...future.workdir, getwd())) 
[17:26:43.358]             setwd(...future.workdir)
[17:26:43.358]         {
[17:26:43.358]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.358]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.358]             }
[17:26:43.358]             base::options(...future.oldOptions)
[17:26:43.358]             if (.Platform$OS.type == "windows") {
[17:26:43.358]                 old_names <- names(...future.oldEnvVars)
[17:26:43.358]                 envs <- base::Sys.getenv()
[17:26:43.358]                 names <- names(envs)
[17:26:43.358]                 common <- intersect(names, old_names)
[17:26:43.358]                 added <- setdiff(names, old_names)
[17:26:43.358]                 removed <- setdiff(old_names, names)
[17:26:43.358]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.358]                   envs[common]]
[17:26:43.358]                 NAMES <- toupper(changed)
[17:26:43.358]                 args <- list()
[17:26:43.358]                 for (kk in seq_along(NAMES)) {
[17:26:43.358]                   name <- changed[[kk]]
[17:26:43.358]                   NAME <- NAMES[[kk]]
[17:26:43.358]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.358]                     next
[17:26:43.358]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.358]                 }
[17:26:43.358]                 NAMES <- toupper(added)
[17:26:43.358]                 for (kk in seq_along(NAMES)) {
[17:26:43.358]                   name <- added[[kk]]
[17:26:43.358]                   NAME <- NAMES[[kk]]
[17:26:43.358]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.358]                     next
[17:26:43.358]                   args[[name]] <- ""
[17:26:43.358]                 }
[17:26:43.358]                 NAMES <- toupper(removed)
[17:26:43.358]                 for (kk in seq_along(NAMES)) {
[17:26:43.358]                   name <- removed[[kk]]
[17:26:43.358]                   NAME <- NAMES[[kk]]
[17:26:43.358]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.358]                     next
[17:26:43.358]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.358]                 }
[17:26:43.358]                 if (length(args) > 0) 
[17:26:43.358]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.358]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.358]             }
[17:26:43.358]             else {
[17:26:43.358]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.358]             }
[17:26:43.358]             {
[17:26:43.358]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.358]                   0L) {
[17:26:43.358]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.358]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.358]                   base::options(opts)
[17:26:43.358]                 }
[17:26:43.358]                 {
[17:26:43.358]                   {
[17:26:43.358]                     NULL
[17:26:43.358]                     RNGkind("Mersenne-Twister")
[17:26:43.358]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.358]                       inherits = FALSE)
[17:26:43.358]                   }
[17:26:43.358]                   options(future.plan = NULL)
[17:26:43.358]                   if (is.na(NA_character_)) 
[17:26:43.358]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.358]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.358]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.358]                     .init = FALSE)
[17:26:43.358]                 }
[17:26:43.358]             }
[17:26:43.358]         }
[17:26:43.358]     })
[17:26:43.358]     if (TRUE) {
[17:26:43.358]         base::sink(type = "output", split = FALSE)
[17:26:43.358]         if (TRUE) {
[17:26:43.358]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.358]         }
[17:26:43.358]         else {
[17:26:43.358]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.358]         }
[17:26:43.358]         base::close(...future.stdout)
[17:26:43.358]         ...future.stdout <- NULL
[17:26:43.358]     }
[17:26:43.358]     ...future.result$conditions <- ...future.conditions
[17:26:43.358]     ...future.result$finished <- base::Sys.time()
[17:26:43.358]     ...future.result
[17:26:43.358] }
[17:26:43.362] plan(): Setting new future strategy stack:
[17:26:43.363] List of future strategies:
[17:26:43.363] 1. sequential:
[17:26:43.363]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.363]    - tweaked: FALSE
[17:26:43.363]    - call: NULL
[17:26:43.363] plan(): nbrOfWorkers() = 1
[17:26:43.364] plan(): Setting new future strategy stack:
[17:26:43.364] List of future strategies:
[17:26:43.364] 1. sequential:
[17:26:43.364]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.364]    - tweaked: FALSE
[17:26:43.364]    - call: plan(strategy)
[17:26:43.365] plan(): nbrOfWorkers() = 1
[17:26:43.365] SequentialFuture started (and completed)
[17:26:43.365] - Launch lazy future ... done
[17:26:43.366] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230b7ab810> 
Classes 'listenv', 'environment' <environment: 0x000002230b15ea00> 
[17:26:43.369] resolved() for 'SequentialFuture' ...
[17:26:43.369] - state: 'finished'
[17:26:43.370] - run: TRUE
[17:26:43.370] - result: 'FutureResult'
[17:26:43.370] resolved() for 'SequentialFuture' ... done
[17:26:43.370] resolved() for 'SequentialFuture' ...
[17:26:43.370] - state: 'finished'
[17:26:43.371] - run: TRUE
[17:26:43.371] - result: 'FutureResult'
[17:26:43.371] resolved() for 'SequentialFuture' ... done
[17:26:43.371] resolved() for 'SequentialFuture' ...
[17:26:43.371] - state: 'finished'
[17:26:43.372] - run: TRUE
[17:26:43.372] - result: 'FutureResult'
[17:26:43.372] resolved() for 'SequentialFuture' ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:43.374] resolve() on list environment ...
[17:26:43.374]  recursive: 0
[17:26:43.375]  length: 6
[17:26:43.376]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:43.376] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.376] - nx: 6
[17:26:43.376] - relay: TRUE
[17:26:43.376] - stdout: TRUE
[17:26:43.377] - signal: TRUE
[17:26:43.377] - resignal: FALSE
[17:26:43.377] - force: TRUE
[17:26:43.377] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.377] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.377]  - until=2
[17:26:43.378]  - relaying element #2
[17:26:43.378] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.378] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.378] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.378]  length: 5 (resolved future 1)
[17:26:43.378] resolved() for 'SequentialFuture' ...
[17:26:43.379] - state: 'finished'
[17:26:43.379] - run: TRUE
[17:26:43.379] - result: 'FutureResult'
[17:26:43.379] resolved() for 'SequentialFuture' ... done
[17:26:43.379] Future #2
[17:26:43.380] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.380] - nx: 6
[17:26:43.380] - relay: TRUE
[17:26:43.380] - stdout: TRUE
[17:26:43.380] - signal: TRUE
[17:26:43.381] - resignal: FALSE
[17:26:43.381] - force: TRUE
[17:26:43.381] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.381] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.381]  - until=2
[17:26:43.381]  - relaying element #2
[17:26:43.382] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.382] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.382] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.382]  length: 4 (resolved future 2)
[17:26:43.382] resolved() for 'SequentialFuture' ...
[17:26:43.383] - state: 'finished'
[17:26:43.383] - run: TRUE
[17:26:43.383] - result: 'FutureResult'
[17:26:43.383] resolved() for 'SequentialFuture' ... done
[17:26:43.383] Future #3
[17:26:43.384] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.384] - nx: 6
[17:26:43.384] - relay: TRUE
[17:26:43.384] - stdout: TRUE
[17:26:43.384] - signal: TRUE
[17:26:43.385] - resignal: FALSE
[17:26:43.385] - force: TRUE
[17:26:43.385] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.385] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.385]  - until=3
[17:26:43.385]  - relaying element #3
[17:26:43.386] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.386] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.386] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.386]  length: 3 (resolved future 3)
[17:26:43.386] resolved() for 'SequentialFuture' ...
[17:26:43.387] - state: 'finished'
[17:26:43.387] - run: TRUE
[17:26:43.387] - result: 'FutureResult'
[17:26:43.387] resolved() for 'SequentialFuture' ... done
[17:26:43.387] Future #4
[17:26:43.388] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.388] - nx: 6
[17:26:43.388] - relay: TRUE
[17:26:43.388] - stdout: TRUE
[17:26:43.388] - signal: TRUE
[17:26:43.388] - resignal: FALSE
[17:26:43.389] - force: TRUE
[17:26:43.389] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.389] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.389]  - until=4
[17:26:43.389]  - relaying element #4
[17:26:43.389] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.390] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.390] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.390]  length: 2 (resolved future 4)
[17:26:43.390] signalConditionsASAP(NULL, pos=5) ...
[17:26:43.390] - nx: 6
[17:26:43.390] - relay: TRUE
[17:26:43.391] - stdout: TRUE
[17:26:43.391] - signal: TRUE
[17:26:43.391] - resignal: FALSE
[17:26:43.391] - force: TRUE
[17:26:43.391] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.392] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.392]  - until=6
[17:26:43.392]  - relaying element #6
[17:26:43.393] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.393] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.393] signalConditionsASAP(NULL, pos=5) ... done
[17:26:43.393]  length: 1 (resolved future 5)
[17:26:43.394] signalConditionsASAP(numeric, pos=6) ...
[17:26:43.394] - nx: 6
[17:26:43.394] - relay: TRUE
[17:26:43.394] - stdout: TRUE
[17:26:43.394] - signal: TRUE
[17:26:43.394] - resignal: FALSE
[17:26:43.394] - force: TRUE
[17:26:43.395] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.395] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.395]  - until=6
[17:26:43.395] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.395] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.395] signalConditionsASAP(numeric, pos=6) ... done
[17:26:43.396]  length: 0 (resolved future 6)
[17:26:43.396] Relaying remaining futures
[17:26:43.396] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.396] - nx: 6
[17:26:43.396] - relay: TRUE
[17:26:43.396] - stdout: TRUE
[17:26:43.397] - signal: TRUE
[17:26:43.397] - resignal: FALSE
[17:26:43.397] - force: TRUE
[17:26:43.397] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.397] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:43.397] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.398] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.398] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.398] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x000002230b958e98> 
Dimensions: c(1, 6)
[17:26:43.399] getGlobalsAndPackages() ...
[17:26:43.399] Searching for globals...
[17:26:43.399] 
[17:26:43.400] Searching for globals ... DONE
[17:26:43.400] - globals: [0] <none>
[17:26:43.400] getGlobalsAndPackages() ... DONE
[17:26:43.400] run() for 'Future' ...
[17:26:43.400] - state: 'created'
[17:26:43.401] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.401] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.401] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.401]   - Field: 'label'
[17:26:43.402]   - Field: 'local'
[17:26:43.402]   - Field: 'owner'
[17:26:43.402]   - Field: 'envir'
[17:26:43.402]   - Field: 'packages'
[17:26:43.402]   - Field: 'gc'
[17:26:43.402]   - Field: 'conditions'
[17:26:43.403]   - Field: 'expr'
[17:26:43.403]   - Field: 'uuid'
[17:26:43.403]   - Field: 'seed'
[17:26:43.403]   - Field: 'version'
[17:26:43.403]   - Field: 'result'
[17:26:43.404]   - Field: 'asynchronous'
[17:26:43.404]   - Field: 'calls'
[17:26:43.404]   - Field: 'globals'
[17:26:43.404]   - Field: 'stdout'
[17:26:43.404]   - Field: 'earlySignal'
[17:26:43.404]   - Field: 'lazy'
[17:26:43.405]   - Field: 'state'
[17:26:43.405] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.405] - Launch lazy future ...
[17:26:43.405] Packages needed by the future expression (n = 0): <none>
[17:26:43.405] Packages needed by future strategies (n = 0): <none>
[17:26:43.406] {
[17:26:43.406]     {
[17:26:43.406]         {
[17:26:43.406]             ...future.startTime <- base::Sys.time()
[17:26:43.406]             {
[17:26:43.406]                 {
[17:26:43.406]                   {
[17:26:43.406]                     base::local({
[17:26:43.406]                       has_future <- base::requireNamespace("future", 
[17:26:43.406]                         quietly = TRUE)
[17:26:43.406]                       if (has_future) {
[17:26:43.406]                         ns <- base::getNamespace("future")
[17:26:43.406]                         version <- ns[[".package"]][["version"]]
[17:26:43.406]                         if (is.null(version)) 
[17:26:43.406]                           version <- utils::packageVersion("future")
[17:26:43.406]                       }
[17:26:43.406]                       else {
[17:26:43.406]                         version <- NULL
[17:26:43.406]                       }
[17:26:43.406]                       if (!has_future || version < "1.8.0") {
[17:26:43.406]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.406]                           "", base::R.version$version.string), 
[17:26:43.406]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.406]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.406]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.406]                             "release", "version")], collapse = " "), 
[17:26:43.406]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.406]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.406]                           info)
[17:26:43.406]                         info <- base::paste(info, collapse = "; ")
[17:26:43.406]                         if (!has_future) {
[17:26:43.406]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.406]                             info)
[17:26:43.406]                         }
[17:26:43.406]                         else {
[17:26:43.406]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.406]                             info, version)
[17:26:43.406]                         }
[17:26:43.406]                         base::stop(msg)
[17:26:43.406]                       }
[17:26:43.406]                     })
[17:26:43.406]                   }
[17:26:43.406]                   ...future.strategy.old <- future::plan("list")
[17:26:43.406]                   options(future.plan = NULL)
[17:26:43.406]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.406]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.406]                 }
[17:26:43.406]                 ...future.workdir <- getwd()
[17:26:43.406]             }
[17:26:43.406]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.406]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.406]         }
[17:26:43.406]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.406]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.406]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.406]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.406]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.406]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.406]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.406]             base::names(...future.oldOptions))
[17:26:43.406]     }
[17:26:43.406]     if (FALSE) {
[17:26:43.406]     }
[17:26:43.406]     else {
[17:26:43.406]         if (TRUE) {
[17:26:43.406]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.406]                 open = "w")
[17:26:43.406]         }
[17:26:43.406]         else {
[17:26:43.406]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.406]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.406]         }
[17:26:43.406]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.406]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.406]             base::sink(type = "output", split = FALSE)
[17:26:43.406]             base::close(...future.stdout)
[17:26:43.406]         }, add = TRUE)
[17:26:43.406]     }
[17:26:43.406]     ...future.frame <- base::sys.nframe()
[17:26:43.406]     ...future.conditions <- base::list()
[17:26:43.406]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.406]     if (FALSE) {
[17:26:43.406]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.406]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.406]     }
[17:26:43.406]     ...future.result <- base::tryCatch({
[17:26:43.406]         base::withCallingHandlers({
[17:26:43.406]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.406]             future::FutureResult(value = ...future.value$value, 
[17:26:43.406]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.406]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.406]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.406]                     ...future.globalenv.names))
[17:26:43.406]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.406]         }, condition = base::local({
[17:26:43.406]             c <- base::c
[17:26:43.406]             inherits <- base::inherits
[17:26:43.406]             invokeRestart <- base::invokeRestart
[17:26:43.406]             length <- base::length
[17:26:43.406]             list <- base::list
[17:26:43.406]             seq.int <- base::seq.int
[17:26:43.406]             signalCondition <- base::signalCondition
[17:26:43.406]             sys.calls <- base::sys.calls
[17:26:43.406]             `[[` <- base::`[[`
[17:26:43.406]             `+` <- base::`+`
[17:26:43.406]             `<<-` <- base::`<<-`
[17:26:43.406]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.406]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.406]                   3L)]
[17:26:43.406]             }
[17:26:43.406]             function(cond) {
[17:26:43.406]                 is_error <- inherits(cond, "error")
[17:26:43.406]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.406]                   NULL)
[17:26:43.406]                 if (is_error) {
[17:26:43.406]                   sessionInformation <- function() {
[17:26:43.406]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.406]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.406]                       search = base::search(), system = base::Sys.info())
[17:26:43.406]                   }
[17:26:43.406]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.406]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.406]                     cond$call), session = sessionInformation(), 
[17:26:43.406]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.406]                   signalCondition(cond)
[17:26:43.406]                 }
[17:26:43.406]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.406]                 "immediateCondition"))) {
[17:26:43.406]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.406]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.406]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.406]                   if (TRUE && !signal) {
[17:26:43.406]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.406]                     {
[17:26:43.406]                       inherits <- base::inherits
[17:26:43.406]                       invokeRestart <- base::invokeRestart
[17:26:43.406]                       is.null <- base::is.null
[17:26:43.406]                       muffled <- FALSE
[17:26:43.406]                       if (inherits(cond, "message")) {
[17:26:43.406]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.406]                         if (muffled) 
[17:26:43.406]                           invokeRestart("muffleMessage")
[17:26:43.406]                       }
[17:26:43.406]                       else if (inherits(cond, "warning")) {
[17:26:43.406]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.406]                         if (muffled) 
[17:26:43.406]                           invokeRestart("muffleWarning")
[17:26:43.406]                       }
[17:26:43.406]                       else if (inherits(cond, "condition")) {
[17:26:43.406]                         if (!is.null(pattern)) {
[17:26:43.406]                           computeRestarts <- base::computeRestarts
[17:26:43.406]                           grepl <- base::grepl
[17:26:43.406]                           restarts <- computeRestarts(cond)
[17:26:43.406]                           for (restart in restarts) {
[17:26:43.406]                             name <- restart$name
[17:26:43.406]                             if (is.null(name)) 
[17:26:43.406]                               next
[17:26:43.406]                             if (!grepl(pattern, name)) 
[17:26:43.406]                               next
[17:26:43.406]                             invokeRestart(restart)
[17:26:43.406]                             muffled <- TRUE
[17:26:43.406]                             break
[17:26:43.406]                           }
[17:26:43.406]                         }
[17:26:43.406]                       }
[17:26:43.406]                       invisible(muffled)
[17:26:43.406]                     }
[17:26:43.406]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.406]                   }
[17:26:43.406]                 }
[17:26:43.406]                 else {
[17:26:43.406]                   if (TRUE) {
[17:26:43.406]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.406]                     {
[17:26:43.406]                       inherits <- base::inherits
[17:26:43.406]                       invokeRestart <- base::invokeRestart
[17:26:43.406]                       is.null <- base::is.null
[17:26:43.406]                       muffled <- FALSE
[17:26:43.406]                       if (inherits(cond, "message")) {
[17:26:43.406]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.406]                         if (muffled) 
[17:26:43.406]                           invokeRestart("muffleMessage")
[17:26:43.406]                       }
[17:26:43.406]                       else if (inherits(cond, "warning")) {
[17:26:43.406]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.406]                         if (muffled) 
[17:26:43.406]                           invokeRestart("muffleWarning")
[17:26:43.406]                       }
[17:26:43.406]                       else if (inherits(cond, "condition")) {
[17:26:43.406]                         if (!is.null(pattern)) {
[17:26:43.406]                           computeRestarts <- base::computeRestarts
[17:26:43.406]                           grepl <- base::grepl
[17:26:43.406]                           restarts <- computeRestarts(cond)
[17:26:43.406]                           for (restart in restarts) {
[17:26:43.406]                             name <- restart$name
[17:26:43.406]                             if (is.null(name)) 
[17:26:43.406]                               next
[17:26:43.406]                             if (!grepl(pattern, name)) 
[17:26:43.406]                               next
[17:26:43.406]                             invokeRestart(restart)
[17:26:43.406]                             muffled <- TRUE
[17:26:43.406]                             break
[17:26:43.406]                           }
[17:26:43.406]                         }
[17:26:43.406]                       }
[17:26:43.406]                       invisible(muffled)
[17:26:43.406]                     }
[17:26:43.406]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.406]                   }
[17:26:43.406]                 }
[17:26:43.406]             }
[17:26:43.406]         }))
[17:26:43.406]     }, error = function(ex) {
[17:26:43.406]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.406]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.406]                 ...future.rng), started = ...future.startTime, 
[17:26:43.406]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.406]             version = "1.8"), class = "FutureResult")
[17:26:43.406]     }, finally = {
[17:26:43.406]         if (!identical(...future.workdir, getwd())) 
[17:26:43.406]             setwd(...future.workdir)
[17:26:43.406]         {
[17:26:43.406]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.406]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.406]             }
[17:26:43.406]             base::options(...future.oldOptions)
[17:26:43.406]             if (.Platform$OS.type == "windows") {
[17:26:43.406]                 old_names <- names(...future.oldEnvVars)
[17:26:43.406]                 envs <- base::Sys.getenv()
[17:26:43.406]                 names <- names(envs)
[17:26:43.406]                 common <- intersect(names, old_names)
[17:26:43.406]                 added <- setdiff(names, old_names)
[17:26:43.406]                 removed <- setdiff(old_names, names)
[17:26:43.406]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.406]                   envs[common]]
[17:26:43.406]                 NAMES <- toupper(changed)
[17:26:43.406]                 args <- list()
[17:26:43.406]                 for (kk in seq_along(NAMES)) {
[17:26:43.406]                   name <- changed[[kk]]
[17:26:43.406]                   NAME <- NAMES[[kk]]
[17:26:43.406]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.406]                     next
[17:26:43.406]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.406]                 }
[17:26:43.406]                 NAMES <- toupper(added)
[17:26:43.406]                 for (kk in seq_along(NAMES)) {
[17:26:43.406]                   name <- added[[kk]]
[17:26:43.406]                   NAME <- NAMES[[kk]]
[17:26:43.406]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.406]                     next
[17:26:43.406]                   args[[name]] <- ""
[17:26:43.406]                 }
[17:26:43.406]                 NAMES <- toupper(removed)
[17:26:43.406]                 for (kk in seq_along(NAMES)) {
[17:26:43.406]                   name <- removed[[kk]]
[17:26:43.406]                   NAME <- NAMES[[kk]]
[17:26:43.406]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.406]                     next
[17:26:43.406]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.406]                 }
[17:26:43.406]                 if (length(args) > 0) 
[17:26:43.406]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.406]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.406]             }
[17:26:43.406]             else {
[17:26:43.406]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.406]             }
[17:26:43.406]             {
[17:26:43.406]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.406]                   0L) {
[17:26:43.406]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.406]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.406]                   base::options(opts)
[17:26:43.406]                 }
[17:26:43.406]                 {
[17:26:43.406]                   {
[17:26:43.406]                     NULL
[17:26:43.406]                     RNGkind("Mersenne-Twister")
[17:26:43.406]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.406]                       inherits = FALSE)
[17:26:43.406]                   }
[17:26:43.406]                   options(future.plan = NULL)
[17:26:43.406]                   if (is.na(NA_character_)) 
[17:26:43.406]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.406]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.406]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.406]                     .init = FALSE)
[17:26:43.406]                 }
[17:26:43.406]             }
[17:26:43.406]         }
[17:26:43.406]     })
[17:26:43.406]     if (TRUE) {
[17:26:43.406]         base::sink(type = "output", split = FALSE)
[17:26:43.406]         if (TRUE) {
[17:26:43.406]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.406]         }
[17:26:43.406]         else {
[17:26:43.406]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.406]         }
[17:26:43.406]         base::close(...future.stdout)
[17:26:43.406]         ...future.stdout <- NULL
[17:26:43.406]     }
[17:26:43.406]     ...future.result$conditions <- ...future.conditions
[17:26:43.406]     ...future.result$finished <- base::Sys.time()
[17:26:43.406]     ...future.result
[17:26:43.406] }
[17:26:43.410] plan(): Setting new future strategy stack:
[17:26:43.410] List of future strategies:
[17:26:43.410] 1. sequential:
[17:26:43.410]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.410]    - tweaked: FALSE
[17:26:43.410]    - call: NULL
[17:26:43.411] plan(): nbrOfWorkers() = 1
[17:26:43.412] plan(): Setting new future strategy stack:
[17:26:43.412] List of future strategies:
[17:26:43.412] 1. sequential:
[17:26:43.412]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.412]    - tweaked: FALSE
[17:26:43.412]    - call: plan(strategy)
[17:26:43.413] plan(): nbrOfWorkers() = 1
[17:26:43.413] SequentialFuture started (and completed)
[17:26:43.413] - Launch lazy future ... done
[17:26:43.413] run() for 'SequentialFuture' ... done
[17:26:43.414] getGlobalsAndPackages() ...
[17:26:43.414] Searching for globals...
[17:26:43.414] 
[17:26:43.414] Searching for globals ... DONE
[17:26:43.414] - globals: [0] <none>
[17:26:43.415] getGlobalsAndPackages() ... DONE
[17:26:43.415] run() for 'Future' ...
[17:26:43.415] - state: 'created'
[17:26:43.415] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.416] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.416] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.416]   - Field: 'label'
[17:26:43.416]   - Field: 'local'
[17:26:43.416]   - Field: 'owner'
[17:26:43.417]   - Field: 'envir'
[17:26:43.417]   - Field: 'packages'
[17:26:43.417]   - Field: 'gc'
[17:26:43.417]   - Field: 'conditions'
[17:26:43.417]   - Field: 'expr'
[17:26:43.418]   - Field: 'uuid'
[17:26:43.418]   - Field: 'seed'
[17:26:43.418]   - Field: 'version'
[17:26:43.418]   - Field: 'result'
[17:26:43.418]   - Field: 'asynchronous'
[17:26:43.418]   - Field: 'calls'
[17:26:43.419]   - Field: 'globals'
[17:26:43.419]   - Field: 'stdout'
[17:26:43.419]   - Field: 'earlySignal'
[17:26:43.419]   - Field: 'lazy'
[17:26:43.419]   - Field: 'state'
[17:26:43.420] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.420] - Launch lazy future ...
[17:26:43.420] Packages needed by the future expression (n = 0): <none>
[17:26:43.420] Packages needed by future strategies (n = 0): <none>
[17:26:43.421] {
[17:26:43.421]     {
[17:26:43.421]         {
[17:26:43.421]             ...future.startTime <- base::Sys.time()
[17:26:43.421]             {
[17:26:43.421]                 {
[17:26:43.421]                   {
[17:26:43.421]                     base::local({
[17:26:43.421]                       has_future <- base::requireNamespace("future", 
[17:26:43.421]                         quietly = TRUE)
[17:26:43.421]                       if (has_future) {
[17:26:43.421]                         ns <- base::getNamespace("future")
[17:26:43.421]                         version <- ns[[".package"]][["version"]]
[17:26:43.421]                         if (is.null(version)) 
[17:26:43.421]                           version <- utils::packageVersion("future")
[17:26:43.421]                       }
[17:26:43.421]                       else {
[17:26:43.421]                         version <- NULL
[17:26:43.421]                       }
[17:26:43.421]                       if (!has_future || version < "1.8.0") {
[17:26:43.421]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.421]                           "", base::R.version$version.string), 
[17:26:43.421]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.421]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.421]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.421]                             "release", "version")], collapse = " "), 
[17:26:43.421]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.421]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.421]                           info)
[17:26:43.421]                         info <- base::paste(info, collapse = "; ")
[17:26:43.421]                         if (!has_future) {
[17:26:43.421]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.421]                             info)
[17:26:43.421]                         }
[17:26:43.421]                         else {
[17:26:43.421]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.421]                             info, version)
[17:26:43.421]                         }
[17:26:43.421]                         base::stop(msg)
[17:26:43.421]                       }
[17:26:43.421]                     })
[17:26:43.421]                   }
[17:26:43.421]                   ...future.strategy.old <- future::plan("list")
[17:26:43.421]                   options(future.plan = NULL)
[17:26:43.421]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.421]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.421]                 }
[17:26:43.421]                 ...future.workdir <- getwd()
[17:26:43.421]             }
[17:26:43.421]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.421]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.421]         }
[17:26:43.421]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.421]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.421]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.421]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.421]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.421]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.421]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.421]             base::names(...future.oldOptions))
[17:26:43.421]     }
[17:26:43.421]     if (FALSE) {
[17:26:43.421]     }
[17:26:43.421]     else {
[17:26:43.421]         if (TRUE) {
[17:26:43.421]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.421]                 open = "w")
[17:26:43.421]         }
[17:26:43.421]         else {
[17:26:43.421]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.421]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.421]         }
[17:26:43.421]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.421]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.421]             base::sink(type = "output", split = FALSE)
[17:26:43.421]             base::close(...future.stdout)
[17:26:43.421]         }, add = TRUE)
[17:26:43.421]     }
[17:26:43.421]     ...future.frame <- base::sys.nframe()
[17:26:43.421]     ...future.conditions <- base::list()
[17:26:43.421]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.421]     if (FALSE) {
[17:26:43.421]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.421]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.421]     }
[17:26:43.421]     ...future.result <- base::tryCatch({
[17:26:43.421]         base::withCallingHandlers({
[17:26:43.421]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.421]             future::FutureResult(value = ...future.value$value, 
[17:26:43.421]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.421]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.421]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.421]                     ...future.globalenv.names))
[17:26:43.421]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.421]         }, condition = base::local({
[17:26:43.421]             c <- base::c
[17:26:43.421]             inherits <- base::inherits
[17:26:43.421]             invokeRestart <- base::invokeRestart
[17:26:43.421]             length <- base::length
[17:26:43.421]             list <- base::list
[17:26:43.421]             seq.int <- base::seq.int
[17:26:43.421]             signalCondition <- base::signalCondition
[17:26:43.421]             sys.calls <- base::sys.calls
[17:26:43.421]             `[[` <- base::`[[`
[17:26:43.421]             `+` <- base::`+`
[17:26:43.421]             `<<-` <- base::`<<-`
[17:26:43.421]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.421]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.421]                   3L)]
[17:26:43.421]             }
[17:26:43.421]             function(cond) {
[17:26:43.421]                 is_error <- inherits(cond, "error")
[17:26:43.421]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.421]                   NULL)
[17:26:43.421]                 if (is_error) {
[17:26:43.421]                   sessionInformation <- function() {
[17:26:43.421]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.421]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.421]                       search = base::search(), system = base::Sys.info())
[17:26:43.421]                   }
[17:26:43.421]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.421]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.421]                     cond$call), session = sessionInformation(), 
[17:26:43.421]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.421]                   signalCondition(cond)
[17:26:43.421]                 }
[17:26:43.421]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.421]                 "immediateCondition"))) {
[17:26:43.421]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.421]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.421]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.421]                   if (TRUE && !signal) {
[17:26:43.421]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.421]                     {
[17:26:43.421]                       inherits <- base::inherits
[17:26:43.421]                       invokeRestart <- base::invokeRestart
[17:26:43.421]                       is.null <- base::is.null
[17:26:43.421]                       muffled <- FALSE
[17:26:43.421]                       if (inherits(cond, "message")) {
[17:26:43.421]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.421]                         if (muffled) 
[17:26:43.421]                           invokeRestart("muffleMessage")
[17:26:43.421]                       }
[17:26:43.421]                       else if (inherits(cond, "warning")) {
[17:26:43.421]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.421]                         if (muffled) 
[17:26:43.421]                           invokeRestart("muffleWarning")
[17:26:43.421]                       }
[17:26:43.421]                       else if (inherits(cond, "condition")) {
[17:26:43.421]                         if (!is.null(pattern)) {
[17:26:43.421]                           computeRestarts <- base::computeRestarts
[17:26:43.421]                           grepl <- base::grepl
[17:26:43.421]                           restarts <- computeRestarts(cond)
[17:26:43.421]                           for (restart in restarts) {
[17:26:43.421]                             name <- restart$name
[17:26:43.421]                             if (is.null(name)) 
[17:26:43.421]                               next
[17:26:43.421]                             if (!grepl(pattern, name)) 
[17:26:43.421]                               next
[17:26:43.421]                             invokeRestart(restart)
[17:26:43.421]                             muffled <- TRUE
[17:26:43.421]                             break
[17:26:43.421]                           }
[17:26:43.421]                         }
[17:26:43.421]                       }
[17:26:43.421]                       invisible(muffled)
[17:26:43.421]                     }
[17:26:43.421]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.421]                   }
[17:26:43.421]                 }
[17:26:43.421]                 else {
[17:26:43.421]                   if (TRUE) {
[17:26:43.421]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.421]                     {
[17:26:43.421]                       inherits <- base::inherits
[17:26:43.421]                       invokeRestart <- base::invokeRestart
[17:26:43.421]                       is.null <- base::is.null
[17:26:43.421]                       muffled <- FALSE
[17:26:43.421]                       if (inherits(cond, "message")) {
[17:26:43.421]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.421]                         if (muffled) 
[17:26:43.421]                           invokeRestart("muffleMessage")
[17:26:43.421]                       }
[17:26:43.421]                       else if (inherits(cond, "warning")) {
[17:26:43.421]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.421]                         if (muffled) 
[17:26:43.421]                           invokeRestart("muffleWarning")
[17:26:43.421]                       }
[17:26:43.421]                       else if (inherits(cond, "condition")) {
[17:26:43.421]                         if (!is.null(pattern)) {
[17:26:43.421]                           computeRestarts <- base::computeRestarts
[17:26:43.421]                           grepl <- base::grepl
[17:26:43.421]                           restarts <- computeRestarts(cond)
[17:26:43.421]                           for (restart in restarts) {
[17:26:43.421]                             name <- restart$name
[17:26:43.421]                             if (is.null(name)) 
[17:26:43.421]                               next
[17:26:43.421]                             if (!grepl(pattern, name)) 
[17:26:43.421]                               next
[17:26:43.421]                             invokeRestart(restart)
[17:26:43.421]                             muffled <- TRUE
[17:26:43.421]                             break
[17:26:43.421]                           }
[17:26:43.421]                         }
[17:26:43.421]                       }
[17:26:43.421]                       invisible(muffled)
[17:26:43.421]                     }
[17:26:43.421]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.421]                   }
[17:26:43.421]                 }
[17:26:43.421]             }
[17:26:43.421]         }))
[17:26:43.421]     }, error = function(ex) {
[17:26:43.421]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.421]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.421]                 ...future.rng), started = ...future.startTime, 
[17:26:43.421]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.421]             version = "1.8"), class = "FutureResult")
[17:26:43.421]     }, finally = {
[17:26:43.421]         if (!identical(...future.workdir, getwd())) 
[17:26:43.421]             setwd(...future.workdir)
[17:26:43.421]         {
[17:26:43.421]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.421]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.421]             }
[17:26:43.421]             base::options(...future.oldOptions)
[17:26:43.421]             if (.Platform$OS.type == "windows") {
[17:26:43.421]                 old_names <- names(...future.oldEnvVars)
[17:26:43.421]                 envs <- base::Sys.getenv()
[17:26:43.421]                 names <- names(envs)
[17:26:43.421]                 common <- intersect(names, old_names)
[17:26:43.421]                 added <- setdiff(names, old_names)
[17:26:43.421]                 removed <- setdiff(old_names, names)
[17:26:43.421]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.421]                   envs[common]]
[17:26:43.421]                 NAMES <- toupper(changed)
[17:26:43.421]                 args <- list()
[17:26:43.421]                 for (kk in seq_along(NAMES)) {
[17:26:43.421]                   name <- changed[[kk]]
[17:26:43.421]                   NAME <- NAMES[[kk]]
[17:26:43.421]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.421]                     next
[17:26:43.421]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.421]                 }
[17:26:43.421]                 NAMES <- toupper(added)
[17:26:43.421]                 for (kk in seq_along(NAMES)) {
[17:26:43.421]                   name <- added[[kk]]
[17:26:43.421]                   NAME <- NAMES[[kk]]
[17:26:43.421]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.421]                     next
[17:26:43.421]                   args[[name]] <- ""
[17:26:43.421]                 }
[17:26:43.421]                 NAMES <- toupper(removed)
[17:26:43.421]                 for (kk in seq_along(NAMES)) {
[17:26:43.421]                   name <- removed[[kk]]
[17:26:43.421]                   NAME <- NAMES[[kk]]
[17:26:43.421]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.421]                     next
[17:26:43.421]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.421]                 }
[17:26:43.421]                 if (length(args) > 0) 
[17:26:43.421]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.421]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.421]             }
[17:26:43.421]             else {
[17:26:43.421]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.421]             }
[17:26:43.421]             {
[17:26:43.421]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.421]                   0L) {
[17:26:43.421]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.421]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.421]                   base::options(opts)
[17:26:43.421]                 }
[17:26:43.421]                 {
[17:26:43.421]                   {
[17:26:43.421]                     NULL
[17:26:43.421]                     RNGkind("Mersenne-Twister")
[17:26:43.421]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.421]                       inherits = FALSE)
[17:26:43.421]                   }
[17:26:43.421]                   options(future.plan = NULL)
[17:26:43.421]                   if (is.na(NA_character_)) 
[17:26:43.421]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.421]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.421]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.421]                     .init = FALSE)
[17:26:43.421]                 }
[17:26:43.421]             }
[17:26:43.421]         }
[17:26:43.421]     })
[17:26:43.421]     if (TRUE) {
[17:26:43.421]         base::sink(type = "output", split = FALSE)
[17:26:43.421]         if (TRUE) {
[17:26:43.421]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.421]         }
[17:26:43.421]         else {
[17:26:43.421]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.421]         }
[17:26:43.421]         base::close(...future.stdout)
[17:26:43.421]         ...future.stdout <- NULL
[17:26:43.421]     }
[17:26:43.421]     ...future.result$conditions <- ...future.conditions
[17:26:43.421]     ...future.result$finished <- base::Sys.time()
[17:26:43.421]     ...future.result
[17:26:43.421] }
[17:26:43.425] plan(): Setting new future strategy stack:
[17:26:43.425] List of future strategies:
[17:26:43.425] 1. sequential:
[17:26:43.425]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.425]    - tweaked: FALSE
[17:26:43.425]    - call: NULL
[17:26:43.425] plan(): nbrOfWorkers() = 1
[17:26:43.427] plan(): Setting new future strategy stack:
[17:26:43.427] List of future strategies:
[17:26:43.427] 1. sequential:
[17:26:43.427]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.427]    - tweaked: FALSE
[17:26:43.427]    - call: plan(strategy)
[17:26:43.427] plan(): nbrOfWorkers() = 1
[17:26:43.428] SequentialFuture started (and completed)
[17:26:43.428] - Launch lazy future ... done
[17:26:43.428] run() for 'SequentialFuture' ... done
[17:26:43.429] getGlobalsAndPackages() ...
[17:26:43.429] Searching for globals...
[17:26:43.430] - globals found: [1] '{'
[17:26:43.430] Searching for globals ... DONE
[17:26:43.430] Resolving globals: FALSE
[17:26:43.430] 
[17:26:43.430] 
[17:26:43.431] getGlobalsAndPackages() ... DONE
[17:26:43.431] run() for 'Future' ...
[17:26:43.431] - state: 'created'
[17:26:43.431] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.432] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.433] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.433]   - Field: 'label'
[17:26:43.433]   - Field: 'local'
[17:26:43.433]   - Field: 'owner'
[17:26:43.433]   - Field: 'envir'
[17:26:43.434]   - Field: 'packages'
[17:26:43.434]   - Field: 'gc'
[17:26:43.434]   - Field: 'conditions'
[17:26:43.434]   - Field: 'expr'
[17:26:43.434]   - Field: 'uuid'
[17:26:43.434]   - Field: 'seed'
[17:26:43.435]   - Field: 'version'
[17:26:43.435]   - Field: 'result'
[17:26:43.435]   - Field: 'asynchronous'
[17:26:43.435]   - Field: 'calls'
[17:26:43.435]   - Field: 'globals'
[17:26:43.436]   - Field: 'stdout'
[17:26:43.436]   - Field: 'earlySignal'
[17:26:43.436]   - Field: 'lazy'
[17:26:43.436]   - Field: 'state'
[17:26:43.436] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.436] - Launch lazy future ...
[17:26:43.437] Packages needed by the future expression (n = 0): <none>
[17:26:43.437] Packages needed by future strategies (n = 0): <none>
[17:26:43.437] {
[17:26:43.437]     {
[17:26:43.437]         {
[17:26:43.437]             ...future.startTime <- base::Sys.time()
[17:26:43.437]             {
[17:26:43.437]                 {
[17:26:43.437]                   {
[17:26:43.437]                     base::local({
[17:26:43.437]                       has_future <- base::requireNamespace("future", 
[17:26:43.437]                         quietly = TRUE)
[17:26:43.437]                       if (has_future) {
[17:26:43.437]                         ns <- base::getNamespace("future")
[17:26:43.437]                         version <- ns[[".package"]][["version"]]
[17:26:43.437]                         if (is.null(version)) 
[17:26:43.437]                           version <- utils::packageVersion("future")
[17:26:43.437]                       }
[17:26:43.437]                       else {
[17:26:43.437]                         version <- NULL
[17:26:43.437]                       }
[17:26:43.437]                       if (!has_future || version < "1.8.0") {
[17:26:43.437]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.437]                           "", base::R.version$version.string), 
[17:26:43.437]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.437]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.437]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.437]                             "release", "version")], collapse = " "), 
[17:26:43.437]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.437]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.437]                           info)
[17:26:43.437]                         info <- base::paste(info, collapse = "; ")
[17:26:43.437]                         if (!has_future) {
[17:26:43.437]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.437]                             info)
[17:26:43.437]                         }
[17:26:43.437]                         else {
[17:26:43.437]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.437]                             info, version)
[17:26:43.437]                         }
[17:26:43.437]                         base::stop(msg)
[17:26:43.437]                       }
[17:26:43.437]                     })
[17:26:43.437]                   }
[17:26:43.437]                   ...future.strategy.old <- future::plan("list")
[17:26:43.437]                   options(future.plan = NULL)
[17:26:43.437]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.437]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.437]                 }
[17:26:43.437]                 ...future.workdir <- getwd()
[17:26:43.437]             }
[17:26:43.437]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.437]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.437]         }
[17:26:43.437]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.437]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.437]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.437]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.437]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.437]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.437]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.437]             base::names(...future.oldOptions))
[17:26:43.437]     }
[17:26:43.437]     if (FALSE) {
[17:26:43.437]     }
[17:26:43.437]     else {
[17:26:43.437]         if (TRUE) {
[17:26:43.437]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.437]                 open = "w")
[17:26:43.437]         }
[17:26:43.437]         else {
[17:26:43.437]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.437]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.437]         }
[17:26:43.437]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.437]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.437]             base::sink(type = "output", split = FALSE)
[17:26:43.437]             base::close(...future.stdout)
[17:26:43.437]         }, add = TRUE)
[17:26:43.437]     }
[17:26:43.437]     ...future.frame <- base::sys.nframe()
[17:26:43.437]     ...future.conditions <- base::list()
[17:26:43.437]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.437]     if (FALSE) {
[17:26:43.437]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.437]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.437]     }
[17:26:43.437]     ...future.result <- base::tryCatch({
[17:26:43.437]         base::withCallingHandlers({
[17:26:43.437]             ...future.value <- base::withVisible(base::local({
[17:26:43.437]                 4
[17:26:43.437]             }))
[17:26:43.437]             future::FutureResult(value = ...future.value$value, 
[17:26:43.437]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.437]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.437]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.437]                     ...future.globalenv.names))
[17:26:43.437]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.437]         }, condition = base::local({
[17:26:43.437]             c <- base::c
[17:26:43.437]             inherits <- base::inherits
[17:26:43.437]             invokeRestart <- base::invokeRestart
[17:26:43.437]             length <- base::length
[17:26:43.437]             list <- base::list
[17:26:43.437]             seq.int <- base::seq.int
[17:26:43.437]             signalCondition <- base::signalCondition
[17:26:43.437]             sys.calls <- base::sys.calls
[17:26:43.437]             `[[` <- base::`[[`
[17:26:43.437]             `+` <- base::`+`
[17:26:43.437]             `<<-` <- base::`<<-`
[17:26:43.437]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.437]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.437]                   3L)]
[17:26:43.437]             }
[17:26:43.437]             function(cond) {
[17:26:43.437]                 is_error <- inherits(cond, "error")
[17:26:43.437]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.437]                   NULL)
[17:26:43.437]                 if (is_error) {
[17:26:43.437]                   sessionInformation <- function() {
[17:26:43.437]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.437]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.437]                       search = base::search(), system = base::Sys.info())
[17:26:43.437]                   }
[17:26:43.437]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.437]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.437]                     cond$call), session = sessionInformation(), 
[17:26:43.437]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.437]                   signalCondition(cond)
[17:26:43.437]                 }
[17:26:43.437]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.437]                 "immediateCondition"))) {
[17:26:43.437]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.437]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.437]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.437]                   if (TRUE && !signal) {
[17:26:43.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.437]                     {
[17:26:43.437]                       inherits <- base::inherits
[17:26:43.437]                       invokeRestart <- base::invokeRestart
[17:26:43.437]                       is.null <- base::is.null
[17:26:43.437]                       muffled <- FALSE
[17:26:43.437]                       if (inherits(cond, "message")) {
[17:26:43.437]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.437]                         if (muffled) 
[17:26:43.437]                           invokeRestart("muffleMessage")
[17:26:43.437]                       }
[17:26:43.437]                       else if (inherits(cond, "warning")) {
[17:26:43.437]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.437]                         if (muffled) 
[17:26:43.437]                           invokeRestart("muffleWarning")
[17:26:43.437]                       }
[17:26:43.437]                       else if (inherits(cond, "condition")) {
[17:26:43.437]                         if (!is.null(pattern)) {
[17:26:43.437]                           computeRestarts <- base::computeRestarts
[17:26:43.437]                           grepl <- base::grepl
[17:26:43.437]                           restarts <- computeRestarts(cond)
[17:26:43.437]                           for (restart in restarts) {
[17:26:43.437]                             name <- restart$name
[17:26:43.437]                             if (is.null(name)) 
[17:26:43.437]                               next
[17:26:43.437]                             if (!grepl(pattern, name)) 
[17:26:43.437]                               next
[17:26:43.437]                             invokeRestart(restart)
[17:26:43.437]                             muffled <- TRUE
[17:26:43.437]                             break
[17:26:43.437]                           }
[17:26:43.437]                         }
[17:26:43.437]                       }
[17:26:43.437]                       invisible(muffled)
[17:26:43.437]                     }
[17:26:43.437]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.437]                   }
[17:26:43.437]                 }
[17:26:43.437]                 else {
[17:26:43.437]                   if (TRUE) {
[17:26:43.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.437]                     {
[17:26:43.437]                       inherits <- base::inherits
[17:26:43.437]                       invokeRestart <- base::invokeRestart
[17:26:43.437]                       is.null <- base::is.null
[17:26:43.437]                       muffled <- FALSE
[17:26:43.437]                       if (inherits(cond, "message")) {
[17:26:43.437]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.437]                         if (muffled) 
[17:26:43.437]                           invokeRestart("muffleMessage")
[17:26:43.437]                       }
[17:26:43.437]                       else if (inherits(cond, "warning")) {
[17:26:43.437]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.437]                         if (muffled) 
[17:26:43.437]                           invokeRestart("muffleWarning")
[17:26:43.437]                       }
[17:26:43.437]                       else if (inherits(cond, "condition")) {
[17:26:43.437]                         if (!is.null(pattern)) {
[17:26:43.437]                           computeRestarts <- base::computeRestarts
[17:26:43.437]                           grepl <- base::grepl
[17:26:43.437]                           restarts <- computeRestarts(cond)
[17:26:43.437]                           for (restart in restarts) {
[17:26:43.437]                             name <- restart$name
[17:26:43.437]                             if (is.null(name)) 
[17:26:43.437]                               next
[17:26:43.437]                             if (!grepl(pattern, name)) 
[17:26:43.437]                               next
[17:26:43.437]                             invokeRestart(restart)
[17:26:43.437]                             muffled <- TRUE
[17:26:43.437]                             break
[17:26:43.437]                           }
[17:26:43.437]                         }
[17:26:43.437]                       }
[17:26:43.437]                       invisible(muffled)
[17:26:43.437]                     }
[17:26:43.437]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.437]                   }
[17:26:43.437]                 }
[17:26:43.437]             }
[17:26:43.437]         }))
[17:26:43.437]     }, error = function(ex) {
[17:26:43.437]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.437]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.437]                 ...future.rng), started = ...future.startTime, 
[17:26:43.437]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.437]             version = "1.8"), class = "FutureResult")
[17:26:43.437]     }, finally = {
[17:26:43.437]         if (!identical(...future.workdir, getwd())) 
[17:26:43.437]             setwd(...future.workdir)
[17:26:43.437]         {
[17:26:43.437]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.437]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.437]             }
[17:26:43.437]             base::options(...future.oldOptions)
[17:26:43.437]             if (.Platform$OS.type == "windows") {
[17:26:43.437]                 old_names <- names(...future.oldEnvVars)
[17:26:43.437]                 envs <- base::Sys.getenv()
[17:26:43.437]                 names <- names(envs)
[17:26:43.437]                 common <- intersect(names, old_names)
[17:26:43.437]                 added <- setdiff(names, old_names)
[17:26:43.437]                 removed <- setdiff(old_names, names)
[17:26:43.437]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.437]                   envs[common]]
[17:26:43.437]                 NAMES <- toupper(changed)
[17:26:43.437]                 args <- list()
[17:26:43.437]                 for (kk in seq_along(NAMES)) {
[17:26:43.437]                   name <- changed[[kk]]
[17:26:43.437]                   NAME <- NAMES[[kk]]
[17:26:43.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.437]                     next
[17:26:43.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.437]                 }
[17:26:43.437]                 NAMES <- toupper(added)
[17:26:43.437]                 for (kk in seq_along(NAMES)) {
[17:26:43.437]                   name <- added[[kk]]
[17:26:43.437]                   NAME <- NAMES[[kk]]
[17:26:43.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.437]                     next
[17:26:43.437]                   args[[name]] <- ""
[17:26:43.437]                 }
[17:26:43.437]                 NAMES <- toupper(removed)
[17:26:43.437]                 for (kk in seq_along(NAMES)) {
[17:26:43.437]                   name <- removed[[kk]]
[17:26:43.437]                   NAME <- NAMES[[kk]]
[17:26:43.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.437]                     next
[17:26:43.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.437]                 }
[17:26:43.437]                 if (length(args) > 0) 
[17:26:43.437]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.437]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.437]             }
[17:26:43.437]             else {
[17:26:43.437]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.437]             }
[17:26:43.437]             {
[17:26:43.437]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.437]                   0L) {
[17:26:43.437]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.437]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.437]                   base::options(opts)
[17:26:43.437]                 }
[17:26:43.437]                 {
[17:26:43.437]                   {
[17:26:43.437]                     NULL
[17:26:43.437]                     RNGkind("Mersenne-Twister")
[17:26:43.437]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.437]                       inherits = FALSE)
[17:26:43.437]                   }
[17:26:43.437]                   options(future.plan = NULL)
[17:26:43.437]                   if (is.na(NA_character_)) 
[17:26:43.437]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.437]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.437]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.437]                     .init = FALSE)
[17:26:43.437]                 }
[17:26:43.437]             }
[17:26:43.437]         }
[17:26:43.437]     })
[17:26:43.437]     if (TRUE) {
[17:26:43.437]         base::sink(type = "output", split = FALSE)
[17:26:43.437]         if (TRUE) {
[17:26:43.437]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.437]         }
[17:26:43.437]         else {
[17:26:43.437]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.437]         }
[17:26:43.437]         base::close(...future.stdout)
[17:26:43.437]         ...future.stdout <- NULL
[17:26:43.437]     }
[17:26:43.437]     ...future.result$conditions <- ...future.conditions
[17:26:43.437]     ...future.result$finished <- base::Sys.time()
[17:26:43.437]     ...future.result
[17:26:43.437] }
[17:26:43.441] plan(): Setting new future strategy stack:
[17:26:43.442] List of future strategies:
[17:26:43.442] 1. sequential:
[17:26:43.442]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.442]    - tweaked: FALSE
[17:26:43.442]    - call: NULL
[17:26:43.442] plan(): nbrOfWorkers() = 1
[17:26:43.443] plan(): Setting new future strategy stack:
[17:26:43.444] List of future strategies:
[17:26:43.444] 1. sequential:
[17:26:43.444]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.444]    - tweaked: FALSE
[17:26:43.444]    - call: plan(strategy)
[17:26:43.444] plan(): nbrOfWorkers() = 1
[17:26:43.444] SequentialFuture started (and completed)
[17:26:43.445] - Launch lazy future ... done
[17:26:43.445] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230b1a63e8> 
Classes 'listenv', 'environment' <environment: 0x0000022309a71560> 
 - attr(*, "dim.")= int [1:2] 1 6
 - attr(*, "dimnames.")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
[17:26:43.449] resolved() for 'SequentialFuture' ...
[17:26:43.449] - state: 'finished'
[17:26:43.449] - run: TRUE
[17:26:43.450] - result: 'FutureResult'
[17:26:43.450] resolved() for 'SequentialFuture' ... done
[17:26:43.450] resolved() for 'SequentialFuture' ...
[17:26:43.450] - state: 'finished'
[17:26:43.450] - run: TRUE
[17:26:43.451] - result: 'FutureResult'
[17:26:43.451] resolved() for 'SequentialFuture' ... done
[17:26:43.451] resolved() for 'SequentialFuture' ...
[17:26:43.451] - state: 'finished'
[17:26:43.451] - run: TRUE
[17:26:43.452] - result: 'FutureResult'
[17:26:43.452] resolved() for 'SequentialFuture' ... done
 logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:43.455] resolve() on list environment ...
[17:26:43.455]  recursive: 0
[17:26:43.456]  length: 6
[17:26:43.456]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:43.456] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.456] - nx: 6
[17:26:43.457] - relay: TRUE
[17:26:43.457] - stdout: TRUE
[17:26:43.457] - signal: TRUE
[17:26:43.457] - resignal: FALSE
[17:26:43.457] - force: TRUE
[17:26:43.457] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.458] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.458]  - until=2
[17:26:43.458]  - relaying element #2
[17:26:43.458] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.458] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.458] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.459]  length: 5 (resolved future 1)
[17:26:43.459] resolved() for 'SequentialFuture' ...
[17:26:43.459] - state: 'finished'
[17:26:43.459] - run: TRUE
[17:26:43.459] - result: 'FutureResult'
[17:26:43.460] resolved() for 'SequentialFuture' ... done
[17:26:43.460] Future #2
[17:26:43.460] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.460] - nx: 6
[17:26:43.460] - relay: TRUE
[17:26:43.460] - stdout: TRUE
[17:26:43.461] - signal: TRUE
[17:26:43.461] - resignal: FALSE
[17:26:43.461] - force: TRUE
[17:26:43.461] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.461] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.461]  - until=2
[17:26:43.462]  - relaying element #2
[17:26:43.462] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.462] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.462] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.462]  length: 4 (resolved future 2)
[17:26:43.463] resolved() for 'SequentialFuture' ...
[17:26:43.463] - state: 'finished'
[17:26:43.463] - run: TRUE
[17:26:43.463] - result: 'FutureResult'
[17:26:43.463] resolved() for 'SequentialFuture' ... done
[17:26:43.464] Future #3
[17:26:43.464] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.464] - nx: 6
[17:26:43.464] - relay: TRUE
[17:26:43.465] - stdout: TRUE
[17:26:43.465] - signal: TRUE
[17:26:43.465] - resignal: FALSE
[17:26:43.465] - force: TRUE
[17:26:43.466] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.466] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.466]  - until=3
[17:26:43.466]  - relaying element #3
[17:26:43.466] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.467] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.467] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.467]  length: 3 (resolved future 3)
[17:26:43.467] resolved() for 'SequentialFuture' ...
[17:26:43.467] - state: 'finished'
[17:26:43.467] - run: TRUE
[17:26:43.468] - result: 'FutureResult'
[17:26:43.468] resolved() for 'SequentialFuture' ... done
[17:26:43.468] Future #4
[17:26:43.468] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.468] - nx: 6
[17:26:43.469] - relay: TRUE
[17:26:43.469] - stdout: TRUE
[17:26:43.469] - signal: TRUE
[17:26:43.469] - resignal: FALSE
[17:26:43.469] - force: TRUE
[17:26:43.469] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.469] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.470]  - until=4
[17:26:43.470]  - relaying element #4
[17:26:43.470] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.470] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.470] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.471]  length: 2 (resolved future 4)
[17:26:43.471] signalConditionsASAP(NULL, pos=5) ...
[17:26:43.471] - nx: 6
[17:26:43.471] - relay: TRUE
[17:26:43.471] - stdout: TRUE
[17:26:43.471] - signal: TRUE
[17:26:43.471] - resignal: FALSE
[17:26:43.472] - force: TRUE
[17:26:43.472] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.472] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.472]  - until=6
[17:26:43.472]  - relaying element #6
[17:26:43.472] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.473] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.473] signalConditionsASAP(NULL, pos=5) ... done
[17:26:43.473]  length: 1 (resolved future 5)
[17:26:43.473] signalConditionsASAP(numeric, pos=6) ...
[17:26:43.473] - nx: 6
[17:26:43.473] - relay: TRUE
[17:26:43.474] - stdout: TRUE
[17:26:43.474] - signal: TRUE
[17:26:43.474] - resignal: FALSE
[17:26:43.474] - force: TRUE
[17:26:43.474] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.474] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.474]  - until=6
[17:26:43.475] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.475] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.475] signalConditionsASAP(numeric, pos=6) ... done
[17:26:43.475]  length: 0 (resolved future 6)
[17:26:43.475] Relaying remaining futures
[17:26:43.475] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.476] - nx: 6
[17:26:43.476] - relay: TRUE
[17:26:43.476] - stdout: TRUE
[17:26:43.476] - signal: TRUE
[17:26:43.476] - resignal: FALSE
[17:26:43.476] - force: TRUE
[17:26:43.476] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.477] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:43.477] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.477] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.477] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.477] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x000002230d36c840> 
 - attr(*, "dim.")= int [1:2] 1 6
 - attr(*, "dimnames.")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
Dimensions: c(2, 3)
[17:26:43.480] getGlobalsAndPackages() ...
[17:26:43.480] Searching for globals...
[17:26:43.480] 
[17:26:43.480] Searching for globals ... DONE
[17:26:43.481] - globals: [0] <none>
[17:26:43.481] getGlobalsAndPackages() ... DONE
[17:26:43.481] run() for 'Future' ...
[17:26:43.481] - state: 'created'
[17:26:43.481] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.482] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.482] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.482]   - Field: 'label'
[17:26:43.482]   - Field: 'local'
[17:26:43.483]   - Field: 'owner'
[17:26:43.483]   - Field: 'envir'
[17:26:43.483]   - Field: 'packages'
[17:26:43.483]   - Field: 'gc'
[17:26:43.483]   - Field: 'conditions'
[17:26:43.483]   - Field: 'expr'
[17:26:43.484]   - Field: 'uuid'
[17:26:43.484]   - Field: 'seed'
[17:26:43.484]   - Field: 'version'
[17:26:43.484]   - Field: 'result'
[17:26:43.484]   - Field: 'asynchronous'
[17:26:43.484]   - Field: 'calls'
[17:26:43.485]   - Field: 'globals'
[17:26:43.485]   - Field: 'stdout'
[17:26:43.485]   - Field: 'earlySignal'
[17:26:43.485]   - Field: 'lazy'
[17:26:43.485]   - Field: 'state'
[17:26:43.486] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.486] - Launch lazy future ...
[17:26:43.486] Packages needed by the future expression (n = 0): <none>
[17:26:43.486] Packages needed by future strategies (n = 0): <none>
[17:26:43.487] {
[17:26:43.487]     {
[17:26:43.487]         {
[17:26:43.487]             ...future.startTime <- base::Sys.time()
[17:26:43.487]             {
[17:26:43.487]                 {
[17:26:43.487]                   {
[17:26:43.487]                     base::local({
[17:26:43.487]                       has_future <- base::requireNamespace("future", 
[17:26:43.487]                         quietly = TRUE)
[17:26:43.487]                       if (has_future) {
[17:26:43.487]                         ns <- base::getNamespace("future")
[17:26:43.487]                         version <- ns[[".package"]][["version"]]
[17:26:43.487]                         if (is.null(version)) 
[17:26:43.487]                           version <- utils::packageVersion("future")
[17:26:43.487]                       }
[17:26:43.487]                       else {
[17:26:43.487]                         version <- NULL
[17:26:43.487]                       }
[17:26:43.487]                       if (!has_future || version < "1.8.0") {
[17:26:43.487]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.487]                           "", base::R.version$version.string), 
[17:26:43.487]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.487]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.487]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.487]                             "release", "version")], collapse = " "), 
[17:26:43.487]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.487]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.487]                           info)
[17:26:43.487]                         info <- base::paste(info, collapse = "; ")
[17:26:43.487]                         if (!has_future) {
[17:26:43.487]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.487]                             info)
[17:26:43.487]                         }
[17:26:43.487]                         else {
[17:26:43.487]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.487]                             info, version)
[17:26:43.487]                         }
[17:26:43.487]                         base::stop(msg)
[17:26:43.487]                       }
[17:26:43.487]                     })
[17:26:43.487]                   }
[17:26:43.487]                   ...future.strategy.old <- future::plan("list")
[17:26:43.487]                   options(future.plan = NULL)
[17:26:43.487]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.487]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.487]                 }
[17:26:43.487]                 ...future.workdir <- getwd()
[17:26:43.487]             }
[17:26:43.487]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.487]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.487]         }
[17:26:43.487]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.487]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.487]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.487]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.487]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.487]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.487]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.487]             base::names(...future.oldOptions))
[17:26:43.487]     }
[17:26:43.487]     if (FALSE) {
[17:26:43.487]     }
[17:26:43.487]     else {
[17:26:43.487]         if (TRUE) {
[17:26:43.487]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.487]                 open = "w")
[17:26:43.487]         }
[17:26:43.487]         else {
[17:26:43.487]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.487]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.487]         }
[17:26:43.487]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.487]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.487]             base::sink(type = "output", split = FALSE)
[17:26:43.487]             base::close(...future.stdout)
[17:26:43.487]         }, add = TRUE)
[17:26:43.487]     }
[17:26:43.487]     ...future.frame <- base::sys.nframe()
[17:26:43.487]     ...future.conditions <- base::list()
[17:26:43.487]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.487]     if (FALSE) {
[17:26:43.487]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.487]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.487]     }
[17:26:43.487]     ...future.result <- base::tryCatch({
[17:26:43.487]         base::withCallingHandlers({
[17:26:43.487]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.487]             future::FutureResult(value = ...future.value$value, 
[17:26:43.487]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.487]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.487]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.487]                     ...future.globalenv.names))
[17:26:43.487]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.487]         }, condition = base::local({
[17:26:43.487]             c <- base::c
[17:26:43.487]             inherits <- base::inherits
[17:26:43.487]             invokeRestart <- base::invokeRestart
[17:26:43.487]             length <- base::length
[17:26:43.487]             list <- base::list
[17:26:43.487]             seq.int <- base::seq.int
[17:26:43.487]             signalCondition <- base::signalCondition
[17:26:43.487]             sys.calls <- base::sys.calls
[17:26:43.487]             `[[` <- base::`[[`
[17:26:43.487]             `+` <- base::`+`
[17:26:43.487]             `<<-` <- base::`<<-`
[17:26:43.487]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.487]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.487]                   3L)]
[17:26:43.487]             }
[17:26:43.487]             function(cond) {
[17:26:43.487]                 is_error <- inherits(cond, "error")
[17:26:43.487]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.487]                   NULL)
[17:26:43.487]                 if (is_error) {
[17:26:43.487]                   sessionInformation <- function() {
[17:26:43.487]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.487]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.487]                       search = base::search(), system = base::Sys.info())
[17:26:43.487]                   }
[17:26:43.487]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.487]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.487]                     cond$call), session = sessionInformation(), 
[17:26:43.487]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.487]                   signalCondition(cond)
[17:26:43.487]                 }
[17:26:43.487]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.487]                 "immediateCondition"))) {
[17:26:43.487]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.487]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.487]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.487]                   if (TRUE && !signal) {
[17:26:43.487]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.487]                     {
[17:26:43.487]                       inherits <- base::inherits
[17:26:43.487]                       invokeRestart <- base::invokeRestart
[17:26:43.487]                       is.null <- base::is.null
[17:26:43.487]                       muffled <- FALSE
[17:26:43.487]                       if (inherits(cond, "message")) {
[17:26:43.487]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.487]                         if (muffled) 
[17:26:43.487]                           invokeRestart("muffleMessage")
[17:26:43.487]                       }
[17:26:43.487]                       else if (inherits(cond, "warning")) {
[17:26:43.487]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.487]                         if (muffled) 
[17:26:43.487]                           invokeRestart("muffleWarning")
[17:26:43.487]                       }
[17:26:43.487]                       else if (inherits(cond, "condition")) {
[17:26:43.487]                         if (!is.null(pattern)) {
[17:26:43.487]                           computeRestarts <- base::computeRestarts
[17:26:43.487]                           grepl <- base::grepl
[17:26:43.487]                           restarts <- computeRestarts(cond)
[17:26:43.487]                           for (restart in restarts) {
[17:26:43.487]                             name <- restart$name
[17:26:43.487]                             if (is.null(name)) 
[17:26:43.487]                               next
[17:26:43.487]                             if (!grepl(pattern, name)) 
[17:26:43.487]                               next
[17:26:43.487]                             invokeRestart(restart)
[17:26:43.487]                             muffled <- TRUE
[17:26:43.487]                             break
[17:26:43.487]                           }
[17:26:43.487]                         }
[17:26:43.487]                       }
[17:26:43.487]                       invisible(muffled)
[17:26:43.487]                     }
[17:26:43.487]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.487]                   }
[17:26:43.487]                 }
[17:26:43.487]                 else {
[17:26:43.487]                   if (TRUE) {
[17:26:43.487]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.487]                     {
[17:26:43.487]                       inherits <- base::inherits
[17:26:43.487]                       invokeRestart <- base::invokeRestart
[17:26:43.487]                       is.null <- base::is.null
[17:26:43.487]                       muffled <- FALSE
[17:26:43.487]                       if (inherits(cond, "message")) {
[17:26:43.487]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.487]                         if (muffled) 
[17:26:43.487]                           invokeRestart("muffleMessage")
[17:26:43.487]                       }
[17:26:43.487]                       else if (inherits(cond, "warning")) {
[17:26:43.487]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.487]                         if (muffled) 
[17:26:43.487]                           invokeRestart("muffleWarning")
[17:26:43.487]                       }
[17:26:43.487]                       else if (inherits(cond, "condition")) {
[17:26:43.487]                         if (!is.null(pattern)) {
[17:26:43.487]                           computeRestarts <- base::computeRestarts
[17:26:43.487]                           grepl <- base::grepl
[17:26:43.487]                           restarts <- computeRestarts(cond)
[17:26:43.487]                           for (restart in restarts) {
[17:26:43.487]                             name <- restart$name
[17:26:43.487]                             if (is.null(name)) 
[17:26:43.487]                               next
[17:26:43.487]                             if (!grepl(pattern, name)) 
[17:26:43.487]                               next
[17:26:43.487]                             invokeRestart(restart)
[17:26:43.487]                             muffled <- TRUE
[17:26:43.487]                             break
[17:26:43.487]                           }
[17:26:43.487]                         }
[17:26:43.487]                       }
[17:26:43.487]                       invisible(muffled)
[17:26:43.487]                     }
[17:26:43.487]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.487]                   }
[17:26:43.487]                 }
[17:26:43.487]             }
[17:26:43.487]         }))
[17:26:43.487]     }, error = function(ex) {
[17:26:43.487]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.487]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.487]                 ...future.rng), started = ...future.startTime, 
[17:26:43.487]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.487]             version = "1.8"), class = "FutureResult")
[17:26:43.487]     }, finally = {
[17:26:43.487]         if (!identical(...future.workdir, getwd())) 
[17:26:43.487]             setwd(...future.workdir)
[17:26:43.487]         {
[17:26:43.487]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.487]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.487]             }
[17:26:43.487]             base::options(...future.oldOptions)
[17:26:43.487]             if (.Platform$OS.type == "windows") {
[17:26:43.487]                 old_names <- names(...future.oldEnvVars)
[17:26:43.487]                 envs <- base::Sys.getenv()
[17:26:43.487]                 names <- names(envs)
[17:26:43.487]                 common <- intersect(names, old_names)
[17:26:43.487]                 added <- setdiff(names, old_names)
[17:26:43.487]                 removed <- setdiff(old_names, names)
[17:26:43.487]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.487]                   envs[common]]
[17:26:43.487]                 NAMES <- toupper(changed)
[17:26:43.487]                 args <- list()
[17:26:43.487]                 for (kk in seq_along(NAMES)) {
[17:26:43.487]                   name <- changed[[kk]]
[17:26:43.487]                   NAME <- NAMES[[kk]]
[17:26:43.487]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.487]                     next
[17:26:43.487]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.487]                 }
[17:26:43.487]                 NAMES <- toupper(added)
[17:26:43.487]                 for (kk in seq_along(NAMES)) {
[17:26:43.487]                   name <- added[[kk]]
[17:26:43.487]                   NAME <- NAMES[[kk]]
[17:26:43.487]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.487]                     next
[17:26:43.487]                   args[[name]] <- ""
[17:26:43.487]                 }
[17:26:43.487]                 NAMES <- toupper(removed)
[17:26:43.487]                 for (kk in seq_along(NAMES)) {
[17:26:43.487]                   name <- removed[[kk]]
[17:26:43.487]                   NAME <- NAMES[[kk]]
[17:26:43.487]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.487]                     next
[17:26:43.487]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.487]                 }
[17:26:43.487]                 if (length(args) > 0) 
[17:26:43.487]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.487]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.487]             }
[17:26:43.487]             else {
[17:26:43.487]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.487]             }
[17:26:43.487]             {
[17:26:43.487]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.487]                   0L) {
[17:26:43.487]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.487]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.487]                   base::options(opts)
[17:26:43.487]                 }
[17:26:43.487]                 {
[17:26:43.487]                   {
[17:26:43.487]                     NULL
[17:26:43.487]                     RNGkind("Mersenne-Twister")
[17:26:43.487]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.487]                       inherits = FALSE)
[17:26:43.487]                   }
[17:26:43.487]                   options(future.plan = NULL)
[17:26:43.487]                   if (is.na(NA_character_)) 
[17:26:43.487]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.487]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.487]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.487]                     .init = FALSE)
[17:26:43.487]                 }
[17:26:43.487]             }
[17:26:43.487]         }
[17:26:43.487]     })
[17:26:43.487]     if (TRUE) {
[17:26:43.487]         base::sink(type = "output", split = FALSE)
[17:26:43.487]         if (TRUE) {
[17:26:43.487]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.487]         }
[17:26:43.487]         else {
[17:26:43.487]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.487]         }
[17:26:43.487]         base::close(...future.stdout)
[17:26:43.487]         ...future.stdout <- NULL
[17:26:43.487]     }
[17:26:43.487]     ...future.result$conditions <- ...future.conditions
[17:26:43.487]     ...future.result$finished <- base::Sys.time()
[17:26:43.487]     ...future.result
[17:26:43.487] }
[17:26:43.491] plan(): Setting new future strategy stack:
[17:26:43.491] List of future strategies:
[17:26:43.491] 1. sequential:
[17:26:43.491]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.491]    - tweaked: FALSE
[17:26:43.491]    - call: NULL
[17:26:43.492] plan(): nbrOfWorkers() = 1
[17:26:43.493] plan(): Setting new future strategy stack:
[17:26:43.493] List of future strategies:
[17:26:43.493] 1. sequential:
[17:26:43.493]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.493]    - tweaked: FALSE
[17:26:43.493]    - call: plan(strategy)
[17:26:43.493] plan(): nbrOfWorkers() = 1
[17:26:43.494] SequentialFuture started (and completed)
[17:26:43.494] - Launch lazy future ... done
[17:26:43.494] run() for 'SequentialFuture' ... done
[17:26:43.494] getGlobalsAndPackages() ...
[17:26:43.494] Searching for globals...
[17:26:43.495] 
[17:26:43.495] Searching for globals ... DONE
[17:26:43.495] - globals: [0] <none>
[17:26:43.495] getGlobalsAndPackages() ... DONE
[17:26:43.496] run() for 'Future' ...
[17:26:43.496] - state: 'created'
[17:26:43.496] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.496] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.497] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.497]   - Field: 'label'
[17:26:43.497]   - Field: 'local'
[17:26:43.497]   - Field: 'owner'
[17:26:43.497]   - Field: 'envir'
[17:26:43.497]   - Field: 'packages'
[17:26:43.498]   - Field: 'gc'
[17:26:43.498]   - Field: 'conditions'
[17:26:43.498]   - Field: 'expr'
[17:26:43.498]   - Field: 'uuid'
[17:26:43.498]   - Field: 'seed'
[17:26:43.499]   - Field: 'version'
[17:26:43.499]   - Field: 'result'
[17:26:43.499]   - Field: 'asynchronous'
[17:26:43.500]   - Field: 'calls'
[17:26:43.500]   - Field: 'globals'
[17:26:43.500]   - Field: 'stdout'
[17:26:43.500]   - Field: 'earlySignal'
[17:26:43.501]   - Field: 'lazy'
[17:26:43.501]   - Field: 'state'
[17:26:43.501] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.501] - Launch lazy future ...
[17:26:43.501] Packages needed by the future expression (n = 0): <none>
[17:26:43.502] Packages needed by future strategies (n = 0): <none>
[17:26:43.502] {
[17:26:43.502]     {
[17:26:43.502]         {
[17:26:43.502]             ...future.startTime <- base::Sys.time()
[17:26:43.502]             {
[17:26:43.502]                 {
[17:26:43.502]                   {
[17:26:43.502]                     base::local({
[17:26:43.502]                       has_future <- base::requireNamespace("future", 
[17:26:43.502]                         quietly = TRUE)
[17:26:43.502]                       if (has_future) {
[17:26:43.502]                         ns <- base::getNamespace("future")
[17:26:43.502]                         version <- ns[[".package"]][["version"]]
[17:26:43.502]                         if (is.null(version)) 
[17:26:43.502]                           version <- utils::packageVersion("future")
[17:26:43.502]                       }
[17:26:43.502]                       else {
[17:26:43.502]                         version <- NULL
[17:26:43.502]                       }
[17:26:43.502]                       if (!has_future || version < "1.8.0") {
[17:26:43.502]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.502]                           "", base::R.version$version.string), 
[17:26:43.502]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.502]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.502]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.502]                             "release", "version")], collapse = " "), 
[17:26:43.502]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.502]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.502]                           info)
[17:26:43.502]                         info <- base::paste(info, collapse = "; ")
[17:26:43.502]                         if (!has_future) {
[17:26:43.502]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.502]                             info)
[17:26:43.502]                         }
[17:26:43.502]                         else {
[17:26:43.502]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.502]                             info, version)
[17:26:43.502]                         }
[17:26:43.502]                         base::stop(msg)
[17:26:43.502]                       }
[17:26:43.502]                     })
[17:26:43.502]                   }
[17:26:43.502]                   ...future.strategy.old <- future::plan("list")
[17:26:43.502]                   options(future.plan = NULL)
[17:26:43.502]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.502]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.502]                 }
[17:26:43.502]                 ...future.workdir <- getwd()
[17:26:43.502]             }
[17:26:43.502]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.502]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.502]         }
[17:26:43.502]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.502]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.502]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.502]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.502]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.502]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.502]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.502]             base::names(...future.oldOptions))
[17:26:43.502]     }
[17:26:43.502]     if (FALSE) {
[17:26:43.502]     }
[17:26:43.502]     else {
[17:26:43.502]         if (TRUE) {
[17:26:43.502]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.502]                 open = "w")
[17:26:43.502]         }
[17:26:43.502]         else {
[17:26:43.502]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.502]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.502]         }
[17:26:43.502]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.502]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.502]             base::sink(type = "output", split = FALSE)
[17:26:43.502]             base::close(...future.stdout)
[17:26:43.502]         }, add = TRUE)
[17:26:43.502]     }
[17:26:43.502]     ...future.frame <- base::sys.nframe()
[17:26:43.502]     ...future.conditions <- base::list()
[17:26:43.502]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.502]     if (FALSE) {
[17:26:43.502]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.502]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.502]     }
[17:26:43.502]     ...future.result <- base::tryCatch({
[17:26:43.502]         base::withCallingHandlers({
[17:26:43.502]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.502]             future::FutureResult(value = ...future.value$value, 
[17:26:43.502]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.502]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.502]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.502]                     ...future.globalenv.names))
[17:26:43.502]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.502]         }, condition = base::local({
[17:26:43.502]             c <- base::c
[17:26:43.502]             inherits <- base::inherits
[17:26:43.502]             invokeRestart <- base::invokeRestart
[17:26:43.502]             length <- base::length
[17:26:43.502]             list <- base::list
[17:26:43.502]             seq.int <- base::seq.int
[17:26:43.502]             signalCondition <- base::signalCondition
[17:26:43.502]             sys.calls <- base::sys.calls
[17:26:43.502]             `[[` <- base::`[[`
[17:26:43.502]             `+` <- base::`+`
[17:26:43.502]             `<<-` <- base::`<<-`
[17:26:43.502]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.502]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.502]                   3L)]
[17:26:43.502]             }
[17:26:43.502]             function(cond) {
[17:26:43.502]                 is_error <- inherits(cond, "error")
[17:26:43.502]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.502]                   NULL)
[17:26:43.502]                 if (is_error) {
[17:26:43.502]                   sessionInformation <- function() {
[17:26:43.502]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.502]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.502]                       search = base::search(), system = base::Sys.info())
[17:26:43.502]                   }
[17:26:43.502]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.502]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.502]                     cond$call), session = sessionInformation(), 
[17:26:43.502]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.502]                   signalCondition(cond)
[17:26:43.502]                 }
[17:26:43.502]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.502]                 "immediateCondition"))) {
[17:26:43.502]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.502]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.502]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.502]                   if (TRUE && !signal) {
[17:26:43.502]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.502]                     {
[17:26:43.502]                       inherits <- base::inherits
[17:26:43.502]                       invokeRestart <- base::invokeRestart
[17:26:43.502]                       is.null <- base::is.null
[17:26:43.502]                       muffled <- FALSE
[17:26:43.502]                       if (inherits(cond, "message")) {
[17:26:43.502]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.502]                         if (muffled) 
[17:26:43.502]                           invokeRestart("muffleMessage")
[17:26:43.502]                       }
[17:26:43.502]                       else if (inherits(cond, "warning")) {
[17:26:43.502]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.502]                         if (muffled) 
[17:26:43.502]                           invokeRestart("muffleWarning")
[17:26:43.502]                       }
[17:26:43.502]                       else if (inherits(cond, "condition")) {
[17:26:43.502]                         if (!is.null(pattern)) {
[17:26:43.502]                           computeRestarts <- base::computeRestarts
[17:26:43.502]                           grepl <- base::grepl
[17:26:43.502]                           restarts <- computeRestarts(cond)
[17:26:43.502]                           for (restart in restarts) {
[17:26:43.502]                             name <- restart$name
[17:26:43.502]                             if (is.null(name)) 
[17:26:43.502]                               next
[17:26:43.502]                             if (!grepl(pattern, name)) 
[17:26:43.502]                               next
[17:26:43.502]                             invokeRestart(restart)
[17:26:43.502]                             muffled <- TRUE
[17:26:43.502]                             break
[17:26:43.502]                           }
[17:26:43.502]                         }
[17:26:43.502]                       }
[17:26:43.502]                       invisible(muffled)
[17:26:43.502]                     }
[17:26:43.502]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.502]                   }
[17:26:43.502]                 }
[17:26:43.502]                 else {
[17:26:43.502]                   if (TRUE) {
[17:26:43.502]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.502]                     {
[17:26:43.502]                       inherits <- base::inherits
[17:26:43.502]                       invokeRestart <- base::invokeRestart
[17:26:43.502]                       is.null <- base::is.null
[17:26:43.502]                       muffled <- FALSE
[17:26:43.502]                       if (inherits(cond, "message")) {
[17:26:43.502]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.502]                         if (muffled) 
[17:26:43.502]                           invokeRestart("muffleMessage")
[17:26:43.502]                       }
[17:26:43.502]                       else if (inherits(cond, "warning")) {
[17:26:43.502]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.502]                         if (muffled) 
[17:26:43.502]                           invokeRestart("muffleWarning")
[17:26:43.502]                       }
[17:26:43.502]                       else if (inherits(cond, "condition")) {
[17:26:43.502]                         if (!is.null(pattern)) {
[17:26:43.502]                           computeRestarts <- base::computeRestarts
[17:26:43.502]                           grepl <- base::grepl
[17:26:43.502]                           restarts <- computeRestarts(cond)
[17:26:43.502]                           for (restart in restarts) {
[17:26:43.502]                             name <- restart$name
[17:26:43.502]                             if (is.null(name)) 
[17:26:43.502]                               next
[17:26:43.502]                             if (!grepl(pattern, name)) 
[17:26:43.502]                               next
[17:26:43.502]                             invokeRestart(restart)
[17:26:43.502]                             muffled <- TRUE
[17:26:43.502]                             break
[17:26:43.502]                           }
[17:26:43.502]                         }
[17:26:43.502]                       }
[17:26:43.502]                       invisible(muffled)
[17:26:43.502]                     }
[17:26:43.502]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.502]                   }
[17:26:43.502]                 }
[17:26:43.502]             }
[17:26:43.502]         }))
[17:26:43.502]     }, error = function(ex) {
[17:26:43.502]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.502]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.502]                 ...future.rng), started = ...future.startTime, 
[17:26:43.502]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.502]             version = "1.8"), class = "FutureResult")
[17:26:43.502]     }, finally = {
[17:26:43.502]         if (!identical(...future.workdir, getwd())) 
[17:26:43.502]             setwd(...future.workdir)
[17:26:43.502]         {
[17:26:43.502]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.502]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.502]             }
[17:26:43.502]             base::options(...future.oldOptions)
[17:26:43.502]             if (.Platform$OS.type == "windows") {
[17:26:43.502]                 old_names <- names(...future.oldEnvVars)
[17:26:43.502]                 envs <- base::Sys.getenv()
[17:26:43.502]                 names <- names(envs)
[17:26:43.502]                 common <- intersect(names, old_names)
[17:26:43.502]                 added <- setdiff(names, old_names)
[17:26:43.502]                 removed <- setdiff(old_names, names)
[17:26:43.502]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.502]                   envs[common]]
[17:26:43.502]                 NAMES <- toupper(changed)
[17:26:43.502]                 args <- list()
[17:26:43.502]                 for (kk in seq_along(NAMES)) {
[17:26:43.502]                   name <- changed[[kk]]
[17:26:43.502]                   NAME <- NAMES[[kk]]
[17:26:43.502]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.502]                     next
[17:26:43.502]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.502]                 }
[17:26:43.502]                 NAMES <- toupper(added)
[17:26:43.502]                 for (kk in seq_along(NAMES)) {
[17:26:43.502]                   name <- added[[kk]]
[17:26:43.502]                   NAME <- NAMES[[kk]]
[17:26:43.502]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.502]                     next
[17:26:43.502]                   args[[name]] <- ""
[17:26:43.502]                 }
[17:26:43.502]                 NAMES <- toupper(removed)
[17:26:43.502]                 for (kk in seq_along(NAMES)) {
[17:26:43.502]                   name <- removed[[kk]]
[17:26:43.502]                   NAME <- NAMES[[kk]]
[17:26:43.502]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.502]                     next
[17:26:43.502]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.502]                 }
[17:26:43.502]                 if (length(args) > 0) 
[17:26:43.502]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.502]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.502]             }
[17:26:43.502]             else {
[17:26:43.502]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.502]             }
[17:26:43.502]             {
[17:26:43.502]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.502]                   0L) {
[17:26:43.502]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.502]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.502]                   base::options(opts)
[17:26:43.502]                 }
[17:26:43.502]                 {
[17:26:43.502]                   {
[17:26:43.502]                     NULL
[17:26:43.502]                     RNGkind("Mersenne-Twister")
[17:26:43.502]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.502]                       inherits = FALSE)
[17:26:43.502]                   }
[17:26:43.502]                   options(future.plan = NULL)
[17:26:43.502]                   if (is.na(NA_character_)) 
[17:26:43.502]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.502]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.502]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.502]                     .init = FALSE)
[17:26:43.502]                 }
[17:26:43.502]             }
[17:26:43.502]         }
[17:26:43.502]     })
[17:26:43.502]     if (TRUE) {
[17:26:43.502]         base::sink(type = "output", split = FALSE)
[17:26:43.502]         if (TRUE) {
[17:26:43.502]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.502]         }
[17:26:43.502]         else {
[17:26:43.502]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.502]         }
[17:26:43.502]         base::close(...future.stdout)
[17:26:43.502]         ...future.stdout <- NULL
[17:26:43.502]     }
[17:26:43.502]     ...future.result$conditions <- ...future.conditions
[17:26:43.502]     ...future.result$finished <- base::Sys.time()
[17:26:43.502]     ...future.result
[17:26:43.502] }
[17:26:43.506] plan(): Setting new future strategy stack:
[17:26:43.506] List of future strategies:
[17:26:43.506] 1. sequential:
[17:26:43.506]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.506]    - tweaked: FALSE
[17:26:43.506]    - call: NULL
[17:26:43.507] plan(): nbrOfWorkers() = 1
[17:26:43.508] plan(): Setting new future strategy stack:
[17:26:43.508] List of future strategies:
[17:26:43.508] 1. sequential:
[17:26:43.508]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.508]    - tweaked: FALSE
[17:26:43.508]    - call: plan(strategy)
[17:26:43.509] plan(): nbrOfWorkers() = 1
[17:26:43.509] SequentialFuture started (and completed)
[17:26:43.509] - Launch lazy future ... done
[17:26:43.509] run() for 'SequentialFuture' ... done
[17:26:43.510] getGlobalsAndPackages() ...
[17:26:43.510] Searching for globals...
[17:26:43.511] - globals found: [1] '{'
[17:26:43.511] Searching for globals ... DONE
[17:26:43.511] Resolving globals: FALSE
[17:26:43.511] 
[17:26:43.511] 
[17:26:43.512] getGlobalsAndPackages() ... DONE
[17:26:43.512] run() for 'Future' ...
[17:26:43.512] - state: 'created'
[17:26:43.512] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.513] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.513] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.513]   - Field: 'label'
[17:26:43.513]   - Field: 'local'
[17:26:43.513]   - Field: 'owner'
[17:26:43.514]   - Field: 'envir'
[17:26:43.514]   - Field: 'packages'
[17:26:43.514]   - Field: 'gc'
[17:26:43.514]   - Field: 'conditions'
[17:26:43.514]   - Field: 'expr'
[17:26:43.514]   - Field: 'uuid'
[17:26:43.515]   - Field: 'seed'
[17:26:43.515]   - Field: 'version'
[17:26:43.515]   - Field: 'result'
[17:26:43.515]   - Field: 'asynchronous'
[17:26:43.515]   - Field: 'calls'
[17:26:43.516]   - Field: 'globals'
[17:26:43.516]   - Field: 'stdout'
[17:26:43.516]   - Field: 'earlySignal'
[17:26:43.516]   - Field: 'lazy'
[17:26:43.516]   - Field: 'state'
[17:26:43.516] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.517] - Launch lazy future ...
[17:26:43.517] Packages needed by the future expression (n = 0): <none>
[17:26:43.517] Packages needed by future strategies (n = 0): <none>
[17:26:43.518] {
[17:26:43.518]     {
[17:26:43.518]         {
[17:26:43.518]             ...future.startTime <- base::Sys.time()
[17:26:43.518]             {
[17:26:43.518]                 {
[17:26:43.518]                   {
[17:26:43.518]                     base::local({
[17:26:43.518]                       has_future <- base::requireNamespace("future", 
[17:26:43.518]                         quietly = TRUE)
[17:26:43.518]                       if (has_future) {
[17:26:43.518]                         ns <- base::getNamespace("future")
[17:26:43.518]                         version <- ns[[".package"]][["version"]]
[17:26:43.518]                         if (is.null(version)) 
[17:26:43.518]                           version <- utils::packageVersion("future")
[17:26:43.518]                       }
[17:26:43.518]                       else {
[17:26:43.518]                         version <- NULL
[17:26:43.518]                       }
[17:26:43.518]                       if (!has_future || version < "1.8.0") {
[17:26:43.518]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.518]                           "", base::R.version$version.string), 
[17:26:43.518]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.518]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.518]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.518]                             "release", "version")], collapse = " "), 
[17:26:43.518]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.518]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.518]                           info)
[17:26:43.518]                         info <- base::paste(info, collapse = "; ")
[17:26:43.518]                         if (!has_future) {
[17:26:43.518]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.518]                             info)
[17:26:43.518]                         }
[17:26:43.518]                         else {
[17:26:43.518]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.518]                             info, version)
[17:26:43.518]                         }
[17:26:43.518]                         base::stop(msg)
[17:26:43.518]                       }
[17:26:43.518]                     })
[17:26:43.518]                   }
[17:26:43.518]                   ...future.strategy.old <- future::plan("list")
[17:26:43.518]                   options(future.plan = NULL)
[17:26:43.518]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.518]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.518]                 }
[17:26:43.518]                 ...future.workdir <- getwd()
[17:26:43.518]             }
[17:26:43.518]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.518]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.518]         }
[17:26:43.518]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.518]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.518]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.518]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.518]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.518]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.518]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.518]             base::names(...future.oldOptions))
[17:26:43.518]     }
[17:26:43.518]     if (FALSE) {
[17:26:43.518]     }
[17:26:43.518]     else {
[17:26:43.518]         if (TRUE) {
[17:26:43.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.518]                 open = "w")
[17:26:43.518]         }
[17:26:43.518]         else {
[17:26:43.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.518]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.518]         }
[17:26:43.518]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.518]             base::sink(type = "output", split = FALSE)
[17:26:43.518]             base::close(...future.stdout)
[17:26:43.518]         }, add = TRUE)
[17:26:43.518]     }
[17:26:43.518]     ...future.frame <- base::sys.nframe()
[17:26:43.518]     ...future.conditions <- base::list()
[17:26:43.518]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.518]     if (FALSE) {
[17:26:43.518]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.518]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.518]     }
[17:26:43.518]     ...future.result <- base::tryCatch({
[17:26:43.518]         base::withCallingHandlers({
[17:26:43.518]             ...future.value <- base::withVisible(base::local({
[17:26:43.518]                 4
[17:26:43.518]             }))
[17:26:43.518]             future::FutureResult(value = ...future.value$value, 
[17:26:43.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.518]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.518]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.518]                     ...future.globalenv.names))
[17:26:43.518]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.518]         }, condition = base::local({
[17:26:43.518]             c <- base::c
[17:26:43.518]             inherits <- base::inherits
[17:26:43.518]             invokeRestart <- base::invokeRestart
[17:26:43.518]             length <- base::length
[17:26:43.518]             list <- base::list
[17:26:43.518]             seq.int <- base::seq.int
[17:26:43.518]             signalCondition <- base::signalCondition
[17:26:43.518]             sys.calls <- base::sys.calls
[17:26:43.518]             `[[` <- base::`[[`
[17:26:43.518]             `+` <- base::`+`
[17:26:43.518]             `<<-` <- base::`<<-`
[17:26:43.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.518]                   3L)]
[17:26:43.518]             }
[17:26:43.518]             function(cond) {
[17:26:43.518]                 is_error <- inherits(cond, "error")
[17:26:43.518]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.518]                   NULL)
[17:26:43.518]                 if (is_error) {
[17:26:43.518]                   sessionInformation <- function() {
[17:26:43.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.518]                       search = base::search(), system = base::Sys.info())
[17:26:43.518]                   }
[17:26:43.518]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.518]                     cond$call), session = sessionInformation(), 
[17:26:43.518]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.518]                   signalCondition(cond)
[17:26:43.518]                 }
[17:26:43.518]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.518]                 "immediateCondition"))) {
[17:26:43.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.518]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.518]                   if (TRUE && !signal) {
[17:26:43.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.518]                     {
[17:26:43.518]                       inherits <- base::inherits
[17:26:43.518]                       invokeRestart <- base::invokeRestart
[17:26:43.518]                       is.null <- base::is.null
[17:26:43.518]                       muffled <- FALSE
[17:26:43.518]                       if (inherits(cond, "message")) {
[17:26:43.518]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.518]                         if (muffled) 
[17:26:43.518]                           invokeRestart("muffleMessage")
[17:26:43.518]                       }
[17:26:43.518]                       else if (inherits(cond, "warning")) {
[17:26:43.518]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.518]                         if (muffled) 
[17:26:43.518]                           invokeRestart("muffleWarning")
[17:26:43.518]                       }
[17:26:43.518]                       else if (inherits(cond, "condition")) {
[17:26:43.518]                         if (!is.null(pattern)) {
[17:26:43.518]                           computeRestarts <- base::computeRestarts
[17:26:43.518]                           grepl <- base::grepl
[17:26:43.518]                           restarts <- computeRestarts(cond)
[17:26:43.518]                           for (restart in restarts) {
[17:26:43.518]                             name <- restart$name
[17:26:43.518]                             if (is.null(name)) 
[17:26:43.518]                               next
[17:26:43.518]                             if (!grepl(pattern, name)) 
[17:26:43.518]                               next
[17:26:43.518]                             invokeRestart(restart)
[17:26:43.518]                             muffled <- TRUE
[17:26:43.518]                             break
[17:26:43.518]                           }
[17:26:43.518]                         }
[17:26:43.518]                       }
[17:26:43.518]                       invisible(muffled)
[17:26:43.518]                     }
[17:26:43.518]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.518]                   }
[17:26:43.518]                 }
[17:26:43.518]                 else {
[17:26:43.518]                   if (TRUE) {
[17:26:43.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.518]                     {
[17:26:43.518]                       inherits <- base::inherits
[17:26:43.518]                       invokeRestart <- base::invokeRestart
[17:26:43.518]                       is.null <- base::is.null
[17:26:43.518]                       muffled <- FALSE
[17:26:43.518]                       if (inherits(cond, "message")) {
[17:26:43.518]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.518]                         if (muffled) 
[17:26:43.518]                           invokeRestart("muffleMessage")
[17:26:43.518]                       }
[17:26:43.518]                       else if (inherits(cond, "warning")) {
[17:26:43.518]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.518]                         if (muffled) 
[17:26:43.518]                           invokeRestart("muffleWarning")
[17:26:43.518]                       }
[17:26:43.518]                       else if (inherits(cond, "condition")) {
[17:26:43.518]                         if (!is.null(pattern)) {
[17:26:43.518]                           computeRestarts <- base::computeRestarts
[17:26:43.518]                           grepl <- base::grepl
[17:26:43.518]                           restarts <- computeRestarts(cond)
[17:26:43.518]                           for (restart in restarts) {
[17:26:43.518]                             name <- restart$name
[17:26:43.518]                             if (is.null(name)) 
[17:26:43.518]                               next
[17:26:43.518]                             if (!grepl(pattern, name)) 
[17:26:43.518]                               next
[17:26:43.518]                             invokeRestart(restart)
[17:26:43.518]                             muffled <- TRUE
[17:26:43.518]                             break
[17:26:43.518]                           }
[17:26:43.518]                         }
[17:26:43.518]                       }
[17:26:43.518]                       invisible(muffled)
[17:26:43.518]                     }
[17:26:43.518]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.518]                   }
[17:26:43.518]                 }
[17:26:43.518]             }
[17:26:43.518]         }))
[17:26:43.518]     }, error = function(ex) {
[17:26:43.518]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.518]                 ...future.rng), started = ...future.startTime, 
[17:26:43.518]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.518]             version = "1.8"), class = "FutureResult")
[17:26:43.518]     }, finally = {
[17:26:43.518]         if (!identical(...future.workdir, getwd())) 
[17:26:43.518]             setwd(...future.workdir)
[17:26:43.518]         {
[17:26:43.518]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.518]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.518]             }
[17:26:43.518]             base::options(...future.oldOptions)
[17:26:43.518]             if (.Platform$OS.type == "windows") {
[17:26:43.518]                 old_names <- names(...future.oldEnvVars)
[17:26:43.518]                 envs <- base::Sys.getenv()
[17:26:43.518]                 names <- names(envs)
[17:26:43.518]                 common <- intersect(names, old_names)
[17:26:43.518]                 added <- setdiff(names, old_names)
[17:26:43.518]                 removed <- setdiff(old_names, names)
[17:26:43.518]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.518]                   envs[common]]
[17:26:43.518]                 NAMES <- toupper(changed)
[17:26:43.518]                 args <- list()
[17:26:43.518]                 for (kk in seq_along(NAMES)) {
[17:26:43.518]                   name <- changed[[kk]]
[17:26:43.518]                   NAME <- NAMES[[kk]]
[17:26:43.518]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.518]                     next
[17:26:43.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.518]                 }
[17:26:43.518]                 NAMES <- toupper(added)
[17:26:43.518]                 for (kk in seq_along(NAMES)) {
[17:26:43.518]                   name <- added[[kk]]
[17:26:43.518]                   NAME <- NAMES[[kk]]
[17:26:43.518]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.518]                     next
[17:26:43.518]                   args[[name]] <- ""
[17:26:43.518]                 }
[17:26:43.518]                 NAMES <- toupper(removed)
[17:26:43.518]                 for (kk in seq_along(NAMES)) {
[17:26:43.518]                   name <- removed[[kk]]
[17:26:43.518]                   NAME <- NAMES[[kk]]
[17:26:43.518]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.518]                     next
[17:26:43.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.518]                 }
[17:26:43.518]                 if (length(args) > 0) 
[17:26:43.518]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.518]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.518]             }
[17:26:43.518]             else {
[17:26:43.518]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.518]             }
[17:26:43.518]             {
[17:26:43.518]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.518]                   0L) {
[17:26:43.518]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.518]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.518]                   base::options(opts)
[17:26:43.518]                 }
[17:26:43.518]                 {
[17:26:43.518]                   {
[17:26:43.518]                     NULL
[17:26:43.518]                     RNGkind("Mersenne-Twister")
[17:26:43.518]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.518]                       inherits = FALSE)
[17:26:43.518]                   }
[17:26:43.518]                   options(future.plan = NULL)
[17:26:43.518]                   if (is.na(NA_character_)) 
[17:26:43.518]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.518]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.518]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.518]                     .init = FALSE)
[17:26:43.518]                 }
[17:26:43.518]             }
[17:26:43.518]         }
[17:26:43.518]     })
[17:26:43.518]     if (TRUE) {
[17:26:43.518]         base::sink(type = "output", split = FALSE)
[17:26:43.518]         if (TRUE) {
[17:26:43.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.518]         }
[17:26:43.518]         else {
[17:26:43.518]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.518]         }
[17:26:43.518]         base::close(...future.stdout)
[17:26:43.518]         ...future.stdout <- NULL
[17:26:43.518]     }
[17:26:43.518]     ...future.result$conditions <- ...future.conditions
[17:26:43.518]     ...future.result$finished <- base::Sys.time()
[17:26:43.518]     ...future.result
[17:26:43.518] }
[17:26:43.522] plan(): Setting new future strategy stack:
[17:26:43.522] List of future strategies:
[17:26:43.522] 1. sequential:
[17:26:43.522]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.522]    - tweaked: FALSE
[17:26:43.522]    - call: NULL
[17:26:43.522] plan(): nbrOfWorkers() = 1
[17:26:43.523] plan(): Setting new future strategy stack:
[17:26:43.524] List of future strategies:
[17:26:43.524] 1. sequential:
[17:26:43.524]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.524]    - tweaked: FALSE
[17:26:43.524]    - call: plan(strategy)
[17:26:43.524] plan(): nbrOfWorkers() = 1
[17:26:43.524] SequentialFuture started (and completed)
[17:26:43.525] - Launch lazy future ... done
[17:26:43.525] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230cabfd80> 
Classes 'listenv', 'environment' <environment: 0x000002230d3239c8> 
 - attr(*, "dim.")= int [1:2] 2 3
 - attr(*, "dimnames.")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
[17:26:43.529] resolved() for 'SequentialFuture' ...
[17:26:43.529] - state: 'finished'
[17:26:43.529] - run: TRUE
[17:26:43.530] - result: 'FutureResult'
[17:26:43.530] resolved() for 'SequentialFuture' ... done
[17:26:43.530] resolved() for 'SequentialFuture' ...
[17:26:43.530] - state: 'finished'
[17:26:43.530] - run: TRUE
[17:26:43.530] - result: 'FutureResult'
[17:26:43.531] resolved() for 'SequentialFuture' ... done
[17:26:43.531] resolved() for 'SequentialFuture' ...
[17:26:43.531] - state: 'finished'
[17:26:43.531] - run: TRUE
[17:26:43.531] - result: 'FutureResult'
[17:26:43.532] resolved() for 'SequentialFuture' ... done
 logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:43.535] resolve() on list environment ...
[17:26:43.535]  recursive: 0
[17:26:43.536]  length: 6
[17:26:43.537]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:43.537] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.537] - nx: 6
[17:26:43.537] - relay: TRUE
[17:26:43.537] - stdout: TRUE
[17:26:43.537] - signal: TRUE
[17:26:43.538] - resignal: FALSE
[17:26:43.538] - force: TRUE
[17:26:43.538] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.538] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.538]  - until=2
[17:26:43.538]  - relaying element #2
[17:26:43.539] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.539] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.539] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.539]  length: 5 (resolved future 1)
[17:26:43.539] resolved() for 'SequentialFuture' ...
[17:26:43.539] - state: 'finished'
[17:26:43.540] - run: TRUE
[17:26:43.540] - result: 'FutureResult'
[17:26:43.540] resolved() for 'SequentialFuture' ... done
[17:26:43.540] Future #2
[17:26:43.540] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.541] - nx: 6
[17:26:43.541] - relay: TRUE
[17:26:43.541] - stdout: TRUE
[17:26:43.541] - signal: TRUE
[17:26:43.541] - resignal: FALSE
[17:26:43.541] - force: TRUE
[17:26:43.541] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.542] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.542]  - until=2
[17:26:43.542]  - relaying element #2
[17:26:43.542] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.542] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.543] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.543]  length: 4 (resolved future 2)
[17:26:43.543] resolved() for 'SequentialFuture' ...
[17:26:43.543] - state: 'finished'
[17:26:43.543] - run: TRUE
[17:26:43.543] - result: 'FutureResult'
[17:26:43.544] resolved() for 'SequentialFuture' ... done
[17:26:43.544] Future #3
[17:26:43.544] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.544] - nx: 6
[17:26:43.544] - relay: TRUE
[17:26:43.545] - stdout: TRUE
[17:26:43.545] - signal: TRUE
[17:26:43.545] - resignal: FALSE
[17:26:43.545] - force: TRUE
[17:26:43.545] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.545] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.545]  - until=3
[17:26:43.546]  - relaying element #3
[17:26:43.546] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.546] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.546] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.546]  length: 3 (resolved future 3)
[17:26:43.547] resolved() for 'SequentialFuture' ...
[17:26:43.547] - state: 'finished'
[17:26:43.547] - run: TRUE
[17:26:43.547] - result: 'FutureResult'
[17:26:43.547] resolved() for 'SequentialFuture' ... done
[17:26:43.547] Future #4
[17:26:43.548] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.548] - nx: 6
[17:26:43.548] - relay: TRUE
[17:26:43.548] - stdout: TRUE
[17:26:43.548] - signal: TRUE
[17:26:43.548] - resignal: FALSE
[17:26:43.549] - force: TRUE
[17:26:43.549] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.549] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.549]  - until=4
[17:26:43.549]  - relaying element #4
[17:26:43.550] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.550] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.550] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.550]  length: 2 (resolved future 4)
[17:26:43.550] signalConditionsASAP(NULL, pos=5) ...
[17:26:43.550] - nx: 6
[17:26:43.551] - relay: TRUE
[17:26:43.551] - stdout: TRUE
[17:26:43.551] - signal: TRUE
[17:26:43.551] - resignal: FALSE
[17:26:43.551] - force: TRUE
[17:26:43.551] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.551] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.552]  - until=6
[17:26:43.552]  - relaying element #6
[17:26:43.552] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.552] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.552] signalConditionsASAP(NULL, pos=5) ... done
[17:26:43.552]  length: 1 (resolved future 5)
[17:26:43.553] signalConditionsASAP(numeric, pos=6) ...
[17:26:43.553] - nx: 6
[17:26:43.553] - relay: TRUE
[17:26:43.553] - stdout: TRUE
[17:26:43.553] - signal: TRUE
[17:26:43.553] - resignal: FALSE
[17:26:43.553] - force: TRUE
[17:26:43.554] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.554] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.554]  - until=6
[17:26:43.554] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.554] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.554] signalConditionsASAP(numeric, pos=6) ... done
[17:26:43.555]  length: 0 (resolved future 6)
[17:26:43.555] Relaying remaining futures
[17:26:43.555] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.555] - nx: 6
[17:26:43.555] - relay: TRUE
[17:26:43.555] - stdout: TRUE
[17:26:43.555] - signal: TRUE
[17:26:43.556] - resignal: FALSE
[17:26:43.556] - force: TRUE
[17:26:43.556] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.556] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:43.556] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.557] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.557] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.557] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x000002230d8b98b0> 
 - attr(*, "dim.")= int [1:2] 2 3
 - attr(*, "dimnames.")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
Dimensions: c(2, 3, 1)
[17:26:43.559] getGlobalsAndPackages() ...
[17:26:43.559] Searching for globals...
[17:26:43.560] 
[17:26:43.560] Searching for globals ... DONE
[17:26:43.560] - globals: [0] <none>
[17:26:43.560] getGlobalsAndPackages() ... DONE
[17:26:43.560] run() for 'Future' ...
[17:26:43.561] - state: 'created'
[17:26:43.561] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.561] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.561] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.562]   - Field: 'label'
[17:26:43.562]   - Field: 'local'
[17:26:43.562]   - Field: 'owner'
[17:26:43.562]   - Field: 'envir'
[17:26:43.562]   - Field: 'packages'
[17:26:43.562]   - Field: 'gc'
[17:26:43.563]   - Field: 'conditions'
[17:26:43.563]   - Field: 'expr'
[17:26:43.563]   - Field: 'uuid'
[17:26:43.563]   - Field: 'seed'
[17:26:43.563]   - Field: 'version'
[17:26:43.564]   - Field: 'result'
[17:26:43.564]   - Field: 'asynchronous'
[17:26:43.564]   - Field: 'calls'
[17:26:43.564]   - Field: 'globals'
[17:26:43.564]   - Field: 'stdout'
[17:26:43.565]   - Field: 'earlySignal'
[17:26:43.565]   - Field: 'lazy'
[17:26:43.565]   - Field: 'state'
[17:26:43.566] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.566] - Launch lazy future ...
[17:26:43.566] Packages needed by the future expression (n = 0): <none>
[17:26:43.566] Packages needed by future strategies (n = 0): <none>
[17:26:43.567] {
[17:26:43.567]     {
[17:26:43.567]         {
[17:26:43.567]             ...future.startTime <- base::Sys.time()
[17:26:43.567]             {
[17:26:43.567]                 {
[17:26:43.567]                   {
[17:26:43.567]                     base::local({
[17:26:43.567]                       has_future <- base::requireNamespace("future", 
[17:26:43.567]                         quietly = TRUE)
[17:26:43.567]                       if (has_future) {
[17:26:43.567]                         ns <- base::getNamespace("future")
[17:26:43.567]                         version <- ns[[".package"]][["version"]]
[17:26:43.567]                         if (is.null(version)) 
[17:26:43.567]                           version <- utils::packageVersion("future")
[17:26:43.567]                       }
[17:26:43.567]                       else {
[17:26:43.567]                         version <- NULL
[17:26:43.567]                       }
[17:26:43.567]                       if (!has_future || version < "1.8.0") {
[17:26:43.567]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.567]                           "", base::R.version$version.string), 
[17:26:43.567]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.567]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.567]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.567]                             "release", "version")], collapse = " "), 
[17:26:43.567]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.567]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.567]                           info)
[17:26:43.567]                         info <- base::paste(info, collapse = "; ")
[17:26:43.567]                         if (!has_future) {
[17:26:43.567]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.567]                             info)
[17:26:43.567]                         }
[17:26:43.567]                         else {
[17:26:43.567]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.567]                             info, version)
[17:26:43.567]                         }
[17:26:43.567]                         base::stop(msg)
[17:26:43.567]                       }
[17:26:43.567]                     })
[17:26:43.567]                   }
[17:26:43.567]                   ...future.strategy.old <- future::plan("list")
[17:26:43.567]                   options(future.plan = NULL)
[17:26:43.567]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.567]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.567]                 }
[17:26:43.567]                 ...future.workdir <- getwd()
[17:26:43.567]             }
[17:26:43.567]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.567]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.567]         }
[17:26:43.567]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.567]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.567]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.567]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.567]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.567]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.567]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.567]             base::names(...future.oldOptions))
[17:26:43.567]     }
[17:26:43.567]     if (FALSE) {
[17:26:43.567]     }
[17:26:43.567]     else {
[17:26:43.567]         if (TRUE) {
[17:26:43.567]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.567]                 open = "w")
[17:26:43.567]         }
[17:26:43.567]         else {
[17:26:43.567]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.567]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.567]         }
[17:26:43.567]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.567]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.567]             base::sink(type = "output", split = FALSE)
[17:26:43.567]             base::close(...future.stdout)
[17:26:43.567]         }, add = TRUE)
[17:26:43.567]     }
[17:26:43.567]     ...future.frame <- base::sys.nframe()
[17:26:43.567]     ...future.conditions <- base::list()
[17:26:43.567]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.567]     if (FALSE) {
[17:26:43.567]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.567]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.567]     }
[17:26:43.567]     ...future.result <- base::tryCatch({
[17:26:43.567]         base::withCallingHandlers({
[17:26:43.567]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.567]             future::FutureResult(value = ...future.value$value, 
[17:26:43.567]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.567]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.567]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.567]                     ...future.globalenv.names))
[17:26:43.567]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.567]         }, condition = base::local({
[17:26:43.567]             c <- base::c
[17:26:43.567]             inherits <- base::inherits
[17:26:43.567]             invokeRestart <- base::invokeRestart
[17:26:43.567]             length <- base::length
[17:26:43.567]             list <- base::list
[17:26:43.567]             seq.int <- base::seq.int
[17:26:43.567]             signalCondition <- base::signalCondition
[17:26:43.567]             sys.calls <- base::sys.calls
[17:26:43.567]             `[[` <- base::`[[`
[17:26:43.567]             `+` <- base::`+`
[17:26:43.567]             `<<-` <- base::`<<-`
[17:26:43.567]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.567]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.567]                   3L)]
[17:26:43.567]             }
[17:26:43.567]             function(cond) {
[17:26:43.567]                 is_error <- inherits(cond, "error")
[17:26:43.567]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.567]                   NULL)
[17:26:43.567]                 if (is_error) {
[17:26:43.567]                   sessionInformation <- function() {
[17:26:43.567]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.567]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.567]                       search = base::search(), system = base::Sys.info())
[17:26:43.567]                   }
[17:26:43.567]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.567]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.567]                     cond$call), session = sessionInformation(), 
[17:26:43.567]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.567]                   signalCondition(cond)
[17:26:43.567]                 }
[17:26:43.567]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.567]                 "immediateCondition"))) {
[17:26:43.567]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.567]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.567]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.567]                   if (TRUE && !signal) {
[17:26:43.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.567]                     {
[17:26:43.567]                       inherits <- base::inherits
[17:26:43.567]                       invokeRestart <- base::invokeRestart
[17:26:43.567]                       is.null <- base::is.null
[17:26:43.567]                       muffled <- FALSE
[17:26:43.567]                       if (inherits(cond, "message")) {
[17:26:43.567]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.567]                         if (muffled) 
[17:26:43.567]                           invokeRestart("muffleMessage")
[17:26:43.567]                       }
[17:26:43.567]                       else if (inherits(cond, "warning")) {
[17:26:43.567]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.567]                         if (muffled) 
[17:26:43.567]                           invokeRestart("muffleWarning")
[17:26:43.567]                       }
[17:26:43.567]                       else if (inherits(cond, "condition")) {
[17:26:43.567]                         if (!is.null(pattern)) {
[17:26:43.567]                           computeRestarts <- base::computeRestarts
[17:26:43.567]                           grepl <- base::grepl
[17:26:43.567]                           restarts <- computeRestarts(cond)
[17:26:43.567]                           for (restart in restarts) {
[17:26:43.567]                             name <- restart$name
[17:26:43.567]                             if (is.null(name)) 
[17:26:43.567]                               next
[17:26:43.567]                             if (!grepl(pattern, name)) 
[17:26:43.567]                               next
[17:26:43.567]                             invokeRestart(restart)
[17:26:43.567]                             muffled <- TRUE
[17:26:43.567]                             break
[17:26:43.567]                           }
[17:26:43.567]                         }
[17:26:43.567]                       }
[17:26:43.567]                       invisible(muffled)
[17:26:43.567]                     }
[17:26:43.567]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.567]                   }
[17:26:43.567]                 }
[17:26:43.567]                 else {
[17:26:43.567]                   if (TRUE) {
[17:26:43.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.567]                     {
[17:26:43.567]                       inherits <- base::inherits
[17:26:43.567]                       invokeRestart <- base::invokeRestart
[17:26:43.567]                       is.null <- base::is.null
[17:26:43.567]                       muffled <- FALSE
[17:26:43.567]                       if (inherits(cond, "message")) {
[17:26:43.567]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.567]                         if (muffled) 
[17:26:43.567]                           invokeRestart("muffleMessage")
[17:26:43.567]                       }
[17:26:43.567]                       else if (inherits(cond, "warning")) {
[17:26:43.567]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.567]                         if (muffled) 
[17:26:43.567]                           invokeRestart("muffleWarning")
[17:26:43.567]                       }
[17:26:43.567]                       else if (inherits(cond, "condition")) {
[17:26:43.567]                         if (!is.null(pattern)) {
[17:26:43.567]                           computeRestarts <- base::computeRestarts
[17:26:43.567]                           grepl <- base::grepl
[17:26:43.567]                           restarts <- computeRestarts(cond)
[17:26:43.567]                           for (restart in restarts) {
[17:26:43.567]                             name <- restart$name
[17:26:43.567]                             if (is.null(name)) 
[17:26:43.567]                               next
[17:26:43.567]                             if (!grepl(pattern, name)) 
[17:26:43.567]                               next
[17:26:43.567]                             invokeRestart(restart)
[17:26:43.567]                             muffled <- TRUE
[17:26:43.567]                             break
[17:26:43.567]                           }
[17:26:43.567]                         }
[17:26:43.567]                       }
[17:26:43.567]                       invisible(muffled)
[17:26:43.567]                     }
[17:26:43.567]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.567]                   }
[17:26:43.567]                 }
[17:26:43.567]             }
[17:26:43.567]         }))
[17:26:43.567]     }, error = function(ex) {
[17:26:43.567]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.567]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.567]                 ...future.rng), started = ...future.startTime, 
[17:26:43.567]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.567]             version = "1.8"), class = "FutureResult")
[17:26:43.567]     }, finally = {
[17:26:43.567]         if (!identical(...future.workdir, getwd())) 
[17:26:43.567]             setwd(...future.workdir)
[17:26:43.567]         {
[17:26:43.567]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.567]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.567]             }
[17:26:43.567]             base::options(...future.oldOptions)
[17:26:43.567]             if (.Platform$OS.type == "windows") {
[17:26:43.567]                 old_names <- names(...future.oldEnvVars)
[17:26:43.567]                 envs <- base::Sys.getenv()
[17:26:43.567]                 names <- names(envs)
[17:26:43.567]                 common <- intersect(names, old_names)
[17:26:43.567]                 added <- setdiff(names, old_names)
[17:26:43.567]                 removed <- setdiff(old_names, names)
[17:26:43.567]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.567]                   envs[common]]
[17:26:43.567]                 NAMES <- toupper(changed)
[17:26:43.567]                 args <- list()
[17:26:43.567]                 for (kk in seq_along(NAMES)) {
[17:26:43.567]                   name <- changed[[kk]]
[17:26:43.567]                   NAME <- NAMES[[kk]]
[17:26:43.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.567]                     next
[17:26:43.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.567]                 }
[17:26:43.567]                 NAMES <- toupper(added)
[17:26:43.567]                 for (kk in seq_along(NAMES)) {
[17:26:43.567]                   name <- added[[kk]]
[17:26:43.567]                   NAME <- NAMES[[kk]]
[17:26:43.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.567]                     next
[17:26:43.567]                   args[[name]] <- ""
[17:26:43.567]                 }
[17:26:43.567]                 NAMES <- toupper(removed)
[17:26:43.567]                 for (kk in seq_along(NAMES)) {
[17:26:43.567]                   name <- removed[[kk]]
[17:26:43.567]                   NAME <- NAMES[[kk]]
[17:26:43.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.567]                     next
[17:26:43.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.567]                 }
[17:26:43.567]                 if (length(args) > 0) 
[17:26:43.567]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.567]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.567]             }
[17:26:43.567]             else {
[17:26:43.567]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.567]             }
[17:26:43.567]             {
[17:26:43.567]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.567]                   0L) {
[17:26:43.567]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.567]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.567]                   base::options(opts)
[17:26:43.567]                 }
[17:26:43.567]                 {
[17:26:43.567]                   {
[17:26:43.567]                     NULL
[17:26:43.567]                     RNGkind("Mersenne-Twister")
[17:26:43.567]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.567]                       inherits = FALSE)
[17:26:43.567]                   }
[17:26:43.567]                   options(future.plan = NULL)
[17:26:43.567]                   if (is.na(NA_character_)) 
[17:26:43.567]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.567]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.567]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.567]                     .init = FALSE)
[17:26:43.567]                 }
[17:26:43.567]             }
[17:26:43.567]         }
[17:26:43.567]     })
[17:26:43.567]     if (TRUE) {
[17:26:43.567]         base::sink(type = "output", split = FALSE)
[17:26:43.567]         if (TRUE) {
[17:26:43.567]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.567]         }
[17:26:43.567]         else {
[17:26:43.567]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.567]         }
[17:26:43.567]         base::close(...future.stdout)
[17:26:43.567]         ...future.stdout <- NULL
[17:26:43.567]     }
[17:26:43.567]     ...future.result$conditions <- ...future.conditions
[17:26:43.567]     ...future.result$finished <- base::Sys.time()
[17:26:43.567]     ...future.result
[17:26:43.567] }
[17:26:43.571] plan(): Setting new future strategy stack:
[17:26:43.571] List of future strategies:
[17:26:43.571] 1. sequential:
[17:26:43.571]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.571]    - tweaked: FALSE
[17:26:43.571]    - call: NULL
[17:26:43.571] plan(): nbrOfWorkers() = 1
[17:26:43.573] plan(): Setting new future strategy stack:
[17:26:43.573] List of future strategies:
[17:26:43.573] 1. sequential:
[17:26:43.573]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.573]    - tweaked: FALSE
[17:26:43.573]    - call: plan(strategy)
[17:26:43.573] plan(): nbrOfWorkers() = 1
[17:26:43.574] SequentialFuture started (and completed)
[17:26:43.574] - Launch lazy future ... done
[17:26:43.574] run() for 'SequentialFuture' ... done
[17:26:43.574] getGlobalsAndPackages() ...
[17:26:43.574] Searching for globals...
[17:26:43.575] 
[17:26:43.575] Searching for globals ... DONE
[17:26:43.575] - globals: [0] <none>
[17:26:43.575] getGlobalsAndPackages() ... DONE
[17:26:43.576] run() for 'Future' ...
[17:26:43.576] - state: 'created'
[17:26:43.576] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.576] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.577] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.577]   - Field: 'label'
[17:26:43.577]   - Field: 'local'
[17:26:43.577]   - Field: 'owner'
[17:26:43.577]   - Field: 'envir'
[17:26:43.577]   - Field: 'packages'
[17:26:43.578]   - Field: 'gc'
[17:26:43.578]   - Field: 'conditions'
[17:26:43.578]   - Field: 'expr'
[17:26:43.578]   - Field: 'uuid'
[17:26:43.578]   - Field: 'seed'
[17:26:43.578]   - Field: 'version'
[17:26:43.579]   - Field: 'result'
[17:26:43.579]   - Field: 'asynchronous'
[17:26:43.579]   - Field: 'calls'
[17:26:43.579]   - Field: 'globals'
[17:26:43.579]   - Field: 'stdout'
[17:26:43.580]   - Field: 'earlySignal'
[17:26:43.580]   - Field: 'lazy'
[17:26:43.580]   - Field: 'state'
[17:26:43.580] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.580] - Launch lazy future ...
[17:26:43.581] Packages needed by the future expression (n = 0): <none>
[17:26:43.581] Packages needed by future strategies (n = 0): <none>
[17:26:43.581] {
[17:26:43.581]     {
[17:26:43.581]         {
[17:26:43.581]             ...future.startTime <- base::Sys.time()
[17:26:43.581]             {
[17:26:43.581]                 {
[17:26:43.581]                   {
[17:26:43.581]                     base::local({
[17:26:43.581]                       has_future <- base::requireNamespace("future", 
[17:26:43.581]                         quietly = TRUE)
[17:26:43.581]                       if (has_future) {
[17:26:43.581]                         ns <- base::getNamespace("future")
[17:26:43.581]                         version <- ns[[".package"]][["version"]]
[17:26:43.581]                         if (is.null(version)) 
[17:26:43.581]                           version <- utils::packageVersion("future")
[17:26:43.581]                       }
[17:26:43.581]                       else {
[17:26:43.581]                         version <- NULL
[17:26:43.581]                       }
[17:26:43.581]                       if (!has_future || version < "1.8.0") {
[17:26:43.581]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.581]                           "", base::R.version$version.string), 
[17:26:43.581]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.581]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.581]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.581]                             "release", "version")], collapse = " "), 
[17:26:43.581]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.581]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.581]                           info)
[17:26:43.581]                         info <- base::paste(info, collapse = "; ")
[17:26:43.581]                         if (!has_future) {
[17:26:43.581]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.581]                             info)
[17:26:43.581]                         }
[17:26:43.581]                         else {
[17:26:43.581]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.581]                             info, version)
[17:26:43.581]                         }
[17:26:43.581]                         base::stop(msg)
[17:26:43.581]                       }
[17:26:43.581]                     })
[17:26:43.581]                   }
[17:26:43.581]                   ...future.strategy.old <- future::plan("list")
[17:26:43.581]                   options(future.plan = NULL)
[17:26:43.581]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.581]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.581]                 }
[17:26:43.581]                 ...future.workdir <- getwd()
[17:26:43.581]             }
[17:26:43.581]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.581]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.581]         }
[17:26:43.581]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.581]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.581]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.581]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.581]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.581]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.581]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.581]             base::names(...future.oldOptions))
[17:26:43.581]     }
[17:26:43.581]     if (FALSE) {
[17:26:43.581]     }
[17:26:43.581]     else {
[17:26:43.581]         if (TRUE) {
[17:26:43.581]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.581]                 open = "w")
[17:26:43.581]         }
[17:26:43.581]         else {
[17:26:43.581]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.581]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.581]         }
[17:26:43.581]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.581]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.581]             base::sink(type = "output", split = FALSE)
[17:26:43.581]             base::close(...future.stdout)
[17:26:43.581]         }, add = TRUE)
[17:26:43.581]     }
[17:26:43.581]     ...future.frame <- base::sys.nframe()
[17:26:43.581]     ...future.conditions <- base::list()
[17:26:43.581]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.581]     if (FALSE) {
[17:26:43.581]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.581]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.581]     }
[17:26:43.581]     ...future.result <- base::tryCatch({
[17:26:43.581]         base::withCallingHandlers({
[17:26:43.581]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.581]             future::FutureResult(value = ...future.value$value, 
[17:26:43.581]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.581]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.581]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.581]                     ...future.globalenv.names))
[17:26:43.581]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.581]         }, condition = base::local({
[17:26:43.581]             c <- base::c
[17:26:43.581]             inherits <- base::inherits
[17:26:43.581]             invokeRestart <- base::invokeRestart
[17:26:43.581]             length <- base::length
[17:26:43.581]             list <- base::list
[17:26:43.581]             seq.int <- base::seq.int
[17:26:43.581]             signalCondition <- base::signalCondition
[17:26:43.581]             sys.calls <- base::sys.calls
[17:26:43.581]             `[[` <- base::`[[`
[17:26:43.581]             `+` <- base::`+`
[17:26:43.581]             `<<-` <- base::`<<-`
[17:26:43.581]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.581]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.581]                   3L)]
[17:26:43.581]             }
[17:26:43.581]             function(cond) {
[17:26:43.581]                 is_error <- inherits(cond, "error")
[17:26:43.581]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.581]                   NULL)
[17:26:43.581]                 if (is_error) {
[17:26:43.581]                   sessionInformation <- function() {
[17:26:43.581]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.581]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.581]                       search = base::search(), system = base::Sys.info())
[17:26:43.581]                   }
[17:26:43.581]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.581]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.581]                     cond$call), session = sessionInformation(), 
[17:26:43.581]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.581]                   signalCondition(cond)
[17:26:43.581]                 }
[17:26:43.581]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.581]                 "immediateCondition"))) {
[17:26:43.581]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.581]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.581]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.581]                   if (TRUE && !signal) {
[17:26:43.581]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.581]                     {
[17:26:43.581]                       inherits <- base::inherits
[17:26:43.581]                       invokeRestart <- base::invokeRestart
[17:26:43.581]                       is.null <- base::is.null
[17:26:43.581]                       muffled <- FALSE
[17:26:43.581]                       if (inherits(cond, "message")) {
[17:26:43.581]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.581]                         if (muffled) 
[17:26:43.581]                           invokeRestart("muffleMessage")
[17:26:43.581]                       }
[17:26:43.581]                       else if (inherits(cond, "warning")) {
[17:26:43.581]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.581]                         if (muffled) 
[17:26:43.581]                           invokeRestart("muffleWarning")
[17:26:43.581]                       }
[17:26:43.581]                       else if (inherits(cond, "condition")) {
[17:26:43.581]                         if (!is.null(pattern)) {
[17:26:43.581]                           computeRestarts <- base::computeRestarts
[17:26:43.581]                           grepl <- base::grepl
[17:26:43.581]                           restarts <- computeRestarts(cond)
[17:26:43.581]                           for (restart in restarts) {
[17:26:43.581]                             name <- restart$name
[17:26:43.581]                             if (is.null(name)) 
[17:26:43.581]                               next
[17:26:43.581]                             if (!grepl(pattern, name)) 
[17:26:43.581]                               next
[17:26:43.581]                             invokeRestart(restart)
[17:26:43.581]                             muffled <- TRUE
[17:26:43.581]                             break
[17:26:43.581]                           }
[17:26:43.581]                         }
[17:26:43.581]                       }
[17:26:43.581]                       invisible(muffled)
[17:26:43.581]                     }
[17:26:43.581]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.581]                   }
[17:26:43.581]                 }
[17:26:43.581]                 else {
[17:26:43.581]                   if (TRUE) {
[17:26:43.581]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.581]                     {
[17:26:43.581]                       inherits <- base::inherits
[17:26:43.581]                       invokeRestart <- base::invokeRestart
[17:26:43.581]                       is.null <- base::is.null
[17:26:43.581]                       muffled <- FALSE
[17:26:43.581]                       if (inherits(cond, "message")) {
[17:26:43.581]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.581]                         if (muffled) 
[17:26:43.581]                           invokeRestart("muffleMessage")
[17:26:43.581]                       }
[17:26:43.581]                       else if (inherits(cond, "warning")) {
[17:26:43.581]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.581]                         if (muffled) 
[17:26:43.581]                           invokeRestart("muffleWarning")
[17:26:43.581]                       }
[17:26:43.581]                       else if (inherits(cond, "condition")) {
[17:26:43.581]                         if (!is.null(pattern)) {
[17:26:43.581]                           computeRestarts <- base::computeRestarts
[17:26:43.581]                           grepl <- base::grepl
[17:26:43.581]                           restarts <- computeRestarts(cond)
[17:26:43.581]                           for (restart in restarts) {
[17:26:43.581]                             name <- restart$name
[17:26:43.581]                             if (is.null(name)) 
[17:26:43.581]                               next
[17:26:43.581]                             if (!grepl(pattern, name)) 
[17:26:43.581]                               next
[17:26:43.581]                             invokeRestart(restart)
[17:26:43.581]                             muffled <- TRUE
[17:26:43.581]                             break
[17:26:43.581]                           }
[17:26:43.581]                         }
[17:26:43.581]                       }
[17:26:43.581]                       invisible(muffled)
[17:26:43.581]                     }
[17:26:43.581]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.581]                   }
[17:26:43.581]                 }
[17:26:43.581]             }
[17:26:43.581]         }))
[17:26:43.581]     }, error = function(ex) {
[17:26:43.581]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.581]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.581]                 ...future.rng), started = ...future.startTime, 
[17:26:43.581]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.581]             version = "1.8"), class = "FutureResult")
[17:26:43.581]     }, finally = {
[17:26:43.581]         if (!identical(...future.workdir, getwd())) 
[17:26:43.581]             setwd(...future.workdir)
[17:26:43.581]         {
[17:26:43.581]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.581]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.581]             }
[17:26:43.581]             base::options(...future.oldOptions)
[17:26:43.581]             if (.Platform$OS.type == "windows") {
[17:26:43.581]                 old_names <- names(...future.oldEnvVars)
[17:26:43.581]                 envs <- base::Sys.getenv()
[17:26:43.581]                 names <- names(envs)
[17:26:43.581]                 common <- intersect(names, old_names)
[17:26:43.581]                 added <- setdiff(names, old_names)
[17:26:43.581]                 removed <- setdiff(old_names, names)
[17:26:43.581]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.581]                   envs[common]]
[17:26:43.581]                 NAMES <- toupper(changed)
[17:26:43.581]                 args <- list()
[17:26:43.581]                 for (kk in seq_along(NAMES)) {
[17:26:43.581]                   name <- changed[[kk]]
[17:26:43.581]                   NAME <- NAMES[[kk]]
[17:26:43.581]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.581]                     next
[17:26:43.581]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.581]                 }
[17:26:43.581]                 NAMES <- toupper(added)
[17:26:43.581]                 for (kk in seq_along(NAMES)) {
[17:26:43.581]                   name <- added[[kk]]
[17:26:43.581]                   NAME <- NAMES[[kk]]
[17:26:43.581]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.581]                     next
[17:26:43.581]                   args[[name]] <- ""
[17:26:43.581]                 }
[17:26:43.581]                 NAMES <- toupper(removed)
[17:26:43.581]                 for (kk in seq_along(NAMES)) {
[17:26:43.581]                   name <- removed[[kk]]
[17:26:43.581]                   NAME <- NAMES[[kk]]
[17:26:43.581]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.581]                     next
[17:26:43.581]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.581]                 }
[17:26:43.581]                 if (length(args) > 0) 
[17:26:43.581]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.581]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.581]             }
[17:26:43.581]             else {
[17:26:43.581]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.581]             }
[17:26:43.581]             {
[17:26:43.581]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.581]                   0L) {
[17:26:43.581]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.581]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.581]                   base::options(opts)
[17:26:43.581]                 }
[17:26:43.581]                 {
[17:26:43.581]                   {
[17:26:43.581]                     NULL
[17:26:43.581]                     RNGkind("Mersenne-Twister")
[17:26:43.581]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.581]                       inherits = FALSE)
[17:26:43.581]                   }
[17:26:43.581]                   options(future.plan = NULL)
[17:26:43.581]                   if (is.na(NA_character_)) 
[17:26:43.581]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.581]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.581]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.581]                     .init = FALSE)
[17:26:43.581]                 }
[17:26:43.581]             }
[17:26:43.581]         }
[17:26:43.581]     })
[17:26:43.581]     if (TRUE) {
[17:26:43.581]         base::sink(type = "output", split = FALSE)
[17:26:43.581]         if (TRUE) {
[17:26:43.581]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.581]         }
[17:26:43.581]         else {
[17:26:43.581]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.581]         }
[17:26:43.581]         base::close(...future.stdout)
[17:26:43.581]         ...future.stdout <- NULL
[17:26:43.581]     }
[17:26:43.581]     ...future.result$conditions <- ...future.conditions
[17:26:43.581]     ...future.result$finished <- base::Sys.time()
[17:26:43.581]     ...future.result
[17:26:43.581] }
[17:26:43.585] plan(): Setting new future strategy stack:
[17:26:43.585] List of future strategies:
[17:26:43.585] 1. sequential:
[17:26:43.585]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.585]    - tweaked: FALSE
[17:26:43.585]    - call: NULL
[17:26:43.586] plan(): nbrOfWorkers() = 1
[17:26:43.587] plan(): Setting new future strategy stack:
[17:26:43.587] List of future strategies:
[17:26:43.587] 1. sequential:
[17:26:43.587]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.587]    - tweaked: FALSE
[17:26:43.587]    - call: plan(strategy)
[17:26:43.588] plan(): nbrOfWorkers() = 1
[17:26:43.588] SequentialFuture started (and completed)
[17:26:43.588] - Launch lazy future ... done
[17:26:43.588] run() for 'SequentialFuture' ... done
[17:26:43.589] getGlobalsAndPackages() ...
[17:26:43.589] Searching for globals...
[17:26:43.590] - globals found: [1] '{'
[17:26:43.590] Searching for globals ... DONE
[17:26:43.590] Resolving globals: FALSE
[17:26:43.590] 
[17:26:43.591] 
[17:26:43.591] getGlobalsAndPackages() ... DONE
[17:26:43.591] run() for 'Future' ...
[17:26:43.591] - state: 'created'
[17:26:43.591] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.592] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.592] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.592]   - Field: 'label'
[17:26:43.592]   - Field: 'local'
[17:26:43.593]   - Field: 'owner'
[17:26:43.593]   - Field: 'envir'
[17:26:43.593]   - Field: 'packages'
[17:26:43.593]   - Field: 'gc'
[17:26:43.593]   - Field: 'conditions'
[17:26:43.593]   - Field: 'expr'
[17:26:43.594]   - Field: 'uuid'
[17:26:43.594]   - Field: 'seed'
[17:26:43.594]   - Field: 'version'
[17:26:43.594]   - Field: 'result'
[17:26:43.594]   - Field: 'asynchronous'
[17:26:43.594]   - Field: 'calls'
[17:26:43.595]   - Field: 'globals'
[17:26:43.595]   - Field: 'stdout'
[17:26:43.595]   - Field: 'earlySignal'
[17:26:43.595]   - Field: 'lazy'
[17:26:43.595]   - Field: 'state'
[17:26:43.596] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.596] - Launch lazy future ...
[17:26:43.596] Packages needed by the future expression (n = 0): <none>
[17:26:43.596] Packages needed by future strategies (n = 0): <none>
[17:26:43.597] {
[17:26:43.597]     {
[17:26:43.597]         {
[17:26:43.597]             ...future.startTime <- base::Sys.time()
[17:26:43.597]             {
[17:26:43.597]                 {
[17:26:43.597]                   {
[17:26:43.597]                     base::local({
[17:26:43.597]                       has_future <- base::requireNamespace("future", 
[17:26:43.597]                         quietly = TRUE)
[17:26:43.597]                       if (has_future) {
[17:26:43.597]                         ns <- base::getNamespace("future")
[17:26:43.597]                         version <- ns[[".package"]][["version"]]
[17:26:43.597]                         if (is.null(version)) 
[17:26:43.597]                           version <- utils::packageVersion("future")
[17:26:43.597]                       }
[17:26:43.597]                       else {
[17:26:43.597]                         version <- NULL
[17:26:43.597]                       }
[17:26:43.597]                       if (!has_future || version < "1.8.0") {
[17:26:43.597]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.597]                           "", base::R.version$version.string), 
[17:26:43.597]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.597]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.597]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.597]                             "release", "version")], collapse = " "), 
[17:26:43.597]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.597]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.597]                           info)
[17:26:43.597]                         info <- base::paste(info, collapse = "; ")
[17:26:43.597]                         if (!has_future) {
[17:26:43.597]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.597]                             info)
[17:26:43.597]                         }
[17:26:43.597]                         else {
[17:26:43.597]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.597]                             info, version)
[17:26:43.597]                         }
[17:26:43.597]                         base::stop(msg)
[17:26:43.597]                       }
[17:26:43.597]                     })
[17:26:43.597]                   }
[17:26:43.597]                   ...future.strategy.old <- future::plan("list")
[17:26:43.597]                   options(future.plan = NULL)
[17:26:43.597]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.597]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.597]                 }
[17:26:43.597]                 ...future.workdir <- getwd()
[17:26:43.597]             }
[17:26:43.597]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.597]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.597]         }
[17:26:43.597]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.597]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.597]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.597]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.597]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.597]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.597]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.597]             base::names(...future.oldOptions))
[17:26:43.597]     }
[17:26:43.597]     if (FALSE) {
[17:26:43.597]     }
[17:26:43.597]     else {
[17:26:43.597]         if (TRUE) {
[17:26:43.597]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.597]                 open = "w")
[17:26:43.597]         }
[17:26:43.597]         else {
[17:26:43.597]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.597]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.597]         }
[17:26:43.597]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.597]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.597]             base::sink(type = "output", split = FALSE)
[17:26:43.597]             base::close(...future.stdout)
[17:26:43.597]         }, add = TRUE)
[17:26:43.597]     }
[17:26:43.597]     ...future.frame <- base::sys.nframe()
[17:26:43.597]     ...future.conditions <- base::list()
[17:26:43.597]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.597]     if (FALSE) {
[17:26:43.597]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.597]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.597]     }
[17:26:43.597]     ...future.result <- base::tryCatch({
[17:26:43.597]         base::withCallingHandlers({
[17:26:43.597]             ...future.value <- base::withVisible(base::local({
[17:26:43.597]                 4
[17:26:43.597]             }))
[17:26:43.597]             future::FutureResult(value = ...future.value$value, 
[17:26:43.597]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.597]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.597]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.597]                     ...future.globalenv.names))
[17:26:43.597]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.597]         }, condition = base::local({
[17:26:43.597]             c <- base::c
[17:26:43.597]             inherits <- base::inherits
[17:26:43.597]             invokeRestart <- base::invokeRestart
[17:26:43.597]             length <- base::length
[17:26:43.597]             list <- base::list
[17:26:43.597]             seq.int <- base::seq.int
[17:26:43.597]             signalCondition <- base::signalCondition
[17:26:43.597]             sys.calls <- base::sys.calls
[17:26:43.597]             `[[` <- base::`[[`
[17:26:43.597]             `+` <- base::`+`
[17:26:43.597]             `<<-` <- base::`<<-`
[17:26:43.597]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.597]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.597]                   3L)]
[17:26:43.597]             }
[17:26:43.597]             function(cond) {
[17:26:43.597]                 is_error <- inherits(cond, "error")
[17:26:43.597]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.597]                   NULL)
[17:26:43.597]                 if (is_error) {
[17:26:43.597]                   sessionInformation <- function() {
[17:26:43.597]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.597]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.597]                       search = base::search(), system = base::Sys.info())
[17:26:43.597]                   }
[17:26:43.597]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.597]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.597]                     cond$call), session = sessionInformation(), 
[17:26:43.597]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.597]                   signalCondition(cond)
[17:26:43.597]                 }
[17:26:43.597]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.597]                 "immediateCondition"))) {
[17:26:43.597]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.597]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.597]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.597]                   if (TRUE && !signal) {
[17:26:43.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.597]                     {
[17:26:43.597]                       inherits <- base::inherits
[17:26:43.597]                       invokeRestart <- base::invokeRestart
[17:26:43.597]                       is.null <- base::is.null
[17:26:43.597]                       muffled <- FALSE
[17:26:43.597]                       if (inherits(cond, "message")) {
[17:26:43.597]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.597]                         if (muffled) 
[17:26:43.597]                           invokeRestart("muffleMessage")
[17:26:43.597]                       }
[17:26:43.597]                       else if (inherits(cond, "warning")) {
[17:26:43.597]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.597]                         if (muffled) 
[17:26:43.597]                           invokeRestart("muffleWarning")
[17:26:43.597]                       }
[17:26:43.597]                       else if (inherits(cond, "condition")) {
[17:26:43.597]                         if (!is.null(pattern)) {
[17:26:43.597]                           computeRestarts <- base::computeRestarts
[17:26:43.597]                           grepl <- base::grepl
[17:26:43.597]                           restarts <- computeRestarts(cond)
[17:26:43.597]                           for (restart in restarts) {
[17:26:43.597]                             name <- restart$name
[17:26:43.597]                             if (is.null(name)) 
[17:26:43.597]                               next
[17:26:43.597]                             if (!grepl(pattern, name)) 
[17:26:43.597]                               next
[17:26:43.597]                             invokeRestart(restart)
[17:26:43.597]                             muffled <- TRUE
[17:26:43.597]                             break
[17:26:43.597]                           }
[17:26:43.597]                         }
[17:26:43.597]                       }
[17:26:43.597]                       invisible(muffled)
[17:26:43.597]                     }
[17:26:43.597]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.597]                   }
[17:26:43.597]                 }
[17:26:43.597]                 else {
[17:26:43.597]                   if (TRUE) {
[17:26:43.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.597]                     {
[17:26:43.597]                       inherits <- base::inherits
[17:26:43.597]                       invokeRestart <- base::invokeRestart
[17:26:43.597]                       is.null <- base::is.null
[17:26:43.597]                       muffled <- FALSE
[17:26:43.597]                       if (inherits(cond, "message")) {
[17:26:43.597]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.597]                         if (muffled) 
[17:26:43.597]                           invokeRestart("muffleMessage")
[17:26:43.597]                       }
[17:26:43.597]                       else if (inherits(cond, "warning")) {
[17:26:43.597]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.597]                         if (muffled) 
[17:26:43.597]                           invokeRestart("muffleWarning")
[17:26:43.597]                       }
[17:26:43.597]                       else if (inherits(cond, "condition")) {
[17:26:43.597]                         if (!is.null(pattern)) {
[17:26:43.597]                           computeRestarts <- base::computeRestarts
[17:26:43.597]                           grepl <- base::grepl
[17:26:43.597]                           restarts <- computeRestarts(cond)
[17:26:43.597]                           for (restart in restarts) {
[17:26:43.597]                             name <- restart$name
[17:26:43.597]                             if (is.null(name)) 
[17:26:43.597]                               next
[17:26:43.597]                             if (!grepl(pattern, name)) 
[17:26:43.597]                               next
[17:26:43.597]                             invokeRestart(restart)
[17:26:43.597]                             muffled <- TRUE
[17:26:43.597]                             break
[17:26:43.597]                           }
[17:26:43.597]                         }
[17:26:43.597]                       }
[17:26:43.597]                       invisible(muffled)
[17:26:43.597]                     }
[17:26:43.597]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.597]                   }
[17:26:43.597]                 }
[17:26:43.597]             }
[17:26:43.597]         }))
[17:26:43.597]     }, error = function(ex) {
[17:26:43.597]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.597]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.597]                 ...future.rng), started = ...future.startTime, 
[17:26:43.597]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.597]             version = "1.8"), class = "FutureResult")
[17:26:43.597]     }, finally = {
[17:26:43.597]         if (!identical(...future.workdir, getwd())) 
[17:26:43.597]             setwd(...future.workdir)
[17:26:43.597]         {
[17:26:43.597]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.597]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.597]             }
[17:26:43.597]             base::options(...future.oldOptions)
[17:26:43.597]             if (.Platform$OS.type == "windows") {
[17:26:43.597]                 old_names <- names(...future.oldEnvVars)
[17:26:43.597]                 envs <- base::Sys.getenv()
[17:26:43.597]                 names <- names(envs)
[17:26:43.597]                 common <- intersect(names, old_names)
[17:26:43.597]                 added <- setdiff(names, old_names)
[17:26:43.597]                 removed <- setdiff(old_names, names)
[17:26:43.597]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.597]                   envs[common]]
[17:26:43.597]                 NAMES <- toupper(changed)
[17:26:43.597]                 args <- list()
[17:26:43.597]                 for (kk in seq_along(NAMES)) {
[17:26:43.597]                   name <- changed[[kk]]
[17:26:43.597]                   NAME <- NAMES[[kk]]
[17:26:43.597]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.597]                     next
[17:26:43.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.597]                 }
[17:26:43.597]                 NAMES <- toupper(added)
[17:26:43.597]                 for (kk in seq_along(NAMES)) {
[17:26:43.597]                   name <- added[[kk]]
[17:26:43.597]                   NAME <- NAMES[[kk]]
[17:26:43.597]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.597]                     next
[17:26:43.597]                   args[[name]] <- ""
[17:26:43.597]                 }
[17:26:43.597]                 NAMES <- toupper(removed)
[17:26:43.597]                 for (kk in seq_along(NAMES)) {
[17:26:43.597]                   name <- removed[[kk]]
[17:26:43.597]                   NAME <- NAMES[[kk]]
[17:26:43.597]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.597]                     next
[17:26:43.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.597]                 }
[17:26:43.597]                 if (length(args) > 0) 
[17:26:43.597]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.597]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.597]             }
[17:26:43.597]             else {
[17:26:43.597]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.597]             }
[17:26:43.597]             {
[17:26:43.597]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.597]                   0L) {
[17:26:43.597]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.597]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.597]                   base::options(opts)
[17:26:43.597]                 }
[17:26:43.597]                 {
[17:26:43.597]                   {
[17:26:43.597]                     NULL
[17:26:43.597]                     RNGkind("Mersenne-Twister")
[17:26:43.597]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.597]                       inherits = FALSE)
[17:26:43.597]                   }
[17:26:43.597]                   options(future.plan = NULL)
[17:26:43.597]                   if (is.na(NA_character_)) 
[17:26:43.597]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.597]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.597]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.597]                     .init = FALSE)
[17:26:43.597]                 }
[17:26:43.597]             }
[17:26:43.597]         }
[17:26:43.597]     })
[17:26:43.597]     if (TRUE) {
[17:26:43.597]         base::sink(type = "output", split = FALSE)
[17:26:43.597]         if (TRUE) {
[17:26:43.597]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.597]         }
[17:26:43.597]         else {
[17:26:43.597]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.597]         }
[17:26:43.597]         base::close(...future.stdout)
[17:26:43.597]         ...future.stdout <- NULL
[17:26:43.597]     }
[17:26:43.597]     ...future.result$conditions <- ...future.conditions
[17:26:43.597]     ...future.result$finished <- base::Sys.time()
[17:26:43.597]     ...future.result
[17:26:43.597] }
[17:26:43.601] plan(): Setting new future strategy stack:
[17:26:43.601] List of future strategies:
[17:26:43.601] 1. sequential:
[17:26:43.601]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.601]    - tweaked: FALSE
[17:26:43.601]    - call: NULL
[17:26:43.601] plan(): nbrOfWorkers() = 1
[17:26:43.603] plan(): Setting new future strategy stack:
[17:26:43.603] List of future strategies:
[17:26:43.603] 1. sequential:
[17:26:43.603]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.603]    - tweaked: FALSE
[17:26:43.603]    - call: plan(strategy)
[17:26:43.604] plan(): nbrOfWorkers() = 1
[17:26:43.604] SequentialFuture started (and completed)
[17:26:43.604] - Launch lazy future ... done
[17:26:43.604] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230d59dca0> 
Classes 'listenv', 'environment' <environment: 0x000002230d0a9338> 
 - attr(*, "dim.")= int [1:3] 2 3 1
 - attr(*, "dimnames.")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:43.609] resolved() for 'SequentialFuture' ...
[17:26:43.610] - state: 'finished'
[17:26:43.610] - run: TRUE
[17:26:43.610] - result: 'FutureResult'
[17:26:43.610] resolved() for 'SequentialFuture' ... done
[17:26:43.610] resolved() for 'SequentialFuture' ...
[17:26:43.611] - state: 'finished'
[17:26:43.611] - run: TRUE
[17:26:43.611] - result: 'FutureResult'
[17:26:43.611] resolved() for 'SequentialFuture' ... done
[17:26:43.611] resolved() for 'SequentialFuture' ...
[17:26:43.612] - state: 'finished'
[17:26:43.612] - run: TRUE
[17:26:43.612] - result: 'FutureResult'
[17:26:43.612] resolved() for 'SequentialFuture' ... done
 logi [1:2, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:43.615] resolve() on list environment ...
[17:26:43.615]  recursive: 0
[17:26:43.616]  length: 6
[17:26:43.617]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:43.617] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.617] - nx: 6
[17:26:43.617] - relay: TRUE
[17:26:43.617] - stdout: TRUE
[17:26:43.617] - signal: TRUE
[17:26:43.618] - resignal: FALSE
[17:26:43.618] - force: TRUE
[17:26:43.618] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.618] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.618]  - until=2
[17:26:43.618]  - relaying element #2
[17:26:43.618] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.619] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.619] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.619]  length: 5 (resolved future 1)
[17:26:43.619] resolved() for 'SequentialFuture' ...
[17:26:43.619] - state: 'finished'
[17:26:43.620] - run: TRUE
[17:26:43.620] - result: 'FutureResult'
[17:26:43.620] resolved() for 'SequentialFuture' ... done
[17:26:43.620] Future #2
[17:26:43.620] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.620] - nx: 6
[17:26:43.621] - relay: TRUE
[17:26:43.621] - stdout: TRUE
[17:26:43.621] - signal: TRUE
[17:26:43.621] - resignal: FALSE
[17:26:43.621] - force: TRUE
[17:26:43.621] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.622] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.622]  - until=2
[17:26:43.622]  - relaying element #2
[17:26:43.622] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.622] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.622] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.623]  length: 4 (resolved future 2)
[17:26:43.623] resolved() for 'SequentialFuture' ...
[17:26:43.623] - state: 'finished'
[17:26:43.623] - run: TRUE
[17:26:43.623] - result: 'FutureResult'
[17:26:43.624] resolved() for 'SequentialFuture' ... done
[17:26:43.624] Future #3
[17:26:43.624] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.624] - nx: 6
[17:26:43.624] - relay: TRUE
[17:26:43.624] - stdout: TRUE
[17:26:43.625] - signal: TRUE
[17:26:43.625] - resignal: FALSE
[17:26:43.625] - force: TRUE
[17:26:43.625] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.625] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.625]  - until=3
[17:26:43.625]  - relaying element #3
[17:26:43.626] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.626] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.626] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.626]  length: 3 (resolved future 3)
[17:26:43.626] resolved() for 'SequentialFuture' ...
[17:26:43.627] - state: 'finished'
[17:26:43.627] - run: TRUE
[17:26:43.627] - result: 'FutureResult'
[17:26:43.627] resolved() for 'SequentialFuture' ... done
[17:26:43.627] Future #4
[17:26:43.628] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.628] - nx: 6
[17:26:43.628] - relay: TRUE
[17:26:43.628] - stdout: TRUE
[17:26:43.628] - signal: TRUE
[17:26:43.628] - resignal: FALSE
[17:26:43.628] - force: TRUE
[17:26:43.629] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.629] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.629]  - until=4
[17:26:43.629]  - relaying element #4
[17:26:43.629] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.630] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.630] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.630]  length: 2 (resolved future 4)
[17:26:43.630] signalConditionsASAP(NULL, pos=5) ...
[17:26:43.630] - nx: 6
[17:26:43.630] - relay: TRUE
[17:26:43.631] - stdout: TRUE
[17:26:43.631] - signal: TRUE
[17:26:43.631] - resignal: FALSE
[17:26:43.631] - force: TRUE
[17:26:43.631] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.631] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.631]  - until=6
[17:26:43.632]  - relaying element #6
[17:26:43.632] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.632] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.632] signalConditionsASAP(NULL, pos=5) ... done
[17:26:43.632]  length: 1 (resolved future 5)
[17:26:43.632] signalConditionsASAP(numeric, pos=6) ...
[17:26:43.633] - nx: 6
[17:26:43.633] - relay: TRUE
[17:26:43.634] - stdout: TRUE
[17:26:43.634] - signal: TRUE
[17:26:43.634] - resignal: FALSE
[17:26:43.634] - force: TRUE
[17:26:43.634] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.634] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.635]  - until=6
[17:26:43.635] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.635] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.635] signalConditionsASAP(numeric, pos=6) ... done
[17:26:43.635]  length: 0 (resolved future 6)
[17:26:43.635] Relaying remaining futures
[17:26:43.636] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.636] - nx: 6
[17:26:43.636] - relay: TRUE
[17:26:43.636] - stdout: TRUE
[17:26:43.636] - signal: TRUE
[17:26:43.636] - resignal: FALSE
[17:26:43.636] - force: TRUE
[17:26:43.637] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.637] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:43.637] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.637] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.637] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.637] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x000002230c4537d8> 
 - attr(*, "dim.")= int [1:3] 2 3 1
 - attr(*, "dimnames.")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
Dimensions: c(2, 1, 3, 1)
[17:26:43.640] getGlobalsAndPackages() ...
[17:26:43.640] Searching for globals...
[17:26:43.641] 
[17:26:43.641] Searching for globals ... DONE
[17:26:43.641] - globals: [0] <none>
[17:26:43.641] getGlobalsAndPackages() ... DONE
[17:26:43.642] run() for 'Future' ...
[17:26:43.642] - state: 'created'
[17:26:43.642] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.642] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.642] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.643]   - Field: 'label'
[17:26:43.643]   - Field: 'local'
[17:26:43.643]   - Field: 'owner'
[17:26:43.643]   - Field: 'envir'
[17:26:43.643]   - Field: 'packages'
[17:26:43.644]   - Field: 'gc'
[17:26:43.644]   - Field: 'conditions'
[17:26:43.644]   - Field: 'expr'
[17:26:43.644]   - Field: 'uuid'
[17:26:43.644]   - Field: 'seed'
[17:26:43.644]   - Field: 'version'
[17:26:43.645]   - Field: 'result'
[17:26:43.645]   - Field: 'asynchronous'
[17:26:43.645]   - Field: 'calls'
[17:26:43.645]   - Field: 'globals'
[17:26:43.645]   - Field: 'stdout'
[17:26:43.645]   - Field: 'earlySignal'
[17:26:43.646]   - Field: 'lazy'
[17:26:43.646]   - Field: 'state'
[17:26:43.646] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.646] - Launch lazy future ...
[17:26:43.646] Packages needed by the future expression (n = 0): <none>
[17:26:43.647] Packages needed by future strategies (n = 0): <none>
[17:26:43.647] {
[17:26:43.647]     {
[17:26:43.647]         {
[17:26:43.647]             ...future.startTime <- base::Sys.time()
[17:26:43.647]             {
[17:26:43.647]                 {
[17:26:43.647]                   {
[17:26:43.647]                     base::local({
[17:26:43.647]                       has_future <- base::requireNamespace("future", 
[17:26:43.647]                         quietly = TRUE)
[17:26:43.647]                       if (has_future) {
[17:26:43.647]                         ns <- base::getNamespace("future")
[17:26:43.647]                         version <- ns[[".package"]][["version"]]
[17:26:43.647]                         if (is.null(version)) 
[17:26:43.647]                           version <- utils::packageVersion("future")
[17:26:43.647]                       }
[17:26:43.647]                       else {
[17:26:43.647]                         version <- NULL
[17:26:43.647]                       }
[17:26:43.647]                       if (!has_future || version < "1.8.0") {
[17:26:43.647]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.647]                           "", base::R.version$version.string), 
[17:26:43.647]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.647]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.647]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.647]                             "release", "version")], collapse = " "), 
[17:26:43.647]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.647]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.647]                           info)
[17:26:43.647]                         info <- base::paste(info, collapse = "; ")
[17:26:43.647]                         if (!has_future) {
[17:26:43.647]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.647]                             info)
[17:26:43.647]                         }
[17:26:43.647]                         else {
[17:26:43.647]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.647]                             info, version)
[17:26:43.647]                         }
[17:26:43.647]                         base::stop(msg)
[17:26:43.647]                       }
[17:26:43.647]                     })
[17:26:43.647]                   }
[17:26:43.647]                   ...future.strategy.old <- future::plan("list")
[17:26:43.647]                   options(future.plan = NULL)
[17:26:43.647]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.647]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.647]                 }
[17:26:43.647]                 ...future.workdir <- getwd()
[17:26:43.647]             }
[17:26:43.647]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.647]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.647]         }
[17:26:43.647]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.647]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.647]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.647]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.647]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.647]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.647]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.647]             base::names(...future.oldOptions))
[17:26:43.647]     }
[17:26:43.647]     if (FALSE) {
[17:26:43.647]     }
[17:26:43.647]     else {
[17:26:43.647]         if (TRUE) {
[17:26:43.647]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.647]                 open = "w")
[17:26:43.647]         }
[17:26:43.647]         else {
[17:26:43.647]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.647]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.647]         }
[17:26:43.647]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.647]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.647]             base::sink(type = "output", split = FALSE)
[17:26:43.647]             base::close(...future.stdout)
[17:26:43.647]         }, add = TRUE)
[17:26:43.647]     }
[17:26:43.647]     ...future.frame <- base::sys.nframe()
[17:26:43.647]     ...future.conditions <- base::list()
[17:26:43.647]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.647]     if (FALSE) {
[17:26:43.647]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.647]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.647]     }
[17:26:43.647]     ...future.result <- base::tryCatch({
[17:26:43.647]         base::withCallingHandlers({
[17:26:43.647]             ...future.value <- base::withVisible(base::local(2))
[17:26:43.647]             future::FutureResult(value = ...future.value$value, 
[17:26:43.647]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.647]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.647]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.647]                     ...future.globalenv.names))
[17:26:43.647]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.647]         }, condition = base::local({
[17:26:43.647]             c <- base::c
[17:26:43.647]             inherits <- base::inherits
[17:26:43.647]             invokeRestart <- base::invokeRestart
[17:26:43.647]             length <- base::length
[17:26:43.647]             list <- base::list
[17:26:43.647]             seq.int <- base::seq.int
[17:26:43.647]             signalCondition <- base::signalCondition
[17:26:43.647]             sys.calls <- base::sys.calls
[17:26:43.647]             `[[` <- base::`[[`
[17:26:43.647]             `+` <- base::`+`
[17:26:43.647]             `<<-` <- base::`<<-`
[17:26:43.647]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.647]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.647]                   3L)]
[17:26:43.647]             }
[17:26:43.647]             function(cond) {
[17:26:43.647]                 is_error <- inherits(cond, "error")
[17:26:43.647]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.647]                   NULL)
[17:26:43.647]                 if (is_error) {
[17:26:43.647]                   sessionInformation <- function() {
[17:26:43.647]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.647]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.647]                       search = base::search(), system = base::Sys.info())
[17:26:43.647]                   }
[17:26:43.647]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.647]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.647]                     cond$call), session = sessionInformation(), 
[17:26:43.647]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.647]                   signalCondition(cond)
[17:26:43.647]                 }
[17:26:43.647]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.647]                 "immediateCondition"))) {
[17:26:43.647]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.647]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.647]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.647]                   if (TRUE && !signal) {
[17:26:43.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.647]                     {
[17:26:43.647]                       inherits <- base::inherits
[17:26:43.647]                       invokeRestart <- base::invokeRestart
[17:26:43.647]                       is.null <- base::is.null
[17:26:43.647]                       muffled <- FALSE
[17:26:43.647]                       if (inherits(cond, "message")) {
[17:26:43.647]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.647]                         if (muffled) 
[17:26:43.647]                           invokeRestart("muffleMessage")
[17:26:43.647]                       }
[17:26:43.647]                       else if (inherits(cond, "warning")) {
[17:26:43.647]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.647]                         if (muffled) 
[17:26:43.647]                           invokeRestart("muffleWarning")
[17:26:43.647]                       }
[17:26:43.647]                       else if (inherits(cond, "condition")) {
[17:26:43.647]                         if (!is.null(pattern)) {
[17:26:43.647]                           computeRestarts <- base::computeRestarts
[17:26:43.647]                           grepl <- base::grepl
[17:26:43.647]                           restarts <- computeRestarts(cond)
[17:26:43.647]                           for (restart in restarts) {
[17:26:43.647]                             name <- restart$name
[17:26:43.647]                             if (is.null(name)) 
[17:26:43.647]                               next
[17:26:43.647]                             if (!grepl(pattern, name)) 
[17:26:43.647]                               next
[17:26:43.647]                             invokeRestart(restart)
[17:26:43.647]                             muffled <- TRUE
[17:26:43.647]                             break
[17:26:43.647]                           }
[17:26:43.647]                         }
[17:26:43.647]                       }
[17:26:43.647]                       invisible(muffled)
[17:26:43.647]                     }
[17:26:43.647]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.647]                   }
[17:26:43.647]                 }
[17:26:43.647]                 else {
[17:26:43.647]                   if (TRUE) {
[17:26:43.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.647]                     {
[17:26:43.647]                       inherits <- base::inherits
[17:26:43.647]                       invokeRestart <- base::invokeRestart
[17:26:43.647]                       is.null <- base::is.null
[17:26:43.647]                       muffled <- FALSE
[17:26:43.647]                       if (inherits(cond, "message")) {
[17:26:43.647]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.647]                         if (muffled) 
[17:26:43.647]                           invokeRestart("muffleMessage")
[17:26:43.647]                       }
[17:26:43.647]                       else if (inherits(cond, "warning")) {
[17:26:43.647]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.647]                         if (muffled) 
[17:26:43.647]                           invokeRestart("muffleWarning")
[17:26:43.647]                       }
[17:26:43.647]                       else if (inherits(cond, "condition")) {
[17:26:43.647]                         if (!is.null(pattern)) {
[17:26:43.647]                           computeRestarts <- base::computeRestarts
[17:26:43.647]                           grepl <- base::grepl
[17:26:43.647]                           restarts <- computeRestarts(cond)
[17:26:43.647]                           for (restart in restarts) {
[17:26:43.647]                             name <- restart$name
[17:26:43.647]                             if (is.null(name)) 
[17:26:43.647]                               next
[17:26:43.647]                             if (!grepl(pattern, name)) 
[17:26:43.647]                               next
[17:26:43.647]                             invokeRestart(restart)
[17:26:43.647]                             muffled <- TRUE
[17:26:43.647]                             break
[17:26:43.647]                           }
[17:26:43.647]                         }
[17:26:43.647]                       }
[17:26:43.647]                       invisible(muffled)
[17:26:43.647]                     }
[17:26:43.647]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.647]                   }
[17:26:43.647]                 }
[17:26:43.647]             }
[17:26:43.647]         }))
[17:26:43.647]     }, error = function(ex) {
[17:26:43.647]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.647]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.647]                 ...future.rng), started = ...future.startTime, 
[17:26:43.647]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.647]             version = "1.8"), class = "FutureResult")
[17:26:43.647]     }, finally = {
[17:26:43.647]         if (!identical(...future.workdir, getwd())) 
[17:26:43.647]             setwd(...future.workdir)
[17:26:43.647]         {
[17:26:43.647]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.647]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.647]             }
[17:26:43.647]             base::options(...future.oldOptions)
[17:26:43.647]             if (.Platform$OS.type == "windows") {
[17:26:43.647]                 old_names <- names(...future.oldEnvVars)
[17:26:43.647]                 envs <- base::Sys.getenv()
[17:26:43.647]                 names <- names(envs)
[17:26:43.647]                 common <- intersect(names, old_names)
[17:26:43.647]                 added <- setdiff(names, old_names)
[17:26:43.647]                 removed <- setdiff(old_names, names)
[17:26:43.647]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.647]                   envs[common]]
[17:26:43.647]                 NAMES <- toupper(changed)
[17:26:43.647]                 args <- list()
[17:26:43.647]                 for (kk in seq_along(NAMES)) {
[17:26:43.647]                   name <- changed[[kk]]
[17:26:43.647]                   NAME <- NAMES[[kk]]
[17:26:43.647]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.647]                     next
[17:26:43.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.647]                 }
[17:26:43.647]                 NAMES <- toupper(added)
[17:26:43.647]                 for (kk in seq_along(NAMES)) {
[17:26:43.647]                   name <- added[[kk]]
[17:26:43.647]                   NAME <- NAMES[[kk]]
[17:26:43.647]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.647]                     next
[17:26:43.647]                   args[[name]] <- ""
[17:26:43.647]                 }
[17:26:43.647]                 NAMES <- toupper(removed)
[17:26:43.647]                 for (kk in seq_along(NAMES)) {
[17:26:43.647]                   name <- removed[[kk]]
[17:26:43.647]                   NAME <- NAMES[[kk]]
[17:26:43.647]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.647]                     next
[17:26:43.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.647]                 }
[17:26:43.647]                 if (length(args) > 0) 
[17:26:43.647]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.647]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.647]             }
[17:26:43.647]             else {
[17:26:43.647]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.647]             }
[17:26:43.647]             {
[17:26:43.647]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.647]                   0L) {
[17:26:43.647]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.647]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.647]                   base::options(opts)
[17:26:43.647]                 }
[17:26:43.647]                 {
[17:26:43.647]                   {
[17:26:43.647]                     NULL
[17:26:43.647]                     RNGkind("Mersenne-Twister")
[17:26:43.647]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.647]                       inherits = FALSE)
[17:26:43.647]                   }
[17:26:43.647]                   options(future.plan = NULL)
[17:26:43.647]                   if (is.na(NA_character_)) 
[17:26:43.647]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.647]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.647]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.647]                     .init = FALSE)
[17:26:43.647]                 }
[17:26:43.647]             }
[17:26:43.647]         }
[17:26:43.647]     })
[17:26:43.647]     if (TRUE) {
[17:26:43.647]         base::sink(type = "output", split = FALSE)
[17:26:43.647]         if (TRUE) {
[17:26:43.647]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.647]         }
[17:26:43.647]         else {
[17:26:43.647]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.647]         }
[17:26:43.647]         base::close(...future.stdout)
[17:26:43.647]         ...future.stdout <- NULL
[17:26:43.647]     }
[17:26:43.647]     ...future.result$conditions <- ...future.conditions
[17:26:43.647]     ...future.result$finished <- base::Sys.time()
[17:26:43.647]     ...future.result
[17:26:43.647] }
[17:26:43.651] plan(): Setting new future strategy stack:
[17:26:43.651] List of future strategies:
[17:26:43.651] 1. sequential:
[17:26:43.651]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.651]    - tweaked: FALSE
[17:26:43.651]    - call: NULL
[17:26:43.652] plan(): nbrOfWorkers() = 1
[17:26:43.653] plan(): Setting new future strategy stack:
[17:26:43.653] List of future strategies:
[17:26:43.653] 1. sequential:
[17:26:43.653]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.653]    - tweaked: FALSE
[17:26:43.653]    - call: plan(strategy)
[17:26:43.654] plan(): nbrOfWorkers() = 1
[17:26:43.654] SequentialFuture started (and completed)
[17:26:43.654] - Launch lazy future ... done
[17:26:43.654] run() for 'SequentialFuture' ... done
[17:26:43.655] getGlobalsAndPackages() ...
[17:26:43.655] Searching for globals...
[17:26:43.655] 
[17:26:43.655] Searching for globals ... DONE
[17:26:43.656] - globals: [0] <none>
[17:26:43.656] getGlobalsAndPackages() ... DONE
[17:26:43.656] run() for 'Future' ...
[17:26:43.656] - state: 'created'
[17:26:43.656] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.657] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.657] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.657]   - Field: 'label'
[17:26:43.657]   - Field: 'local'
[17:26:43.658]   - Field: 'owner'
[17:26:43.658]   - Field: 'envir'
[17:26:43.658]   - Field: 'packages'
[17:26:43.658]   - Field: 'gc'
[17:26:43.658]   - Field: 'conditions'
[17:26:43.658]   - Field: 'expr'
[17:26:43.659]   - Field: 'uuid'
[17:26:43.659]   - Field: 'seed'
[17:26:43.659]   - Field: 'version'
[17:26:43.659]   - Field: 'result'
[17:26:43.659]   - Field: 'asynchronous'
[17:26:43.659]   - Field: 'calls'
[17:26:43.660]   - Field: 'globals'
[17:26:43.660]   - Field: 'stdout'
[17:26:43.660]   - Field: 'earlySignal'
[17:26:43.660]   - Field: 'lazy'
[17:26:43.660]   - Field: 'state'
[17:26:43.660] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.661] - Launch lazy future ...
[17:26:43.661] Packages needed by the future expression (n = 0): <none>
[17:26:43.661] Packages needed by future strategies (n = 0): <none>
[17:26:43.662] {
[17:26:43.662]     {
[17:26:43.662]         {
[17:26:43.662]             ...future.startTime <- base::Sys.time()
[17:26:43.662]             {
[17:26:43.662]                 {
[17:26:43.662]                   {
[17:26:43.662]                     base::local({
[17:26:43.662]                       has_future <- base::requireNamespace("future", 
[17:26:43.662]                         quietly = TRUE)
[17:26:43.662]                       if (has_future) {
[17:26:43.662]                         ns <- base::getNamespace("future")
[17:26:43.662]                         version <- ns[[".package"]][["version"]]
[17:26:43.662]                         if (is.null(version)) 
[17:26:43.662]                           version <- utils::packageVersion("future")
[17:26:43.662]                       }
[17:26:43.662]                       else {
[17:26:43.662]                         version <- NULL
[17:26:43.662]                       }
[17:26:43.662]                       if (!has_future || version < "1.8.0") {
[17:26:43.662]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.662]                           "", base::R.version$version.string), 
[17:26:43.662]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.662]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.662]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.662]                             "release", "version")], collapse = " "), 
[17:26:43.662]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.662]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.662]                           info)
[17:26:43.662]                         info <- base::paste(info, collapse = "; ")
[17:26:43.662]                         if (!has_future) {
[17:26:43.662]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.662]                             info)
[17:26:43.662]                         }
[17:26:43.662]                         else {
[17:26:43.662]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.662]                             info, version)
[17:26:43.662]                         }
[17:26:43.662]                         base::stop(msg)
[17:26:43.662]                       }
[17:26:43.662]                     })
[17:26:43.662]                   }
[17:26:43.662]                   ...future.strategy.old <- future::plan("list")
[17:26:43.662]                   options(future.plan = NULL)
[17:26:43.662]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.662]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.662]                 }
[17:26:43.662]                 ...future.workdir <- getwd()
[17:26:43.662]             }
[17:26:43.662]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.662]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.662]         }
[17:26:43.662]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.662]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.662]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.662]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.662]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.662]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.662]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.662]             base::names(...future.oldOptions))
[17:26:43.662]     }
[17:26:43.662]     if (FALSE) {
[17:26:43.662]     }
[17:26:43.662]     else {
[17:26:43.662]         if (TRUE) {
[17:26:43.662]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.662]                 open = "w")
[17:26:43.662]         }
[17:26:43.662]         else {
[17:26:43.662]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.662]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.662]         }
[17:26:43.662]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.662]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.662]             base::sink(type = "output", split = FALSE)
[17:26:43.662]             base::close(...future.stdout)
[17:26:43.662]         }, add = TRUE)
[17:26:43.662]     }
[17:26:43.662]     ...future.frame <- base::sys.nframe()
[17:26:43.662]     ...future.conditions <- base::list()
[17:26:43.662]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.662]     if (FALSE) {
[17:26:43.662]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.662]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.662]     }
[17:26:43.662]     ...future.result <- base::tryCatch({
[17:26:43.662]         base::withCallingHandlers({
[17:26:43.662]             ...future.value <- base::withVisible(base::local(NULL))
[17:26:43.662]             future::FutureResult(value = ...future.value$value, 
[17:26:43.662]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.662]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.662]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.662]                     ...future.globalenv.names))
[17:26:43.662]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.662]         }, condition = base::local({
[17:26:43.662]             c <- base::c
[17:26:43.662]             inherits <- base::inherits
[17:26:43.662]             invokeRestart <- base::invokeRestart
[17:26:43.662]             length <- base::length
[17:26:43.662]             list <- base::list
[17:26:43.662]             seq.int <- base::seq.int
[17:26:43.662]             signalCondition <- base::signalCondition
[17:26:43.662]             sys.calls <- base::sys.calls
[17:26:43.662]             `[[` <- base::`[[`
[17:26:43.662]             `+` <- base::`+`
[17:26:43.662]             `<<-` <- base::`<<-`
[17:26:43.662]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.662]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.662]                   3L)]
[17:26:43.662]             }
[17:26:43.662]             function(cond) {
[17:26:43.662]                 is_error <- inherits(cond, "error")
[17:26:43.662]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.662]                   NULL)
[17:26:43.662]                 if (is_error) {
[17:26:43.662]                   sessionInformation <- function() {
[17:26:43.662]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.662]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.662]                       search = base::search(), system = base::Sys.info())
[17:26:43.662]                   }
[17:26:43.662]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.662]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.662]                     cond$call), session = sessionInformation(), 
[17:26:43.662]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.662]                   signalCondition(cond)
[17:26:43.662]                 }
[17:26:43.662]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.662]                 "immediateCondition"))) {
[17:26:43.662]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.662]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.662]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.662]                   if (TRUE && !signal) {
[17:26:43.662]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.662]                     {
[17:26:43.662]                       inherits <- base::inherits
[17:26:43.662]                       invokeRestart <- base::invokeRestart
[17:26:43.662]                       is.null <- base::is.null
[17:26:43.662]                       muffled <- FALSE
[17:26:43.662]                       if (inherits(cond, "message")) {
[17:26:43.662]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.662]                         if (muffled) 
[17:26:43.662]                           invokeRestart("muffleMessage")
[17:26:43.662]                       }
[17:26:43.662]                       else if (inherits(cond, "warning")) {
[17:26:43.662]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.662]                         if (muffled) 
[17:26:43.662]                           invokeRestart("muffleWarning")
[17:26:43.662]                       }
[17:26:43.662]                       else if (inherits(cond, "condition")) {
[17:26:43.662]                         if (!is.null(pattern)) {
[17:26:43.662]                           computeRestarts <- base::computeRestarts
[17:26:43.662]                           grepl <- base::grepl
[17:26:43.662]                           restarts <- computeRestarts(cond)
[17:26:43.662]                           for (restart in restarts) {
[17:26:43.662]                             name <- restart$name
[17:26:43.662]                             if (is.null(name)) 
[17:26:43.662]                               next
[17:26:43.662]                             if (!grepl(pattern, name)) 
[17:26:43.662]                               next
[17:26:43.662]                             invokeRestart(restart)
[17:26:43.662]                             muffled <- TRUE
[17:26:43.662]                             break
[17:26:43.662]                           }
[17:26:43.662]                         }
[17:26:43.662]                       }
[17:26:43.662]                       invisible(muffled)
[17:26:43.662]                     }
[17:26:43.662]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.662]                   }
[17:26:43.662]                 }
[17:26:43.662]                 else {
[17:26:43.662]                   if (TRUE) {
[17:26:43.662]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.662]                     {
[17:26:43.662]                       inherits <- base::inherits
[17:26:43.662]                       invokeRestart <- base::invokeRestart
[17:26:43.662]                       is.null <- base::is.null
[17:26:43.662]                       muffled <- FALSE
[17:26:43.662]                       if (inherits(cond, "message")) {
[17:26:43.662]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.662]                         if (muffled) 
[17:26:43.662]                           invokeRestart("muffleMessage")
[17:26:43.662]                       }
[17:26:43.662]                       else if (inherits(cond, "warning")) {
[17:26:43.662]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.662]                         if (muffled) 
[17:26:43.662]                           invokeRestart("muffleWarning")
[17:26:43.662]                       }
[17:26:43.662]                       else if (inherits(cond, "condition")) {
[17:26:43.662]                         if (!is.null(pattern)) {
[17:26:43.662]                           computeRestarts <- base::computeRestarts
[17:26:43.662]                           grepl <- base::grepl
[17:26:43.662]                           restarts <- computeRestarts(cond)
[17:26:43.662]                           for (restart in restarts) {
[17:26:43.662]                             name <- restart$name
[17:26:43.662]                             if (is.null(name)) 
[17:26:43.662]                               next
[17:26:43.662]                             if (!grepl(pattern, name)) 
[17:26:43.662]                               next
[17:26:43.662]                             invokeRestart(restart)
[17:26:43.662]                             muffled <- TRUE
[17:26:43.662]                             break
[17:26:43.662]                           }
[17:26:43.662]                         }
[17:26:43.662]                       }
[17:26:43.662]                       invisible(muffled)
[17:26:43.662]                     }
[17:26:43.662]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.662]                   }
[17:26:43.662]                 }
[17:26:43.662]             }
[17:26:43.662]         }))
[17:26:43.662]     }, error = function(ex) {
[17:26:43.662]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.662]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.662]                 ...future.rng), started = ...future.startTime, 
[17:26:43.662]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.662]             version = "1.8"), class = "FutureResult")
[17:26:43.662]     }, finally = {
[17:26:43.662]         if (!identical(...future.workdir, getwd())) 
[17:26:43.662]             setwd(...future.workdir)
[17:26:43.662]         {
[17:26:43.662]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.662]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.662]             }
[17:26:43.662]             base::options(...future.oldOptions)
[17:26:43.662]             if (.Platform$OS.type == "windows") {
[17:26:43.662]                 old_names <- names(...future.oldEnvVars)
[17:26:43.662]                 envs <- base::Sys.getenv()
[17:26:43.662]                 names <- names(envs)
[17:26:43.662]                 common <- intersect(names, old_names)
[17:26:43.662]                 added <- setdiff(names, old_names)
[17:26:43.662]                 removed <- setdiff(old_names, names)
[17:26:43.662]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.662]                   envs[common]]
[17:26:43.662]                 NAMES <- toupper(changed)
[17:26:43.662]                 args <- list()
[17:26:43.662]                 for (kk in seq_along(NAMES)) {
[17:26:43.662]                   name <- changed[[kk]]
[17:26:43.662]                   NAME <- NAMES[[kk]]
[17:26:43.662]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.662]                     next
[17:26:43.662]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.662]                 }
[17:26:43.662]                 NAMES <- toupper(added)
[17:26:43.662]                 for (kk in seq_along(NAMES)) {
[17:26:43.662]                   name <- added[[kk]]
[17:26:43.662]                   NAME <- NAMES[[kk]]
[17:26:43.662]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.662]                     next
[17:26:43.662]                   args[[name]] <- ""
[17:26:43.662]                 }
[17:26:43.662]                 NAMES <- toupper(removed)
[17:26:43.662]                 for (kk in seq_along(NAMES)) {
[17:26:43.662]                   name <- removed[[kk]]
[17:26:43.662]                   NAME <- NAMES[[kk]]
[17:26:43.662]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.662]                     next
[17:26:43.662]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.662]                 }
[17:26:43.662]                 if (length(args) > 0) 
[17:26:43.662]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.662]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.662]             }
[17:26:43.662]             else {
[17:26:43.662]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.662]             }
[17:26:43.662]             {
[17:26:43.662]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.662]                   0L) {
[17:26:43.662]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.662]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.662]                   base::options(opts)
[17:26:43.662]                 }
[17:26:43.662]                 {
[17:26:43.662]                   {
[17:26:43.662]                     NULL
[17:26:43.662]                     RNGkind("Mersenne-Twister")
[17:26:43.662]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.662]                       inherits = FALSE)
[17:26:43.662]                   }
[17:26:43.662]                   options(future.plan = NULL)
[17:26:43.662]                   if (is.na(NA_character_)) 
[17:26:43.662]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.662]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.662]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.662]                     .init = FALSE)
[17:26:43.662]                 }
[17:26:43.662]             }
[17:26:43.662]         }
[17:26:43.662]     })
[17:26:43.662]     if (TRUE) {
[17:26:43.662]         base::sink(type = "output", split = FALSE)
[17:26:43.662]         if (TRUE) {
[17:26:43.662]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.662]         }
[17:26:43.662]         else {
[17:26:43.662]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.662]         }
[17:26:43.662]         base::close(...future.stdout)
[17:26:43.662]         ...future.stdout <- NULL
[17:26:43.662]     }
[17:26:43.662]     ...future.result$conditions <- ...future.conditions
[17:26:43.662]     ...future.result$finished <- base::Sys.time()
[17:26:43.662]     ...future.result
[17:26:43.662] }
[17:26:43.666] plan(): Setting new future strategy stack:
[17:26:43.666] List of future strategies:
[17:26:43.666] 1. sequential:
[17:26:43.666]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.666]    - tweaked: FALSE
[17:26:43.666]    - call: NULL
[17:26:43.666] plan(): nbrOfWorkers() = 1
[17:26:43.667] plan(): Setting new future strategy stack:
[17:26:43.668] List of future strategies:
[17:26:43.668] 1. sequential:
[17:26:43.668]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.668]    - tweaked: FALSE
[17:26:43.668]    - call: plan(strategy)
[17:26:43.668] plan(): nbrOfWorkers() = 1
[17:26:43.668] SequentialFuture started (and completed)
[17:26:43.669] - Launch lazy future ... done
[17:26:43.669] run() for 'SequentialFuture' ... done
[17:26:43.669] getGlobalsAndPackages() ...
[17:26:43.670] Searching for globals...
[17:26:43.671] - globals found: [1] '{'
[17:26:43.671] Searching for globals ... DONE
[17:26:43.672] Resolving globals: FALSE
[17:26:43.672] 
[17:26:43.672] 
[17:26:43.672] getGlobalsAndPackages() ... DONE
[17:26:43.673] run() for 'Future' ...
[17:26:43.673] - state: 'created'
[17:26:43.673] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:43.673] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:43.674] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:43.674]   - Field: 'label'
[17:26:43.674]   - Field: 'local'
[17:26:43.674]   - Field: 'owner'
[17:26:43.674]   - Field: 'envir'
[17:26:43.674]   - Field: 'packages'
[17:26:43.675]   - Field: 'gc'
[17:26:43.675]   - Field: 'conditions'
[17:26:43.675]   - Field: 'expr'
[17:26:43.675]   - Field: 'uuid'
[17:26:43.675]   - Field: 'seed'
[17:26:43.676]   - Field: 'version'
[17:26:43.676]   - Field: 'result'
[17:26:43.676]   - Field: 'asynchronous'
[17:26:43.676]   - Field: 'calls'
[17:26:43.676]   - Field: 'globals'
[17:26:43.676]   - Field: 'stdout'
[17:26:43.677]   - Field: 'earlySignal'
[17:26:43.677]   - Field: 'lazy'
[17:26:43.677]   - Field: 'state'
[17:26:43.677] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:43.677] - Launch lazy future ...
[17:26:43.678] Packages needed by the future expression (n = 0): <none>
[17:26:43.678] Packages needed by future strategies (n = 0): <none>
[17:26:43.678] {
[17:26:43.678]     {
[17:26:43.678]         {
[17:26:43.678]             ...future.startTime <- base::Sys.time()
[17:26:43.678]             {
[17:26:43.678]                 {
[17:26:43.678]                   {
[17:26:43.678]                     base::local({
[17:26:43.678]                       has_future <- base::requireNamespace("future", 
[17:26:43.678]                         quietly = TRUE)
[17:26:43.678]                       if (has_future) {
[17:26:43.678]                         ns <- base::getNamespace("future")
[17:26:43.678]                         version <- ns[[".package"]][["version"]]
[17:26:43.678]                         if (is.null(version)) 
[17:26:43.678]                           version <- utils::packageVersion("future")
[17:26:43.678]                       }
[17:26:43.678]                       else {
[17:26:43.678]                         version <- NULL
[17:26:43.678]                       }
[17:26:43.678]                       if (!has_future || version < "1.8.0") {
[17:26:43.678]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:43.678]                           "", base::R.version$version.string), 
[17:26:43.678]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:43.678]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:43.678]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:43.678]                             "release", "version")], collapse = " "), 
[17:26:43.678]                           hostname = base::Sys.info()[["nodename"]])
[17:26:43.678]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:43.678]                           info)
[17:26:43.678]                         info <- base::paste(info, collapse = "; ")
[17:26:43.678]                         if (!has_future) {
[17:26:43.678]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:43.678]                             info)
[17:26:43.678]                         }
[17:26:43.678]                         else {
[17:26:43.678]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:43.678]                             info, version)
[17:26:43.678]                         }
[17:26:43.678]                         base::stop(msg)
[17:26:43.678]                       }
[17:26:43.678]                     })
[17:26:43.678]                   }
[17:26:43.678]                   ...future.strategy.old <- future::plan("list")
[17:26:43.678]                   options(future.plan = NULL)
[17:26:43.678]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.678]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:43.678]                 }
[17:26:43.678]                 ...future.workdir <- getwd()
[17:26:43.678]             }
[17:26:43.678]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:43.678]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:43.678]         }
[17:26:43.678]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:43.678]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:43.678]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:43.678]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:43.678]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:43.678]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:43.678]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:43.678]             base::names(...future.oldOptions))
[17:26:43.678]     }
[17:26:43.678]     if (FALSE) {
[17:26:43.678]     }
[17:26:43.678]     else {
[17:26:43.678]         if (TRUE) {
[17:26:43.678]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:43.678]                 open = "w")
[17:26:43.678]         }
[17:26:43.678]         else {
[17:26:43.678]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:43.678]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:43.678]         }
[17:26:43.678]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:43.678]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:43.678]             base::sink(type = "output", split = FALSE)
[17:26:43.678]             base::close(...future.stdout)
[17:26:43.678]         }, add = TRUE)
[17:26:43.678]     }
[17:26:43.678]     ...future.frame <- base::sys.nframe()
[17:26:43.678]     ...future.conditions <- base::list()
[17:26:43.678]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:43.678]     if (FALSE) {
[17:26:43.678]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:43.678]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:43.678]     }
[17:26:43.678]     ...future.result <- base::tryCatch({
[17:26:43.678]         base::withCallingHandlers({
[17:26:43.678]             ...future.value <- base::withVisible(base::local({
[17:26:43.678]                 4
[17:26:43.678]             }))
[17:26:43.678]             future::FutureResult(value = ...future.value$value, 
[17:26:43.678]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.678]                   ...future.rng), globalenv = if (FALSE) 
[17:26:43.678]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:43.678]                     ...future.globalenv.names))
[17:26:43.678]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:43.678]         }, condition = base::local({
[17:26:43.678]             c <- base::c
[17:26:43.678]             inherits <- base::inherits
[17:26:43.678]             invokeRestart <- base::invokeRestart
[17:26:43.678]             length <- base::length
[17:26:43.678]             list <- base::list
[17:26:43.678]             seq.int <- base::seq.int
[17:26:43.678]             signalCondition <- base::signalCondition
[17:26:43.678]             sys.calls <- base::sys.calls
[17:26:43.678]             `[[` <- base::`[[`
[17:26:43.678]             `+` <- base::`+`
[17:26:43.678]             `<<-` <- base::`<<-`
[17:26:43.678]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:43.678]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:43.678]                   3L)]
[17:26:43.678]             }
[17:26:43.678]             function(cond) {
[17:26:43.678]                 is_error <- inherits(cond, "error")
[17:26:43.678]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:43.678]                   NULL)
[17:26:43.678]                 if (is_error) {
[17:26:43.678]                   sessionInformation <- function() {
[17:26:43.678]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:43.678]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:43.678]                       search = base::search(), system = base::Sys.info())
[17:26:43.678]                   }
[17:26:43.678]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.678]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:43.678]                     cond$call), session = sessionInformation(), 
[17:26:43.678]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:43.678]                   signalCondition(cond)
[17:26:43.678]                 }
[17:26:43.678]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:43.678]                 "immediateCondition"))) {
[17:26:43.678]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:43.678]                   ...future.conditions[[length(...future.conditions) + 
[17:26:43.678]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:43.678]                   if (TRUE && !signal) {
[17:26:43.678]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.678]                     {
[17:26:43.678]                       inherits <- base::inherits
[17:26:43.678]                       invokeRestart <- base::invokeRestart
[17:26:43.678]                       is.null <- base::is.null
[17:26:43.678]                       muffled <- FALSE
[17:26:43.678]                       if (inherits(cond, "message")) {
[17:26:43.678]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.678]                         if (muffled) 
[17:26:43.678]                           invokeRestart("muffleMessage")
[17:26:43.678]                       }
[17:26:43.678]                       else if (inherits(cond, "warning")) {
[17:26:43.678]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.678]                         if (muffled) 
[17:26:43.678]                           invokeRestart("muffleWarning")
[17:26:43.678]                       }
[17:26:43.678]                       else if (inherits(cond, "condition")) {
[17:26:43.678]                         if (!is.null(pattern)) {
[17:26:43.678]                           computeRestarts <- base::computeRestarts
[17:26:43.678]                           grepl <- base::grepl
[17:26:43.678]                           restarts <- computeRestarts(cond)
[17:26:43.678]                           for (restart in restarts) {
[17:26:43.678]                             name <- restart$name
[17:26:43.678]                             if (is.null(name)) 
[17:26:43.678]                               next
[17:26:43.678]                             if (!grepl(pattern, name)) 
[17:26:43.678]                               next
[17:26:43.678]                             invokeRestart(restart)
[17:26:43.678]                             muffled <- TRUE
[17:26:43.678]                             break
[17:26:43.678]                           }
[17:26:43.678]                         }
[17:26:43.678]                       }
[17:26:43.678]                       invisible(muffled)
[17:26:43.678]                     }
[17:26:43.678]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.678]                   }
[17:26:43.678]                 }
[17:26:43.678]                 else {
[17:26:43.678]                   if (TRUE) {
[17:26:43.678]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:43.678]                     {
[17:26:43.678]                       inherits <- base::inherits
[17:26:43.678]                       invokeRestart <- base::invokeRestart
[17:26:43.678]                       is.null <- base::is.null
[17:26:43.678]                       muffled <- FALSE
[17:26:43.678]                       if (inherits(cond, "message")) {
[17:26:43.678]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:43.678]                         if (muffled) 
[17:26:43.678]                           invokeRestart("muffleMessage")
[17:26:43.678]                       }
[17:26:43.678]                       else if (inherits(cond, "warning")) {
[17:26:43.678]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:43.678]                         if (muffled) 
[17:26:43.678]                           invokeRestart("muffleWarning")
[17:26:43.678]                       }
[17:26:43.678]                       else if (inherits(cond, "condition")) {
[17:26:43.678]                         if (!is.null(pattern)) {
[17:26:43.678]                           computeRestarts <- base::computeRestarts
[17:26:43.678]                           grepl <- base::grepl
[17:26:43.678]                           restarts <- computeRestarts(cond)
[17:26:43.678]                           for (restart in restarts) {
[17:26:43.678]                             name <- restart$name
[17:26:43.678]                             if (is.null(name)) 
[17:26:43.678]                               next
[17:26:43.678]                             if (!grepl(pattern, name)) 
[17:26:43.678]                               next
[17:26:43.678]                             invokeRestart(restart)
[17:26:43.678]                             muffled <- TRUE
[17:26:43.678]                             break
[17:26:43.678]                           }
[17:26:43.678]                         }
[17:26:43.678]                       }
[17:26:43.678]                       invisible(muffled)
[17:26:43.678]                     }
[17:26:43.678]                     muffleCondition(cond, pattern = "^muffle")
[17:26:43.678]                   }
[17:26:43.678]                 }
[17:26:43.678]             }
[17:26:43.678]         }))
[17:26:43.678]     }, error = function(ex) {
[17:26:43.678]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:43.678]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:43.678]                 ...future.rng), started = ...future.startTime, 
[17:26:43.678]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:43.678]             version = "1.8"), class = "FutureResult")
[17:26:43.678]     }, finally = {
[17:26:43.678]         if (!identical(...future.workdir, getwd())) 
[17:26:43.678]             setwd(...future.workdir)
[17:26:43.678]         {
[17:26:43.678]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:43.678]                 ...future.oldOptions$nwarnings <- NULL
[17:26:43.678]             }
[17:26:43.678]             base::options(...future.oldOptions)
[17:26:43.678]             if (.Platform$OS.type == "windows") {
[17:26:43.678]                 old_names <- names(...future.oldEnvVars)
[17:26:43.678]                 envs <- base::Sys.getenv()
[17:26:43.678]                 names <- names(envs)
[17:26:43.678]                 common <- intersect(names, old_names)
[17:26:43.678]                 added <- setdiff(names, old_names)
[17:26:43.678]                 removed <- setdiff(old_names, names)
[17:26:43.678]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:43.678]                   envs[common]]
[17:26:43.678]                 NAMES <- toupper(changed)
[17:26:43.678]                 args <- list()
[17:26:43.678]                 for (kk in seq_along(NAMES)) {
[17:26:43.678]                   name <- changed[[kk]]
[17:26:43.678]                   NAME <- NAMES[[kk]]
[17:26:43.678]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.678]                     next
[17:26:43.678]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.678]                 }
[17:26:43.678]                 NAMES <- toupper(added)
[17:26:43.678]                 for (kk in seq_along(NAMES)) {
[17:26:43.678]                   name <- added[[kk]]
[17:26:43.678]                   NAME <- NAMES[[kk]]
[17:26:43.678]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.678]                     next
[17:26:43.678]                   args[[name]] <- ""
[17:26:43.678]                 }
[17:26:43.678]                 NAMES <- toupper(removed)
[17:26:43.678]                 for (kk in seq_along(NAMES)) {
[17:26:43.678]                   name <- removed[[kk]]
[17:26:43.678]                   NAME <- NAMES[[kk]]
[17:26:43.678]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:43.678]                     next
[17:26:43.678]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:43.678]                 }
[17:26:43.678]                 if (length(args) > 0) 
[17:26:43.678]                   base::do.call(base::Sys.setenv, args = args)
[17:26:43.678]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:43.678]             }
[17:26:43.678]             else {
[17:26:43.678]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:43.678]             }
[17:26:43.678]             {
[17:26:43.678]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:43.678]                   0L) {
[17:26:43.678]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:43.678]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:43.678]                   base::options(opts)
[17:26:43.678]                 }
[17:26:43.678]                 {
[17:26:43.678]                   {
[17:26:43.678]                     NULL
[17:26:43.678]                     RNGkind("Mersenne-Twister")
[17:26:43.678]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:43.678]                       inherits = FALSE)
[17:26:43.678]                   }
[17:26:43.678]                   options(future.plan = NULL)
[17:26:43.678]                   if (is.na(NA_character_)) 
[17:26:43.678]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:43.678]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:43.678]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:43.678]                     .init = FALSE)
[17:26:43.678]                 }
[17:26:43.678]             }
[17:26:43.678]         }
[17:26:43.678]     })
[17:26:43.678]     if (TRUE) {
[17:26:43.678]         base::sink(type = "output", split = FALSE)
[17:26:43.678]         if (TRUE) {
[17:26:43.678]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:43.678]         }
[17:26:43.678]         else {
[17:26:43.678]             ...future.result["stdout"] <- base::list(NULL)
[17:26:43.678]         }
[17:26:43.678]         base::close(...future.stdout)
[17:26:43.678]         ...future.stdout <- NULL
[17:26:43.678]     }
[17:26:43.678]     ...future.result$conditions <- ...future.conditions
[17:26:43.678]     ...future.result$finished <- base::Sys.time()
[17:26:43.678]     ...future.result
[17:26:43.678] }
[17:26:43.682] plan(): Setting new future strategy stack:
[17:26:43.682] List of future strategies:
[17:26:43.682] 1. sequential:
[17:26:43.682]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.682]    - tweaked: FALSE
[17:26:43.682]    - call: NULL
[17:26:43.683] plan(): nbrOfWorkers() = 1
[17:26:43.684] plan(): Setting new future strategy stack:
[17:26:43.684] List of future strategies:
[17:26:43.684] 1. sequential:
[17:26:43.684]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:43.684]    - tweaked: FALSE
[17:26:43.684]    - call: plan(strategy)
[17:26:43.685] plan(): nbrOfWorkers() = 1
[17:26:43.685] SequentialFuture started (and completed)
[17:26:43.685] - Launch lazy future ... done
[17:26:43.685] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230b07f068> 
Classes 'listenv', 'environment' <environment: 0x0000022309e1ec68> 
 - attr(*, "dim.")= int [1:4] 2 1 3 1
 - attr(*, "dimnames.")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:43.690] resolved() for 'SequentialFuture' ...
[17:26:43.690] - state: 'finished'
[17:26:43.691] - run: TRUE
[17:26:43.691] - result: 'FutureResult'
[17:26:43.691] resolved() for 'SequentialFuture' ... done
[17:26:43.691] resolved() for 'SequentialFuture' ...
[17:26:43.691] - state: 'finished'
[17:26:43.692] - run: TRUE
[17:26:43.692] - result: 'FutureResult'
[17:26:43.692] resolved() for 'SequentialFuture' ... done
[17:26:43.692] resolved() for 'SequentialFuture' ...
[17:26:43.692] - state: 'finished'
[17:26:43.693] - run: TRUE
[17:26:43.693] - result: 'FutureResult'
[17:26:43.693] resolved() for 'SequentialFuture' ... done
 logi [1:2, 1, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:43.696] resolve() on list environment ...
[17:26:43.696]  recursive: 0
[17:26:43.697]  length: 6
[17:26:43.698]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:43.698] signalConditionsASAP(numeric, pos=1) ...
[17:26:43.698] - nx: 6
[17:26:43.698] - relay: TRUE
[17:26:43.698] - stdout: TRUE
[17:26:43.698] - signal: TRUE
[17:26:43.699] - resignal: FALSE
[17:26:43.699] - force: TRUE
[17:26:43.699] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.699] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.699]  - until=2
[17:26:43.700]  - relaying element #2
[17:26:43.700] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.701] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.701] signalConditionsASAP(NULL, pos=1) ... done
[17:26:43.701]  length: 5 (resolved future 1)
[17:26:43.701] resolved() for 'SequentialFuture' ...
[17:26:43.701] - state: 'finished'
[17:26:43.702] - run: TRUE
[17:26:43.702] - result: 'FutureResult'
[17:26:43.702] resolved() for 'SequentialFuture' ... done
[17:26:43.702] Future #2
[17:26:43.702] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:26:43.703] - nx: 6
[17:26:43.703] - relay: TRUE
[17:26:43.703] - stdout: TRUE
[17:26:43.703] - signal: TRUE
[17:26:43.703] - resignal: FALSE
[17:26:43.703] - force: TRUE
[17:26:43.703] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.704] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:43.704]  - until=2
[17:26:43.704]  - relaying element #2
[17:26:43.704] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.704] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.705] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:26:43.705]  length: 4 (resolved future 2)
[17:26:43.705] resolved() for 'SequentialFuture' ...
[17:26:43.705] - state: 'finished'
[17:26:43.705] - run: TRUE
[17:26:43.705] - result: 'FutureResult'
[17:26:43.706] resolved() for 'SequentialFuture' ... done
[17:26:43.706] Future #3
[17:26:43.706] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:26:43.706] - nx: 6
[17:26:43.706] - relay: TRUE
[17:26:43.707] - stdout: TRUE
[17:26:43.707] - signal: TRUE
[17:26:43.707] - resignal: FALSE
[17:26:43.707] - force: TRUE
[17:26:43.707] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.707] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:43.707]  - until=3
[17:26:43.708]  - relaying element #3
[17:26:43.708] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.708] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.708] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:26:43.708]  length: 3 (resolved future 3)
[17:26:43.709] resolved() for 'SequentialFuture' ...
[17:26:43.709] - state: 'finished'
[17:26:43.709] - run: TRUE
[17:26:43.709] - result: 'FutureResult'
[17:26:43.709] resolved() for 'SequentialFuture' ... done
[17:26:43.709] Future #4
[17:26:43.710] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:26:43.710] - nx: 6
[17:26:43.710] - relay: TRUE
[17:26:43.710] - stdout: TRUE
[17:26:43.710] - signal: TRUE
[17:26:43.710] - resignal: FALSE
[17:26:43.711] - force: TRUE
[17:26:43.711] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.711] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:43.711]  - until=4
[17:26:43.711]  - relaying element #4
[17:26:43.712] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.712] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.712] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:26:43.712]  length: 2 (resolved future 4)
[17:26:43.712] signalConditionsASAP(NULL, pos=5) ...
[17:26:43.712] - nx: 6
[17:26:43.712] - relay: TRUE
[17:26:43.713] - stdout: TRUE
[17:26:43.713] - signal: TRUE
[17:26:43.713] - resignal: FALSE
[17:26:43.713] - force: TRUE
[17:26:43.713] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.713] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.714]  - until=6
[17:26:43.714]  - relaying element #6
[17:26:43.714] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.714] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.714] signalConditionsASAP(NULL, pos=5) ... done
[17:26:43.714]  length: 1 (resolved future 5)
[17:26:43.715] signalConditionsASAP(numeric, pos=6) ...
[17:26:43.715] - nx: 6
[17:26:43.715] - relay: TRUE
[17:26:43.715] - stdout: TRUE
[17:26:43.715] - signal: TRUE
[17:26:43.715] - resignal: FALSE
[17:26:43.715] - force: TRUE
[17:26:43.716] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:43.716] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.716]  - until=6
[17:26:43.716] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.716] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.716] signalConditionsASAP(numeric, pos=6) ... done
[17:26:43.717]  length: 0 (resolved future 6)
[17:26:43.717] Relaying remaining futures
[17:26:43.717] signalConditionsASAP(NULL, pos=0) ...
[17:26:43.717] - nx: 6
[17:26:43.717] - relay: TRUE
[17:26:43.717] - stdout: TRUE
[17:26:43.717] - signal: TRUE
[17:26:43.718] - resignal: FALSE
[17:26:43.718] - force: TRUE
[17:26:43.718] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.718] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:43.718] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:43.718] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:43.719] signalConditionsASAP(NULL, pos=0) ... done
[17:26:43.719] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x000002230d5a67d8> 
 - attr(*, "dim.")= int [1:4] 2 1 3 1
 - attr(*, "dimnames.")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
*** futures() - listenv ... DONE
Testing with 1 cores ... DONE
Testing with 2 cores ...
Type of object: list
Type of future: multisession
[17:26:43.722] plan(): Setting new future strategy stack:
[17:26:43.722] List of future strategies:
[17:26:43.722] 1. multisession:
[17:26:43.722]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:43.722]    - tweaked: FALSE
[17:26:43.722]    - call: plan(strategy)
[17:26:43.723] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:43.723] multisession:
[17:26:43.723] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:43.723] - tweaked: FALSE
[17:26:43.723] - call: plan(strategy)
[17:26:43.727] getGlobalsAndPackages() ...
[17:26:43.727] Not searching for globals
[17:26:43.728] - globals: [0] <none>
[17:26:43.728] getGlobalsAndPackages() ... DONE
[17:26:43.728] [local output] makeClusterPSOCK() ...
[17:26:43.793] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:43.799] [local output] Base port: 31181
[17:26:43.799] [local output] Getting setup options for 2 cluster nodes ...
[17:26:43.799] [local output]  - Node 1 of 2 ...
[17:26:43.800] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:43.801] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf862777d31.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf862777d31.pid\")"'
[17:26:44.017] - Possible to infer worker's PID: TRUE
[17:26:44.018] [local output] Rscript port: 31181

[17:26:44.018] [local output]  - Node 2 of 2 ...
[17:26:44.019] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:44.020] [local output] Rscript port: 31181

[17:26:44.021] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:44.021] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:44.022] [local output] Setting up PSOCK nodes in parallel
[17:26:44.022] List of 36
[17:26:44.022]  $ worker          : chr "localhost"
[17:26:44.022]   ..- attr(*, "localhost")= logi TRUE
[17:26:44.022]  $ master          : chr "localhost"
[17:26:44.022]  $ port            : int 31181
[17:26:44.022]  $ connectTimeout  : num 120
[17:26:44.022]  $ timeout         : num 120
[17:26:44.022]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:44.022]  $ homogeneous     : logi TRUE
[17:26:44.022]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futures.R:105464:CRANWIN3:CRAN\""| __truncated__
[17:26:44.022]  $ rscript_envs    : NULL
[17:26:44.022]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:44.022]  $ rscript_startup : NULL
[17:26:44.022]  $ rscript_sh      : chr "cmd"
[17:26:44.022]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:44.022]  $ methods         : logi TRUE
[17:26:44.022]  $ socketOptions   : chr "no-delay"
[17:26:44.022]  $ useXDR          : logi FALSE
[17:26:44.022]  $ outfile         : chr "/dev/null"
[17:26:44.022]  $ renice          : int NA
[17:26:44.022]  $ rshcmd          : NULL
[17:26:44.022]  $ user            : chr(0) 
[17:26:44.022]  $ revtunnel       : logi FALSE
[17:26:44.022]  $ rshlogfile      : NULL
[17:26:44.022]  $ rshopts         : chr(0) 
[17:26:44.022]  $ rank            : int 1
[17:26:44.022]  $ manual          : logi FALSE
[17:26:44.022]  $ dryrun          : logi FALSE
[17:26:44.022]  $ quiet           : logi FALSE
[17:26:44.022]  $ setup_strategy  : chr "parallel"
[17:26:44.022]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:44.022]  $ pidfile         : chr "D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf862777d31.pid"
[17:26:44.022]  $ rshcmd_label    : NULL
[17:26:44.022]  $ rsh_call        : NULL
[17:26:44.022]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:44.022]  $ localMachine    : logi TRUE
[17:26:44.022]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:44.022]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:44.022]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:44.022]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:44.022]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:44.022]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:26:44.022]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:44.022]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:44.022]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:44.022]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:44.022]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:44.022]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:44.022]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:44.022]  $ arguments       :List of 28
[17:26:44.022]   ..$ worker          : chr "localhost"
[17:26:44.022]   ..$ master          : NULL
[17:26:44.022]   ..$ port            : int 31181
[17:26:44.022]   ..$ connectTimeout  : num 120
[17:26:44.022]   ..$ timeout         : num 120
[17:26:44.022]   ..$ rscript         : NULL
[17:26:44.022]   ..$ homogeneous     : NULL
[17:26:44.022]   ..$ rscript_args    : NULL
[17:26:44.022]   ..$ rscript_envs    : NULL
[17:26:44.022]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:44.022]   ..$ rscript_startup : NULL
[17:26:44.022]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:26:44.022]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:44.022]   ..$ methods         : logi TRUE
[17:26:44.022]   ..$ socketOptions   : chr "no-delay"
[17:26:44.022]   ..$ useXDR          : logi FALSE
[17:26:44.022]   ..$ outfile         : chr "/dev/null"
[17:26:44.022]   ..$ renice          : int NA
[17:26:44.022]   ..$ rshcmd          : NULL
[17:26:44.022]   ..$ user            : NULL
[17:26:44.022]   ..$ revtunnel       : logi NA
[17:26:44.022]   ..$ rshlogfile      : NULL
[17:26:44.022]   ..$ rshopts         : NULL
[17:26:44.022]   ..$ rank            : int 1
[17:26:44.022]   ..$ manual          : logi FALSE
[17:26:44.022]   ..$ dryrun          : logi FALSE
[17:26:44.022]   ..$ quiet           : logi FALSE
[17:26:44.022]   ..$ setup_strategy  : chr "parallel"
[17:26:44.022]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:44.047] [local output] System call to launch all workers:
[17:26:44.047] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futures.R:105464:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf862777d31.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=31181 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:44.048] [local output] Starting PSOCK main server
[17:26:44.053] [local output] Workers launched
[17:26:44.053] [local output] Waiting for workers to connect back
[17:26:44.053]  - [local output] 0 workers out of 2 ready
[17:26:44.214]  - [local output] 0 workers out of 2 ready
[17:26:44.215]  - [local output] 1 workers out of 2 ready
[17:26:44.218]  - [local output] 1 workers out of 2 ready
[17:26:44.218]  - [local output] 2 workers out of 2 ready
[17:26:44.218] [local output] Launching of workers completed
[17:26:44.218] [local output] Collecting session information from workers
[17:26:44.219] [local output]  - Worker #1 of 2
[17:26:44.220] [local output]  - Worker #2 of 2
[17:26:44.221] [local output] makeClusterPSOCK() ... done
[17:26:44.233] Packages needed by the future expression (n = 0): <none>
[17:26:44.234] Packages needed by future strategies (n = 0): <none>
[17:26:44.234] {
[17:26:44.234]     {
[17:26:44.234]         {
[17:26:44.234]             ...future.startTime <- base::Sys.time()
[17:26:44.234]             {
[17:26:44.234]                 {
[17:26:44.234]                   {
[17:26:44.234]                     {
[17:26:44.234]                       base::local({
[17:26:44.234]                         has_future <- base::requireNamespace("future", 
[17:26:44.234]                           quietly = TRUE)
[17:26:44.234]                         if (has_future) {
[17:26:44.234]                           ns <- base::getNamespace("future")
[17:26:44.234]                           version <- ns[[".package"]][["version"]]
[17:26:44.234]                           if (is.null(version)) 
[17:26:44.234]                             version <- utils::packageVersion("future")
[17:26:44.234]                         }
[17:26:44.234]                         else {
[17:26:44.234]                           version <- NULL
[17:26:44.234]                         }
[17:26:44.234]                         if (!has_future || version < "1.8.0") {
[17:26:44.234]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.234]                             "", base::R.version$version.string), 
[17:26:44.234]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.234]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.234]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.234]                               "release", "version")], collapse = " "), 
[17:26:44.234]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.234]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.234]                             info)
[17:26:44.234]                           info <- base::paste(info, collapse = "; ")
[17:26:44.234]                           if (!has_future) {
[17:26:44.234]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.234]                               info)
[17:26:44.234]                           }
[17:26:44.234]                           else {
[17:26:44.234]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.234]                               info, version)
[17:26:44.234]                           }
[17:26:44.234]                           base::stop(msg)
[17:26:44.234]                         }
[17:26:44.234]                       })
[17:26:44.234]                     }
[17:26:44.234]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.234]                     base::options(mc.cores = 1L)
[17:26:44.234]                   }
[17:26:44.234]                   ...future.strategy.old <- future::plan("list")
[17:26:44.234]                   options(future.plan = NULL)
[17:26:44.234]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.234]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.234]                 }
[17:26:44.234]                 ...future.workdir <- getwd()
[17:26:44.234]             }
[17:26:44.234]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.234]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.234]         }
[17:26:44.234]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.234]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.234]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.234]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.234]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.234]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.234]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.234]             base::names(...future.oldOptions))
[17:26:44.234]     }
[17:26:44.234]     if (FALSE) {
[17:26:44.234]     }
[17:26:44.234]     else {
[17:26:44.234]         if (TRUE) {
[17:26:44.234]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.234]                 open = "w")
[17:26:44.234]         }
[17:26:44.234]         else {
[17:26:44.234]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.234]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.234]         }
[17:26:44.234]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.234]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.234]             base::sink(type = "output", split = FALSE)
[17:26:44.234]             base::close(...future.stdout)
[17:26:44.234]         }, add = TRUE)
[17:26:44.234]     }
[17:26:44.234]     ...future.frame <- base::sys.nframe()
[17:26:44.234]     ...future.conditions <- base::list()
[17:26:44.234]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.234]     if (FALSE) {
[17:26:44.234]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.234]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.234]     }
[17:26:44.234]     ...future.result <- base::tryCatch({
[17:26:44.234]         base::withCallingHandlers({
[17:26:44.234]             ...future.value <- base::withVisible(base::local({
[17:26:44.234]                 ...future.makeSendCondition <- base::local({
[17:26:44.234]                   sendCondition <- NULL
[17:26:44.234]                   function(frame = 1L) {
[17:26:44.234]                     if (is.function(sendCondition)) 
[17:26:44.234]                       return(sendCondition)
[17:26:44.234]                     ns <- getNamespace("parallel")
[17:26:44.234]                     if (exists("sendData", mode = "function", 
[17:26:44.234]                       envir = ns)) {
[17:26:44.234]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.234]                         envir = ns)
[17:26:44.234]                       envir <- sys.frame(frame)
[17:26:44.234]                       master <- NULL
[17:26:44.234]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.234]                         !identical(envir, emptyenv())) {
[17:26:44.234]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.234]                           inherits = FALSE)) {
[17:26:44.234]                           master <- get("master", mode = "list", 
[17:26:44.234]                             envir = envir, inherits = FALSE)
[17:26:44.234]                           if (inherits(master, c("SOCKnode", 
[17:26:44.234]                             "SOCK0node"))) {
[17:26:44.234]                             sendCondition <<- function(cond) {
[17:26:44.234]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.234]                                 success = TRUE)
[17:26:44.234]                               parallel_sendData(master, data)
[17:26:44.234]                             }
[17:26:44.234]                             return(sendCondition)
[17:26:44.234]                           }
[17:26:44.234]                         }
[17:26:44.234]                         frame <- frame + 1L
[17:26:44.234]                         envir <- sys.frame(frame)
[17:26:44.234]                       }
[17:26:44.234]                     }
[17:26:44.234]                     sendCondition <<- function(cond) NULL
[17:26:44.234]                   }
[17:26:44.234]                 })
[17:26:44.234]                 withCallingHandlers({
[17:26:44.234]                   NA
[17:26:44.234]                 }, immediateCondition = function(cond) {
[17:26:44.234]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.234]                   sendCondition(cond)
[17:26:44.234]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.234]                   {
[17:26:44.234]                     inherits <- base::inherits
[17:26:44.234]                     invokeRestart <- base::invokeRestart
[17:26:44.234]                     is.null <- base::is.null
[17:26:44.234]                     muffled <- FALSE
[17:26:44.234]                     if (inherits(cond, "message")) {
[17:26:44.234]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.234]                       if (muffled) 
[17:26:44.234]                         invokeRestart("muffleMessage")
[17:26:44.234]                     }
[17:26:44.234]                     else if (inherits(cond, "warning")) {
[17:26:44.234]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.234]                       if (muffled) 
[17:26:44.234]                         invokeRestart("muffleWarning")
[17:26:44.234]                     }
[17:26:44.234]                     else if (inherits(cond, "condition")) {
[17:26:44.234]                       if (!is.null(pattern)) {
[17:26:44.234]                         computeRestarts <- base::computeRestarts
[17:26:44.234]                         grepl <- base::grepl
[17:26:44.234]                         restarts <- computeRestarts(cond)
[17:26:44.234]                         for (restart in restarts) {
[17:26:44.234]                           name <- restart$name
[17:26:44.234]                           if (is.null(name)) 
[17:26:44.234]                             next
[17:26:44.234]                           if (!grepl(pattern, name)) 
[17:26:44.234]                             next
[17:26:44.234]                           invokeRestart(restart)
[17:26:44.234]                           muffled <- TRUE
[17:26:44.234]                           break
[17:26:44.234]                         }
[17:26:44.234]                       }
[17:26:44.234]                     }
[17:26:44.234]                     invisible(muffled)
[17:26:44.234]                   }
[17:26:44.234]                   muffleCondition(cond)
[17:26:44.234]                 })
[17:26:44.234]             }))
[17:26:44.234]             future::FutureResult(value = ...future.value$value, 
[17:26:44.234]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.234]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.234]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.234]                     ...future.globalenv.names))
[17:26:44.234]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.234]         }, condition = base::local({
[17:26:44.234]             c <- base::c
[17:26:44.234]             inherits <- base::inherits
[17:26:44.234]             invokeRestart <- base::invokeRestart
[17:26:44.234]             length <- base::length
[17:26:44.234]             list <- base::list
[17:26:44.234]             seq.int <- base::seq.int
[17:26:44.234]             signalCondition <- base::signalCondition
[17:26:44.234]             sys.calls <- base::sys.calls
[17:26:44.234]             `[[` <- base::`[[`
[17:26:44.234]             `+` <- base::`+`
[17:26:44.234]             `<<-` <- base::`<<-`
[17:26:44.234]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.234]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.234]                   3L)]
[17:26:44.234]             }
[17:26:44.234]             function(cond) {
[17:26:44.234]                 is_error <- inherits(cond, "error")
[17:26:44.234]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.234]                   NULL)
[17:26:44.234]                 if (is_error) {
[17:26:44.234]                   sessionInformation <- function() {
[17:26:44.234]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.234]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.234]                       search = base::search(), system = base::Sys.info())
[17:26:44.234]                   }
[17:26:44.234]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.234]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.234]                     cond$call), session = sessionInformation(), 
[17:26:44.234]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.234]                   signalCondition(cond)
[17:26:44.234]                 }
[17:26:44.234]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.234]                 "immediateCondition"))) {
[17:26:44.234]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.234]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.234]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.234]                   if (TRUE && !signal) {
[17:26:44.234]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.234]                     {
[17:26:44.234]                       inherits <- base::inherits
[17:26:44.234]                       invokeRestart <- base::invokeRestart
[17:26:44.234]                       is.null <- base::is.null
[17:26:44.234]                       muffled <- FALSE
[17:26:44.234]                       if (inherits(cond, "message")) {
[17:26:44.234]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.234]                         if (muffled) 
[17:26:44.234]                           invokeRestart("muffleMessage")
[17:26:44.234]                       }
[17:26:44.234]                       else if (inherits(cond, "warning")) {
[17:26:44.234]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.234]                         if (muffled) 
[17:26:44.234]                           invokeRestart("muffleWarning")
[17:26:44.234]                       }
[17:26:44.234]                       else if (inherits(cond, "condition")) {
[17:26:44.234]                         if (!is.null(pattern)) {
[17:26:44.234]                           computeRestarts <- base::computeRestarts
[17:26:44.234]                           grepl <- base::grepl
[17:26:44.234]                           restarts <- computeRestarts(cond)
[17:26:44.234]                           for (restart in restarts) {
[17:26:44.234]                             name <- restart$name
[17:26:44.234]                             if (is.null(name)) 
[17:26:44.234]                               next
[17:26:44.234]                             if (!grepl(pattern, name)) 
[17:26:44.234]                               next
[17:26:44.234]                             invokeRestart(restart)
[17:26:44.234]                             muffled <- TRUE
[17:26:44.234]                             break
[17:26:44.234]                           }
[17:26:44.234]                         }
[17:26:44.234]                       }
[17:26:44.234]                       invisible(muffled)
[17:26:44.234]                     }
[17:26:44.234]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.234]                   }
[17:26:44.234]                 }
[17:26:44.234]                 else {
[17:26:44.234]                   if (TRUE) {
[17:26:44.234]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.234]                     {
[17:26:44.234]                       inherits <- base::inherits
[17:26:44.234]                       invokeRestart <- base::invokeRestart
[17:26:44.234]                       is.null <- base::is.null
[17:26:44.234]                       muffled <- FALSE
[17:26:44.234]                       if (inherits(cond, "message")) {
[17:26:44.234]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.234]                         if (muffled) 
[17:26:44.234]                           invokeRestart("muffleMessage")
[17:26:44.234]                       }
[17:26:44.234]                       else if (inherits(cond, "warning")) {
[17:26:44.234]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.234]                         if (muffled) 
[17:26:44.234]                           invokeRestart("muffleWarning")
[17:26:44.234]                       }
[17:26:44.234]                       else if (inherits(cond, "condition")) {
[17:26:44.234]                         if (!is.null(pattern)) {
[17:26:44.234]                           computeRestarts <- base::computeRestarts
[17:26:44.234]                           grepl <- base::grepl
[17:26:44.234]                           restarts <- computeRestarts(cond)
[17:26:44.234]                           for (restart in restarts) {
[17:26:44.234]                             name <- restart$name
[17:26:44.234]                             if (is.null(name)) 
[17:26:44.234]                               next
[17:26:44.234]                             if (!grepl(pattern, name)) 
[17:26:44.234]                               next
[17:26:44.234]                             invokeRestart(restart)
[17:26:44.234]                             muffled <- TRUE
[17:26:44.234]                             break
[17:26:44.234]                           }
[17:26:44.234]                         }
[17:26:44.234]                       }
[17:26:44.234]                       invisible(muffled)
[17:26:44.234]                     }
[17:26:44.234]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.234]                   }
[17:26:44.234]                 }
[17:26:44.234]             }
[17:26:44.234]         }))
[17:26:44.234]     }, error = function(ex) {
[17:26:44.234]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.234]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.234]                 ...future.rng), started = ...future.startTime, 
[17:26:44.234]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.234]             version = "1.8"), class = "FutureResult")
[17:26:44.234]     }, finally = {
[17:26:44.234]         if (!identical(...future.workdir, getwd())) 
[17:26:44.234]             setwd(...future.workdir)
[17:26:44.234]         {
[17:26:44.234]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.234]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.234]             }
[17:26:44.234]             base::options(...future.oldOptions)
[17:26:44.234]             if (.Platform$OS.type == "windows") {
[17:26:44.234]                 old_names <- names(...future.oldEnvVars)
[17:26:44.234]                 envs <- base::Sys.getenv()
[17:26:44.234]                 names <- names(envs)
[17:26:44.234]                 common <- intersect(names, old_names)
[17:26:44.234]                 added <- setdiff(names, old_names)
[17:26:44.234]                 removed <- setdiff(old_names, names)
[17:26:44.234]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.234]                   envs[common]]
[17:26:44.234]                 NAMES <- toupper(changed)
[17:26:44.234]                 args <- list()
[17:26:44.234]                 for (kk in seq_along(NAMES)) {
[17:26:44.234]                   name <- changed[[kk]]
[17:26:44.234]                   NAME <- NAMES[[kk]]
[17:26:44.234]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.234]                     next
[17:26:44.234]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.234]                 }
[17:26:44.234]                 NAMES <- toupper(added)
[17:26:44.234]                 for (kk in seq_along(NAMES)) {
[17:26:44.234]                   name <- added[[kk]]
[17:26:44.234]                   NAME <- NAMES[[kk]]
[17:26:44.234]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.234]                     next
[17:26:44.234]                   args[[name]] <- ""
[17:26:44.234]                 }
[17:26:44.234]                 NAMES <- toupper(removed)
[17:26:44.234]                 for (kk in seq_along(NAMES)) {
[17:26:44.234]                   name <- removed[[kk]]
[17:26:44.234]                   NAME <- NAMES[[kk]]
[17:26:44.234]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.234]                     next
[17:26:44.234]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.234]                 }
[17:26:44.234]                 if (length(args) > 0) 
[17:26:44.234]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.234]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.234]             }
[17:26:44.234]             else {
[17:26:44.234]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.234]             }
[17:26:44.234]             {
[17:26:44.234]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.234]                   0L) {
[17:26:44.234]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.234]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.234]                   base::options(opts)
[17:26:44.234]                 }
[17:26:44.234]                 {
[17:26:44.234]                   {
[17:26:44.234]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.234]                     NULL
[17:26:44.234]                   }
[17:26:44.234]                   options(future.plan = NULL)
[17:26:44.234]                   if (is.na(NA_character_)) 
[17:26:44.234]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.234]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.234]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.234]                     .init = FALSE)
[17:26:44.234]                 }
[17:26:44.234]             }
[17:26:44.234]         }
[17:26:44.234]     })
[17:26:44.234]     if (TRUE) {
[17:26:44.234]         base::sink(type = "output", split = FALSE)
[17:26:44.234]         if (TRUE) {
[17:26:44.234]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.234]         }
[17:26:44.234]         else {
[17:26:44.234]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.234]         }
[17:26:44.234]         base::close(...future.stdout)
[17:26:44.234]         ...future.stdout <- NULL
[17:26:44.234]     }
[17:26:44.234]     ...future.result$conditions <- ...future.conditions
[17:26:44.234]     ...future.result$finished <- base::Sys.time()
[17:26:44.234]     ...future.result
[17:26:44.234] }
[17:26:44.314] MultisessionFuture started
[17:26:44.315] result() for ClusterFuture ...
[17:26:44.315] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.316] - Validating connection of MultisessionFuture
[17:26:44.367] - received message: FutureResult
[17:26:44.367] - Received FutureResult
[17:26:44.371] - Erased future from FutureRegistry
[17:26:44.371] result() for ClusterFuture ...
[17:26:44.371] - result already collected: FutureResult
[17:26:44.372] result() for ClusterFuture ... done
[17:26:44.372] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:44.372] result() for ClusterFuture ... done
[17:26:44.372] result() for ClusterFuture ...
[17:26:44.372] - result already collected: FutureResult
[17:26:44.372] result() for ClusterFuture ... done
[17:26:44.373] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:44.375] plan(): nbrOfWorkers() = 2
Dimensions: NULL
[17:26:44.376] getGlobalsAndPackages() ...
[17:26:44.376] Searching for globals...
[17:26:44.377] 
[17:26:44.377] Searching for globals ... DONE
[17:26:44.377] - globals: [0] <none>
[17:26:44.377] getGlobalsAndPackages() ... DONE
[17:26:44.378] run() for 'Future' ...
[17:26:44.378] - state: 'created'
[17:26:44.378] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.392] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.393] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.393]   - Field: 'node'
[17:26:44.393]   - Field: 'label'
[17:26:44.393]   - Field: 'local'
[17:26:44.393]   - Field: 'owner'
[17:26:44.394]   - Field: 'envir'
[17:26:44.394]   - Field: 'workers'
[17:26:44.394]   - Field: 'packages'
[17:26:44.394]   - Field: 'gc'
[17:26:44.394]   - Field: 'conditions'
[17:26:44.394]   - Field: 'persistent'
[17:26:44.395]   - Field: 'expr'
[17:26:44.395]   - Field: 'uuid'
[17:26:44.395]   - Field: 'seed'
[17:26:44.395]   - Field: 'version'
[17:26:44.395]   - Field: 'result'
[17:26:44.396]   - Field: 'asynchronous'
[17:26:44.396]   - Field: 'calls'
[17:26:44.396]   - Field: 'globals'
[17:26:44.396]   - Field: 'stdout'
[17:26:44.396]   - Field: 'earlySignal'
[17:26:44.397]   - Field: 'lazy'
[17:26:44.397]   - Field: 'state'
[17:26:44.397] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.397] - Launch lazy future ...
[17:26:44.398] Packages needed by the future expression (n = 0): <none>
[17:26:44.398] Packages needed by future strategies (n = 0): <none>
[17:26:44.398] {
[17:26:44.398]     {
[17:26:44.398]         {
[17:26:44.398]             ...future.startTime <- base::Sys.time()
[17:26:44.398]             {
[17:26:44.398]                 {
[17:26:44.398]                   {
[17:26:44.398]                     {
[17:26:44.398]                       base::local({
[17:26:44.398]                         has_future <- base::requireNamespace("future", 
[17:26:44.398]                           quietly = TRUE)
[17:26:44.398]                         if (has_future) {
[17:26:44.398]                           ns <- base::getNamespace("future")
[17:26:44.398]                           version <- ns[[".package"]][["version"]]
[17:26:44.398]                           if (is.null(version)) 
[17:26:44.398]                             version <- utils::packageVersion("future")
[17:26:44.398]                         }
[17:26:44.398]                         else {
[17:26:44.398]                           version <- NULL
[17:26:44.398]                         }
[17:26:44.398]                         if (!has_future || version < "1.8.0") {
[17:26:44.398]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.398]                             "", base::R.version$version.string), 
[17:26:44.398]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.398]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.398]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.398]                               "release", "version")], collapse = " "), 
[17:26:44.398]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.398]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.398]                             info)
[17:26:44.398]                           info <- base::paste(info, collapse = "; ")
[17:26:44.398]                           if (!has_future) {
[17:26:44.398]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.398]                               info)
[17:26:44.398]                           }
[17:26:44.398]                           else {
[17:26:44.398]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.398]                               info, version)
[17:26:44.398]                           }
[17:26:44.398]                           base::stop(msg)
[17:26:44.398]                         }
[17:26:44.398]                       })
[17:26:44.398]                     }
[17:26:44.398]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.398]                     base::options(mc.cores = 1L)
[17:26:44.398]                   }
[17:26:44.398]                   ...future.strategy.old <- future::plan("list")
[17:26:44.398]                   options(future.plan = NULL)
[17:26:44.398]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.398]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.398]                 }
[17:26:44.398]                 ...future.workdir <- getwd()
[17:26:44.398]             }
[17:26:44.398]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.398]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.398]         }
[17:26:44.398]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.398]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.398]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.398]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.398]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.398]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.398]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.398]             base::names(...future.oldOptions))
[17:26:44.398]     }
[17:26:44.398]     if (FALSE) {
[17:26:44.398]     }
[17:26:44.398]     else {
[17:26:44.398]         if (TRUE) {
[17:26:44.398]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.398]                 open = "w")
[17:26:44.398]         }
[17:26:44.398]         else {
[17:26:44.398]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.398]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.398]         }
[17:26:44.398]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.398]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.398]             base::sink(type = "output", split = FALSE)
[17:26:44.398]             base::close(...future.stdout)
[17:26:44.398]         }, add = TRUE)
[17:26:44.398]     }
[17:26:44.398]     ...future.frame <- base::sys.nframe()
[17:26:44.398]     ...future.conditions <- base::list()
[17:26:44.398]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.398]     if (FALSE) {
[17:26:44.398]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.398]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.398]     }
[17:26:44.398]     ...future.result <- base::tryCatch({
[17:26:44.398]         base::withCallingHandlers({
[17:26:44.398]             ...future.value <- base::withVisible(base::local({
[17:26:44.398]                 ...future.makeSendCondition <- base::local({
[17:26:44.398]                   sendCondition <- NULL
[17:26:44.398]                   function(frame = 1L) {
[17:26:44.398]                     if (is.function(sendCondition)) 
[17:26:44.398]                       return(sendCondition)
[17:26:44.398]                     ns <- getNamespace("parallel")
[17:26:44.398]                     if (exists("sendData", mode = "function", 
[17:26:44.398]                       envir = ns)) {
[17:26:44.398]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.398]                         envir = ns)
[17:26:44.398]                       envir <- sys.frame(frame)
[17:26:44.398]                       master <- NULL
[17:26:44.398]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.398]                         !identical(envir, emptyenv())) {
[17:26:44.398]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.398]                           inherits = FALSE)) {
[17:26:44.398]                           master <- get("master", mode = "list", 
[17:26:44.398]                             envir = envir, inherits = FALSE)
[17:26:44.398]                           if (inherits(master, c("SOCKnode", 
[17:26:44.398]                             "SOCK0node"))) {
[17:26:44.398]                             sendCondition <<- function(cond) {
[17:26:44.398]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.398]                                 success = TRUE)
[17:26:44.398]                               parallel_sendData(master, data)
[17:26:44.398]                             }
[17:26:44.398]                             return(sendCondition)
[17:26:44.398]                           }
[17:26:44.398]                         }
[17:26:44.398]                         frame <- frame + 1L
[17:26:44.398]                         envir <- sys.frame(frame)
[17:26:44.398]                       }
[17:26:44.398]                     }
[17:26:44.398]                     sendCondition <<- function(cond) NULL
[17:26:44.398]                   }
[17:26:44.398]                 })
[17:26:44.398]                 withCallingHandlers({
[17:26:44.398]                   2
[17:26:44.398]                 }, immediateCondition = function(cond) {
[17:26:44.398]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.398]                   sendCondition(cond)
[17:26:44.398]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.398]                   {
[17:26:44.398]                     inherits <- base::inherits
[17:26:44.398]                     invokeRestart <- base::invokeRestart
[17:26:44.398]                     is.null <- base::is.null
[17:26:44.398]                     muffled <- FALSE
[17:26:44.398]                     if (inherits(cond, "message")) {
[17:26:44.398]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.398]                       if (muffled) 
[17:26:44.398]                         invokeRestart("muffleMessage")
[17:26:44.398]                     }
[17:26:44.398]                     else if (inherits(cond, "warning")) {
[17:26:44.398]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.398]                       if (muffled) 
[17:26:44.398]                         invokeRestart("muffleWarning")
[17:26:44.398]                     }
[17:26:44.398]                     else if (inherits(cond, "condition")) {
[17:26:44.398]                       if (!is.null(pattern)) {
[17:26:44.398]                         computeRestarts <- base::computeRestarts
[17:26:44.398]                         grepl <- base::grepl
[17:26:44.398]                         restarts <- computeRestarts(cond)
[17:26:44.398]                         for (restart in restarts) {
[17:26:44.398]                           name <- restart$name
[17:26:44.398]                           if (is.null(name)) 
[17:26:44.398]                             next
[17:26:44.398]                           if (!grepl(pattern, name)) 
[17:26:44.398]                             next
[17:26:44.398]                           invokeRestart(restart)
[17:26:44.398]                           muffled <- TRUE
[17:26:44.398]                           break
[17:26:44.398]                         }
[17:26:44.398]                       }
[17:26:44.398]                     }
[17:26:44.398]                     invisible(muffled)
[17:26:44.398]                   }
[17:26:44.398]                   muffleCondition(cond)
[17:26:44.398]                 })
[17:26:44.398]             }))
[17:26:44.398]             future::FutureResult(value = ...future.value$value, 
[17:26:44.398]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.398]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.398]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.398]                     ...future.globalenv.names))
[17:26:44.398]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.398]         }, condition = base::local({
[17:26:44.398]             c <- base::c
[17:26:44.398]             inherits <- base::inherits
[17:26:44.398]             invokeRestart <- base::invokeRestart
[17:26:44.398]             length <- base::length
[17:26:44.398]             list <- base::list
[17:26:44.398]             seq.int <- base::seq.int
[17:26:44.398]             signalCondition <- base::signalCondition
[17:26:44.398]             sys.calls <- base::sys.calls
[17:26:44.398]             `[[` <- base::`[[`
[17:26:44.398]             `+` <- base::`+`
[17:26:44.398]             `<<-` <- base::`<<-`
[17:26:44.398]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.398]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.398]                   3L)]
[17:26:44.398]             }
[17:26:44.398]             function(cond) {
[17:26:44.398]                 is_error <- inherits(cond, "error")
[17:26:44.398]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.398]                   NULL)
[17:26:44.398]                 if (is_error) {
[17:26:44.398]                   sessionInformation <- function() {
[17:26:44.398]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.398]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.398]                       search = base::search(), system = base::Sys.info())
[17:26:44.398]                   }
[17:26:44.398]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.398]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.398]                     cond$call), session = sessionInformation(), 
[17:26:44.398]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.398]                   signalCondition(cond)
[17:26:44.398]                 }
[17:26:44.398]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.398]                 "immediateCondition"))) {
[17:26:44.398]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.398]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.398]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.398]                   if (TRUE && !signal) {
[17:26:44.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.398]                     {
[17:26:44.398]                       inherits <- base::inherits
[17:26:44.398]                       invokeRestart <- base::invokeRestart
[17:26:44.398]                       is.null <- base::is.null
[17:26:44.398]                       muffled <- FALSE
[17:26:44.398]                       if (inherits(cond, "message")) {
[17:26:44.398]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.398]                         if (muffled) 
[17:26:44.398]                           invokeRestart("muffleMessage")
[17:26:44.398]                       }
[17:26:44.398]                       else if (inherits(cond, "warning")) {
[17:26:44.398]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.398]                         if (muffled) 
[17:26:44.398]                           invokeRestart("muffleWarning")
[17:26:44.398]                       }
[17:26:44.398]                       else if (inherits(cond, "condition")) {
[17:26:44.398]                         if (!is.null(pattern)) {
[17:26:44.398]                           computeRestarts <- base::computeRestarts
[17:26:44.398]                           grepl <- base::grepl
[17:26:44.398]                           restarts <- computeRestarts(cond)
[17:26:44.398]                           for (restart in restarts) {
[17:26:44.398]                             name <- restart$name
[17:26:44.398]                             if (is.null(name)) 
[17:26:44.398]                               next
[17:26:44.398]                             if (!grepl(pattern, name)) 
[17:26:44.398]                               next
[17:26:44.398]                             invokeRestart(restart)
[17:26:44.398]                             muffled <- TRUE
[17:26:44.398]                             break
[17:26:44.398]                           }
[17:26:44.398]                         }
[17:26:44.398]                       }
[17:26:44.398]                       invisible(muffled)
[17:26:44.398]                     }
[17:26:44.398]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.398]                   }
[17:26:44.398]                 }
[17:26:44.398]                 else {
[17:26:44.398]                   if (TRUE) {
[17:26:44.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.398]                     {
[17:26:44.398]                       inherits <- base::inherits
[17:26:44.398]                       invokeRestart <- base::invokeRestart
[17:26:44.398]                       is.null <- base::is.null
[17:26:44.398]                       muffled <- FALSE
[17:26:44.398]                       if (inherits(cond, "message")) {
[17:26:44.398]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.398]                         if (muffled) 
[17:26:44.398]                           invokeRestart("muffleMessage")
[17:26:44.398]                       }
[17:26:44.398]                       else if (inherits(cond, "warning")) {
[17:26:44.398]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.398]                         if (muffled) 
[17:26:44.398]                           invokeRestart("muffleWarning")
[17:26:44.398]                       }
[17:26:44.398]                       else if (inherits(cond, "condition")) {
[17:26:44.398]                         if (!is.null(pattern)) {
[17:26:44.398]                           computeRestarts <- base::computeRestarts
[17:26:44.398]                           grepl <- base::grepl
[17:26:44.398]                           restarts <- computeRestarts(cond)
[17:26:44.398]                           for (restart in restarts) {
[17:26:44.398]                             name <- restart$name
[17:26:44.398]                             if (is.null(name)) 
[17:26:44.398]                               next
[17:26:44.398]                             if (!grepl(pattern, name)) 
[17:26:44.398]                               next
[17:26:44.398]                             invokeRestart(restart)
[17:26:44.398]                             muffled <- TRUE
[17:26:44.398]                             break
[17:26:44.398]                           }
[17:26:44.398]                         }
[17:26:44.398]                       }
[17:26:44.398]                       invisible(muffled)
[17:26:44.398]                     }
[17:26:44.398]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.398]                   }
[17:26:44.398]                 }
[17:26:44.398]             }
[17:26:44.398]         }))
[17:26:44.398]     }, error = function(ex) {
[17:26:44.398]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.398]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.398]                 ...future.rng), started = ...future.startTime, 
[17:26:44.398]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.398]             version = "1.8"), class = "FutureResult")
[17:26:44.398]     }, finally = {
[17:26:44.398]         if (!identical(...future.workdir, getwd())) 
[17:26:44.398]             setwd(...future.workdir)
[17:26:44.398]         {
[17:26:44.398]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.398]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.398]             }
[17:26:44.398]             base::options(...future.oldOptions)
[17:26:44.398]             if (.Platform$OS.type == "windows") {
[17:26:44.398]                 old_names <- names(...future.oldEnvVars)
[17:26:44.398]                 envs <- base::Sys.getenv()
[17:26:44.398]                 names <- names(envs)
[17:26:44.398]                 common <- intersect(names, old_names)
[17:26:44.398]                 added <- setdiff(names, old_names)
[17:26:44.398]                 removed <- setdiff(old_names, names)
[17:26:44.398]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.398]                   envs[common]]
[17:26:44.398]                 NAMES <- toupper(changed)
[17:26:44.398]                 args <- list()
[17:26:44.398]                 for (kk in seq_along(NAMES)) {
[17:26:44.398]                   name <- changed[[kk]]
[17:26:44.398]                   NAME <- NAMES[[kk]]
[17:26:44.398]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.398]                     next
[17:26:44.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.398]                 }
[17:26:44.398]                 NAMES <- toupper(added)
[17:26:44.398]                 for (kk in seq_along(NAMES)) {
[17:26:44.398]                   name <- added[[kk]]
[17:26:44.398]                   NAME <- NAMES[[kk]]
[17:26:44.398]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.398]                     next
[17:26:44.398]                   args[[name]] <- ""
[17:26:44.398]                 }
[17:26:44.398]                 NAMES <- toupper(removed)
[17:26:44.398]                 for (kk in seq_along(NAMES)) {
[17:26:44.398]                   name <- removed[[kk]]
[17:26:44.398]                   NAME <- NAMES[[kk]]
[17:26:44.398]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.398]                     next
[17:26:44.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.398]                 }
[17:26:44.398]                 if (length(args) > 0) 
[17:26:44.398]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.398]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.398]             }
[17:26:44.398]             else {
[17:26:44.398]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.398]             }
[17:26:44.398]             {
[17:26:44.398]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.398]                   0L) {
[17:26:44.398]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.398]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.398]                   base::options(opts)
[17:26:44.398]                 }
[17:26:44.398]                 {
[17:26:44.398]                   {
[17:26:44.398]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.398]                     NULL
[17:26:44.398]                   }
[17:26:44.398]                   options(future.plan = NULL)
[17:26:44.398]                   if (is.na(NA_character_)) 
[17:26:44.398]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.398]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.398]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.398]                     .init = FALSE)
[17:26:44.398]                 }
[17:26:44.398]             }
[17:26:44.398]         }
[17:26:44.398]     })
[17:26:44.398]     if (TRUE) {
[17:26:44.398]         base::sink(type = "output", split = FALSE)
[17:26:44.398]         if (TRUE) {
[17:26:44.398]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.398]         }
[17:26:44.398]         else {
[17:26:44.398]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.398]         }
[17:26:44.398]         base::close(...future.stdout)
[17:26:44.398]         ...future.stdout <- NULL
[17:26:44.398]     }
[17:26:44.398]     ...future.result$conditions <- ...future.conditions
[17:26:44.398]     ...future.result$finished <- base::Sys.time()
[17:26:44.398]     ...future.result
[17:26:44.398] }
[17:26:44.404] MultisessionFuture started
[17:26:44.405] - Launch lazy future ... done
[17:26:44.405] run() for 'MultisessionFuture' ... done
[17:26:44.405] getGlobalsAndPackages() ...
[17:26:44.405] Searching for globals...
[17:26:44.406] 
[17:26:44.406] Searching for globals ... DONE
[17:26:44.406] - globals: [0] <none>
[17:26:44.406] getGlobalsAndPackages() ... DONE
[17:26:44.407] run() for 'Future' ...
[17:26:44.407] - state: 'created'
[17:26:44.407] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.421] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.421] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.422]   - Field: 'node'
[17:26:44.422]   - Field: 'label'
[17:26:44.422]   - Field: 'local'
[17:26:44.422]   - Field: 'owner'
[17:26:44.422]   - Field: 'envir'
[17:26:44.423]   - Field: 'workers'
[17:26:44.423]   - Field: 'packages'
[17:26:44.423]   - Field: 'gc'
[17:26:44.423]   - Field: 'conditions'
[17:26:44.423]   - Field: 'persistent'
[17:26:44.424]   - Field: 'expr'
[17:26:44.424]   - Field: 'uuid'
[17:26:44.424]   - Field: 'seed'
[17:26:44.424]   - Field: 'version'
[17:26:44.424]   - Field: 'result'
[17:26:44.425]   - Field: 'asynchronous'
[17:26:44.425]   - Field: 'calls'
[17:26:44.425]   - Field: 'globals'
[17:26:44.425]   - Field: 'stdout'
[17:26:44.425]   - Field: 'earlySignal'
[17:26:44.426]   - Field: 'lazy'
[17:26:44.426]   - Field: 'state'
[17:26:44.426] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.426] - Launch lazy future ...
[17:26:44.427] Packages needed by the future expression (n = 0): <none>
[17:26:44.427] Packages needed by future strategies (n = 0): <none>
[17:26:44.427] {
[17:26:44.427]     {
[17:26:44.427]         {
[17:26:44.427]             ...future.startTime <- base::Sys.time()
[17:26:44.427]             {
[17:26:44.427]                 {
[17:26:44.427]                   {
[17:26:44.427]                     {
[17:26:44.427]                       base::local({
[17:26:44.427]                         has_future <- base::requireNamespace("future", 
[17:26:44.427]                           quietly = TRUE)
[17:26:44.427]                         if (has_future) {
[17:26:44.427]                           ns <- base::getNamespace("future")
[17:26:44.427]                           version <- ns[[".package"]][["version"]]
[17:26:44.427]                           if (is.null(version)) 
[17:26:44.427]                             version <- utils::packageVersion("future")
[17:26:44.427]                         }
[17:26:44.427]                         else {
[17:26:44.427]                           version <- NULL
[17:26:44.427]                         }
[17:26:44.427]                         if (!has_future || version < "1.8.0") {
[17:26:44.427]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.427]                             "", base::R.version$version.string), 
[17:26:44.427]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.427]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.427]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.427]                               "release", "version")], collapse = " "), 
[17:26:44.427]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.427]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.427]                             info)
[17:26:44.427]                           info <- base::paste(info, collapse = "; ")
[17:26:44.427]                           if (!has_future) {
[17:26:44.427]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.427]                               info)
[17:26:44.427]                           }
[17:26:44.427]                           else {
[17:26:44.427]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.427]                               info, version)
[17:26:44.427]                           }
[17:26:44.427]                           base::stop(msg)
[17:26:44.427]                         }
[17:26:44.427]                       })
[17:26:44.427]                     }
[17:26:44.427]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.427]                     base::options(mc.cores = 1L)
[17:26:44.427]                   }
[17:26:44.427]                   ...future.strategy.old <- future::plan("list")
[17:26:44.427]                   options(future.plan = NULL)
[17:26:44.427]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.427]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.427]                 }
[17:26:44.427]                 ...future.workdir <- getwd()
[17:26:44.427]             }
[17:26:44.427]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.427]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.427]         }
[17:26:44.427]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.427]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.427]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.427]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.427]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.427]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.427]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.427]             base::names(...future.oldOptions))
[17:26:44.427]     }
[17:26:44.427]     if (FALSE) {
[17:26:44.427]     }
[17:26:44.427]     else {
[17:26:44.427]         if (TRUE) {
[17:26:44.427]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.427]                 open = "w")
[17:26:44.427]         }
[17:26:44.427]         else {
[17:26:44.427]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.427]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.427]         }
[17:26:44.427]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.427]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.427]             base::sink(type = "output", split = FALSE)
[17:26:44.427]             base::close(...future.stdout)
[17:26:44.427]         }, add = TRUE)
[17:26:44.427]     }
[17:26:44.427]     ...future.frame <- base::sys.nframe()
[17:26:44.427]     ...future.conditions <- base::list()
[17:26:44.427]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.427]     if (FALSE) {
[17:26:44.427]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.427]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.427]     }
[17:26:44.427]     ...future.result <- base::tryCatch({
[17:26:44.427]         base::withCallingHandlers({
[17:26:44.427]             ...future.value <- base::withVisible(base::local({
[17:26:44.427]                 ...future.makeSendCondition <- base::local({
[17:26:44.427]                   sendCondition <- NULL
[17:26:44.427]                   function(frame = 1L) {
[17:26:44.427]                     if (is.function(sendCondition)) 
[17:26:44.427]                       return(sendCondition)
[17:26:44.427]                     ns <- getNamespace("parallel")
[17:26:44.427]                     if (exists("sendData", mode = "function", 
[17:26:44.427]                       envir = ns)) {
[17:26:44.427]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.427]                         envir = ns)
[17:26:44.427]                       envir <- sys.frame(frame)
[17:26:44.427]                       master <- NULL
[17:26:44.427]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.427]                         !identical(envir, emptyenv())) {
[17:26:44.427]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.427]                           inherits = FALSE)) {
[17:26:44.427]                           master <- get("master", mode = "list", 
[17:26:44.427]                             envir = envir, inherits = FALSE)
[17:26:44.427]                           if (inherits(master, c("SOCKnode", 
[17:26:44.427]                             "SOCK0node"))) {
[17:26:44.427]                             sendCondition <<- function(cond) {
[17:26:44.427]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.427]                                 success = TRUE)
[17:26:44.427]                               parallel_sendData(master, data)
[17:26:44.427]                             }
[17:26:44.427]                             return(sendCondition)
[17:26:44.427]                           }
[17:26:44.427]                         }
[17:26:44.427]                         frame <- frame + 1L
[17:26:44.427]                         envir <- sys.frame(frame)
[17:26:44.427]                       }
[17:26:44.427]                     }
[17:26:44.427]                     sendCondition <<- function(cond) NULL
[17:26:44.427]                   }
[17:26:44.427]                 })
[17:26:44.427]                 withCallingHandlers({
[17:26:44.427]                   NULL
[17:26:44.427]                 }, immediateCondition = function(cond) {
[17:26:44.427]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.427]                   sendCondition(cond)
[17:26:44.427]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.427]                   {
[17:26:44.427]                     inherits <- base::inherits
[17:26:44.427]                     invokeRestart <- base::invokeRestart
[17:26:44.427]                     is.null <- base::is.null
[17:26:44.427]                     muffled <- FALSE
[17:26:44.427]                     if (inherits(cond, "message")) {
[17:26:44.427]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.427]                       if (muffled) 
[17:26:44.427]                         invokeRestart("muffleMessage")
[17:26:44.427]                     }
[17:26:44.427]                     else if (inherits(cond, "warning")) {
[17:26:44.427]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.427]                       if (muffled) 
[17:26:44.427]                         invokeRestart("muffleWarning")
[17:26:44.427]                     }
[17:26:44.427]                     else if (inherits(cond, "condition")) {
[17:26:44.427]                       if (!is.null(pattern)) {
[17:26:44.427]                         computeRestarts <- base::computeRestarts
[17:26:44.427]                         grepl <- base::grepl
[17:26:44.427]                         restarts <- computeRestarts(cond)
[17:26:44.427]                         for (restart in restarts) {
[17:26:44.427]                           name <- restart$name
[17:26:44.427]                           if (is.null(name)) 
[17:26:44.427]                             next
[17:26:44.427]                           if (!grepl(pattern, name)) 
[17:26:44.427]                             next
[17:26:44.427]                           invokeRestart(restart)
[17:26:44.427]                           muffled <- TRUE
[17:26:44.427]                           break
[17:26:44.427]                         }
[17:26:44.427]                       }
[17:26:44.427]                     }
[17:26:44.427]                     invisible(muffled)
[17:26:44.427]                   }
[17:26:44.427]                   muffleCondition(cond)
[17:26:44.427]                 })
[17:26:44.427]             }))
[17:26:44.427]             future::FutureResult(value = ...future.value$value, 
[17:26:44.427]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.427]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.427]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.427]                     ...future.globalenv.names))
[17:26:44.427]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.427]         }, condition = base::local({
[17:26:44.427]             c <- base::c
[17:26:44.427]             inherits <- base::inherits
[17:26:44.427]             invokeRestart <- base::invokeRestart
[17:26:44.427]             length <- base::length
[17:26:44.427]             list <- base::list
[17:26:44.427]             seq.int <- base::seq.int
[17:26:44.427]             signalCondition <- base::signalCondition
[17:26:44.427]             sys.calls <- base::sys.calls
[17:26:44.427]             `[[` <- base::`[[`
[17:26:44.427]             `+` <- base::`+`
[17:26:44.427]             `<<-` <- base::`<<-`
[17:26:44.427]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.427]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.427]                   3L)]
[17:26:44.427]             }
[17:26:44.427]             function(cond) {
[17:26:44.427]                 is_error <- inherits(cond, "error")
[17:26:44.427]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.427]                   NULL)
[17:26:44.427]                 if (is_error) {
[17:26:44.427]                   sessionInformation <- function() {
[17:26:44.427]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.427]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.427]                       search = base::search(), system = base::Sys.info())
[17:26:44.427]                   }
[17:26:44.427]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.427]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.427]                     cond$call), session = sessionInformation(), 
[17:26:44.427]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.427]                   signalCondition(cond)
[17:26:44.427]                 }
[17:26:44.427]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.427]                 "immediateCondition"))) {
[17:26:44.427]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.427]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.427]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.427]                   if (TRUE && !signal) {
[17:26:44.427]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.427]                     {
[17:26:44.427]                       inherits <- base::inherits
[17:26:44.427]                       invokeRestart <- base::invokeRestart
[17:26:44.427]                       is.null <- base::is.null
[17:26:44.427]                       muffled <- FALSE
[17:26:44.427]                       if (inherits(cond, "message")) {
[17:26:44.427]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.427]                         if (muffled) 
[17:26:44.427]                           invokeRestart("muffleMessage")
[17:26:44.427]                       }
[17:26:44.427]                       else if (inherits(cond, "warning")) {
[17:26:44.427]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.427]                         if (muffled) 
[17:26:44.427]                           invokeRestart("muffleWarning")
[17:26:44.427]                       }
[17:26:44.427]                       else if (inherits(cond, "condition")) {
[17:26:44.427]                         if (!is.null(pattern)) {
[17:26:44.427]                           computeRestarts <- base::computeRestarts
[17:26:44.427]                           grepl <- base::grepl
[17:26:44.427]                           restarts <- computeRestarts(cond)
[17:26:44.427]                           for (restart in restarts) {
[17:26:44.427]                             name <- restart$name
[17:26:44.427]                             if (is.null(name)) 
[17:26:44.427]                               next
[17:26:44.427]                             if (!grepl(pattern, name)) 
[17:26:44.427]                               next
[17:26:44.427]                             invokeRestart(restart)
[17:26:44.427]                             muffled <- TRUE
[17:26:44.427]                             break
[17:26:44.427]                           }
[17:26:44.427]                         }
[17:26:44.427]                       }
[17:26:44.427]                       invisible(muffled)
[17:26:44.427]                     }
[17:26:44.427]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.427]                   }
[17:26:44.427]                 }
[17:26:44.427]                 else {
[17:26:44.427]                   if (TRUE) {
[17:26:44.427]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.427]                     {
[17:26:44.427]                       inherits <- base::inherits
[17:26:44.427]                       invokeRestart <- base::invokeRestart
[17:26:44.427]                       is.null <- base::is.null
[17:26:44.427]                       muffled <- FALSE
[17:26:44.427]                       if (inherits(cond, "message")) {
[17:26:44.427]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.427]                         if (muffled) 
[17:26:44.427]                           invokeRestart("muffleMessage")
[17:26:44.427]                       }
[17:26:44.427]                       else if (inherits(cond, "warning")) {
[17:26:44.427]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.427]                         if (muffled) 
[17:26:44.427]                           invokeRestart("muffleWarning")
[17:26:44.427]                       }
[17:26:44.427]                       else if (inherits(cond, "condition")) {
[17:26:44.427]                         if (!is.null(pattern)) {
[17:26:44.427]                           computeRestarts <- base::computeRestarts
[17:26:44.427]                           grepl <- base::grepl
[17:26:44.427]                           restarts <- computeRestarts(cond)
[17:26:44.427]                           for (restart in restarts) {
[17:26:44.427]                             name <- restart$name
[17:26:44.427]                             if (is.null(name)) 
[17:26:44.427]                               next
[17:26:44.427]                             if (!grepl(pattern, name)) 
[17:26:44.427]                               next
[17:26:44.427]                             invokeRestart(restart)
[17:26:44.427]                             muffled <- TRUE
[17:26:44.427]                             break
[17:26:44.427]                           }
[17:26:44.427]                         }
[17:26:44.427]                       }
[17:26:44.427]                       invisible(muffled)
[17:26:44.427]                     }
[17:26:44.427]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.427]                   }
[17:26:44.427]                 }
[17:26:44.427]             }
[17:26:44.427]         }))
[17:26:44.427]     }, error = function(ex) {
[17:26:44.427]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.427]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.427]                 ...future.rng), started = ...future.startTime, 
[17:26:44.427]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.427]             version = "1.8"), class = "FutureResult")
[17:26:44.427]     }, finally = {
[17:26:44.427]         if (!identical(...future.workdir, getwd())) 
[17:26:44.427]             setwd(...future.workdir)
[17:26:44.427]         {
[17:26:44.427]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.427]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.427]             }
[17:26:44.427]             base::options(...future.oldOptions)
[17:26:44.427]             if (.Platform$OS.type == "windows") {
[17:26:44.427]                 old_names <- names(...future.oldEnvVars)
[17:26:44.427]                 envs <- base::Sys.getenv()
[17:26:44.427]                 names <- names(envs)
[17:26:44.427]                 common <- intersect(names, old_names)
[17:26:44.427]                 added <- setdiff(names, old_names)
[17:26:44.427]                 removed <- setdiff(old_names, names)
[17:26:44.427]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.427]                   envs[common]]
[17:26:44.427]                 NAMES <- toupper(changed)
[17:26:44.427]                 args <- list()
[17:26:44.427]                 for (kk in seq_along(NAMES)) {
[17:26:44.427]                   name <- changed[[kk]]
[17:26:44.427]                   NAME <- NAMES[[kk]]
[17:26:44.427]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.427]                     next
[17:26:44.427]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.427]                 }
[17:26:44.427]                 NAMES <- toupper(added)
[17:26:44.427]                 for (kk in seq_along(NAMES)) {
[17:26:44.427]                   name <- added[[kk]]
[17:26:44.427]                   NAME <- NAMES[[kk]]
[17:26:44.427]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.427]                     next
[17:26:44.427]                   args[[name]] <- ""
[17:26:44.427]                 }
[17:26:44.427]                 NAMES <- toupper(removed)
[17:26:44.427]                 for (kk in seq_along(NAMES)) {
[17:26:44.427]                   name <- removed[[kk]]
[17:26:44.427]                   NAME <- NAMES[[kk]]
[17:26:44.427]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.427]                     next
[17:26:44.427]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.427]                 }
[17:26:44.427]                 if (length(args) > 0) 
[17:26:44.427]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.427]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.427]             }
[17:26:44.427]             else {
[17:26:44.427]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.427]             }
[17:26:44.427]             {
[17:26:44.427]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.427]                   0L) {
[17:26:44.427]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.427]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.427]                   base::options(opts)
[17:26:44.427]                 }
[17:26:44.427]                 {
[17:26:44.427]                   {
[17:26:44.427]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.427]                     NULL
[17:26:44.427]                   }
[17:26:44.427]                   options(future.plan = NULL)
[17:26:44.427]                   if (is.na(NA_character_)) 
[17:26:44.427]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.427]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.427]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.427]                     .init = FALSE)
[17:26:44.427]                 }
[17:26:44.427]             }
[17:26:44.427]         }
[17:26:44.427]     })
[17:26:44.427]     if (TRUE) {
[17:26:44.427]         base::sink(type = "output", split = FALSE)
[17:26:44.427]         if (TRUE) {
[17:26:44.427]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.427]         }
[17:26:44.427]         else {
[17:26:44.427]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.427]         }
[17:26:44.427]         base::close(...future.stdout)
[17:26:44.427]         ...future.stdout <- NULL
[17:26:44.427]     }
[17:26:44.427]     ...future.result$conditions <- ...future.conditions
[17:26:44.427]     ...future.result$finished <- base::Sys.time()
[17:26:44.427]     ...future.result
[17:26:44.427] }
[17:26:44.510] MultisessionFuture started
[17:26:44.511] - Launch lazy future ... done
[17:26:44.511] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230fd339c8> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002231027bd18> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230fd339c8> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002231027bd18> 
 $  : NULL
 $  : NULL
 $  : num 6
[17:26:44.517] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.518] - Validating connection of MultisessionFuture
[17:26:44.518] - received message: FutureResult
[17:26:44.518] - Received FutureResult
[17:26:44.518] - Erased future from FutureRegistry
[17:26:44.519] result() for ClusterFuture ...
[17:26:44.519] - result already collected: FutureResult
[17:26:44.519] result() for ClusterFuture ... done
[17:26:44.519] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:44.563] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.563] - Validating connection of MultisessionFuture
[17:26:44.563] - received message: FutureResult
[17:26:44.564] - Received FutureResult
[17:26:44.564] - Erased future from FutureRegistry
[17:26:44.564] result() for ClusterFuture ...
[17:26:44.564] - result already collected: FutureResult
[17:26:44.564] result() for ClusterFuture ... done
[17:26:44.565] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:44.566] resolve() on list ...
[17:26:44.566]  recursive: 0
[17:26:44.566]  length: 6
[17:26:44.566]  elements: 'a', 'b', 'c', '', '', ''
[17:26:44.567] signalConditionsASAP(numeric, pos=1) ...
[17:26:44.567] - nx: 6
[17:26:44.567] - relay: TRUE
[17:26:44.567] - stdout: TRUE
[17:26:44.567] - signal: TRUE
[17:26:44.567] - resignal: FALSE
[17:26:44.568] - force: TRUE
[17:26:44.568] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.568] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.568]  - until=2
[17:26:44.568]  - relaying element #2
[17:26:44.569] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.569] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.569] signalConditionsASAP(NULL, pos=1) ... done
[17:26:44.569]  length: 5 (resolved future 1)
[17:26:44.569] Future #2
[17:26:44.570] result() for ClusterFuture ...
[17:26:44.570] - result already collected: FutureResult
[17:26:44.570] result() for ClusterFuture ... done
[17:26:44.570] result() for ClusterFuture ...
[17:26:44.570] - result already collected: FutureResult
[17:26:44.570] result() for ClusterFuture ... done
[17:26:44.571] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:44.571] - nx: 6
[17:26:44.571] - relay: TRUE
[17:26:44.571] - stdout: TRUE
[17:26:44.571] - signal: TRUE
[17:26:44.571] - resignal: FALSE
[17:26:44.572] - force: TRUE
[17:26:44.572] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.572] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.572]  - until=2
[17:26:44.572]  - relaying element #2
[17:26:44.573] result() for ClusterFuture ...
[17:26:44.573] - result already collected: FutureResult
[17:26:44.573] result() for ClusterFuture ... done
[17:26:44.573] result() for ClusterFuture ...
[17:26:44.573] - result already collected: FutureResult
[17:26:44.573] result() for ClusterFuture ... done
[17:26:44.574] result() for ClusterFuture ...
[17:26:44.574] - result already collected: FutureResult
[17:26:44.574] result() for ClusterFuture ... done
[17:26:44.574] result() for ClusterFuture ...
[17:26:44.574] - result already collected: FutureResult
[17:26:44.575] result() for ClusterFuture ... done
[17:26:44.575] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.575] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.575] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:44.575]  length: 4 (resolved future 2)
[17:26:44.575] Future #3
[17:26:44.576] result() for ClusterFuture ...
[17:26:44.576] - result already collected: FutureResult
[17:26:44.576] result() for ClusterFuture ... done
[17:26:44.576] result() for ClusterFuture ...
[17:26:44.576] - result already collected: FutureResult
[17:26:44.577] result() for ClusterFuture ... done
[17:26:44.577] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:44.577] - nx: 6
[17:26:44.577] - relay: TRUE
[17:26:44.577] - stdout: TRUE
[17:26:44.577] - signal: TRUE
[17:26:44.578] - resignal: FALSE
[17:26:44.578] - force: TRUE
[17:26:44.578] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.578] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.578]  - until=3
[17:26:44.578]  - relaying element #3
[17:26:44.579] result() for ClusterFuture ...
[17:26:44.579] - result already collected: FutureResult
[17:26:44.579] result() for ClusterFuture ... done
[17:26:44.579] result() for ClusterFuture ...
[17:26:44.579] - result already collected: FutureResult
[17:26:44.580] result() for ClusterFuture ... done
[17:26:44.580] result() for ClusterFuture ...
[17:26:44.580] - result already collected: FutureResult
[17:26:44.580] result() for ClusterFuture ... done
[17:26:44.580] result() for ClusterFuture ...
[17:26:44.581] - result already collected: FutureResult
[17:26:44.581] result() for ClusterFuture ... done
[17:26:44.581] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.581] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.581] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:44.581]  length: 3 (resolved future 3)
[17:26:44.582] signalConditionsASAP(NULL, pos=4) ...
[17:26:44.582] - nx: 6
[17:26:44.582] - relay: TRUE
[17:26:44.582] - stdout: TRUE
[17:26:44.582] - signal: TRUE
[17:26:44.583] - resignal: FALSE
[17:26:44.583] - force: TRUE
[17:26:44.583] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.583] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.583]  - until=5
[17:26:44.583]  - relaying element #5
[17:26:44.584] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.584] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.584] signalConditionsASAP(NULL, pos=4) ... done
[17:26:44.584]  length: 2 (resolved future 4)
[17:26:44.584] signalConditionsASAP(NULL, pos=5) ...
[17:26:44.584] - nx: 6
[17:26:44.585] - relay: TRUE
[17:26:44.585] - stdout: TRUE
[17:26:44.585] - signal: TRUE
[17:26:44.585] - resignal: FALSE
[17:26:44.585] - force: TRUE
[17:26:44.585] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.586] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.586]  - until=6
[17:26:44.586]  - relaying element #6
[17:26:44.586] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.586] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.587] signalConditionsASAP(NULL, pos=5) ... done
[17:26:44.587]  length: 1 (resolved future 5)
[17:26:44.587] signalConditionsASAP(numeric, pos=6) ...
[17:26:44.587] - nx: 6
[17:26:44.587] - relay: TRUE
[17:26:44.587] - stdout: TRUE
[17:26:44.588] - signal: TRUE
[17:26:44.588] - resignal: FALSE
[17:26:44.588] - force: TRUE
[17:26:44.588] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.588] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.588]  - until=6
[17:26:44.589] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.589] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.589] signalConditionsASAP(numeric, pos=6) ... done
[17:26:44.589]  length: 0 (resolved future 6)
[17:26:44.589] Relaying remaining futures
[17:26:44.590] signalConditionsASAP(NULL, pos=0) ...
[17:26:44.590] - nx: 6
[17:26:44.590] - relay: TRUE
[17:26:44.590] - stdout: TRUE
[17:26:44.593] - signal: TRUE
[17:26:44.593] - resignal: FALSE
[17:26:44.593] - force: TRUE
[17:26:44.593] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.593] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:44.594] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.594] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.594] signalConditionsASAP(NULL, pos=0) ... done
[17:26:44.594] resolve() on list ... DONE
[17:26:44.594] result() for ClusterFuture ...
[17:26:44.594] - result already collected: FutureResult
[17:26:44.594] result() for ClusterFuture ... done
[17:26:44.595] result() for ClusterFuture ...
[17:26:44.595] - result already collected: FutureResult
[17:26:44.595] result() for ClusterFuture ... done
[17:26:44.595] result() for ClusterFuture ...
[17:26:44.595] - result already collected: FutureResult
[17:26:44.595] result() for ClusterFuture ... done
[17:26:44.596] result() for ClusterFuture ...
[17:26:44.596] - result already collected: FutureResult
[17:26:44.596] result() for ClusterFuture ... done
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
Dimensions: c(1, 6)
[17:26:44.598] getGlobalsAndPackages() ...
[17:26:44.599] Searching for globals...
[17:26:44.599] 
[17:26:44.599] Searching for globals ... DONE
[17:26:44.599] - globals: [0] <none>
[17:26:44.599] getGlobalsAndPackages() ... DONE
[17:26:44.600] run() for 'Future' ...
[17:26:44.600] - state: 'created'
[17:26:44.600] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.614] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.615] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.615]   - Field: 'node'
[17:26:44.615]   - Field: 'label'
[17:26:44.615]   - Field: 'local'
[17:26:44.615]   - Field: 'owner'
[17:26:44.616]   - Field: 'envir'
[17:26:44.616]   - Field: 'workers'
[17:26:44.616]   - Field: 'packages'
[17:26:44.616]   - Field: 'gc'
[17:26:44.616]   - Field: 'conditions'
[17:26:44.617]   - Field: 'persistent'
[17:26:44.617]   - Field: 'expr'
[17:26:44.617]   - Field: 'uuid'
[17:26:44.617]   - Field: 'seed'
[17:26:44.617]   - Field: 'version'
[17:26:44.617]   - Field: 'result'
[17:26:44.618]   - Field: 'asynchronous'
[17:26:44.618]   - Field: 'calls'
[17:26:44.618]   - Field: 'globals'
[17:26:44.618]   - Field: 'stdout'
[17:26:44.618]   - Field: 'earlySignal'
[17:26:44.618]   - Field: 'lazy'
[17:26:44.619]   - Field: 'state'
[17:26:44.619] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.619] - Launch lazy future ...
[17:26:44.619] Packages needed by the future expression (n = 0): <none>
[17:26:44.620] Packages needed by future strategies (n = 0): <none>
[17:26:44.620] {
[17:26:44.620]     {
[17:26:44.620]         {
[17:26:44.620]             ...future.startTime <- base::Sys.time()
[17:26:44.620]             {
[17:26:44.620]                 {
[17:26:44.620]                   {
[17:26:44.620]                     {
[17:26:44.620]                       base::local({
[17:26:44.620]                         has_future <- base::requireNamespace("future", 
[17:26:44.620]                           quietly = TRUE)
[17:26:44.620]                         if (has_future) {
[17:26:44.620]                           ns <- base::getNamespace("future")
[17:26:44.620]                           version <- ns[[".package"]][["version"]]
[17:26:44.620]                           if (is.null(version)) 
[17:26:44.620]                             version <- utils::packageVersion("future")
[17:26:44.620]                         }
[17:26:44.620]                         else {
[17:26:44.620]                           version <- NULL
[17:26:44.620]                         }
[17:26:44.620]                         if (!has_future || version < "1.8.0") {
[17:26:44.620]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.620]                             "", base::R.version$version.string), 
[17:26:44.620]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.620]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.620]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.620]                               "release", "version")], collapse = " "), 
[17:26:44.620]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.620]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.620]                             info)
[17:26:44.620]                           info <- base::paste(info, collapse = "; ")
[17:26:44.620]                           if (!has_future) {
[17:26:44.620]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.620]                               info)
[17:26:44.620]                           }
[17:26:44.620]                           else {
[17:26:44.620]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.620]                               info, version)
[17:26:44.620]                           }
[17:26:44.620]                           base::stop(msg)
[17:26:44.620]                         }
[17:26:44.620]                       })
[17:26:44.620]                     }
[17:26:44.620]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.620]                     base::options(mc.cores = 1L)
[17:26:44.620]                   }
[17:26:44.620]                   ...future.strategy.old <- future::plan("list")
[17:26:44.620]                   options(future.plan = NULL)
[17:26:44.620]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.620]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.620]                 }
[17:26:44.620]                 ...future.workdir <- getwd()
[17:26:44.620]             }
[17:26:44.620]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.620]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.620]         }
[17:26:44.620]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.620]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.620]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.620]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.620]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.620]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.620]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.620]             base::names(...future.oldOptions))
[17:26:44.620]     }
[17:26:44.620]     if (FALSE) {
[17:26:44.620]     }
[17:26:44.620]     else {
[17:26:44.620]         if (TRUE) {
[17:26:44.620]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.620]                 open = "w")
[17:26:44.620]         }
[17:26:44.620]         else {
[17:26:44.620]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.620]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.620]         }
[17:26:44.620]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.620]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.620]             base::sink(type = "output", split = FALSE)
[17:26:44.620]             base::close(...future.stdout)
[17:26:44.620]         }, add = TRUE)
[17:26:44.620]     }
[17:26:44.620]     ...future.frame <- base::sys.nframe()
[17:26:44.620]     ...future.conditions <- base::list()
[17:26:44.620]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.620]     if (FALSE) {
[17:26:44.620]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.620]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.620]     }
[17:26:44.620]     ...future.result <- base::tryCatch({
[17:26:44.620]         base::withCallingHandlers({
[17:26:44.620]             ...future.value <- base::withVisible(base::local({
[17:26:44.620]                 ...future.makeSendCondition <- base::local({
[17:26:44.620]                   sendCondition <- NULL
[17:26:44.620]                   function(frame = 1L) {
[17:26:44.620]                     if (is.function(sendCondition)) 
[17:26:44.620]                       return(sendCondition)
[17:26:44.620]                     ns <- getNamespace("parallel")
[17:26:44.620]                     if (exists("sendData", mode = "function", 
[17:26:44.620]                       envir = ns)) {
[17:26:44.620]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.620]                         envir = ns)
[17:26:44.620]                       envir <- sys.frame(frame)
[17:26:44.620]                       master <- NULL
[17:26:44.620]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.620]                         !identical(envir, emptyenv())) {
[17:26:44.620]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.620]                           inherits = FALSE)) {
[17:26:44.620]                           master <- get("master", mode = "list", 
[17:26:44.620]                             envir = envir, inherits = FALSE)
[17:26:44.620]                           if (inherits(master, c("SOCKnode", 
[17:26:44.620]                             "SOCK0node"))) {
[17:26:44.620]                             sendCondition <<- function(cond) {
[17:26:44.620]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.620]                                 success = TRUE)
[17:26:44.620]                               parallel_sendData(master, data)
[17:26:44.620]                             }
[17:26:44.620]                             return(sendCondition)
[17:26:44.620]                           }
[17:26:44.620]                         }
[17:26:44.620]                         frame <- frame + 1L
[17:26:44.620]                         envir <- sys.frame(frame)
[17:26:44.620]                       }
[17:26:44.620]                     }
[17:26:44.620]                     sendCondition <<- function(cond) NULL
[17:26:44.620]                   }
[17:26:44.620]                 })
[17:26:44.620]                 withCallingHandlers({
[17:26:44.620]                   2
[17:26:44.620]                 }, immediateCondition = function(cond) {
[17:26:44.620]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.620]                   sendCondition(cond)
[17:26:44.620]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.620]                   {
[17:26:44.620]                     inherits <- base::inherits
[17:26:44.620]                     invokeRestart <- base::invokeRestart
[17:26:44.620]                     is.null <- base::is.null
[17:26:44.620]                     muffled <- FALSE
[17:26:44.620]                     if (inherits(cond, "message")) {
[17:26:44.620]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.620]                       if (muffled) 
[17:26:44.620]                         invokeRestart("muffleMessage")
[17:26:44.620]                     }
[17:26:44.620]                     else if (inherits(cond, "warning")) {
[17:26:44.620]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.620]                       if (muffled) 
[17:26:44.620]                         invokeRestart("muffleWarning")
[17:26:44.620]                     }
[17:26:44.620]                     else if (inherits(cond, "condition")) {
[17:26:44.620]                       if (!is.null(pattern)) {
[17:26:44.620]                         computeRestarts <- base::computeRestarts
[17:26:44.620]                         grepl <- base::grepl
[17:26:44.620]                         restarts <- computeRestarts(cond)
[17:26:44.620]                         for (restart in restarts) {
[17:26:44.620]                           name <- restart$name
[17:26:44.620]                           if (is.null(name)) 
[17:26:44.620]                             next
[17:26:44.620]                           if (!grepl(pattern, name)) 
[17:26:44.620]                             next
[17:26:44.620]                           invokeRestart(restart)
[17:26:44.620]                           muffled <- TRUE
[17:26:44.620]                           break
[17:26:44.620]                         }
[17:26:44.620]                       }
[17:26:44.620]                     }
[17:26:44.620]                     invisible(muffled)
[17:26:44.620]                   }
[17:26:44.620]                   muffleCondition(cond)
[17:26:44.620]                 })
[17:26:44.620]             }))
[17:26:44.620]             future::FutureResult(value = ...future.value$value, 
[17:26:44.620]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.620]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.620]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.620]                     ...future.globalenv.names))
[17:26:44.620]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.620]         }, condition = base::local({
[17:26:44.620]             c <- base::c
[17:26:44.620]             inherits <- base::inherits
[17:26:44.620]             invokeRestart <- base::invokeRestart
[17:26:44.620]             length <- base::length
[17:26:44.620]             list <- base::list
[17:26:44.620]             seq.int <- base::seq.int
[17:26:44.620]             signalCondition <- base::signalCondition
[17:26:44.620]             sys.calls <- base::sys.calls
[17:26:44.620]             `[[` <- base::`[[`
[17:26:44.620]             `+` <- base::`+`
[17:26:44.620]             `<<-` <- base::`<<-`
[17:26:44.620]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.620]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.620]                   3L)]
[17:26:44.620]             }
[17:26:44.620]             function(cond) {
[17:26:44.620]                 is_error <- inherits(cond, "error")
[17:26:44.620]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.620]                   NULL)
[17:26:44.620]                 if (is_error) {
[17:26:44.620]                   sessionInformation <- function() {
[17:26:44.620]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.620]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.620]                       search = base::search(), system = base::Sys.info())
[17:26:44.620]                   }
[17:26:44.620]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.620]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.620]                     cond$call), session = sessionInformation(), 
[17:26:44.620]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.620]                   signalCondition(cond)
[17:26:44.620]                 }
[17:26:44.620]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.620]                 "immediateCondition"))) {
[17:26:44.620]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.620]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.620]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.620]                   if (TRUE && !signal) {
[17:26:44.620]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.620]                     {
[17:26:44.620]                       inherits <- base::inherits
[17:26:44.620]                       invokeRestart <- base::invokeRestart
[17:26:44.620]                       is.null <- base::is.null
[17:26:44.620]                       muffled <- FALSE
[17:26:44.620]                       if (inherits(cond, "message")) {
[17:26:44.620]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.620]                         if (muffled) 
[17:26:44.620]                           invokeRestart("muffleMessage")
[17:26:44.620]                       }
[17:26:44.620]                       else if (inherits(cond, "warning")) {
[17:26:44.620]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.620]                         if (muffled) 
[17:26:44.620]                           invokeRestart("muffleWarning")
[17:26:44.620]                       }
[17:26:44.620]                       else if (inherits(cond, "condition")) {
[17:26:44.620]                         if (!is.null(pattern)) {
[17:26:44.620]                           computeRestarts <- base::computeRestarts
[17:26:44.620]                           grepl <- base::grepl
[17:26:44.620]                           restarts <- computeRestarts(cond)
[17:26:44.620]                           for (restart in restarts) {
[17:26:44.620]                             name <- restart$name
[17:26:44.620]                             if (is.null(name)) 
[17:26:44.620]                               next
[17:26:44.620]                             if (!grepl(pattern, name)) 
[17:26:44.620]                               next
[17:26:44.620]                             invokeRestart(restart)
[17:26:44.620]                             muffled <- TRUE
[17:26:44.620]                             break
[17:26:44.620]                           }
[17:26:44.620]                         }
[17:26:44.620]                       }
[17:26:44.620]                       invisible(muffled)
[17:26:44.620]                     }
[17:26:44.620]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.620]                   }
[17:26:44.620]                 }
[17:26:44.620]                 else {
[17:26:44.620]                   if (TRUE) {
[17:26:44.620]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.620]                     {
[17:26:44.620]                       inherits <- base::inherits
[17:26:44.620]                       invokeRestart <- base::invokeRestart
[17:26:44.620]                       is.null <- base::is.null
[17:26:44.620]                       muffled <- FALSE
[17:26:44.620]                       if (inherits(cond, "message")) {
[17:26:44.620]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.620]                         if (muffled) 
[17:26:44.620]                           invokeRestart("muffleMessage")
[17:26:44.620]                       }
[17:26:44.620]                       else if (inherits(cond, "warning")) {
[17:26:44.620]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.620]                         if (muffled) 
[17:26:44.620]                           invokeRestart("muffleWarning")
[17:26:44.620]                       }
[17:26:44.620]                       else if (inherits(cond, "condition")) {
[17:26:44.620]                         if (!is.null(pattern)) {
[17:26:44.620]                           computeRestarts <- base::computeRestarts
[17:26:44.620]                           grepl <- base::grepl
[17:26:44.620]                           restarts <- computeRestarts(cond)
[17:26:44.620]                           for (restart in restarts) {
[17:26:44.620]                             name <- restart$name
[17:26:44.620]                             if (is.null(name)) 
[17:26:44.620]                               next
[17:26:44.620]                             if (!grepl(pattern, name)) 
[17:26:44.620]                               next
[17:26:44.620]                             invokeRestart(restart)
[17:26:44.620]                             muffled <- TRUE
[17:26:44.620]                             break
[17:26:44.620]                           }
[17:26:44.620]                         }
[17:26:44.620]                       }
[17:26:44.620]                       invisible(muffled)
[17:26:44.620]                     }
[17:26:44.620]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.620]                   }
[17:26:44.620]                 }
[17:26:44.620]             }
[17:26:44.620]         }))
[17:26:44.620]     }, error = function(ex) {
[17:26:44.620]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.620]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.620]                 ...future.rng), started = ...future.startTime, 
[17:26:44.620]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.620]             version = "1.8"), class = "FutureResult")
[17:26:44.620]     }, finally = {
[17:26:44.620]         if (!identical(...future.workdir, getwd())) 
[17:26:44.620]             setwd(...future.workdir)
[17:26:44.620]         {
[17:26:44.620]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.620]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.620]             }
[17:26:44.620]             base::options(...future.oldOptions)
[17:26:44.620]             if (.Platform$OS.type == "windows") {
[17:26:44.620]                 old_names <- names(...future.oldEnvVars)
[17:26:44.620]                 envs <- base::Sys.getenv()
[17:26:44.620]                 names <- names(envs)
[17:26:44.620]                 common <- intersect(names, old_names)
[17:26:44.620]                 added <- setdiff(names, old_names)
[17:26:44.620]                 removed <- setdiff(old_names, names)
[17:26:44.620]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.620]                   envs[common]]
[17:26:44.620]                 NAMES <- toupper(changed)
[17:26:44.620]                 args <- list()
[17:26:44.620]                 for (kk in seq_along(NAMES)) {
[17:26:44.620]                   name <- changed[[kk]]
[17:26:44.620]                   NAME <- NAMES[[kk]]
[17:26:44.620]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.620]                     next
[17:26:44.620]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.620]                 }
[17:26:44.620]                 NAMES <- toupper(added)
[17:26:44.620]                 for (kk in seq_along(NAMES)) {
[17:26:44.620]                   name <- added[[kk]]
[17:26:44.620]                   NAME <- NAMES[[kk]]
[17:26:44.620]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.620]                     next
[17:26:44.620]                   args[[name]] <- ""
[17:26:44.620]                 }
[17:26:44.620]                 NAMES <- toupper(removed)
[17:26:44.620]                 for (kk in seq_along(NAMES)) {
[17:26:44.620]                   name <- removed[[kk]]
[17:26:44.620]                   NAME <- NAMES[[kk]]
[17:26:44.620]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.620]                     next
[17:26:44.620]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.620]                 }
[17:26:44.620]                 if (length(args) > 0) 
[17:26:44.620]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.620]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.620]             }
[17:26:44.620]             else {
[17:26:44.620]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.620]             }
[17:26:44.620]             {
[17:26:44.620]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.620]                   0L) {
[17:26:44.620]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.620]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.620]                   base::options(opts)
[17:26:44.620]                 }
[17:26:44.620]                 {
[17:26:44.620]                   {
[17:26:44.620]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.620]                     NULL
[17:26:44.620]                   }
[17:26:44.620]                   options(future.plan = NULL)
[17:26:44.620]                   if (is.na(NA_character_)) 
[17:26:44.620]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.620]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.620]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.620]                     .init = FALSE)
[17:26:44.620]                 }
[17:26:44.620]             }
[17:26:44.620]         }
[17:26:44.620]     })
[17:26:44.620]     if (TRUE) {
[17:26:44.620]         base::sink(type = "output", split = FALSE)
[17:26:44.620]         if (TRUE) {
[17:26:44.620]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.620]         }
[17:26:44.620]         else {
[17:26:44.620]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.620]         }
[17:26:44.620]         base::close(...future.stdout)
[17:26:44.620]         ...future.stdout <- NULL
[17:26:44.620]     }
[17:26:44.620]     ...future.result$conditions <- ...future.conditions
[17:26:44.620]     ...future.result$finished <- base::Sys.time()
[17:26:44.620]     ...future.result
[17:26:44.620] }
[17:26:44.626] MultisessionFuture started
[17:26:44.626] - Launch lazy future ... done
[17:26:44.626] run() for 'MultisessionFuture' ... done
[17:26:44.626] getGlobalsAndPackages() ...
[17:26:44.627] Searching for globals...
[17:26:44.627] 
[17:26:44.627] Searching for globals ... DONE
[17:26:44.627] - globals: [0] <none>
[17:26:44.627] getGlobalsAndPackages() ... DONE
[17:26:44.628] run() for 'Future' ...
[17:26:44.628] - state: 'created'
[17:26:44.628] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.643] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.643] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.643]   - Field: 'node'
[17:26:44.643]   - Field: 'label'
[17:26:44.643]   - Field: 'local'
[17:26:44.644]   - Field: 'owner'
[17:26:44.644]   - Field: 'envir'
[17:26:44.644]   - Field: 'workers'
[17:26:44.644]   - Field: 'packages'
[17:26:44.644]   - Field: 'gc'
[17:26:44.645]   - Field: 'conditions'
[17:26:44.645]   - Field: 'persistent'
[17:26:44.645]   - Field: 'expr'
[17:26:44.645]   - Field: 'uuid'
[17:26:44.645]   - Field: 'seed'
[17:26:44.645]   - Field: 'version'
[17:26:44.646]   - Field: 'result'
[17:26:44.646]   - Field: 'asynchronous'
[17:26:44.646]   - Field: 'calls'
[17:26:44.646]   - Field: 'globals'
[17:26:44.646]   - Field: 'stdout'
[17:26:44.646]   - Field: 'earlySignal'
[17:26:44.647]   - Field: 'lazy'
[17:26:44.647]   - Field: 'state'
[17:26:44.647] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.647] - Launch lazy future ...
[17:26:44.648] Packages needed by the future expression (n = 0): <none>
[17:26:44.648] Packages needed by future strategies (n = 0): <none>
[17:26:44.648] {
[17:26:44.648]     {
[17:26:44.648]         {
[17:26:44.648]             ...future.startTime <- base::Sys.time()
[17:26:44.648]             {
[17:26:44.648]                 {
[17:26:44.648]                   {
[17:26:44.648]                     {
[17:26:44.648]                       base::local({
[17:26:44.648]                         has_future <- base::requireNamespace("future", 
[17:26:44.648]                           quietly = TRUE)
[17:26:44.648]                         if (has_future) {
[17:26:44.648]                           ns <- base::getNamespace("future")
[17:26:44.648]                           version <- ns[[".package"]][["version"]]
[17:26:44.648]                           if (is.null(version)) 
[17:26:44.648]                             version <- utils::packageVersion("future")
[17:26:44.648]                         }
[17:26:44.648]                         else {
[17:26:44.648]                           version <- NULL
[17:26:44.648]                         }
[17:26:44.648]                         if (!has_future || version < "1.8.0") {
[17:26:44.648]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.648]                             "", base::R.version$version.string), 
[17:26:44.648]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.648]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.648]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.648]                               "release", "version")], collapse = " "), 
[17:26:44.648]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.648]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.648]                             info)
[17:26:44.648]                           info <- base::paste(info, collapse = "; ")
[17:26:44.648]                           if (!has_future) {
[17:26:44.648]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.648]                               info)
[17:26:44.648]                           }
[17:26:44.648]                           else {
[17:26:44.648]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.648]                               info, version)
[17:26:44.648]                           }
[17:26:44.648]                           base::stop(msg)
[17:26:44.648]                         }
[17:26:44.648]                       })
[17:26:44.648]                     }
[17:26:44.648]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.648]                     base::options(mc.cores = 1L)
[17:26:44.648]                   }
[17:26:44.648]                   ...future.strategy.old <- future::plan("list")
[17:26:44.648]                   options(future.plan = NULL)
[17:26:44.648]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.648]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.648]                 }
[17:26:44.648]                 ...future.workdir <- getwd()
[17:26:44.648]             }
[17:26:44.648]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.648]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.648]         }
[17:26:44.648]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.648]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.648]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.648]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.648]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.648]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.648]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.648]             base::names(...future.oldOptions))
[17:26:44.648]     }
[17:26:44.648]     if (FALSE) {
[17:26:44.648]     }
[17:26:44.648]     else {
[17:26:44.648]         if (TRUE) {
[17:26:44.648]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.648]                 open = "w")
[17:26:44.648]         }
[17:26:44.648]         else {
[17:26:44.648]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.648]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.648]         }
[17:26:44.648]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.648]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.648]             base::sink(type = "output", split = FALSE)
[17:26:44.648]             base::close(...future.stdout)
[17:26:44.648]         }, add = TRUE)
[17:26:44.648]     }
[17:26:44.648]     ...future.frame <- base::sys.nframe()
[17:26:44.648]     ...future.conditions <- base::list()
[17:26:44.648]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.648]     if (FALSE) {
[17:26:44.648]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.648]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.648]     }
[17:26:44.648]     ...future.result <- base::tryCatch({
[17:26:44.648]         base::withCallingHandlers({
[17:26:44.648]             ...future.value <- base::withVisible(base::local({
[17:26:44.648]                 ...future.makeSendCondition <- base::local({
[17:26:44.648]                   sendCondition <- NULL
[17:26:44.648]                   function(frame = 1L) {
[17:26:44.648]                     if (is.function(sendCondition)) 
[17:26:44.648]                       return(sendCondition)
[17:26:44.648]                     ns <- getNamespace("parallel")
[17:26:44.648]                     if (exists("sendData", mode = "function", 
[17:26:44.648]                       envir = ns)) {
[17:26:44.648]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.648]                         envir = ns)
[17:26:44.648]                       envir <- sys.frame(frame)
[17:26:44.648]                       master <- NULL
[17:26:44.648]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.648]                         !identical(envir, emptyenv())) {
[17:26:44.648]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.648]                           inherits = FALSE)) {
[17:26:44.648]                           master <- get("master", mode = "list", 
[17:26:44.648]                             envir = envir, inherits = FALSE)
[17:26:44.648]                           if (inherits(master, c("SOCKnode", 
[17:26:44.648]                             "SOCK0node"))) {
[17:26:44.648]                             sendCondition <<- function(cond) {
[17:26:44.648]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.648]                                 success = TRUE)
[17:26:44.648]                               parallel_sendData(master, data)
[17:26:44.648]                             }
[17:26:44.648]                             return(sendCondition)
[17:26:44.648]                           }
[17:26:44.648]                         }
[17:26:44.648]                         frame <- frame + 1L
[17:26:44.648]                         envir <- sys.frame(frame)
[17:26:44.648]                       }
[17:26:44.648]                     }
[17:26:44.648]                     sendCondition <<- function(cond) NULL
[17:26:44.648]                   }
[17:26:44.648]                 })
[17:26:44.648]                 withCallingHandlers({
[17:26:44.648]                   NULL
[17:26:44.648]                 }, immediateCondition = function(cond) {
[17:26:44.648]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.648]                   sendCondition(cond)
[17:26:44.648]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.648]                   {
[17:26:44.648]                     inherits <- base::inherits
[17:26:44.648]                     invokeRestart <- base::invokeRestart
[17:26:44.648]                     is.null <- base::is.null
[17:26:44.648]                     muffled <- FALSE
[17:26:44.648]                     if (inherits(cond, "message")) {
[17:26:44.648]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.648]                       if (muffled) 
[17:26:44.648]                         invokeRestart("muffleMessage")
[17:26:44.648]                     }
[17:26:44.648]                     else if (inherits(cond, "warning")) {
[17:26:44.648]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.648]                       if (muffled) 
[17:26:44.648]                         invokeRestart("muffleWarning")
[17:26:44.648]                     }
[17:26:44.648]                     else if (inherits(cond, "condition")) {
[17:26:44.648]                       if (!is.null(pattern)) {
[17:26:44.648]                         computeRestarts <- base::computeRestarts
[17:26:44.648]                         grepl <- base::grepl
[17:26:44.648]                         restarts <- computeRestarts(cond)
[17:26:44.648]                         for (restart in restarts) {
[17:26:44.648]                           name <- restart$name
[17:26:44.648]                           if (is.null(name)) 
[17:26:44.648]                             next
[17:26:44.648]                           if (!grepl(pattern, name)) 
[17:26:44.648]                             next
[17:26:44.648]                           invokeRestart(restart)
[17:26:44.648]                           muffled <- TRUE
[17:26:44.648]                           break
[17:26:44.648]                         }
[17:26:44.648]                       }
[17:26:44.648]                     }
[17:26:44.648]                     invisible(muffled)
[17:26:44.648]                   }
[17:26:44.648]                   muffleCondition(cond)
[17:26:44.648]                 })
[17:26:44.648]             }))
[17:26:44.648]             future::FutureResult(value = ...future.value$value, 
[17:26:44.648]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.648]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.648]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.648]                     ...future.globalenv.names))
[17:26:44.648]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.648]         }, condition = base::local({
[17:26:44.648]             c <- base::c
[17:26:44.648]             inherits <- base::inherits
[17:26:44.648]             invokeRestart <- base::invokeRestart
[17:26:44.648]             length <- base::length
[17:26:44.648]             list <- base::list
[17:26:44.648]             seq.int <- base::seq.int
[17:26:44.648]             signalCondition <- base::signalCondition
[17:26:44.648]             sys.calls <- base::sys.calls
[17:26:44.648]             `[[` <- base::`[[`
[17:26:44.648]             `+` <- base::`+`
[17:26:44.648]             `<<-` <- base::`<<-`
[17:26:44.648]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.648]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.648]                   3L)]
[17:26:44.648]             }
[17:26:44.648]             function(cond) {
[17:26:44.648]                 is_error <- inherits(cond, "error")
[17:26:44.648]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.648]                   NULL)
[17:26:44.648]                 if (is_error) {
[17:26:44.648]                   sessionInformation <- function() {
[17:26:44.648]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.648]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.648]                       search = base::search(), system = base::Sys.info())
[17:26:44.648]                   }
[17:26:44.648]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.648]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.648]                     cond$call), session = sessionInformation(), 
[17:26:44.648]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.648]                   signalCondition(cond)
[17:26:44.648]                 }
[17:26:44.648]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.648]                 "immediateCondition"))) {
[17:26:44.648]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.648]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.648]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.648]                   if (TRUE && !signal) {
[17:26:44.648]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.648]                     {
[17:26:44.648]                       inherits <- base::inherits
[17:26:44.648]                       invokeRestart <- base::invokeRestart
[17:26:44.648]                       is.null <- base::is.null
[17:26:44.648]                       muffled <- FALSE
[17:26:44.648]                       if (inherits(cond, "message")) {
[17:26:44.648]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.648]                         if (muffled) 
[17:26:44.648]                           invokeRestart("muffleMessage")
[17:26:44.648]                       }
[17:26:44.648]                       else if (inherits(cond, "warning")) {
[17:26:44.648]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.648]                         if (muffled) 
[17:26:44.648]                           invokeRestart("muffleWarning")
[17:26:44.648]                       }
[17:26:44.648]                       else if (inherits(cond, "condition")) {
[17:26:44.648]                         if (!is.null(pattern)) {
[17:26:44.648]                           computeRestarts <- base::computeRestarts
[17:26:44.648]                           grepl <- base::grepl
[17:26:44.648]                           restarts <- computeRestarts(cond)
[17:26:44.648]                           for (restart in restarts) {
[17:26:44.648]                             name <- restart$name
[17:26:44.648]                             if (is.null(name)) 
[17:26:44.648]                               next
[17:26:44.648]                             if (!grepl(pattern, name)) 
[17:26:44.648]                               next
[17:26:44.648]                             invokeRestart(restart)
[17:26:44.648]                             muffled <- TRUE
[17:26:44.648]                             break
[17:26:44.648]                           }
[17:26:44.648]                         }
[17:26:44.648]                       }
[17:26:44.648]                       invisible(muffled)
[17:26:44.648]                     }
[17:26:44.648]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.648]                   }
[17:26:44.648]                 }
[17:26:44.648]                 else {
[17:26:44.648]                   if (TRUE) {
[17:26:44.648]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.648]                     {
[17:26:44.648]                       inherits <- base::inherits
[17:26:44.648]                       invokeRestart <- base::invokeRestart
[17:26:44.648]                       is.null <- base::is.null
[17:26:44.648]                       muffled <- FALSE
[17:26:44.648]                       if (inherits(cond, "message")) {
[17:26:44.648]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.648]                         if (muffled) 
[17:26:44.648]                           invokeRestart("muffleMessage")
[17:26:44.648]                       }
[17:26:44.648]                       else if (inherits(cond, "warning")) {
[17:26:44.648]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.648]                         if (muffled) 
[17:26:44.648]                           invokeRestart("muffleWarning")
[17:26:44.648]                       }
[17:26:44.648]                       else if (inherits(cond, "condition")) {
[17:26:44.648]                         if (!is.null(pattern)) {
[17:26:44.648]                           computeRestarts <- base::computeRestarts
[17:26:44.648]                           grepl <- base::grepl
[17:26:44.648]                           restarts <- computeRestarts(cond)
[17:26:44.648]                           for (restart in restarts) {
[17:26:44.648]                             name <- restart$name
[17:26:44.648]                             if (is.null(name)) 
[17:26:44.648]                               next
[17:26:44.648]                             if (!grepl(pattern, name)) 
[17:26:44.648]                               next
[17:26:44.648]                             invokeRestart(restart)
[17:26:44.648]                             muffled <- TRUE
[17:26:44.648]                             break
[17:26:44.648]                           }
[17:26:44.648]                         }
[17:26:44.648]                       }
[17:26:44.648]                       invisible(muffled)
[17:26:44.648]                     }
[17:26:44.648]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.648]                   }
[17:26:44.648]                 }
[17:26:44.648]             }
[17:26:44.648]         }))
[17:26:44.648]     }, error = function(ex) {
[17:26:44.648]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.648]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.648]                 ...future.rng), started = ...future.startTime, 
[17:26:44.648]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.648]             version = "1.8"), class = "FutureResult")
[17:26:44.648]     }, finally = {
[17:26:44.648]         if (!identical(...future.workdir, getwd())) 
[17:26:44.648]             setwd(...future.workdir)
[17:26:44.648]         {
[17:26:44.648]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.648]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.648]             }
[17:26:44.648]             base::options(...future.oldOptions)
[17:26:44.648]             if (.Platform$OS.type == "windows") {
[17:26:44.648]                 old_names <- names(...future.oldEnvVars)
[17:26:44.648]                 envs <- base::Sys.getenv()
[17:26:44.648]                 names <- names(envs)
[17:26:44.648]                 common <- intersect(names, old_names)
[17:26:44.648]                 added <- setdiff(names, old_names)
[17:26:44.648]                 removed <- setdiff(old_names, names)
[17:26:44.648]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.648]                   envs[common]]
[17:26:44.648]                 NAMES <- toupper(changed)
[17:26:44.648]                 args <- list()
[17:26:44.648]                 for (kk in seq_along(NAMES)) {
[17:26:44.648]                   name <- changed[[kk]]
[17:26:44.648]                   NAME <- NAMES[[kk]]
[17:26:44.648]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.648]                     next
[17:26:44.648]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.648]                 }
[17:26:44.648]                 NAMES <- toupper(added)
[17:26:44.648]                 for (kk in seq_along(NAMES)) {
[17:26:44.648]                   name <- added[[kk]]
[17:26:44.648]                   NAME <- NAMES[[kk]]
[17:26:44.648]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.648]                     next
[17:26:44.648]                   args[[name]] <- ""
[17:26:44.648]                 }
[17:26:44.648]                 NAMES <- toupper(removed)
[17:26:44.648]                 for (kk in seq_along(NAMES)) {
[17:26:44.648]                   name <- removed[[kk]]
[17:26:44.648]                   NAME <- NAMES[[kk]]
[17:26:44.648]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.648]                     next
[17:26:44.648]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.648]                 }
[17:26:44.648]                 if (length(args) > 0) 
[17:26:44.648]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.648]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.648]             }
[17:26:44.648]             else {
[17:26:44.648]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.648]             }
[17:26:44.648]             {
[17:26:44.648]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.648]                   0L) {
[17:26:44.648]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.648]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.648]                   base::options(opts)
[17:26:44.648]                 }
[17:26:44.648]                 {
[17:26:44.648]                   {
[17:26:44.648]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.648]                     NULL
[17:26:44.648]                   }
[17:26:44.648]                   options(future.plan = NULL)
[17:26:44.648]                   if (is.na(NA_character_)) 
[17:26:44.648]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.648]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.648]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.648]                     .init = FALSE)
[17:26:44.648]                 }
[17:26:44.648]             }
[17:26:44.648]         }
[17:26:44.648]     })
[17:26:44.648]     if (TRUE) {
[17:26:44.648]         base::sink(type = "output", split = FALSE)
[17:26:44.648]         if (TRUE) {
[17:26:44.648]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.648]         }
[17:26:44.648]         else {
[17:26:44.648]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.648]         }
[17:26:44.648]         base::close(...future.stdout)
[17:26:44.648]         ...future.stdout <- NULL
[17:26:44.648]     }
[17:26:44.648]     ...future.result$conditions <- ...future.conditions
[17:26:44.648]     ...future.result$finished <- base::Sys.time()
[17:26:44.648]     ...future.result
[17:26:44.648] }
[17:26:44.654] MultisessionFuture started
[17:26:44.654] - Launch lazy future ... done
[17:26:44.654] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230d91fb88> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230cd10260> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230d91fb88> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230cd10260> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 1 6
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
[17:26:44.660] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.661] - Validating connection of MultisessionFuture
[17:26:44.661] - received message: FutureResult
[17:26:44.661] - Received FutureResult
[17:26:44.661] - Erased future from FutureRegistry
[17:26:44.661] result() for ClusterFuture ...
[17:26:44.662] - result already collected: FutureResult
[17:26:44.662] result() for ClusterFuture ... done
[17:26:44.662] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:44.669] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.669] - Validating connection of MultisessionFuture
[17:26:44.669] - received message: FutureResult
[17:26:44.669] - Received FutureResult
[17:26:44.669] - Erased future from FutureRegistry
[17:26:44.670] result() for ClusterFuture ...
[17:26:44.670] - result already collected: FutureResult
[17:26:44.670] result() for ClusterFuture ... done
[17:26:44.670] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:44.672] resolve() on list ...
[17:26:44.672]  recursive: 0
[17:26:44.672]  length: 6
[17:26:44.673]  elements: 'a', 'b', 'c', '', '', ''
[17:26:44.673] signalConditionsASAP(numeric, pos=1) ...
[17:26:44.673] - nx: 6
[17:26:44.673] - relay: TRUE
[17:26:44.673] - stdout: TRUE
[17:26:44.673] - signal: TRUE
[17:26:44.674] - resignal: FALSE
[17:26:44.674] - force: TRUE
[17:26:44.674] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.674] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.674]  - until=2
[17:26:44.674]  - relaying element #2
[17:26:44.675] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.675] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.675] signalConditionsASAP(NULL, pos=1) ... done
[17:26:44.675]  length: 5 (resolved future 1)
[17:26:44.675] Future #2
[17:26:44.675] result() for ClusterFuture ...
[17:26:44.676] - result already collected: FutureResult
[17:26:44.676] result() for ClusterFuture ... done
[17:26:44.676] result() for ClusterFuture ...
[17:26:44.676] - result already collected: FutureResult
[17:26:44.676] result() for ClusterFuture ... done
[17:26:44.676] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:44.677] - nx: 6
[17:26:44.677] - relay: TRUE
[17:26:44.677] - stdout: TRUE
[17:26:44.677] - signal: TRUE
[17:26:44.677] - resignal: FALSE
[17:26:44.677] - force: TRUE
[17:26:44.677] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.678] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.678]  - until=2
[17:26:44.678]  - relaying element #2
[17:26:44.678] result() for ClusterFuture ...
[17:26:44.678] - result already collected: FutureResult
[17:26:44.678] result() for ClusterFuture ... done
[17:26:44.679] result() for ClusterFuture ...
[17:26:44.679] - result already collected: FutureResult
[17:26:44.679] result() for ClusterFuture ... done
[17:26:44.679] result() for ClusterFuture ...
[17:26:44.679] - result already collected: FutureResult
[17:26:44.679] result() for ClusterFuture ... done
[17:26:44.680] result() for ClusterFuture ...
[17:26:44.680] - result already collected: FutureResult
[17:26:44.680] result() for ClusterFuture ... done
[17:26:44.680] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.680] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.680] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:44.681]  length: 4 (resolved future 2)
[17:26:44.681] Future #3
[17:26:44.681] result() for ClusterFuture ...
[17:26:44.681] - result already collected: FutureResult
[17:26:44.681] result() for ClusterFuture ... done
[17:26:44.681] result() for ClusterFuture ...
[17:26:44.682] - result already collected: FutureResult
[17:26:44.682] result() for ClusterFuture ... done
[17:26:44.682] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:44.682] - nx: 6
[17:26:44.682] - relay: TRUE
[17:26:44.682] - stdout: TRUE
[17:26:44.682] - signal: TRUE
[17:26:44.683] - resignal: FALSE
[17:26:44.683] - force: TRUE
[17:26:44.683] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.683] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.683]  - until=3
[17:26:44.683]  - relaying element #3
[17:26:44.684] result() for ClusterFuture ...
[17:26:44.684] - result already collected: FutureResult
[17:26:44.684] result() for ClusterFuture ... done
[17:26:44.684] result() for ClusterFuture ...
[17:26:44.684] - result already collected: FutureResult
[17:26:44.684] result() for ClusterFuture ... done
[17:26:44.685] result() for ClusterFuture ...
[17:26:44.685] - result already collected: FutureResult
[17:26:44.685] result() for ClusterFuture ... done
[17:26:44.685] result() for ClusterFuture ...
[17:26:44.685] - result already collected: FutureResult
[17:26:44.685] result() for ClusterFuture ... done
[17:26:44.685] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.686] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.686] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:44.686]  length: 3 (resolved future 3)
[17:26:44.686] signalConditionsASAP(NULL, pos=4) ...
[17:26:44.686] - nx: 6
[17:26:44.686] - relay: TRUE
[17:26:44.687] - stdout: TRUE
[17:26:44.687] - signal: TRUE
[17:26:44.687] - resignal: FALSE
[17:26:44.687] - force: TRUE
[17:26:44.687] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.687] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.688]  - until=5
[17:26:44.688]  - relaying element #5
[17:26:44.688] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.688] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.688] signalConditionsASAP(NULL, pos=4) ... done
[17:26:44.689]  length: 2 (resolved future 4)
[17:26:44.689] signalConditionsASAP(NULL, pos=5) ...
[17:26:44.689] - nx: 6
[17:26:44.689] - relay: TRUE
[17:26:44.689] - stdout: TRUE
[17:26:44.689] - signal: TRUE
[17:26:44.689] - resignal: FALSE
[17:26:44.690] - force: TRUE
[17:26:44.690] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.690] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.690]  - until=6
[17:26:44.690]  - relaying element #6
[17:26:44.690] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.691] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.691] signalConditionsASAP(NULL, pos=5) ... done
[17:26:44.691]  length: 1 (resolved future 5)
[17:26:44.691] signalConditionsASAP(numeric, pos=6) ...
[17:26:44.691] - nx: 6
[17:26:44.691] - relay: TRUE
[17:26:44.691] - stdout: TRUE
[17:26:44.692] - signal: TRUE
[17:26:44.692] - resignal: FALSE
[17:26:44.692] - force: TRUE
[17:26:44.692] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.692] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.692]  - until=6
[17:26:44.693] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.693] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.693] signalConditionsASAP(numeric, pos=6) ... done
[17:26:44.693]  length: 0 (resolved future 6)
[17:26:44.693] Relaying remaining futures
[17:26:44.693] signalConditionsASAP(NULL, pos=0) ...
[17:26:44.694] - nx: 6
[17:26:44.694] - relay: TRUE
[17:26:44.694] - stdout: TRUE
[17:26:44.694] - signal: TRUE
[17:26:44.694] - resignal: FALSE
[17:26:44.694] - force: TRUE
[17:26:44.694] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.695] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:44.695] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.695] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.695] signalConditionsASAP(NULL, pos=0) ... done
[17:26:44.695] resolve() on list ... DONE
[17:26:44.695] result() for ClusterFuture ...
[17:26:44.696] - result already collected: FutureResult
[17:26:44.696] result() for ClusterFuture ... done
[17:26:44.696] result() for ClusterFuture ...
[17:26:44.696] - result already collected: FutureResult
[17:26:44.696] result() for ClusterFuture ... done
[17:26:44.696] result() for ClusterFuture ...
[17:26:44.697] - result already collected: FutureResult
[17:26:44.697] result() for ClusterFuture ... done
[17:26:44.697] result() for ClusterFuture ...
[17:26:44.697] - result already collected: FutureResult
[17:26:44.697] result() for ClusterFuture ... done
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 1 6
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
Dimensions: c(2, 3)
[17:26:44.701] getGlobalsAndPackages() ...
[17:26:44.701] Searching for globals...
[17:26:44.702] 
[17:26:44.702] Searching for globals ... DONE
[17:26:44.702] - globals: [0] <none>
[17:26:44.702] getGlobalsAndPackages() ... DONE
[17:26:44.702] run() for 'Future' ...
[17:26:44.703] - state: 'created'
[17:26:44.703] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.716] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.716] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.716]   - Field: 'node'
[17:26:44.717]   - Field: 'label'
[17:26:44.717]   - Field: 'local'
[17:26:44.717]   - Field: 'owner'
[17:26:44.717]   - Field: 'envir'
[17:26:44.717]   - Field: 'workers'
[17:26:44.718]   - Field: 'packages'
[17:26:44.718]   - Field: 'gc'
[17:26:44.718]   - Field: 'conditions'
[17:26:44.718]   - Field: 'persistent'
[17:26:44.718]   - Field: 'expr'
[17:26:44.718]   - Field: 'uuid'
[17:26:44.719]   - Field: 'seed'
[17:26:44.719]   - Field: 'version'
[17:26:44.719]   - Field: 'result'
[17:26:44.719]   - Field: 'asynchronous'
[17:26:44.719]   - Field: 'calls'
[17:26:44.719]   - Field: 'globals'
[17:26:44.720]   - Field: 'stdout'
[17:26:44.720]   - Field: 'earlySignal'
[17:26:44.720]   - Field: 'lazy'
[17:26:44.720]   - Field: 'state'
[17:26:44.720] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.721] - Launch lazy future ...
[17:26:44.721] Packages needed by the future expression (n = 0): <none>
[17:26:44.721] Packages needed by future strategies (n = 0): <none>
[17:26:44.722] {
[17:26:44.722]     {
[17:26:44.722]         {
[17:26:44.722]             ...future.startTime <- base::Sys.time()
[17:26:44.722]             {
[17:26:44.722]                 {
[17:26:44.722]                   {
[17:26:44.722]                     {
[17:26:44.722]                       base::local({
[17:26:44.722]                         has_future <- base::requireNamespace("future", 
[17:26:44.722]                           quietly = TRUE)
[17:26:44.722]                         if (has_future) {
[17:26:44.722]                           ns <- base::getNamespace("future")
[17:26:44.722]                           version <- ns[[".package"]][["version"]]
[17:26:44.722]                           if (is.null(version)) 
[17:26:44.722]                             version <- utils::packageVersion("future")
[17:26:44.722]                         }
[17:26:44.722]                         else {
[17:26:44.722]                           version <- NULL
[17:26:44.722]                         }
[17:26:44.722]                         if (!has_future || version < "1.8.0") {
[17:26:44.722]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.722]                             "", base::R.version$version.string), 
[17:26:44.722]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.722]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.722]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.722]                               "release", "version")], collapse = " "), 
[17:26:44.722]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.722]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.722]                             info)
[17:26:44.722]                           info <- base::paste(info, collapse = "; ")
[17:26:44.722]                           if (!has_future) {
[17:26:44.722]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.722]                               info)
[17:26:44.722]                           }
[17:26:44.722]                           else {
[17:26:44.722]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.722]                               info, version)
[17:26:44.722]                           }
[17:26:44.722]                           base::stop(msg)
[17:26:44.722]                         }
[17:26:44.722]                       })
[17:26:44.722]                     }
[17:26:44.722]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.722]                     base::options(mc.cores = 1L)
[17:26:44.722]                   }
[17:26:44.722]                   ...future.strategy.old <- future::plan("list")
[17:26:44.722]                   options(future.plan = NULL)
[17:26:44.722]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.722]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.722]                 }
[17:26:44.722]                 ...future.workdir <- getwd()
[17:26:44.722]             }
[17:26:44.722]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.722]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.722]         }
[17:26:44.722]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.722]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.722]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.722]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.722]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.722]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.722]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.722]             base::names(...future.oldOptions))
[17:26:44.722]     }
[17:26:44.722]     if (FALSE) {
[17:26:44.722]     }
[17:26:44.722]     else {
[17:26:44.722]         if (TRUE) {
[17:26:44.722]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.722]                 open = "w")
[17:26:44.722]         }
[17:26:44.722]         else {
[17:26:44.722]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.722]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.722]         }
[17:26:44.722]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.722]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.722]             base::sink(type = "output", split = FALSE)
[17:26:44.722]             base::close(...future.stdout)
[17:26:44.722]         }, add = TRUE)
[17:26:44.722]     }
[17:26:44.722]     ...future.frame <- base::sys.nframe()
[17:26:44.722]     ...future.conditions <- base::list()
[17:26:44.722]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.722]     if (FALSE) {
[17:26:44.722]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.722]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.722]     }
[17:26:44.722]     ...future.result <- base::tryCatch({
[17:26:44.722]         base::withCallingHandlers({
[17:26:44.722]             ...future.value <- base::withVisible(base::local({
[17:26:44.722]                 ...future.makeSendCondition <- base::local({
[17:26:44.722]                   sendCondition <- NULL
[17:26:44.722]                   function(frame = 1L) {
[17:26:44.722]                     if (is.function(sendCondition)) 
[17:26:44.722]                       return(sendCondition)
[17:26:44.722]                     ns <- getNamespace("parallel")
[17:26:44.722]                     if (exists("sendData", mode = "function", 
[17:26:44.722]                       envir = ns)) {
[17:26:44.722]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.722]                         envir = ns)
[17:26:44.722]                       envir <- sys.frame(frame)
[17:26:44.722]                       master <- NULL
[17:26:44.722]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.722]                         !identical(envir, emptyenv())) {
[17:26:44.722]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.722]                           inherits = FALSE)) {
[17:26:44.722]                           master <- get("master", mode = "list", 
[17:26:44.722]                             envir = envir, inherits = FALSE)
[17:26:44.722]                           if (inherits(master, c("SOCKnode", 
[17:26:44.722]                             "SOCK0node"))) {
[17:26:44.722]                             sendCondition <<- function(cond) {
[17:26:44.722]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.722]                                 success = TRUE)
[17:26:44.722]                               parallel_sendData(master, data)
[17:26:44.722]                             }
[17:26:44.722]                             return(sendCondition)
[17:26:44.722]                           }
[17:26:44.722]                         }
[17:26:44.722]                         frame <- frame + 1L
[17:26:44.722]                         envir <- sys.frame(frame)
[17:26:44.722]                       }
[17:26:44.722]                     }
[17:26:44.722]                     sendCondition <<- function(cond) NULL
[17:26:44.722]                   }
[17:26:44.722]                 })
[17:26:44.722]                 withCallingHandlers({
[17:26:44.722]                   2
[17:26:44.722]                 }, immediateCondition = function(cond) {
[17:26:44.722]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.722]                   sendCondition(cond)
[17:26:44.722]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.722]                   {
[17:26:44.722]                     inherits <- base::inherits
[17:26:44.722]                     invokeRestart <- base::invokeRestart
[17:26:44.722]                     is.null <- base::is.null
[17:26:44.722]                     muffled <- FALSE
[17:26:44.722]                     if (inherits(cond, "message")) {
[17:26:44.722]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.722]                       if (muffled) 
[17:26:44.722]                         invokeRestart("muffleMessage")
[17:26:44.722]                     }
[17:26:44.722]                     else if (inherits(cond, "warning")) {
[17:26:44.722]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.722]                       if (muffled) 
[17:26:44.722]                         invokeRestart("muffleWarning")
[17:26:44.722]                     }
[17:26:44.722]                     else if (inherits(cond, "condition")) {
[17:26:44.722]                       if (!is.null(pattern)) {
[17:26:44.722]                         computeRestarts <- base::computeRestarts
[17:26:44.722]                         grepl <- base::grepl
[17:26:44.722]                         restarts <- computeRestarts(cond)
[17:26:44.722]                         for (restart in restarts) {
[17:26:44.722]                           name <- restart$name
[17:26:44.722]                           if (is.null(name)) 
[17:26:44.722]                             next
[17:26:44.722]                           if (!grepl(pattern, name)) 
[17:26:44.722]                             next
[17:26:44.722]                           invokeRestart(restart)
[17:26:44.722]                           muffled <- TRUE
[17:26:44.722]                           break
[17:26:44.722]                         }
[17:26:44.722]                       }
[17:26:44.722]                     }
[17:26:44.722]                     invisible(muffled)
[17:26:44.722]                   }
[17:26:44.722]                   muffleCondition(cond)
[17:26:44.722]                 })
[17:26:44.722]             }))
[17:26:44.722]             future::FutureResult(value = ...future.value$value, 
[17:26:44.722]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.722]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.722]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.722]                     ...future.globalenv.names))
[17:26:44.722]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.722]         }, condition = base::local({
[17:26:44.722]             c <- base::c
[17:26:44.722]             inherits <- base::inherits
[17:26:44.722]             invokeRestart <- base::invokeRestart
[17:26:44.722]             length <- base::length
[17:26:44.722]             list <- base::list
[17:26:44.722]             seq.int <- base::seq.int
[17:26:44.722]             signalCondition <- base::signalCondition
[17:26:44.722]             sys.calls <- base::sys.calls
[17:26:44.722]             `[[` <- base::`[[`
[17:26:44.722]             `+` <- base::`+`
[17:26:44.722]             `<<-` <- base::`<<-`
[17:26:44.722]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.722]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.722]                   3L)]
[17:26:44.722]             }
[17:26:44.722]             function(cond) {
[17:26:44.722]                 is_error <- inherits(cond, "error")
[17:26:44.722]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.722]                   NULL)
[17:26:44.722]                 if (is_error) {
[17:26:44.722]                   sessionInformation <- function() {
[17:26:44.722]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.722]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.722]                       search = base::search(), system = base::Sys.info())
[17:26:44.722]                   }
[17:26:44.722]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.722]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.722]                     cond$call), session = sessionInformation(), 
[17:26:44.722]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.722]                   signalCondition(cond)
[17:26:44.722]                 }
[17:26:44.722]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.722]                 "immediateCondition"))) {
[17:26:44.722]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.722]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.722]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.722]                   if (TRUE && !signal) {
[17:26:44.722]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.722]                     {
[17:26:44.722]                       inherits <- base::inherits
[17:26:44.722]                       invokeRestart <- base::invokeRestart
[17:26:44.722]                       is.null <- base::is.null
[17:26:44.722]                       muffled <- FALSE
[17:26:44.722]                       if (inherits(cond, "message")) {
[17:26:44.722]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.722]                         if (muffled) 
[17:26:44.722]                           invokeRestart("muffleMessage")
[17:26:44.722]                       }
[17:26:44.722]                       else if (inherits(cond, "warning")) {
[17:26:44.722]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.722]                         if (muffled) 
[17:26:44.722]                           invokeRestart("muffleWarning")
[17:26:44.722]                       }
[17:26:44.722]                       else if (inherits(cond, "condition")) {
[17:26:44.722]                         if (!is.null(pattern)) {
[17:26:44.722]                           computeRestarts <- base::computeRestarts
[17:26:44.722]                           grepl <- base::grepl
[17:26:44.722]                           restarts <- computeRestarts(cond)
[17:26:44.722]                           for (restart in restarts) {
[17:26:44.722]                             name <- restart$name
[17:26:44.722]                             if (is.null(name)) 
[17:26:44.722]                               next
[17:26:44.722]                             if (!grepl(pattern, name)) 
[17:26:44.722]                               next
[17:26:44.722]                             invokeRestart(restart)
[17:26:44.722]                             muffled <- TRUE
[17:26:44.722]                             break
[17:26:44.722]                           }
[17:26:44.722]                         }
[17:26:44.722]                       }
[17:26:44.722]                       invisible(muffled)
[17:26:44.722]                     }
[17:26:44.722]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.722]                   }
[17:26:44.722]                 }
[17:26:44.722]                 else {
[17:26:44.722]                   if (TRUE) {
[17:26:44.722]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.722]                     {
[17:26:44.722]                       inherits <- base::inherits
[17:26:44.722]                       invokeRestart <- base::invokeRestart
[17:26:44.722]                       is.null <- base::is.null
[17:26:44.722]                       muffled <- FALSE
[17:26:44.722]                       if (inherits(cond, "message")) {
[17:26:44.722]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.722]                         if (muffled) 
[17:26:44.722]                           invokeRestart("muffleMessage")
[17:26:44.722]                       }
[17:26:44.722]                       else if (inherits(cond, "warning")) {
[17:26:44.722]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.722]                         if (muffled) 
[17:26:44.722]                           invokeRestart("muffleWarning")
[17:26:44.722]                       }
[17:26:44.722]                       else if (inherits(cond, "condition")) {
[17:26:44.722]                         if (!is.null(pattern)) {
[17:26:44.722]                           computeRestarts <- base::computeRestarts
[17:26:44.722]                           grepl <- base::grepl
[17:26:44.722]                           restarts <- computeRestarts(cond)
[17:26:44.722]                           for (restart in restarts) {
[17:26:44.722]                             name <- restart$name
[17:26:44.722]                             if (is.null(name)) 
[17:26:44.722]                               next
[17:26:44.722]                             if (!grepl(pattern, name)) 
[17:26:44.722]                               next
[17:26:44.722]                             invokeRestart(restart)
[17:26:44.722]                             muffled <- TRUE
[17:26:44.722]                             break
[17:26:44.722]                           }
[17:26:44.722]                         }
[17:26:44.722]                       }
[17:26:44.722]                       invisible(muffled)
[17:26:44.722]                     }
[17:26:44.722]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.722]                   }
[17:26:44.722]                 }
[17:26:44.722]             }
[17:26:44.722]         }))
[17:26:44.722]     }, error = function(ex) {
[17:26:44.722]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.722]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.722]                 ...future.rng), started = ...future.startTime, 
[17:26:44.722]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.722]             version = "1.8"), class = "FutureResult")
[17:26:44.722]     }, finally = {
[17:26:44.722]         if (!identical(...future.workdir, getwd())) 
[17:26:44.722]             setwd(...future.workdir)
[17:26:44.722]         {
[17:26:44.722]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.722]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.722]             }
[17:26:44.722]             base::options(...future.oldOptions)
[17:26:44.722]             if (.Platform$OS.type == "windows") {
[17:26:44.722]                 old_names <- names(...future.oldEnvVars)
[17:26:44.722]                 envs <- base::Sys.getenv()
[17:26:44.722]                 names <- names(envs)
[17:26:44.722]                 common <- intersect(names, old_names)
[17:26:44.722]                 added <- setdiff(names, old_names)
[17:26:44.722]                 removed <- setdiff(old_names, names)
[17:26:44.722]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.722]                   envs[common]]
[17:26:44.722]                 NAMES <- toupper(changed)
[17:26:44.722]                 args <- list()
[17:26:44.722]                 for (kk in seq_along(NAMES)) {
[17:26:44.722]                   name <- changed[[kk]]
[17:26:44.722]                   NAME <- NAMES[[kk]]
[17:26:44.722]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.722]                     next
[17:26:44.722]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.722]                 }
[17:26:44.722]                 NAMES <- toupper(added)
[17:26:44.722]                 for (kk in seq_along(NAMES)) {
[17:26:44.722]                   name <- added[[kk]]
[17:26:44.722]                   NAME <- NAMES[[kk]]
[17:26:44.722]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.722]                     next
[17:26:44.722]                   args[[name]] <- ""
[17:26:44.722]                 }
[17:26:44.722]                 NAMES <- toupper(removed)
[17:26:44.722]                 for (kk in seq_along(NAMES)) {
[17:26:44.722]                   name <- removed[[kk]]
[17:26:44.722]                   NAME <- NAMES[[kk]]
[17:26:44.722]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.722]                     next
[17:26:44.722]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.722]                 }
[17:26:44.722]                 if (length(args) > 0) 
[17:26:44.722]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.722]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.722]             }
[17:26:44.722]             else {
[17:26:44.722]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.722]             }
[17:26:44.722]             {
[17:26:44.722]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.722]                   0L) {
[17:26:44.722]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.722]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.722]                   base::options(opts)
[17:26:44.722]                 }
[17:26:44.722]                 {
[17:26:44.722]                   {
[17:26:44.722]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.722]                     NULL
[17:26:44.722]                   }
[17:26:44.722]                   options(future.plan = NULL)
[17:26:44.722]                   if (is.na(NA_character_)) 
[17:26:44.722]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.722]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.722]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.722]                     .init = FALSE)
[17:26:44.722]                 }
[17:26:44.722]             }
[17:26:44.722]         }
[17:26:44.722]     })
[17:26:44.722]     if (TRUE) {
[17:26:44.722]         base::sink(type = "output", split = FALSE)
[17:26:44.722]         if (TRUE) {
[17:26:44.722]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.722]         }
[17:26:44.722]         else {
[17:26:44.722]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.722]         }
[17:26:44.722]         base::close(...future.stdout)
[17:26:44.722]         ...future.stdout <- NULL
[17:26:44.722]     }
[17:26:44.722]     ...future.result$conditions <- ...future.conditions
[17:26:44.722]     ...future.result$finished <- base::Sys.time()
[17:26:44.722]     ...future.result
[17:26:44.722] }
[17:26:44.727] MultisessionFuture started
[17:26:44.727] - Launch lazy future ... done
[17:26:44.727] run() for 'MultisessionFuture' ... done
[17:26:44.728] getGlobalsAndPackages() ...
[17:26:44.728] Searching for globals...
[17:26:44.728] 
[17:26:44.728] Searching for globals ... DONE
[17:26:44.729] - globals: [0] <none>
[17:26:44.729] getGlobalsAndPackages() ... DONE
[17:26:44.729] run() for 'Future' ...
[17:26:44.729] - state: 'created'
[17:26:44.729] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.743] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.743] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.743]   - Field: 'node'
[17:26:44.744]   - Field: 'label'
[17:26:44.744]   - Field: 'local'
[17:26:44.744]   - Field: 'owner'
[17:26:44.744]   - Field: 'envir'
[17:26:44.744]   - Field: 'workers'
[17:26:44.744]   - Field: 'packages'
[17:26:44.745]   - Field: 'gc'
[17:26:44.745]   - Field: 'conditions'
[17:26:44.745]   - Field: 'persistent'
[17:26:44.745]   - Field: 'expr'
[17:26:44.745]   - Field: 'uuid'
[17:26:44.746]   - Field: 'seed'
[17:26:44.746]   - Field: 'version'
[17:26:44.746]   - Field: 'result'
[17:26:44.746]   - Field: 'asynchronous'
[17:26:44.746]   - Field: 'calls'
[17:26:44.746]   - Field: 'globals'
[17:26:44.747]   - Field: 'stdout'
[17:26:44.747]   - Field: 'earlySignal'
[17:26:44.747]   - Field: 'lazy'
[17:26:44.747]   - Field: 'state'
[17:26:44.747] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.747] - Launch lazy future ...
[17:26:44.748] Packages needed by the future expression (n = 0): <none>
[17:26:44.748] Packages needed by future strategies (n = 0): <none>
[17:26:44.749] {
[17:26:44.749]     {
[17:26:44.749]         {
[17:26:44.749]             ...future.startTime <- base::Sys.time()
[17:26:44.749]             {
[17:26:44.749]                 {
[17:26:44.749]                   {
[17:26:44.749]                     {
[17:26:44.749]                       base::local({
[17:26:44.749]                         has_future <- base::requireNamespace("future", 
[17:26:44.749]                           quietly = TRUE)
[17:26:44.749]                         if (has_future) {
[17:26:44.749]                           ns <- base::getNamespace("future")
[17:26:44.749]                           version <- ns[[".package"]][["version"]]
[17:26:44.749]                           if (is.null(version)) 
[17:26:44.749]                             version <- utils::packageVersion("future")
[17:26:44.749]                         }
[17:26:44.749]                         else {
[17:26:44.749]                           version <- NULL
[17:26:44.749]                         }
[17:26:44.749]                         if (!has_future || version < "1.8.0") {
[17:26:44.749]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.749]                             "", base::R.version$version.string), 
[17:26:44.749]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.749]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.749]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.749]                               "release", "version")], collapse = " "), 
[17:26:44.749]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.749]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.749]                             info)
[17:26:44.749]                           info <- base::paste(info, collapse = "; ")
[17:26:44.749]                           if (!has_future) {
[17:26:44.749]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.749]                               info)
[17:26:44.749]                           }
[17:26:44.749]                           else {
[17:26:44.749]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.749]                               info, version)
[17:26:44.749]                           }
[17:26:44.749]                           base::stop(msg)
[17:26:44.749]                         }
[17:26:44.749]                       })
[17:26:44.749]                     }
[17:26:44.749]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.749]                     base::options(mc.cores = 1L)
[17:26:44.749]                   }
[17:26:44.749]                   ...future.strategy.old <- future::plan("list")
[17:26:44.749]                   options(future.plan = NULL)
[17:26:44.749]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.749]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.749]                 }
[17:26:44.749]                 ...future.workdir <- getwd()
[17:26:44.749]             }
[17:26:44.749]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.749]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.749]         }
[17:26:44.749]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.749]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.749]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.749]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.749]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.749]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.749]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.749]             base::names(...future.oldOptions))
[17:26:44.749]     }
[17:26:44.749]     if (FALSE) {
[17:26:44.749]     }
[17:26:44.749]     else {
[17:26:44.749]         if (TRUE) {
[17:26:44.749]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.749]                 open = "w")
[17:26:44.749]         }
[17:26:44.749]         else {
[17:26:44.749]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.749]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.749]         }
[17:26:44.749]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.749]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.749]             base::sink(type = "output", split = FALSE)
[17:26:44.749]             base::close(...future.stdout)
[17:26:44.749]         }, add = TRUE)
[17:26:44.749]     }
[17:26:44.749]     ...future.frame <- base::sys.nframe()
[17:26:44.749]     ...future.conditions <- base::list()
[17:26:44.749]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.749]     if (FALSE) {
[17:26:44.749]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.749]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.749]     }
[17:26:44.749]     ...future.result <- base::tryCatch({
[17:26:44.749]         base::withCallingHandlers({
[17:26:44.749]             ...future.value <- base::withVisible(base::local({
[17:26:44.749]                 ...future.makeSendCondition <- base::local({
[17:26:44.749]                   sendCondition <- NULL
[17:26:44.749]                   function(frame = 1L) {
[17:26:44.749]                     if (is.function(sendCondition)) 
[17:26:44.749]                       return(sendCondition)
[17:26:44.749]                     ns <- getNamespace("parallel")
[17:26:44.749]                     if (exists("sendData", mode = "function", 
[17:26:44.749]                       envir = ns)) {
[17:26:44.749]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.749]                         envir = ns)
[17:26:44.749]                       envir <- sys.frame(frame)
[17:26:44.749]                       master <- NULL
[17:26:44.749]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.749]                         !identical(envir, emptyenv())) {
[17:26:44.749]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.749]                           inherits = FALSE)) {
[17:26:44.749]                           master <- get("master", mode = "list", 
[17:26:44.749]                             envir = envir, inherits = FALSE)
[17:26:44.749]                           if (inherits(master, c("SOCKnode", 
[17:26:44.749]                             "SOCK0node"))) {
[17:26:44.749]                             sendCondition <<- function(cond) {
[17:26:44.749]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.749]                                 success = TRUE)
[17:26:44.749]                               parallel_sendData(master, data)
[17:26:44.749]                             }
[17:26:44.749]                             return(sendCondition)
[17:26:44.749]                           }
[17:26:44.749]                         }
[17:26:44.749]                         frame <- frame + 1L
[17:26:44.749]                         envir <- sys.frame(frame)
[17:26:44.749]                       }
[17:26:44.749]                     }
[17:26:44.749]                     sendCondition <<- function(cond) NULL
[17:26:44.749]                   }
[17:26:44.749]                 })
[17:26:44.749]                 withCallingHandlers({
[17:26:44.749]                   NULL
[17:26:44.749]                 }, immediateCondition = function(cond) {
[17:26:44.749]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.749]                   sendCondition(cond)
[17:26:44.749]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.749]                   {
[17:26:44.749]                     inherits <- base::inherits
[17:26:44.749]                     invokeRestart <- base::invokeRestart
[17:26:44.749]                     is.null <- base::is.null
[17:26:44.749]                     muffled <- FALSE
[17:26:44.749]                     if (inherits(cond, "message")) {
[17:26:44.749]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.749]                       if (muffled) 
[17:26:44.749]                         invokeRestart("muffleMessage")
[17:26:44.749]                     }
[17:26:44.749]                     else if (inherits(cond, "warning")) {
[17:26:44.749]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.749]                       if (muffled) 
[17:26:44.749]                         invokeRestart("muffleWarning")
[17:26:44.749]                     }
[17:26:44.749]                     else if (inherits(cond, "condition")) {
[17:26:44.749]                       if (!is.null(pattern)) {
[17:26:44.749]                         computeRestarts <- base::computeRestarts
[17:26:44.749]                         grepl <- base::grepl
[17:26:44.749]                         restarts <- computeRestarts(cond)
[17:26:44.749]                         for (restart in restarts) {
[17:26:44.749]                           name <- restart$name
[17:26:44.749]                           if (is.null(name)) 
[17:26:44.749]                             next
[17:26:44.749]                           if (!grepl(pattern, name)) 
[17:26:44.749]                             next
[17:26:44.749]                           invokeRestart(restart)
[17:26:44.749]                           muffled <- TRUE
[17:26:44.749]                           break
[17:26:44.749]                         }
[17:26:44.749]                       }
[17:26:44.749]                     }
[17:26:44.749]                     invisible(muffled)
[17:26:44.749]                   }
[17:26:44.749]                   muffleCondition(cond)
[17:26:44.749]                 })
[17:26:44.749]             }))
[17:26:44.749]             future::FutureResult(value = ...future.value$value, 
[17:26:44.749]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.749]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.749]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.749]                     ...future.globalenv.names))
[17:26:44.749]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.749]         }, condition = base::local({
[17:26:44.749]             c <- base::c
[17:26:44.749]             inherits <- base::inherits
[17:26:44.749]             invokeRestart <- base::invokeRestart
[17:26:44.749]             length <- base::length
[17:26:44.749]             list <- base::list
[17:26:44.749]             seq.int <- base::seq.int
[17:26:44.749]             signalCondition <- base::signalCondition
[17:26:44.749]             sys.calls <- base::sys.calls
[17:26:44.749]             `[[` <- base::`[[`
[17:26:44.749]             `+` <- base::`+`
[17:26:44.749]             `<<-` <- base::`<<-`
[17:26:44.749]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.749]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.749]                   3L)]
[17:26:44.749]             }
[17:26:44.749]             function(cond) {
[17:26:44.749]                 is_error <- inherits(cond, "error")
[17:26:44.749]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.749]                   NULL)
[17:26:44.749]                 if (is_error) {
[17:26:44.749]                   sessionInformation <- function() {
[17:26:44.749]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.749]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.749]                       search = base::search(), system = base::Sys.info())
[17:26:44.749]                   }
[17:26:44.749]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.749]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.749]                     cond$call), session = sessionInformation(), 
[17:26:44.749]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.749]                   signalCondition(cond)
[17:26:44.749]                 }
[17:26:44.749]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.749]                 "immediateCondition"))) {
[17:26:44.749]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.749]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.749]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.749]                   if (TRUE && !signal) {
[17:26:44.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.749]                     {
[17:26:44.749]                       inherits <- base::inherits
[17:26:44.749]                       invokeRestart <- base::invokeRestart
[17:26:44.749]                       is.null <- base::is.null
[17:26:44.749]                       muffled <- FALSE
[17:26:44.749]                       if (inherits(cond, "message")) {
[17:26:44.749]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.749]                         if (muffled) 
[17:26:44.749]                           invokeRestart("muffleMessage")
[17:26:44.749]                       }
[17:26:44.749]                       else if (inherits(cond, "warning")) {
[17:26:44.749]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.749]                         if (muffled) 
[17:26:44.749]                           invokeRestart("muffleWarning")
[17:26:44.749]                       }
[17:26:44.749]                       else if (inherits(cond, "condition")) {
[17:26:44.749]                         if (!is.null(pattern)) {
[17:26:44.749]                           computeRestarts <- base::computeRestarts
[17:26:44.749]                           grepl <- base::grepl
[17:26:44.749]                           restarts <- computeRestarts(cond)
[17:26:44.749]                           for (restart in restarts) {
[17:26:44.749]                             name <- restart$name
[17:26:44.749]                             if (is.null(name)) 
[17:26:44.749]                               next
[17:26:44.749]                             if (!grepl(pattern, name)) 
[17:26:44.749]                               next
[17:26:44.749]                             invokeRestart(restart)
[17:26:44.749]                             muffled <- TRUE
[17:26:44.749]                             break
[17:26:44.749]                           }
[17:26:44.749]                         }
[17:26:44.749]                       }
[17:26:44.749]                       invisible(muffled)
[17:26:44.749]                     }
[17:26:44.749]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.749]                   }
[17:26:44.749]                 }
[17:26:44.749]                 else {
[17:26:44.749]                   if (TRUE) {
[17:26:44.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.749]                     {
[17:26:44.749]                       inherits <- base::inherits
[17:26:44.749]                       invokeRestart <- base::invokeRestart
[17:26:44.749]                       is.null <- base::is.null
[17:26:44.749]                       muffled <- FALSE
[17:26:44.749]                       if (inherits(cond, "message")) {
[17:26:44.749]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.749]                         if (muffled) 
[17:26:44.749]                           invokeRestart("muffleMessage")
[17:26:44.749]                       }
[17:26:44.749]                       else if (inherits(cond, "warning")) {
[17:26:44.749]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.749]                         if (muffled) 
[17:26:44.749]                           invokeRestart("muffleWarning")
[17:26:44.749]                       }
[17:26:44.749]                       else if (inherits(cond, "condition")) {
[17:26:44.749]                         if (!is.null(pattern)) {
[17:26:44.749]                           computeRestarts <- base::computeRestarts
[17:26:44.749]                           grepl <- base::grepl
[17:26:44.749]                           restarts <- computeRestarts(cond)
[17:26:44.749]                           for (restart in restarts) {
[17:26:44.749]                             name <- restart$name
[17:26:44.749]                             if (is.null(name)) 
[17:26:44.749]                               next
[17:26:44.749]                             if (!grepl(pattern, name)) 
[17:26:44.749]                               next
[17:26:44.749]                             invokeRestart(restart)
[17:26:44.749]                             muffled <- TRUE
[17:26:44.749]                             break
[17:26:44.749]                           }
[17:26:44.749]                         }
[17:26:44.749]                       }
[17:26:44.749]                       invisible(muffled)
[17:26:44.749]                     }
[17:26:44.749]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.749]                   }
[17:26:44.749]                 }
[17:26:44.749]             }
[17:26:44.749]         }))
[17:26:44.749]     }, error = function(ex) {
[17:26:44.749]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.749]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.749]                 ...future.rng), started = ...future.startTime, 
[17:26:44.749]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.749]             version = "1.8"), class = "FutureResult")
[17:26:44.749]     }, finally = {
[17:26:44.749]         if (!identical(...future.workdir, getwd())) 
[17:26:44.749]             setwd(...future.workdir)
[17:26:44.749]         {
[17:26:44.749]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.749]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.749]             }
[17:26:44.749]             base::options(...future.oldOptions)
[17:26:44.749]             if (.Platform$OS.type == "windows") {
[17:26:44.749]                 old_names <- names(...future.oldEnvVars)
[17:26:44.749]                 envs <- base::Sys.getenv()
[17:26:44.749]                 names <- names(envs)
[17:26:44.749]                 common <- intersect(names, old_names)
[17:26:44.749]                 added <- setdiff(names, old_names)
[17:26:44.749]                 removed <- setdiff(old_names, names)
[17:26:44.749]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.749]                   envs[common]]
[17:26:44.749]                 NAMES <- toupper(changed)
[17:26:44.749]                 args <- list()
[17:26:44.749]                 for (kk in seq_along(NAMES)) {
[17:26:44.749]                   name <- changed[[kk]]
[17:26:44.749]                   NAME <- NAMES[[kk]]
[17:26:44.749]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.749]                     next
[17:26:44.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.749]                 }
[17:26:44.749]                 NAMES <- toupper(added)
[17:26:44.749]                 for (kk in seq_along(NAMES)) {
[17:26:44.749]                   name <- added[[kk]]
[17:26:44.749]                   NAME <- NAMES[[kk]]
[17:26:44.749]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.749]                     next
[17:26:44.749]                   args[[name]] <- ""
[17:26:44.749]                 }
[17:26:44.749]                 NAMES <- toupper(removed)
[17:26:44.749]                 for (kk in seq_along(NAMES)) {
[17:26:44.749]                   name <- removed[[kk]]
[17:26:44.749]                   NAME <- NAMES[[kk]]
[17:26:44.749]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.749]                     next
[17:26:44.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.749]                 }
[17:26:44.749]                 if (length(args) > 0) 
[17:26:44.749]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.749]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.749]             }
[17:26:44.749]             else {
[17:26:44.749]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.749]             }
[17:26:44.749]             {
[17:26:44.749]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.749]                   0L) {
[17:26:44.749]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.749]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.749]                   base::options(opts)
[17:26:44.749]                 }
[17:26:44.749]                 {
[17:26:44.749]                   {
[17:26:44.749]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.749]                     NULL
[17:26:44.749]                   }
[17:26:44.749]                   options(future.plan = NULL)
[17:26:44.749]                   if (is.na(NA_character_)) 
[17:26:44.749]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.749]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.749]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.749]                     .init = FALSE)
[17:26:44.749]                 }
[17:26:44.749]             }
[17:26:44.749]         }
[17:26:44.749]     })
[17:26:44.749]     if (TRUE) {
[17:26:44.749]         base::sink(type = "output", split = FALSE)
[17:26:44.749]         if (TRUE) {
[17:26:44.749]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.749]         }
[17:26:44.749]         else {
[17:26:44.749]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.749]         }
[17:26:44.749]         base::close(...future.stdout)
[17:26:44.749]         ...future.stdout <- NULL
[17:26:44.749]     }
[17:26:44.749]     ...future.result$conditions <- ...future.conditions
[17:26:44.749]     ...future.result$finished <- base::Sys.time()
[17:26:44.749]     ...future.result
[17:26:44.749] }
[17:26:44.754] MultisessionFuture started
[17:26:44.754] - Launch lazy future ... done
[17:26:44.754] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000022310463b20> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x00000223109b3840> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000022310463b20> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x00000223109b3840> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 2 3
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
[17:26:44.761] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.761] - Validating connection of MultisessionFuture
[17:26:44.761] - received message: FutureResult
[17:26:44.761] - Received FutureResult
[17:26:44.762] - Erased future from FutureRegistry
[17:26:44.762] result() for ClusterFuture ...
[17:26:44.762] - result already collected: FutureResult
[17:26:44.762] result() for ClusterFuture ... done
[17:26:44.762] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:44.767] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.768] - Validating connection of MultisessionFuture
[17:26:44.768] - received message: FutureResult
[17:26:44.768] - Received FutureResult
[17:26:44.768] - Erased future from FutureRegistry
[17:26:44.768] result() for ClusterFuture ...
[17:26:44.769] - result already collected: FutureResult
[17:26:44.769] result() for ClusterFuture ... done
[17:26:44.769] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:44.773] resolve() on list ...
[17:26:44.773]  recursive: 0
[17:26:44.773]  length: 6
[17:26:44.773]  elements: 'a', 'b', 'c', '', '', ''
[17:26:44.774] signalConditionsASAP(numeric, pos=1) ...
[17:26:44.774] - nx: 6
[17:26:44.774] - relay: TRUE
[17:26:44.774] - stdout: TRUE
[17:26:44.774] - signal: TRUE
[17:26:44.774] - resignal: FALSE
[17:26:44.774] - force: TRUE
[17:26:44.775] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.775] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.775]  - until=2
[17:26:44.775]  - relaying element #2
[17:26:44.775] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.775] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.776] signalConditionsASAP(NULL, pos=1) ... done
[17:26:44.776]  length: 5 (resolved future 1)
[17:26:44.776] Future #2
[17:26:44.776] result() for ClusterFuture ...
[17:26:44.776] - result already collected: FutureResult
[17:26:44.776] result() for ClusterFuture ... done
[17:26:44.777] result() for ClusterFuture ...
[17:26:44.777] - result already collected: FutureResult
[17:26:44.777] result() for ClusterFuture ... done
[17:26:44.777] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:44.777] - nx: 6
[17:26:44.777] - relay: TRUE
[17:26:44.777] - stdout: TRUE
[17:26:44.778] - signal: TRUE
[17:26:44.778] - resignal: FALSE
[17:26:44.778] - force: TRUE
[17:26:44.778] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.778] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.778]  - until=2
[17:26:44.779]  - relaying element #2
[17:26:44.779] result() for ClusterFuture ...
[17:26:44.779] - result already collected: FutureResult
[17:26:44.779] result() for ClusterFuture ... done
[17:26:44.779] result() for ClusterFuture ...
[17:26:44.779] - result already collected: FutureResult
[17:26:44.779] result() for ClusterFuture ... done
[17:26:44.780] result() for ClusterFuture ...
[17:26:44.780] - result already collected: FutureResult
[17:26:44.780] result() for ClusterFuture ... done
[17:26:44.780] result() for ClusterFuture ...
[17:26:44.780] - result already collected: FutureResult
[17:26:44.780] result() for ClusterFuture ... done
[17:26:44.781] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.781] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.781] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:44.781]  length: 4 (resolved future 2)
[17:26:44.781] Future #3
[17:26:44.781] result() for ClusterFuture ...
[17:26:44.782] - result already collected: FutureResult
[17:26:44.782] result() for ClusterFuture ... done
[17:26:44.782] result() for ClusterFuture ...
[17:26:44.782] - result already collected: FutureResult
[17:26:44.782] result() for ClusterFuture ... done
[17:26:44.783] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:44.783] - nx: 6
[17:26:44.783] - relay: TRUE
[17:26:44.783] - stdout: TRUE
[17:26:44.783] - signal: TRUE
[17:26:44.783] - resignal: FALSE
[17:26:44.784] - force: TRUE
[17:26:44.784] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.784] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.784]  - until=3
[17:26:44.784]  - relaying element #3
[17:26:44.784] result() for ClusterFuture ...
[17:26:44.784] - result already collected: FutureResult
[17:26:44.785] result() for ClusterFuture ... done
[17:26:44.785] result() for ClusterFuture ...
[17:26:44.785] - result already collected: FutureResult
[17:26:44.785] result() for ClusterFuture ... done
[17:26:44.785] result() for ClusterFuture ...
[17:26:44.785] - result already collected: FutureResult
[17:26:44.786] result() for ClusterFuture ... done
[17:26:44.786] result() for ClusterFuture ...
[17:26:44.786] - result already collected: FutureResult
[17:26:44.786] result() for ClusterFuture ... done
[17:26:44.786] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.786] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.787] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:44.787]  length: 3 (resolved future 3)
[17:26:44.787] signalConditionsASAP(NULL, pos=4) ...
[17:26:44.787] - nx: 6
[17:26:44.787] - relay: TRUE
[17:26:44.787] - stdout: TRUE
[17:26:44.787] - signal: TRUE
[17:26:44.788] - resignal: FALSE
[17:26:44.788] - force: TRUE
[17:26:44.788] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.788] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.788]  - until=5
[17:26:44.788]  - relaying element #5
[17:26:44.789] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.789] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.789] signalConditionsASAP(NULL, pos=4) ... done
[17:26:44.789]  length: 2 (resolved future 4)
[17:26:44.789] signalConditionsASAP(NULL, pos=5) ...
[17:26:44.789] - nx: 6
[17:26:44.789] - relay: TRUE
[17:26:44.790] - stdout: TRUE
[17:26:44.790] - signal: TRUE
[17:26:44.790] - resignal: FALSE
[17:26:44.790] - force: TRUE
[17:26:44.790] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.790] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.791]  - until=6
[17:26:44.791]  - relaying element #6
[17:26:44.791] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.791] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.791] signalConditionsASAP(NULL, pos=5) ... done
[17:26:44.791]  length: 1 (resolved future 5)
[17:26:44.792] signalConditionsASAP(numeric, pos=6) ...
[17:26:44.792] - nx: 6
[17:26:44.792] - relay: TRUE
[17:26:44.792] - stdout: TRUE
[17:26:44.792] - signal: TRUE
[17:26:44.792] - resignal: FALSE
[17:26:44.792] - force: TRUE
[17:26:44.793] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.793] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.793]  - until=6
[17:26:44.793] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.793] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.793] signalConditionsASAP(numeric, pos=6) ... done
[17:26:44.794]  length: 0 (resolved future 6)
[17:26:44.794] Relaying remaining futures
[17:26:44.794] signalConditionsASAP(NULL, pos=0) ...
[17:26:44.794] - nx: 6
[17:26:44.794] - relay: TRUE
[17:26:44.794] - stdout: TRUE
[17:26:44.794] - signal: TRUE
[17:26:44.795] - resignal: FALSE
[17:26:44.795] - force: TRUE
[17:26:44.795] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.795] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:44.795] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.795] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.796] signalConditionsASAP(NULL, pos=0) ... done
[17:26:44.796] resolve() on list ... DONE
[17:26:44.796] result() for ClusterFuture ...
[17:26:44.796] - result already collected: FutureResult
[17:26:44.796] result() for ClusterFuture ... done
[17:26:44.796] result() for ClusterFuture ...
[17:26:44.797] - result already collected: FutureResult
[17:26:44.797] result() for ClusterFuture ... done
[17:26:44.797] result() for ClusterFuture ...
[17:26:44.797] - result already collected: FutureResult
[17:26:44.797] result() for ClusterFuture ... done
[17:26:44.797] result() for ClusterFuture ...
[17:26:44.798] - result already collected: FutureResult
[17:26:44.798] result() for ClusterFuture ... done
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:2] 2 3
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
Dimensions: c(2, 3, 1)
[17:26:44.802] getGlobalsAndPackages() ...
[17:26:44.802] Searching for globals...
[17:26:44.802] 
[17:26:44.802] Searching for globals ... DONE
[17:26:44.802] - globals: [0] <none>
[17:26:44.803] getGlobalsAndPackages() ... DONE
[17:26:44.803] run() for 'Future' ...
[17:26:44.803] - state: 'created'
[17:26:44.803] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.818] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.818] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.818]   - Field: 'node'
[17:26:44.818]   - Field: 'label'
[17:26:44.819]   - Field: 'local'
[17:26:44.819]   - Field: 'owner'
[17:26:44.819]   - Field: 'envir'
[17:26:44.819]   - Field: 'workers'
[17:26:44.819]   - Field: 'packages'
[17:26:44.820]   - Field: 'gc'
[17:26:44.820]   - Field: 'conditions'
[17:26:44.820]   - Field: 'persistent'
[17:26:44.820]   - Field: 'expr'
[17:26:44.820]   - Field: 'uuid'
[17:26:44.820]   - Field: 'seed'
[17:26:44.821]   - Field: 'version'
[17:26:44.821]   - Field: 'result'
[17:26:44.821]   - Field: 'asynchronous'
[17:26:44.821]   - Field: 'calls'
[17:26:44.821]   - Field: 'globals'
[17:26:44.821]   - Field: 'stdout'
[17:26:44.822]   - Field: 'earlySignal'
[17:26:44.822]   - Field: 'lazy'
[17:26:44.822]   - Field: 'state'
[17:26:44.822] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.822] - Launch lazy future ...
[17:26:44.823] Packages needed by the future expression (n = 0): <none>
[17:26:44.823] Packages needed by future strategies (n = 0): <none>
[17:26:44.823] {
[17:26:44.823]     {
[17:26:44.823]         {
[17:26:44.823]             ...future.startTime <- base::Sys.time()
[17:26:44.823]             {
[17:26:44.823]                 {
[17:26:44.823]                   {
[17:26:44.823]                     {
[17:26:44.823]                       base::local({
[17:26:44.823]                         has_future <- base::requireNamespace("future", 
[17:26:44.823]                           quietly = TRUE)
[17:26:44.823]                         if (has_future) {
[17:26:44.823]                           ns <- base::getNamespace("future")
[17:26:44.823]                           version <- ns[[".package"]][["version"]]
[17:26:44.823]                           if (is.null(version)) 
[17:26:44.823]                             version <- utils::packageVersion("future")
[17:26:44.823]                         }
[17:26:44.823]                         else {
[17:26:44.823]                           version <- NULL
[17:26:44.823]                         }
[17:26:44.823]                         if (!has_future || version < "1.8.0") {
[17:26:44.823]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.823]                             "", base::R.version$version.string), 
[17:26:44.823]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.823]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.823]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.823]                               "release", "version")], collapse = " "), 
[17:26:44.823]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.823]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.823]                             info)
[17:26:44.823]                           info <- base::paste(info, collapse = "; ")
[17:26:44.823]                           if (!has_future) {
[17:26:44.823]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.823]                               info)
[17:26:44.823]                           }
[17:26:44.823]                           else {
[17:26:44.823]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.823]                               info, version)
[17:26:44.823]                           }
[17:26:44.823]                           base::stop(msg)
[17:26:44.823]                         }
[17:26:44.823]                       })
[17:26:44.823]                     }
[17:26:44.823]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.823]                     base::options(mc.cores = 1L)
[17:26:44.823]                   }
[17:26:44.823]                   ...future.strategy.old <- future::plan("list")
[17:26:44.823]                   options(future.plan = NULL)
[17:26:44.823]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.823]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.823]                 }
[17:26:44.823]                 ...future.workdir <- getwd()
[17:26:44.823]             }
[17:26:44.823]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.823]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.823]         }
[17:26:44.823]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.823]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.823]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.823]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.823]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.823]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.823]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.823]             base::names(...future.oldOptions))
[17:26:44.823]     }
[17:26:44.823]     if (FALSE) {
[17:26:44.823]     }
[17:26:44.823]     else {
[17:26:44.823]         if (TRUE) {
[17:26:44.823]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.823]                 open = "w")
[17:26:44.823]         }
[17:26:44.823]         else {
[17:26:44.823]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.823]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.823]         }
[17:26:44.823]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.823]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.823]             base::sink(type = "output", split = FALSE)
[17:26:44.823]             base::close(...future.stdout)
[17:26:44.823]         }, add = TRUE)
[17:26:44.823]     }
[17:26:44.823]     ...future.frame <- base::sys.nframe()
[17:26:44.823]     ...future.conditions <- base::list()
[17:26:44.823]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.823]     if (FALSE) {
[17:26:44.823]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.823]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.823]     }
[17:26:44.823]     ...future.result <- base::tryCatch({
[17:26:44.823]         base::withCallingHandlers({
[17:26:44.823]             ...future.value <- base::withVisible(base::local({
[17:26:44.823]                 ...future.makeSendCondition <- base::local({
[17:26:44.823]                   sendCondition <- NULL
[17:26:44.823]                   function(frame = 1L) {
[17:26:44.823]                     if (is.function(sendCondition)) 
[17:26:44.823]                       return(sendCondition)
[17:26:44.823]                     ns <- getNamespace("parallel")
[17:26:44.823]                     if (exists("sendData", mode = "function", 
[17:26:44.823]                       envir = ns)) {
[17:26:44.823]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.823]                         envir = ns)
[17:26:44.823]                       envir <- sys.frame(frame)
[17:26:44.823]                       master <- NULL
[17:26:44.823]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.823]                         !identical(envir, emptyenv())) {
[17:26:44.823]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.823]                           inherits = FALSE)) {
[17:26:44.823]                           master <- get("master", mode = "list", 
[17:26:44.823]                             envir = envir, inherits = FALSE)
[17:26:44.823]                           if (inherits(master, c("SOCKnode", 
[17:26:44.823]                             "SOCK0node"))) {
[17:26:44.823]                             sendCondition <<- function(cond) {
[17:26:44.823]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.823]                                 success = TRUE)
[17:26:44.823]                               parallel_sendData(master, data)
[17:26:44.823]                             }
[17:26:44.823]                             return(sendCondition)
[17:26:44.823]                           }
[17:26:44.823]                         }
[17:26:44.823]                         frame <- frame + 1L
[17:26:44.823]                         envir <- sys.frame(frame)
[17:26:44.823]                       }
[17:26:44.823]                     }
[17:26:44.823]                     sendCondition <<- function(cond) NULL
[17:26:44.823]                   }
[17:26:44.823]                 })
[17:26:44.823]                 withCallingHandlers({
[17:26:44.823]                   2
[17:26:44.823]                 }, immediateCondition = function(cond) {
[17:26:44.823]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.823]                   sendCondition(cond)
[17:26:44.823]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.823]                   {
[17:26:44.823]                     inherits <- base::inherits
[17:26:44.823]                     invokeRestart <- base::invokeRestart
[17:26:44.823]                     is.null <- base::is.null
[17:26:44.823]                     muffled <- FALSE
[17:26:44.823]                     if (inherits(cond, "message")) {
[17:26:44.823]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.823]                       if (muffled) 
[17:26:44.823]                         invokeRestart("muffleMessage")
[17:26:44.823]                     }
[17:26:44.823]                     else if (inherits(cond, "warning")) {
[17:26:44.823]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.823]                       if (muffled) 
[17:26:44.823]                         invokeRestart("muffleWarning")
[17:26:44.823]                     }
[17:26:44.823]                     else if (inherits(cond, "condition")) {
[17:26:44.823]                       if (!is.null(pattern)) {
[17:26:44.823]                         computeRestarts <- base::computeRestarts
[17:26:44.823]                         grepl <- base::grepl
[17:26:44.823]                         restarts <- computeRestarts(cond)
[17:26:44.823]                         for (restart in restarts) {
[17:26:44.823]                           name <- restart$name
[17:26:44.823]                           if (is.null(name)) 
[17:26:44.823]                             next
[17:26:44.823]                           if (!grepl(pattern, name)) 
[17:26:44.823]                             next
[17:26:44.823]                           invokeRestart(restart)
[17:26:44.823]                           muffled <- TRUE
[17:26:44.823]                           break
[17:26:44.823]                         }
[17:26:44.823]                       }
[17:26:44.823]                     }
[17:26:44.823]                     invisible(muffled)
[17:26:44.823]                   }
[17:26:44.823]                   muffleCondition(cond)
[17:26:44.823]                 })
[17:26:44.823]             }))
[17:26:44.823]             future::FutureResult(value = ...future.value$value, 
[17:26:44.823]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.823]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.823]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.823]                     ...future.globalenv.names))
[17:26:44.823]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.823]         }, condition = base::local({
[17:26:44.823]             c <- base::c
[17:26:44.823]             inherits <- base::inherits
[17:26:44.823]             invokeRestart <- base::invokeRestart
[17:26:44.823]             length <- base::length
[17:26:44.823]             list <- base::list
[17:26:44.823]             seq.int <- base::seq.int
[17:26:44.823]             signalCondition <- base::signalCondition
[17:26:44.823]             sys.calls <- base::sys.calls
[17:26:44.823]             `[[` <- base::`[[`
[17:26:44.823]             `+` <- base::`+`
[17:26:44.823]             `<<-` <- base::`<<-`
[17:26:44.823]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.823]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.823]                   3L)]
[17:26:44.823]             }
[17:26:44.823]             function(cond) {
[17:26:44.823]                 is_error <- inherits(cond, "error")
[17:26:44.823]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.823]                   NULL)
[17:26:44.823]                 if (is_error) {
[17:26:44.823]                   sessionInformation <- function() {
[17:26:44.823]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.823]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.823]                       search = base::search(), system = base::Sys.info())
[17:26:44.823]                   }
[17:26:44.823]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.823]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.823]                     cond$call), session = sessionInformation(), 
[17:26:44.823]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.823]                   signalCondition(cond)
[17:26:44.823]                 }
[17:26:44.823]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.823]                 "immediateCondition"))) {
[17:26:44.823]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.823]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.823]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.823]                   if (TRUE && !signal) {
[17:26:44.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.823]                     {
[17:26:44.823]                       inherits <- base::inherits
[17:26:44.823]                       invokeRestart <- base::invokeRestart
[17:26:44.823]                       is.null <- base::is.null
[17:26:44.823]                       muffled <- FALSE
[17:26:44.823]                       if (inherits(cond, "message")) {
[17:26:44.823]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.823]                         if (muffled) 
[17:26:44.823]                           invokeRestart("muffleMessage")
[17:26:44.823]                       }
[17:26:44.823]                       else if (inherits(cond, "warning")) {
[17:26:44.823]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.823]                         if (muffled) 
[17:26:44.823]                           invokeRestart("muffleWarning")
[17:26:44.823]                       }
[17:26:44.823]                       else if (inherits(cond, "condition")) {
[17:26:44.823]                         if (!is.null(pattern)) {
[17:26:44.823]                           computeRestarts <- base::computeRestarts
[17:26:44.823]                           grepl <- base::grepl
[17:26:44.823]                           restarts <- computeRestarts(cond)
[17:26:44.823]                           for (restart in restarts) {
[17:26:44.823]                             name <- restart$name
[17:26:44.823]                             if (is.null(name)) 
[17:26:44.823]                               next
[17:26:44.823]                             if (!grepl(pattern, name)) 
[17:26:44.823]                               next
[17:26:44.823]                             invokeRestart(restart)
[17:26:44.823]                             muffled <- TRUE
[17:26:44.823]                             break
[17:26:44.823]                           }
[17:26:44.823]                         }
[17:26:44.823]                       }
[17:26:44.823]                       invisible(muffled)
[17:26:44.823]                     }
[17:26:44.823]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.823]                   }
[17:26:44.823]                 }
[17:26:44.823]                 else {
[17:26:44.823]                   if (TRUE) {
[17:26:44.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.823]                     {
[17:26:44.823]                       inherits <- base::inherits
[17:26:44.823]                       invokeRestart <- base::invokeRestart
[17:26:44.823]                       is.null <- base::is.null
[17:26:44.823]                       muffled <- FALSE
[17:26:44.823]                       if (inherits(cond, "message")) {
[17:26:44.823]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.823]                         if (muffled) 
[17:26:44.823]                           invokeRestart("muffleMessage")
[17:26:44.823]                       }
[17:26:44.823]                       else if (inherits(cond, "warning")) {
[17:26:44.823]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.823]                         if (muffled) 
[17:26:44.823]                           invokeRestart("muffleWarning")
[17:26:44.823]                       }
[17:26:44.823]                       else if (inherits(cond, "condition")) {
[17:26:44.823]                         if (!is.null(pattern)) {
[17:26:44.823]                           computeRestarts <- base::computeRestarts
[17:26:44.823]                           grepl <- base::grepl
[17:26:44.823]                           restarts <- computeRestarts(cond)
[17:26:44.823]                           for (restart in restarts) {
[17:26:44.823]                             name <- restart$name
[17:26:44.823]                             if (is.null(name)) 
[17:26:44.823]                               next
[17:26:44.823]                             if (!grepl(pattern, name)) 
[17:26:44.823]                               next
[17:26:44.823]                             invokeRestart(restart)
[17:26:44.823]                             muffled <- TRUE
[17:26:44.823]                             break
[17:26:44.823]                           }
[17:26:44.823]                         }
[17:26:44.823]                       }
[17:26:44.823]                       invisible(muffled)
[17:26:44.823]                     }
[17:26:44.823]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.823]                   }
[17:26:44.823]                 }
[17:26:44.823]             }
[17:26:44.823]         }))
[17:26:44.823]     }, error = function(ex) {
[17:26:44.823]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.823]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.823]                 ...future.rng), started = ...future.startTime, 
[17:26:44.823]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.823]             version = "1.8"), class = "FutureResult")
[17:26:44.823]     }, finally = {
[17:26:44.823]         if (!identical(...future.workdir, getwd())) 
[17:26:44.823]             setwd(...future.workdir)
[17:26:44.823]         {
[17:26:44.823]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.823]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.823]             }
[17:26:44.823]             base::options(...future.oldOptions)
[17:26:44.823]             if (.Platform$OS.type == "windows") {
[17:26:44.823]                 old_names <- names(...future.oldEnvVars)
[17:26:44.823]                 envs <- base::Sys.getenv()
[17:26:44.823]                 names <- names(envs)
[17:26:44.823]                 common <- intersect(names, old_names)
[17:26:44.823]                 added <- setdiff(names, old_names)
[17:26:44.823]                 removed <- setdiff(old_names, names)
[17:26:44.823]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.823]                   envs[common]]
[17:26:44.823]                 NAMES <- toupper(changed)
[17:26:44.823]                 args <- list()
[17:26:44.823]                 for (kk in seq_along(NAMES)) {
[17:26:44.823]                   name <- changed[[kk]]
[17:26:44.823]                   NAME <- NAMES[[kk]]
[17:26:44.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.823]                     next
[17:26:44.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.823]                 }
[17:26:44.823]                 NAMES <- toupper(added)
[17:26:44.823]                 for (kk in seq_along(NAMES)) {
[17:26:44.823]                   name <- added[[kk]]
[17:26:44.823]                   NAME <- NAMES[[kk]]
[17:26:44.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.823]                     next
[17:26:44.823]                   args[[name]] <- ""
[17:26:44.823]                 }
[17:26:44.823]                 NAMES <- toupper(removed)
[17:26:44.823]                 for (kk in seq_along(NAMES)) {
[17:26:44.823]                   name <- removed[[kk]]
[17:26:44.823]                   NAME <- NAMES[[kk]]
[17:26:44.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.823]                     next
[17:26:44.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.823]                 }
[17:26:44.823]                 if (length(args) > 0) 
[17:26:44.823]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.823]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.823]             }
[17:26:44.823]             else {
[17:26:44.823]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.823]             }
[17:26:44.823]             {
[17:26:44.823]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.823]                   0L) {
[17:26:44.823]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.823]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.823]                   base::options(opts)
[17:26:44.823]                 }
[17:26:44.823]                 {
[17:26:44.823]                   {
[17:26:44.823]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.823]                     NULL
[17:26:44.823]                   }
[17:26:44.823]                   options(future.plan = NULL)
[17:26:44.823]                   if (is.na(NA_character_)) 
[17:26:44.823]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.823]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.823]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.823]                     .init = FALSE)
[17:26:44.823]                 }
[17:26:44.823]             }
[17:26:44.823]         }
[17:26:44.823]     })
[17:26:44.823]     if (TRUE) {
[17:26:44.823]         base::sink(type = "output", split = FALSE)
[17:26:44.823]         if (TRUE) {
[17:26:44.823]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.823]         }
[17:26:44.823]         else {
[17:26:44.823]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.823]         }
[17:26:44.823]         base::close(...future.stdout)
[17:26:44.823]         ...future.stdout <- NULL
[17:26:44.823]     }
[17:26:44.823]     ...future.result$conditions <- ...future.conditions
[17:26:44.823]     ...future.result$finished <- base::Sys.time()
[17:26:44.823]     ...future.result
[17:26:44.823] }
[17:26:44.829] MultisessionFuture started
[17:26:44.829] - Launch lazy future ... done
[17:26:44.829] run() for 'MultisessionFuture' ... done
[17:26:44.830] getGlobalsAndPackages() ...
[17:26:44.830] Searching for globals...
[17:26:44.830] 
[17:26:44.830] Searching for globals ... DONE
[17:26:44.830] - globals: [0] <none>
[17:26:44.831] getGlobalsAndPackages() ... DONE
[17:26:44.831] run() for 'Future' ...
[17:26:44.831] - state: 'created'
[17:26:44.831] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.845] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.845] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.845]   - Field: 'node'
[17:26:44.845]   - Field: 'label'
[17:26:44.845]   - Field: 'local'
[17:26:44.846]   - Field: 'owner'
[17:26:44.846]   - Field: 'envir'
[17:26:44.846]   - Field: 'workers'
[17:26:44.846]   - Field: 'packages'
[17:26:44.846]   - Field: 'gc'
[17:26:44.846]   - Field: 'conditions'
[17:26:44.847]   - Field: 'persistent'
[17:26:44.847]   - Field: 'expr'
[17:26:44.847]   - Field: 'uuid'
[17:26:44.847]   - Field: 'seed'
[17:26:44.847]   - Field: 'version'
[17:26:44.848]   - Field: 'result'
[17:26:44.848]   - Field: 'asynchronous'
[17:26:44.848]   - Field: 'calls'
[17:26:44.848]   - Field: 'globals'
[17:26:44.848]   - Field: 'stdout'
[17:26:44.848]   - Field: 'earlySignal'
[17:26:44.849]   - Field: 'lazy'
[17:26:44.849]   - Field: 'state'
[17:26:44.849] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.849] - Launch lazy future ...
[17:26:44.849] Packages needed by the future expression (n = 0): <none>
[17:26:44.850] Packages needed by future strategies (n = 0): <none>
[17:26:44.850] {
[17:26:44.850]     {
[17:26:44.850]         {
[17:26:44.850]             ...future.startTime <- base::Sys.time()
[17:26:44.850]             {
[17:26:44.850]                 {
[17:26:44.850]                   {
[17:26:44.850]                     {
[17:26:44.850]                       base::local({
[17:26:44.850]                         has_future <- base::requireNamespace("future", 
[17:26:44.850]                           quietly = TRUE)
[17:26:44.850]                         if (has_future) {
[17:26:44.850]                           ns <- base::getNamespace("future")
[17:26:44.850]                           version <- ns[[".package"]][["version"]]
[17:26:44.850]                           if (is.null(version)) 
[17:26:44.850]                             version <- utils::packageVersion("future")
[17:26:44.850]                         }
[17:26:44.850]                         else {
[17:26:44.850]                           version <- NULL
[17:26:44.850]                         }
[17:26:44.850]                         if (!has_future || version < "1.8.0") {
[17:26:44.850]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.850]                             "", base::R.version$version.string), 
[17:26:44.850]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.850]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.850]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.850]                               "release", "version")], collapse = " "), 
[17:26:44.850]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.850]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.850]                             info)
[17:26:44.850]                           info <- base::paste(info, collapse = "; ")
[17:26:44.850]                           if (!has_future) {
[17:26:44.850]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.850]                               info)
[17:26:44.850]                           }
[17:26:44.850]                           else {
[17:26:44.850]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.850]                               info, version)
[17:26:44.850]                           }
[17:26:44.850]                           base::stop(msg)
[17:26:44.850]                         }
[17:26:44.850]                       })
[17:26:44.850]                     }
[17:26:44.850]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.850]                     base::options(mc.cores = 1L)
[17:26:44.850]                   }
[17:26:44.850]                   ...future.strategy.old <- future::plan("list")
[17:26:44.850]                   options(future.plan = NULL)
[17:26:44.850]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.850]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.850]                 }
[17:26:44.850]                 ...future.workdir <- getwd()
[17:26:44.850]             }
[17:26:44.850]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.850]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.850]         }
[17:26:44.850]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.850]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.850]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.850]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.850]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.850]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.850]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.850]             base::names(...future.oldOptions))
[17:26:44.850]     }
[17:26:44.850]     if (FALSE) {
[17:26:44.850]     }
[17:26:44.850]     else {
[17:26:44.850]         if (TRUE) {
[17:26:44.850]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.850]                 open = "w")
[17:26:44.850]         }
[17:26:44.850]         else {
[17:26:44.850]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.850]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.850]         }
[17:26:44.850]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.850]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.850]             base::sink(type = "output", split = FALSE)
[17:26:44.850]             base::close(...future.stdout)
[17:26:44.850]         }, add = TRUE)
[17:26:44.850]     }
[17:26:44.850]     ...future.frame <- base::sys.nframe()
[17:26:44.850]     ...future.conditions <- base::list()
[17:26:44.850]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.850]     if (FALSE) {
[17:26:44.850]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.850]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.850]     }
[17:26:44.850]     ...future.result <- base::tryCatch({
[17:26:44.850]         base::withCallingHandlers({
[17:26:44.850]             ...future.value <- base::withVisible(base::local({
[17:26:44.850]                 ...future.makeSendCondition <- base::local({
[17:26:44.850]                   sendCondition <- NULL
[17:26:44.850]                   function(frame = 1L) {
[17:26:44.850]                     if (is.function(sendCondition)) 
[17:26:44.850]                       return(sendCondition)
[17:26:44.850]                     ns <- getNamespace("parallel")
[17:26:44.850]                     if (exists("sendData", mode = "function", 
[17:26:44.850]                       envir = ns)) {
[17:26:44.850]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.850]                         envir = ns)
[17:26:44.850]                       envir <- sys.frame(frame)
[17:26:44.850]                       master <- NULL
[17:26:44.850]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.850]                         !identical(envir, emptyenv())) {
[17:26:44.850]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.850]                           inherits = FALSE)) {
[17:26:44.850]                           master <- get("master", mode = "list", 
[17:26:44.850]                             envir = envir, inherits = FALSE)
[17:26:44.850]                           if (inherits(master, c("SOCKnode", 
[17:26:44.850]                             "SOCK0node"))) {
[17:26:44.850]                             sendCondition <<- function(cond) {
[17:26:44.850]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.850]                                 success = TRUE)
[17:26:44.850]                               parallel_sendData(master, data)
[17:26:44.850]                             }
[17:26:44.850]                             return(sendCondition)
[17:26:44.850]                           }
[17:26:44.850]                         }
[17:26:44.850]                         frame <- frame + 1L
[17:26:44.850]                         envir <- sys.frame(frame)
[17:26:44.850]                       }
[17:26:44.850]                     }
[17:26:44.850]                     sendCondition <<- function(cond) NULL
[17:26:44.850]                   }
[17:26:44.850]                 })
[17:26:44.850]                 withCallingHandlers({
[17:26:44.850]                   NULL
[17:26:44.850]                 }, immediateCondition = function(cond) {
[17:26:44.850]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.850]                   sendCondition(cond)
[17:26:44.850]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.850]                   {
[17:26:44.850]                     inherits <- base::inherits
[17:26:44.850]                     invokeRestart <- base::invokeRestart
[17:26:44.850]                     is.null <- base::is.null
[17:26:44.850]                     muffled <- FALSE
[17:26:44.850]                     if (inherits(cond, "message")) {
[17:26:44.850]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.850]                       if (muffled) 
[17:26:44.850]                         invokeRestart("muffleMessage")
[17:26:44.850]                     }
[17:26:44.850]                     else if (inherits(cond, "warning")) {
[17:26:44.850]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.850]                       if (muffled) 
[17:26:44.850]                         invokeRestart("muffleWarning")
[17:26:44.850]                     }
[17:26:44.850]                     else if (inherits(cond, "condition")) {
[17:26:44.850]                       if (!is.null(pattern)) {
[17:26:44.850]                         computeRestarts <- base::computeRestarts
[17:26:44.850]                         grepl <- base::grepl
[17:26:44.850]                         restarts <- computeRestarts(cond)
[17:26:44.850]                         for (restart in restarts) {
[17:26:44.850]                           name <- restart$name
[17:26:44.850]                           if (is.null(name)) 
[17:26:44.850]                             next
[17:26:44.850]                           if (!grepl(pattern, name)) 
[17:26:44.850]                             next
[17:26:44.850]                           invokeRestart(restart)
[17:26:44.850]                           muffled <- TRUE
[17:26:44.850]                           break
[17:26:44.850]                         }
[17:26:44.850]                       }
[17:26:44.850]                     }
[17:26:44.850]                     invisible(muffled)
[17:26:44.850]                   }
[17:26:44.850]                   muffleCondition(cond)
[17:26:44.850]                 })
[17:26:44.850]             }))
[17:26:44.850]             future::FutureResult(value = ...future.value$value, 
[17:26:44.850]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.850]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.850]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.850]                     ...future.globalenv.names))
[17:26:44.850]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.850]         }, condition = base::local({
[17:26:44.850]             c <- base::c
[17:26:44.850]             inherits <- base::inherits
[17:26:44.850]             invokeRestart <- base::invokeRestart
[17:26:44.850]             length <- base::length
[17:26:44.850]             list <- base::list
[17:26:44.850]             seq.int <- base::seq.int
[17:26:44.850]             signalCondition <- base::signalCondition
[17:26:44.850]             sys.calls <- base::sys.calls
[17:26:44.850]             `[[` <- base::`[[`
[17:26:44.850]             `+` <- base::`+`
[17:26:44.850]             `<<-` <- base::`<<-`
[17:26:44.850]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.850]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.850]                   3L)]
[17:26:44.850]             }
[17:26:44.850]             function(cond) {
[17:26:44.850]                 is_error <- inherits(cond, "error")
[17:26:44.850]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.850]                   NULL)
[17:26:44.850]                 if (is_error) {
[17:26:44.850]                   sessionInformation <- function() {
[17:26:44.850]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.850]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.850]                       search = base::search(), system = base::Sys.info())
[17:26:44.850]                   }
[17:26:44.850]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.850]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.850]                     cond$call), session = sessionInformation(), 
[17:26:44.850]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.850]                   signalCondition(cond)
[17:26:44.850]                 }
[17:26:44.850]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.850]                 "immediateCondition"))) {
[17:26:44.850]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.850]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.850]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.850]                   if (TRUE && !signal) {
[17:26:44.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.850]                     {
[17:26:44.850]                       inherits <- base::inherits
[17:26:44.850]                       invokeRestart <- base::invokeRestart
[17:26:44.850]                       is.null <- base::is.null
[17:26:44.850]                       muffled <- FALSE
[17:26:44.850]                       if (inherits(cond, "message")) {
[17:26:44.850]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.850]                         if (muffled) 
[17:26:44.850]                           invokeRestart("muffleMessage")
[17:26:44.850]                       }
[17:26:44.850]                       else if (inherits(cond, "warning")) {
[17:26:44.850]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.850]                         if (muffled) 
[17:26:44.850]                           invokeRestart("muffleWarning")
[17:26:44.850]                       }
[17:26:44.850]                       else if (inherits(cond, "condition")) {
[17:26:44.850]                         if (!is.null(pattern)) {
[17:26:44.850]                           computeRestarts <- base::computeRestarts
[17:26:44.850]                           grepl <- base::grepl
[17:26:44.850]                           restarts <- computeRestarts(cond)
[17:26:44.850]                           for (restart in restarts) {
[17:26:44.850]                             name <- restart$name
[17:26:44.850]                             if (is.null(name)) 
[17:26:44.850]                               next
[17:26:44.850]                             if (!grepl(pattern, name)) 
[17:26:44.850]                               next
[17:26:44.850]                             invokeRestart(restart)
[17:26:44.850]                             muffled <- TRUE
[17:26:44.850]                             break
[17:26:44.850]                           }
[17:26:44.850]                         }
[17:26:44.850]                       }
[17:26:44.850]                       invisible(muffled)
[17:26:44.850]                     }
[17:26:44.850]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.850]                   }
[17:26:44.850]                 }
[17:26:44.850]                 else {
[17:26:44.850]                   if (TRUE) {
[17:26:44.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.850]                     {
[17:26:44.850]                       inherits <- base::inherits
[17:26:44.850]                       invokeRestart <- base::invokeRestart
[17:26:44.850]                       is.null <- base::is.null
[17:26:44.850]                       muffled <- FALSE
[17:26:44.850]                       if (inherits(cond, "message")) {
[17:26:44.850]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.850]                         if (muffled) 
[17:26:44.850]                           invokeRestart("muffleMessage")
[17:26:44.850]                       }
[17:26:44.850]                       else if (inherits(cond, "warning")) {
[17:26:44.850]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.850]                         if (muffled) 
[17:26:44.850]                           invokeRestart("muffleWarning")
[17:26:44.850]                       }
[17:26:44.850]                       else if (inherits(cond, "condition")) {
[17:26:44.850]                         if (!is.null(pattern)) {
[17:26:44.850]                           computeRestarts <- base::computeRestarts
[17:26:44.850]                           grepl <- base::grepl
[17:26:44.850]                           restarts <- computeRestarts(cond)
[17:26:44.850]                           for (restart in restarts) {
[17:26:44.850]                             name <- restart$name
[17:26:44.850]                             if (is.null(name)) 
[17:26:44.850]                               next
[17:26:44.850]                             if (!grepl(pattern, name)) 
[17:26:44.850]                               next
[17:26:44.850]                             invokeRestart(restart)
[17:26:44.850]                             muffled <- TRUE
[17:26:44.850]                             break
[17:26:44.850]                           }
[17:26:44.850]                         }
[17:26:44.850]                       }
[17:26:44.850]                       invisible(muffled)
[17:26:44.850]                     }
[17:26:44.850]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.850]                   }
[17:26:44.850]                 }
[17:26:44.850]             }
[17:26:44.850]         }))
[17:26:44.850]     }, error = function(ex) {
[17:26:44.850]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.850]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.850]                 ...future.rng), started = ...future.startTime, 
[17:26:44.850]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.850]             version = "1.8"), class = "FutureResult")
[17:26:44.850]     }, finally = {
[17:26:44.850]         if (!identical(...future.workdir, getwd())) 
[17:26:44.850]             setwd(...future.workdir)
[17:26:44.850]         {
[17:26:44.850]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.850]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.850]             }
[17:26:44.850]             base::options(...future.oldOptions)
[17:26:44.850]             if (.Platform$OS.type == "windows") {
[17:26:44.850]                 old_names <- names(...future.oldEnvVars)
[17:26:44.850]                 envs <- base::Sys.getenv()
[17:26:44.850]                 names <- names(envs)
[17:26:44.850]                 common <- intersect(names, old_names)
[17:26:44.850]                 added <- setdiff(names, old_names)
[17:26:44.850]                 removed <- setdiff(old_names, names)
[17:26:44.850]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.850]                   envs[common]]
[17:26:44.850]                 NAMES <- toupper(changed)
[17:26:44.850]                 args <- list()
[17:26:44.850]                 for (kk in seq_along(NAMES)) {
[17:26:44.850]                   name <- changed[[kk]]
[17:26:44.850]                   NAME <- NAMES[[kk]]
[17:26:44.850]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.850]                     next
[17:26:44.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.850]                 }
[17:26:44.850]                 NAMES <- toupper(added)
[17:26:44.850]                 for (kk in seq_along(NAMES)) {
[17:26:44.850]                   name <- added[[kk]]
[17:26:44.850]                   NAME <- NAMES[[kk]]
[17:26:44.850]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.850]                     next
[17:26:44.850]                   args[[name]] <- ""
[17:26:44.850]                 }
[17:26:44.850]                 NAMES <- toupper(removed)
[17:26:44.850]                 for (kk in seq_along(NAMES)) {
[17:26:44.850]                   name <- removed[[kk]]
[17:26:44.850]                   NAME <- NAMES[[kk]]
[17:26:44.850]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.850]                     next
[17:26:44.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.850]                 }
[17:26:44.850]                 if (length(args) > 0) 
[17:26:44.850]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.850]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.850]             }
[17:26:44.850]             else {
[17:26:44.850]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.850]             }
[17:26:44.850]             {
[17:26:44.850]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.850]                   0L) {
[17:26:44.850]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.850]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.850]                   base::options(opts)
[17:26:44.850]                 }
[17:26:44.850]                 {
[17:26:44.850]                   {
[17:26:44.850]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.850]                     NULL
[17:26:44.850]                   }
[17:26:44.850]                   options(future.plan = NULL)
[17:26:44.850]                   if (is.na(NA_character_)) 
[17:26:44.850]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.850]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.850]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.850]                     .init = FALSE)
[17:26:44.850]                 }
[17:26:44.850]             }
[17:26:44.850]         }
[17:26:44.850]     })
[17:26:44.850]     if (TRUE) {
[17:26:44.850]         base::sink(type = "output", split = FALSE)
[17:26:44.850]         if (TRUE) {
[17:26:44.850]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.850]         }
[17:26:44.850]         else {
[17:26:44.850]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.850]         }
[17:26:44.850]         base::close(...future.stdout)
[17:26:44.850]         ...future.stdout <- NULL
[17:26:44.850]     }
[17:26:44.850]     ...future.result$conditions <- ...future.conditions
[17:26:44.850]     ...future.result$finished <- base::Sys.time()
[17:26:44.850]     ...future.result
[17:26:44.850] }
[17:26:44.856] MultisessionFuture started
[17:26:44.856] - Launch lazy future ... done
[17:26:44.856] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230b1af8b0> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230f6a9cd8> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230b1af8b0> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230f6a9cd8> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:3] 2 3 1
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:44.863] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.863] - Validating connection of MultisessionFuture
[17:26:44.863] - received message: FutureResult
[17:26:44.863] - Received FutureResult
[17:26:44.863] - Erased future from FutureRegistry
[17:26:44.864] result() for ClusterFuture ...
[17:26:44.864] - result already collected: FutureResult
[17:26:44.864] result() for ClusterFuture ... done
[17:26:44.864] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:44.870] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.870] - Validating connection of MultisessionFuture
[17:26:44.870] - received message: FutureResult
[17:26:44.871] - Received FutureResult
[17:26:44.871] - Erased future from FutureRegistry
[17:26:44.871] result() for ClusterFuture ...
[17:26:44.871] - result already collected: FutureResult
[17:26:44.871] result() for ClusterFuture ... done
[17:26:44.871] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1:2, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:44.874] resolve() on list ...
[17:26:44.874]  recursive: 0
[17:26:44.874]  length: 6
[17:26:44.874]  elements: 'a', 'b', 'c', '', '', ''
[17:26:44.874] signalConditionsASAP(numeric, pos=1) ...
[17:26:44.874] - nx: 6
[17:26:44.875] - relay: TRUE
[17:26:44.875] - stdout: TRUE
[17:26:44.875] - signal: TRUE
[17:26:44.875] - resignal: FALSE
[17:26:44.875] - force: TRUE
[17:26:44.875] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.876] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.876]  - until=2
[17:26:44.876]  - relaying element #2
[17:26:44.876] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.876] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.876] signalConditionsASAP(NULL, pos=1) ... done
[17:26:44.877]  length: 5 (resolved future 1)
[17:26:44.877] Future #2
[17:26:44.877] result() for ClusterFuture ...
[17:26:44.877] - result already collected: FutureResult
[17:26:44.877] result() for ClusterFuture ... done
[17:26:44.877] result() for ClusterFuture ...
[17:26:44.878] - result already collected: FutureResult
[17:26:44.878] result() for ClusterFuture ... done
[17:26:44.878] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:44.878] - nx: 6
[17:26:44.878] - relay: TRUE
[17:26:44.878] - stdout: TRUE
[17:26:44.878] - signal: TRUE
[17:26:44.879] - resignal: FALSE
[17:26:44.879] - force: TRUE
[17:26:44.879] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.879] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.879]  - until=2
[17:26:44.879]  - relaying element #2
[17:26:44.880] result() for ClusterFuture ...
[17:26:44.880] - result already collected: FutureResult
[17:26:44.880] result() for ClusterFuture ... done
[17:26:44.880] result() for ClusterFuture ...
[17:26:44.880] - result already collected: FutureResult
[17:26:44.880] result() for ClusterFuture ... done
[17:26:44.881] result() for ClusterFuture ...
[17:26:44.881] - result already collected: FutureResult
[17:26:44.881] result() for ClusterFuture ... done
[17:26:44.881] result() for ClusterFuture ...
[17:26:44.881] - result already collected: FutureResult
[17:26:44.881] result() for ClusterFuture ... done
[17:26:44.881] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.882] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.882] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:44.882]  length: 4 (resolved future 2)
[17:26:44.882] Future #3
[17:26:44.882] result() for ClusterFuture ...
[17:26:44.883] - result already collected: FutureResult
[17:26:44.883] result() for ClusterFuture ... done
[17:26:44.883] result() for ClusterFuture ...
[17:26:44.883] - result already collected: FutureResult
[17:26:44.883] result() for ClusterFuture ... done
[17:26:44.883] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:44.883] - nx: 6
[17:26:44.884] - relay: TRUE
[17:26:44.884] - stdout: TRUE
[17:26:44.884] - signal: TRUE
[17:26:44.884] - resignal: FALSE
[17:26:44.884] - force: TRUE
[17:26:44.884] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.885] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.885]  - until=3
[17:26:44.885]  - relaying element #3
[17:26:44.885] result() for ClusterFuture ...
[17:26:44.885] - result already collected: FutureResult
[17:26:44.885] result() for ClusterFuture ... done
[17:26:44.886] result() for ClusterFuture ...
[17:26:44.886] - result already collected: FutureResult
[17:26:44.886] result() for ClusterFuture ... done
[17:26:44.886] result() for ClusterFuture ...
[17:26:44.886] - result already collected: FutureResult
[17:26:44.886] result() for ClusterFuture ... done
[17:26:44.887] result() for ClusterFuture ...
[17:26:44.887] - result already collected: FutureResult
[17:26:44.887] result() for ClusterFuture ... done
[17:26:44.887] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.887] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.887] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:44.887]  length: 3 (resolved future 3)
[17:26:44.888] signalConditionsASAP(NULL, pos=4) ...
[17:26:44.888] - nx: 6
[17:26:44.888] - relay: TRUE
[17:26:44.888] - stdout: TRUE
[17:26:44.888] - signal: TRUE
[17:26:44.888] - resignal: FALSE
[17:26:44.889] - force: TRUE
[17:26:44.889] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.889] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.889]  - until=5
[17:26:44.889]  - relaying element #5
[17:26:44.889] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.889] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.890] signalConditionsASAP(NULL, pos=4) ... done
[17:26:44.890]  length: 2 (resolved future 4)
[17:26:44.890] signalConditionsASAP(NULL, pos=5) ...
[17:26:44.890] - nx: 6
[17:26:44.890] - relay: TRUE
[17:26:44.890] - stdout: TRUE
[17:26:44.891] - signal: TRUE
[17:26:44.891] - resignal: FALSE
[17:26:44.891] - force: TRUE
[17:26:44.891] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.891] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.892]  - until=6
[17:26:44.892]  - relaying element #6
[17:26:44.892] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.892] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.892] signalConditionsASAP(NULL, pos=5) ... done
[17:26:44.892]  length: 1 (resolved future 5)
[17:26:44.892] signalConditionsASAP(numeric, pos=6) ...
[17:26:44.893] - nx: 6
[17:26:44.893] - relay: TRUE
[17:26:44.893] - stdout: TRUE
[17:26:44.893] - signal: TRUE
[17:26:44.893] - resignal: FALSE
[17:26:44.893] - force: TRUE
[17:26:44.894] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.894] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.894]  - until=6
[17:26:44.894] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.894] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.894] signalConditionsASAP(numeric, pos=6) ... done
[17:26:44.894]  length: 0 (resolved future 6)
[17:26:44.895] Relaying remaining futures
[17:26:44.895] signalConditionsASAP(NULL, pos=0) ...
[17:26:44.895] - nx: 6
[17:26:44.895] - relay: TRUE
[17:26:44.895] - stdout: TRUE
[17:26:44.895] - signal: TRUE
[17:26:44.896] - resignal: FALSE
[17:26:44.896] - force: TRUE
[17:26:44.896] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.896] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:44.896] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.896] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.897] signalConditionsASAP(NULL, pos=0) ... done
[17:26:44.897] resolve() on list ... DONE
[17:26:44.897] result() for ClusterFuture ...
[17:26:44.897] - result already collected: FutureResult
[17:26:44.897] result() for ClusterFuture ... done
[17:26:44.897] result() for ClusterFuture ...
[17:26:44.898] - result already collected: FutureResult
[17:26:44.898] result() for ClusterFuture ... done
[17:26:44.898] result() for ClusterFuture ...
[17:26:44.898] - result already collected: FutureResult
[17:26:44.898] result() for ClusterFuture ... done
[17:26:44.898] result() for ClusterFuture ...
[17:26:44.898] - result already collected: FutureResult
[17:26:44.899] result() for ClusterFuture ... done
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:3] 2 3 1
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
Dimensions: c(2, 1, 3, 1)
[17:26:44.903] getGlobalsAndPackages() ...
[17:26:44.903] Searching for globals...
[17:26:44.903] 
[17:26:44.904] Searching for globals ... DONE
[17:26:44.904] - globals: [0] <none>
[17:26:44.904] getGlobalsAndPackages() ... DONE
[17:26:44.904] run() for 'Future' ...
[17:26:44.904] - state: 'created'
[17:26:44.905] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.918] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.918] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.918]   - Field: 'node'
[17:26:44.918]   - Field: 'label'
[17:26:44.919]   - Field: 'local'
[17:26:44.919]   - Field: 'owner'
[17:26:44.919]   - Field: 'envir'
[17:26:44.919]   - Field: 'workers'
[17:26:44.919]   - Field: 'packages'
[17:26:44.920]   - Field: 'gc'
[17:26:44.920]   - Field: 'conditions'
[17:26:44.920]   - Field: 'persistent'
[17:26:44.920]   - Field: 'expr'
[17:26:44.920]   - Field: 'uuid'
[17:26:44.920]   - Field: 'seed'
[17:26:44.921]   - Field: 'version'
[17:26:44.921]   - Field: 'result'
[17:26:44.921]   - Field: 'asynchronous'
[17:26:44.921]   - Field: 'calls'
[17:26:44.921]   - Field: 'globals'
[17:26:44.921]   - Field: 'stdout'
[17:26:44.922]   - Field: 'earlySignal'
[17:26:44.922]   - Field: 'lazy'
[17:26:44.922]   - Field: 'state'
[17:26:44.922] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.922] - Launch lazy future ...
[17:26:44.923] Packages needed by the future expression (n = 0): <none>
[17:26:44.923] Packages needed by future strategies (n = 0): <none>
[17:26:44.923] {
[17:26:44.923]     {
[17:26:44.923]         {
[17:26:44.923]             ...future.startTime <- base::Sys.time()
[17:26:44.923]             {
[17:26:44.923]                 {
[17:26:44.923]                   {
[17:26:44.923]                     {
[17:26:44.923]                       base::local({
[17:26:44.923]                         has_future <- base::requireNamespace("future", 
[17:26:44.923]                           quietly = TRUE)
[17:26:44.923]                         if (has_future) {
[17:26:44.923]                           ns <- base::getNamespace("future")
[17:26:44.923]                           version <- ns[[".package"]][["version"]]
[17:26:44.923]                           if (is.null(version)) 
[17:26:44.923]                             version <- utils::packageVersion("future")
[17:26:44.923]                         }
[17:26:44.923]                         else {
[17:26:44.923]                           version <- NULL
[17:26:44.923]                         }
[17:26:44.923]                         if (!has_future || version < "1.8.0") {
[17:26:44.923]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.923]                             "", base::R.version$version.string), 
[17:26:44.923]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.923]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.923]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.923]                               "release", "version")], collapse = " "), 
[17:26:44.923]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.923]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.923]                             info)
[17:26:44.923]                           info <- base::paste(info, collapse = "; ")
[17:26:44.923]                           if (!has_future) {
[17:26:44.923]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.923]                               info)
[17:26:44.923]                           }
[17:26:44.923]                           else {
[17:26:44.923]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.923]                               info, version)
[17:26:44.923]                           }
[17:26:44.923]                           base::stop(msg)
[17:26:44.923]                         }
[17:26:44.923]                       })
[17:26:44.923]                     }
[17:26:44.923]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.923]                     base::options(mc.cores = 1L)
[17:26:44.923]                   }
[17:26:44.923]                   ...future.strategy.old <- future::plan("list")
[17:26:44.923]                   options(future.plan = NULL)
[17:26:44.923]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.923]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.923]                 }
[17:26:44.923]                 ...future.workdir <- getwd()
[17:26:44.923]             }
[17:26:44.923]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.923]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.923]         }
[17:26:44.923]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.923]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.923]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.923]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.923]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.923]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.923]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.923]             base::names(...future.oldOptions))
[17:26:44.923]     }
[17:26:44.923]     if (FALSE) {
[17:26:44.923]     }
[17:26:44.923]     else {
[17:26:44.923]         if (TRUE) {
[17:26:44.923]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.923]                 open = "w")
[17:26:44.923]         }
[17:26:44.923]         else {
[17:26:44.923]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.923]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.923]         }
[17:26:44.923]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.923]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.923]             base::sink(type = "output", split = FALSE)
[17:26:44.923]             base::close(...future.stdout)
[17:26:44.923]         }, add = TRUE)
[17:26:44.923]     }
[17:26:44.923]     ...future.frame <- base::sys.nframe()
[17:26:44.923]     ...future.conditions <- base::list()
[17:26:44.923]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.923]     if (FALSE) {
[17:26:44.923]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.923]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.923]     }
[17:26:44.923]     ...future.result <- base::tryCatch({
[17:26:44.923]         base::withCallingHandlers({
[17:26:44.923]             ...future.value <- base::withVisible(base::local({
[17:26:44.923]                 ...future.makeSendCondition <- base::local({
[17:26:44.923]                   sendCondition <- NULL
[17:26:44.923]                   function(frame = 1L) {
[17:26:44.923]                     if (is.function(sendCondition)) 
[17:26:44.923]                       return(sendCondition)
[17:26:44.923]                     ns <- getNamespace("parallel")
[17:26:44.923]                     if (exists("sendData", mode = "function", 
[17:26:44.923]                       envir = ns)) {
[17:26:44.923]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.923]                         envir = ns)
[17:26:44.923]                       envir <- sys.frame(frame)
[17:26:44.923]                       master <- NULL
[17:26:44.923]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.923]                         !identical(envir, emptyenv())) {
[17:26:44.923]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.923]                           inherits = FALSE)) {
[17:26:44.923]                           master <- get("master", mode = "list", 
[17:26:44.923]                             envir = envir, inherits = FALSE)
[17:26:44.923]                           if (inherits(master, c("SOCKnode", 
[17:26:44.923]                             "SOCK0node"))) {
[17:26:44.923]                             sendCondition <<- function(cond) {
[17:26:44.923]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.923]                                 success = TRUE)
[17:26:44.923]                               parallel_sendData(master, data)
[17:26:44.923]                             }
[17:26:44.923]                             return(sendCondition)
[17:26:44.923]                           }
[17:26:44.923]                         }
[17:26:44.923]                         frame <- frame + 1L
[17:26:44.923]                         envir <- sys.frame(frame)
[17:26:44.923]                       }
[17:26:44.923]                     }
[17:26:44.923]                     sendCondition <<- function(cond) NULL
[17:26:44.923]                   }
[17:26:44.923]                 })
[17:26:44.923]                 withCallingHandlers({
[17:26:44.923]                   2
[17:26:44.923]                 }, immediateCondition = function(cond) {
[17:26:44.923]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.923]                   sendCondition(cond)
[17:26:44.923]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.923]                   {
[17:26:44.923]                     inherits <- base::inherits
[17:26:44.923]                     invokeRestart <- base::invokeRestart
[17:26:44.923]                     is.null <- base::is.null
[17:26:44.923]                     muffled <- FALSE
[17:26:44.923]                     if (inherits(cond, "message")) {
[17:26:44.923]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.923]                       if (muffled) 
[17:26:44.923]                         invokeRestart("muffleMessage")
[17:26:44.923]                     }
[17:26:44.923]                     else if (inherits(cond, "warning")) {
[17:26:44.923]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.923]                       if (muffled) 
[17:26:44.923]                         invokeRestart("muffleWarning")
[17:26:44.923]                     }
[17:26:44.923]                     else if (inherits(cond, "condition")) {
[17:26:44.923]                       if (!is.null(pattern)) {
[17:26:44.923]                         computeRestarts <- base::computeRestarts
[17:26:44.923]                         grepl <- base::grepl
[17:26:44.923]                         restarts <- computeRestarts(cond)
[17:26:44.923]                         for (restart in restarts) {
[17:26:44.923]                           name <- restart$name
[17:26:44.923]                           if (is.null(name)) 
[17:26:44.923]                             next
[17:26:44.923]                           if (!grepl(pattern, name)) 
[17:26:44.923]                             next
[17:26:44.923]                           invokeRestart(restart)
[17:26:44.923]                           muffled <- TRUE
[17:26:44.923]                           break
[17:26:44.923]                         }
[17:26:44.923]                       }
[17:26:44.923]                     }
[17:26:44.923]                     invisible(muffled)
[17:26:44.923]                   }
[17:26:44.923]                   muffleCondition(cond)
[17:26:44.923]                 })
[17:26:44.923]             }))
[17:26:44.923]             future::FutureResult(value = ...future.value$value, 
[17:26:44.923]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.923]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.923]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.923]                     ...future.globalenv.names))
[17:26:44.923]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.923]         }, condition = base::local({
[17:26:44.923]             c <- base::c
[17:26:44.923]             inherits <- base::inherits
[17:26:44.923]             invokeRestart <- base::invokeRestart
[17:26:44.923]             length <- base::length
[17:26:44.923]             list <- base::list
[17:26:44.923]             seq.int <- base::seq.int
[17:26:44.923]             signalCondition <- base::signalCondition
[17:26:44.923]             sys.calls <- base::sys.calls
[17:26:44.923]             `[[` <- base::`[[`
[17:26:44.923]             `+` <- base::`+`
[17:26:44.923]             `<<-` <- base::`<<-`
[17:26:44.923]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.923]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.923]                   3L)]
[17:26:44.923]             }
[17:26:44.923]             function(cond) {
[17:26:44.923]                 is_error <- inherits(cond, "error")
[17:26:44.923]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.923]                   NULL)
[17:26:44.923]                 if (is_error) {
[17:26:44.923]                   sessionInformation <- function() {
[17:26:44.923]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.923]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.923]                       search = base::search(), system = base::Sys.info())
[17:26:44.923]                   }
[17:26:44.923]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.923]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.923]                     cond$call), session = sessionInformation(), 
[17:26:44.923]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.923]                   signalCondition(cond)
[17:26:44.923]                 }
[17:26:44.923]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.923]                 "immediateCondition"))) {
[17:26:44.923]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.923]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.923]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.923]                   if (TRUE && !signal) {
[17:26:44.923]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.923]                     {
[17:26:44.923]                       inherits <- base::inherits
[17:26:44.923]                       invokeRestart <- base::invokeRestart
[17:26:44.923]                       is.null <- base::is.null
[17:26:44.923]                       muffled <- FALSE
[17:26:44.923]                       if (inherits(cond, "message")) {
[17:26:44.923]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.923]                         if (muffled) 
[17:26:44.923]                           invokeRestart("muffleMessage")
[17:26:44.923]                       }
[17:26:44.923]                       else if (inherits(cond, "warning")) {
[17:26:44.923]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.923]                         if (muffled) 
[17:26:44.923]                           invokeRestart("muffleWarning")
[17:26:44.923]                       }
[17:26:44.923]                       else if (inherits(cond, "condition")) {
[17:26:44.923]                         if (!is.null(pattern)) {
[17:26:44.923]                           computeRestarts <- base::computeRestarts
[17:26:44.923]                           grepl <- base::grepl
[17:26:44.923]                           restarts <- computeRestarts(cond)
[17:26:44.923]                           for (restart in restarts) {
[17:26:44.923]                             name <- restart$name
[17:26:44.923]                             if (is.null(name)) 
[17:26:44.923]                               next
[17:26:44.923]                             if (!grepl(pattern, name)) 
[17:26:44.923]                               next
[17:26:44.923]                             invokeRestart(restart)
[17:26:44.923]                             muffled <- TRUE
[17:26:44.923]                             break
[17:26:44.923]                           }
[17:26:44.923]                         }
[17:26:44.923]                       }
[17:26:44.923]                       invisible(muffled)
[17:26:44.923]                     }
[17:26:44.923]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.923]                   }
[17:26:44.923]                 }
[17:26:44.923]                 else {
[17:26:44.923]                   if (TRUE) {
[17:26:44.923]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.923]                     {
[17:26:44.923]                       inherits <- base::inherits
[17:26:44.923]                       invokeRestart <- base::invokeRestart
[17:26:44.923]                       is.null <- base::is.null
[17:26:44.923]                       muffled <- FALSE
[17:26:44.923]                       if (inherits(cond, "message")) {
[17:26:44.923]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.923]                         if (muffled) 
[17:26:44.923]                           invokeRestart("muffleMessage")
[17:26:44.923]                       }
[17:26:44.923]                       else if (inherits(cond, "warning")) {
[17:26:44.923]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.923]                         if (muffled) 
[17:26:44.923]                           invokeRestart("muffleWarning")
[17:26:44.923]                       }
[17:26:44.923]                       else if (inherits(cond, "condition")) {
[17:26:44.923]                         if (!is.null(pattern)) {
[17:26:44.923]                           computeRestarts <- base::computeRestarts
[17:26:44.923]                           grepl <- base::grepl
[17:26:44.923]                           restarts <- computeRestarts(cond)
[17:26:44.923]                           for (restart in restarts) {
[17:26:44.923]                             name <- restart$name
[17:26:44.923]                             if (is.null(name)) 
[17:26:44.923]                               next
[17:26:44.923]                             if (!grepl(pattern, name)) 
[17:26:44.923]                               next
[17:26:44.923]                             invokeRestart(restart)
[17:26:44.923]                             muffled <- TRUE
[17:26:44.923]                             break
[17:26:44.923]                           }
[17:26:44.923]                         }
[17:26:44.923]                       }
[17:26:44.923]                       invisible(muffled)
[17:26:44.923]                     }
[17:26:44.923]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.923]                   }
[17:26:44.923]                 }
[17:26:44.923]             }
[17:26:44.923]         }))
[17:26:44.923]     }, error = function(ex) {
[17:26:44.923]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.923]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.923]                 ...future.rng), started = ...future.startTime, 
[17:26:44.923]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.923]             version = "1.8"), class = "FutureResult")
[17:26:44.923]     }, finally = {
[17:26:44.923]         if (!identical(...future.workdir, getwd())) 
[17:26:44.923]             setwd(...future.workdir)
[17:26:44.923]         {
[17:26:44.923]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.923]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.923]             }
[17:26:44.923]             base::options(...future.oldOptions)
[17:26:44.923]             if (.Platform$OS.type == "windows") {
[17:26:44.923]                 old_names <- names(...future.oldEnvVars)
[17:26:44.923]                 envs <- base::Sys.getenv()
[17:26:44.923]                 names <- names(envs)
[17:26:44.923]                 common <- intersect(names, old_names)
[17:26:44.923]                 added <- setdiff(names, old_names)
[17:26:44.923]                 removed <- setdiff(old_names, names)
[17:26:44.923]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.923]                   envs[common]]
[17:26:44.923]                 NAMES <- toupper(changed)
[17:26:44.923]                 args <- list()
[17:26:44.923]                 for (kk in seq_along(NAMES)) {
[17:26:44.923]                   name <- changed[[kk]]
[17:26:44.923]                   NAME <- NAMES[[kk]]
[17:26:44.923]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.923]                     next
[17:26:44.923]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.923]                 }
[17:26:44.923]                 NAMES <- toupper(added)
[17:26:44.923]                 for (kk in seq_along(NAMES)) {
[17:26:44.923]                   name <- added[[kk]]
[17:26:44.923]                   NAME <- NAMES[[kk]]
[17:26:44.923]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.923]                     next
[17:26:44.923]                   args[[name]] <- ""
[17:26:44.923]                 }
[17:26:44.923]                 NAMES <- toupper(removed)
[17:26:44.923]                 for (kk in seq_along(NAMES)) {
[17:26:44.923]                   name <- removed[[kk]]
[17:26:44.923]                   NAME <- NAMES[[kk]]
[17:26:44.923]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.923]                     next
[17:26:44.923]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.923]                 }
[17:26:44.923]                 if (length(args) > 0) 
[17:26:44.923]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.923]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.923]             }
[17:26:44.923]             else {
[17:26:44.923]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.923]             }
[17:26:44.923]             {
[17:26:44.923]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.923]                   0L) {
[17:26:44.923]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.923]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.923]                   base::options(opts)
[17:26:44.923]                 }
[17:26:44.923]                 {
[17:26:44.923]                   {
[17:26:44.923]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.923]                     NULL
[17:26:44.923]                   }
[17:26:44.923]                   options(future.plan = NULL)
[17:26:44.923]                   if (is.na(NA_character_)) 
[17:26:44.923]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.923]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.923]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.923]                     .init = FALSE)
[17:26:44.923]                 }
[17:26:44.923]             }
[17:26:44.923]         }
[17:26:44.923]     })
[17:26:44.923]     if (TRUE) {
[17:26:44.923]         base::sink(type = "output", split = FALSE)
[17:26:44.923]         if (TRUE) {
[17:26:44.923]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.923]         }
[17:26:44.923]         else {
[17:26:44.923]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.923]         }
[17:26:44.923]         base::close(...future.stdout)
[17:26:44.923]         ...future.stdout <- NULL
[17:26:44.923]     }
[17:26:44.923]     ...future.result$conditions <- ...future.conditions
[17:26:44.923]     ...future.result$finished <- base::Sys.time()
[17:26:44.923]     ...future.result
[17:26:44.923] }
[17:26:44.931] MultisessionFuture started
[17:26:44.931] - Launch lazy future ... done
[17:26:44.931] run() for 'MultisessionFuture' ... done
[17:26:44.931] getGlobalsAndPackages() ...
[17:26:44.931] Searching for globals...
[17:26:44.932] 
[17:26:44.932] Searching for globals ... DONE
[17:26:44.932] - globals: [0] <none>
[17:26:44.932] getGlobalsAndPackages() ... DONE
[17:26:44.933] run() for 'Future' ...
[17:26:44.933] - state: 'created'
[17:26:44.933] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:44.947] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:44.947] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:44.947]   - Field: 'node'
[17:26:44.947]   - Field: 'label'
[17:26:44.947]   - Field: 'local'
[17:26:44.948]   - Field: 'owner'
[17:26:44.948]   - Field: 'envir'
[17:26:44.948]   - Field: 'workers'
[17:26:44.948]   - Field: 'packages'
[17:26:44.948]   - Field: 'gc'
[17:26:44.948]   - Field: 'conditions'
[17:26:44.949]   - Field: 'persistent'
[17:26:44.949]   - Field: 'expr'
[17:26:44.949]   - Field: 'uuid'
[17:26:44.949]   - Field: 'seed'
[17:26:44.949]   - Field: 'version'
[17:26:44.950]   - Field: 'result'
[17:26:44.950]   - Field: 'asynchronous'
[17:26:44.950]   - Field: 'calls'
[17:26:44.950]   - Field: 'globals'
[17:26:44.950]   - Field: 'stdout'
[17:26:44.950]   - Field: 'earlySignal'
[17:26:44.951]   - Field: 'lazy'
[17:26:44.951]   - Field: 'state'
[17:26:44.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:44.951] - Launch lazy future ...
[17:26:44.951] Packages needed by the future expression (n = 0): <none>
[17:26:44.952] Packages needed by future strategies (n = 0): <none>
[17:26:44.952] {
[17:26:44.952]     {
[17:26:44.952]         {
[17:26:44.952]             ...future.startTime <- base::Sys.time()
[17:26:44.952]             {
[17:26:44.952]                 {
[17:26:44.952]                   {
[17:26:44.952]                     {
[17:26:44.952]                       base::local({
[17:26:44.952]                         has_future <- base::requireNamespace("future", 
[17:26:44.952]                           quietly = TRUE)
[17:26:44.952]                         if (has_future) {
[17:26:44.952]                           ns <- base::getNamespace("future")
[17:26:44.952]                           version <- ns[[".package"]][["version"]]
[17:26:44.952]                           if (is.null(version)) 
[17:26:44.952]                             version <- utils::packageVersion("future")
[17:26:44.952]                         }
[17:26:44.952]                         else {
[17:26:44.952]                           version <- NULL
[17:26:44.952]                         }
[17:26:44.952]                         if (!has_future || version < "1.8.0") {
[17:26:44.952]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:44.952]                             "", base::R.version$version.string), 
[17:26:44.952]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:44.952]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:44.952]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:44.952]                               "release", "version")], collapse = " "), 
[17:26:44.952]                             hostname = base::Sys.info()[["nodename"]])
[17:26:44.952]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:44.952]                             info)
[17:26:44.952]                           info <- base::paste(info, collapse = "; ")
[17:26:44.952]                           if (!has_future) {
[17:26:44.952]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:44.952]                               info)
[17:26:44.952]                           }
[17:26:44.952]                           else {
[17:26:44.952]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:44.952]                               info, version)
[17:26:44.952]                           }
[17:26:44.952]                           base::stop(msg)
[17:26:44.952]                         }
[17:26:44.952]                       })
[17:26:44.952]                     }
[17:26:44.952]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:44.952]                     base::options(mc.cores = 1L)
[17:26:44.952]                   }
[17:26:44.952]                   ...future.strategy.old <- future::plan("list")
[17:26:44.952]                   options(future.plan = NULL)
[17:26:44.952]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.952]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:44.952]                 }
[17:26:44.952]                 ...future.workdir <- getwd()
[17:26:44.952]             }
[17:26:44.952]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:44.952]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:44.952]         }
[17:26:44.952]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:44.952]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:44.952]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:44.952]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:44.952]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:44.952]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:44.952]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:44.952]             base::names(...future.oldOptions))
[17:26:44.952]     }
[17:26:44.952]     if (FALSE) {
[17:26:44.952]     }
[17:26:44.952]     else {
[17:26:44.952]         if (TRUE) {
[17:26:44.952]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:44.952]                 open = "w")
[17:26:44.952]         }
[17:26:44.952]         else {
[17:26:44.952]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:44.952]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:44.952]         }
[17:26:44.952]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:44.952]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:44.952]             base::sink(type = "output", split = FALSE)
[17:26:44.952]             base::close(...future.stdout)
[17:26:44.952]         }, add = TRUE)
[17:26:44.952]     }
[17:26:44.952]     ...future.frame <- base::sys.nframe()
[17:26:44.952]     ...future.conditions <- base::list()
[17:26:44.952]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:44.952]     if (FALSE) {
[17:26:44.952]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:44.952]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:44.952]     }
[17:26:44.952]     ...future.result <- base::tryCatch({
[17:26:44.952]         base::withCallingHandlers({
[17:26:44.952]             ...future.value <- base::withVisible(base::local({
[17:26:44.952]                 ...future.makeSendCondition <- base::local({
[17:26:44.952]                   sendCondition <- NULL
[17:26:44.952]                   function(frame = 1L) {
[17:26:44.952]                     if (is.function(sendCondition)) 
[17:26:44.952]                       return(sendCondition)
[17:26:44.952]                     ns <- getNamespace("parallel")
[17:26:44.952]                     if (exists("sendData", mode = "function", 
[17:26:44.952]                       envir = ns)) {
[17:26:44.952]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:44.952]                         envir = ns)
[17:26:44.952]                       envir <- sys.frame(frame)
[17:26:44.952]                       master <- NULL
[17:26:44.952]                       while (!identical(envir, .GlobalEnv) && 
[17:26:44.952]                         !identical(envir, emptyenv())) {
[17:26:44.952]                         if (exists("master", mode = "list", envir = envir, 
[17:26:44.952]                           inherits = FALSE)) {
[17:26:44.952]                           master <- get("master", mode = "list", 
[17:26:44.952]                             envir = envir, inherits = FALSE)
[17:26:44.952]                           if (inherits(master, c("SOCKnode", 
[17:26:44.952]                             "SOCK0node"))) {
[17:26:44.952]                             sendCondition <<- function(cond) {
[17:26:44.952]                               data <- list(type = "VALUE", value = cond, 
[17:26:44.952]                                 success = TRUE)
[17:26:44.952]                               parallel_sendData(master, data)
[17:26:44.952]                             }
[17:26:44.952]                             return(sendCondition)
[17:26:44.952]                           }
[17:26:44.952]                         }
[17:26:44.952]                         frame <- frame + 1L
[17:26:44.952]                         envir <- sys.frame(frame)
[17:26:44.952]                       }
[17:26:44.952]                     }
[17:26:44.952]                     sendCondition <<- function(cond) NULL
[17:26:44.952]                   }
[17:26:44.952]                 })
[17:26:44.952]                 withCallingHandlers({
[17:26:44.952]                   NULL
[17:26:44.952]                 }, immediateCondition = function(cond) {
[17:26:44.952]                   sendCondition <- ...future.makeSendCondition()
[17:26:44.952]                   sendCondition(cond)
[17:26:44.952]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.952]                   {
[17:26:44.952]                     inherits <- base::inherits
[17:26:44.952]                     invokeRestart <- base::invokeRestart
[17:26:44.952]                     is.null <- base::is.null
[17:26:44.952]                     muffled <- FALSE
[17:26:44.952]                     if (inherits(cond, "message")) {
[17:26:44.952]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:44.952]                       if (muffled) 
[17:26:44.952]                         invokeRestart("muffleMessage")
[17:26:44.952]                     }
[17:26:44.952]                     else if (inherits(cond, "warning")) {
[17:26:44.952]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:44.952]                       if (muffled) 
[17:26:44.952]                         invokeRestart("muffleWarning")
[17:26:44.952]                     }
[17:26:44.952]                     else if (inherits(cond, "condition")) {
[17:26:44.952]                       if (!is.null(pattern)) {
[17:26:44.952]                         computeRestarts <- base::computeRestarts
[17:26:44.952]                         grepl <- base::grepl
[17:26:44.952]                         restarts <- computeRestarts(cond)
[17:26:44.952]                         for (restart in restarts) {
[17:26:44.952]                           name <- restart$name
[17:26:44.952]                           if (is.null(name)) 
[17:26:44.952]                             next
[17:26:44.952]                           if (!grepl(pattern, name)) 
[17:26:44.952]                             next
[17:26:44.952]                           invokeRestart(restart)
[17:26:44.952]                           muffled <- TRUE
[17:26:44.952]                           break
[17:26:44.952]                         }
[17:26:44.952]                       }
[17:26:44.952]                     }
[17:26:44.952]                     invisible(muffled)
[17:26:44.952]                   }
[17:26:44.952]                   muffleCondition(cond)
[17:26:44.952]                 })
[17:26:44.952]             }))
[17:26:44.952]             future::FutureResult(value = ...future.value$value, 
[17:26:44.952]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.952]                   ...future.rng), globalenv = if (FALSE) 
[17:26:44.952]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:44.952]                     ...future.globalenv.names))
[17:26:44.952]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:44.952]         }, condition = base::local({
[17:26:44.952]             c <- base::c
[17:26:44.952]             inherits <- base::inherits
[17:26:44.952]             invokeRestart <- base::invokeRestart
[17:26:44.952]             length <- base::length
[17:26:44.952]             list <- base::list
[17:26:44.952]             seq.int <- base::seq.int
[17:26:44.952]             signalCondition <- base::signalCondition
[17:26:44.952]             sys.calls <- base::sys.calls
[17:26:44.952]             `[[` <- base::`[[`
[17:26:44.952]             `+` <- base::`+`
[17:26:44.952]             `<<-` <- base::`<<-`
[17:26:44.952]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:44.952]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:44.952]                   3L)]
[17:26:44.952]             }
[17:26:44.952]             function(cond) {
[17:26:44.952]                 is_error <- inherits(cond, "error")
[17:26:44.952]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:44.952]                   NULL)
[17:26:44.952]                 if (is_error) {
[17:26:44.952]                   sessionInformation <- function() {
[17:26:44.952]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:44.952]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:44.952]                       search = base::search(), system = base::Sys.info())
[17:26:44.952]                   }
[17:26:44.952]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.952]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:44.952]                     cond$call), session = sessionInformation(), 
[17:26:44.952]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:44.952]                   signalCondition(cond)
[17:26:44.952]                 }
[17:26:44.952]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:44.952]                 "immediateCondition"))) {
[17:26:44.952]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:44.952]                   ...future.conditions[[length(...future.conditions) + 
[17:26:44.952]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:44.952]                   if (TRUE && !signal) {
[17:26:44.952]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.952]                     {
[17:26:44.952]                       inherits <- base::inherits
[17:26:44.952]                       invokeRestart <- base::invokeRestart
[17:26:44.952]                       is.null <- base::is.null
[17:26:44.952]                       muffled <- FALSE
[17:26:44.952]                       if (inherits(cond, "message")) {
[17:26:44.952]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.952]                         if (muffled) 
[17:26:44.952]                           invokeRestart("muffleMessage")
[17:26:44.952]                       }
[17:26:44.952]                       else if (inherits(cond, "warning")) {
[17:26:44.952]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.952]                         if (muffled) 
[17:26:44.952]                           invokeRestart("muffleWarning")
[17:26:44.952]                       }
[17:26:44.952]                       else if (inherits(cond, "condition")) {
[17:26:44.952]                         if (!is.null(pattern)) {
[17:26:44.952]                           computeRestarts <- base::computeRestarts
[17:26:44.952]                           grepl <- base::grepl
[17:26:44.952]                           restarts <- computeRestarts(cond)
[17:26:44.952]                           for (restart in restarts) {
[17:26:44.952]                             name <- restart$name
[17:26:44.952]                             if (is.null(name)) 
[17:26:44.952]                               next
[17:26:44.952]                             if (!grepl(pattern, name)) 
[17:26:44.952]                               next
[17:26:44.952]                             invokeRestart(restart)
[17:26:44.952]                             muffled <- TRUE
[17:26:44.952]                             break
[17:26:44.952]                           }
[17:26:44.952]                         }
[17:26:44.952]                       }
[17:26:44.952]                       invisible(muffled)
[17:26:44.952]                     }
[17:26:44.952]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.952]                   }
[17:26:44.952]                 }
[17:26:44.952]                 else {
[17:26:44.952]                   if (TRUE) {
[17:26:44.952]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:44.952]                     {
[17:26:44.952]                       inherits <- base::inherits
[17:26:44.952]                       invokeRestart <- base::invokeRestart
[17:26:44.952]                       is.null <- base::is.null
[17:26:44.952]                       muffled <- FALSE
[17:26:44.952]                       if (inherits(cond, "message")) {
[17:26:44.952]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:44.952]                         if (muffled) 
[17:26:44.952]                           invokeRestart("muffleMessage")
[17:26:44.952]                       }
[17:26:44.952]                       else if (inherits(cond, "warning")) {
[17:26:44.952]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:44.952]                         if (muffled) 
[17:26:44.952]                           invokeRestart("muffleWarning")
[17:26:44.952]                       }
[17:26:44.952]                       else if (inherits(cond, "condition")) {
[17:26:44.952]                         if (!is.null(pattern)) {
[17:26:44.952]                           computeRestarts <- base::computeRestarts
[17:26:44.952]                           grepl <- base::grepl
[17:26:44.952]                           restarts <- computeRestarts(cond)
[17:26:44.952]                           for (restart in restarts) {
[17:26:44.952]                             name <- restart$name
[17:26:44.952]                             if (is.null(name)) 
[17:26:44.952]                               next
[17:26:44.952]                             if (!grepl(pattern, name)) 
[17:26:44.952]                               next
[17:26:44.952]                             invokeRestart(restart)
[17:26:44.952]                             muffled <- TRUE
[17:26:44.952]                             break
[17:26:44.952]                           }
[17:26:44.952]                         }
[17:26:44.952]                       }
[17:26:44.952]                       invisible(muffled)
[17:26:44.952]                     }
[17:26:44.952]                     muffleCondition(cond, pattern = "^muffle")
[17:26:44.952]                   }
[17:26:44.952]                 }
[17:26:44.952]             }
[17:26:44.952]         }))
[17:26:44.952]     }, error = function(ex) {
[17:26:44.952]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:44.952]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:44.952]                 ...future.rng), started = ...future.startTime, 
[17:26:44.952]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:44.952]             version = "1.8"), class = "FutureResult")
[17:26:44.952]     }, finally = {
[17:26:44.952]         if (!identical(...future.workdir, getwd())) 
[17:26:44.952]             setwd(...future.workdir)
[17:26:44.952]         {
[17:26:44.952]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:44.952]                 ...future.oldOptions$nwarnings <- NULL
[17:26:44.952]             }
[17:26:44.952]             base::options(...future.oldOptions)
[17:26:44.952]             if (.Platform$OS.type == "windows") {
[17:26:44.952]                 old_names <- names(...future.oldEnvVars)
[17:26:44.952]                 envs <- base::Sys.getenv()
[17:26:44.952]                 names <- names(envs)
[17:26:44.952]                 common <- intersect(names, old_names)
[17:26:44.952]                 added <- setdiff(names, old_names)
[17:26:44.952]                 removed <- setdiff(old_names, names)
[17:26:44.952]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:44.952]                   envs[common]]
[17:26:44.952]                 NAMES <- toupper(changed)
[17:26:44.952]                 args <- list()
[17:26:44.952]                 for (kk in seq_along(NAMES)) {
[17:26:44.952]                   name <- changed[[kk]]
[17:26:44.952]                   NAME <- NAMES[[kk]]
[17:26:44.952]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.952]                     next
[17:26:44.952]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.952]                 }
[17:26:44.952]                 NAMES <- toupper(added)
[17:26:44.952]                 for (kk in seq_along(NAMES)) {
[17:26:44.952]                   name <- added[[kk]]
[17:26:44.952]                   NAME <- NAMES[[kk]]
[17:26:44.952]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.952]                     next
[17:26:44.952]                   args[[name]] <- ""
[17:26:44.952]                 }
[17:26:44.952]                 NAMES <- toupper(removed)
[17:26:44.952]                 for (kk in seq_along(NAMES)) {
[17:26:44.952]                   name <- removed[[kk]]
[17:26:44.952]                   NAME <- NAMES[[kk]]
[17:26:44.952]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:44.952]                     next
[17:26:44.952]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:44.952]                 }
[17:26:44.952]                 if (length(args) > 0) 
[17:26:44.952]                   base::do.call(base::Sys.setenv, args = args)
[17:26:44.952]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:44.952]             }
[17:26:44.952]             else {
[17:26:44.952]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:44.952]             }
[17:26:44.952]             {
[17:26:44.952]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:44.952]                   0L) {
[17:26:44.952]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:44.952]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:44.952]                   base::options(opts)
[17:26:44.952]                 }
[17:26:44.952]                 {
[17:26:44.952]                   {
[17:26:44.952]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:44.952]                     NULL
[17:26:44.952]                   }
[17:26:44.952]                   options(future.plan = NULL)
[17:26:44.952]                   if (is.na(NA_character_)) 
[17:26:44.952]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:44.952]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:44.952]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:44.952]                     .init = FALSE)
[17:26:44.952]                 }
[17:26:44.952]             }
[17:26:44.952]         }
[17:26:44.952]     })
[17:26:44.952]     if (TRUE) {
[17:26:44.952]         base::sink(type = "output", split = FALSE)
[17:26:44.952]         if (TRUE) {
[17:26:44.952]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:44.952]         }
[17:26:44.952]         else {
[17:26:44.952]             ...future.result["stdout"] <- base::list(NULL)
[17:26:44.952]         }
[17:26:44.952]         base::close(...future.stdout)
[17:26:44.952]         ...future.stdout <- NULL
[17:26:44.952]     }
[17:26:44.952]     ...future.result$conditions <- ...future.conditions
[17:26:44.952]     ...future.result$finished <- base::Sys.time()
[17:26:44.952]     ...future.result
[17:26:44.952] }
[17:26:44.958] MultisessionFuture started
[17:26:44.958] - Launch lazy future ... done
[17:26:44.958] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000022310f1e668> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230dd1d370> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000022310f1e668> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x000002230dd1d370> 
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:4] 2 1 3 1
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:44.965] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.965] - Validating connection of MultisessionFuture
[17:26:44.965] - received message: FutureResult
[17:26:44.965] - Received FutureResult
[17:26:44.966] - Erased future from FutureRegistry
[17:26:44.966] result() for ClusterFuture ...
[17:26:44.966] - result already collected: FutureResult
[17:26:44.966] result() for ClusterFuture ... done
[17:26:44.966] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:44.972] receiveMessageFromWorker() for ClusterFuture ...
[17:26:44.972] - Validating connection of MultisessionFuture
[17:26:44.972] - received message: FutureResult
[17:26:44.972] - Received FutureResult
[17:26:44.973] - Erased future from FutureRegistry
[17:26:44.973] result() for ClusterFuture ...
[17:26:44.973] - result already collected: FutureResult
[17:26:44.973] result() for ClusterFuture ... done
[17:26:44.973] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1:2, 1, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[17:26:44.976] resolve() on list ...
[17:26:44.976]  recursive: 0
[17:26:44.976]  length: 6
[17:26:44.976]  elements: 'a', 'b', 'c', '', '', ''
[17:26:44.976] signalConditionsASAP(numeric, pos=1) ...
[17:26:44.977] - nx: 6
[17:26:44.977] - relay: TRUE
[17:26:44.977] - stdout: TRUE
[17:26:44.977] - signal: TRUE
[17:26:44.977] - resignal: FALSE
[17:26:44.977] - force: TRUE
[17:26:44.977] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.978] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.978]  - until=2
[17:26:44.978]  - relaying element #2
[17:26:44.978] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.978] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.978] signalConditionsASAP(NULL, pos=1) ... done
[17:26:44.979]  length: 5 (resolved future 1)
[17:26:44.979] Future #2
[17:26:44.979] result() for ClusterFuture ...
[17:26:44.979] - result already collected: FutureResult
[17:26:44.979] result() for ClusterFuture ... done
[17:26:44.979] result() for ClusterFuture ...
[17:26:44.980] - result already collected: FutureResult
[17:26:44.980] result() for ClusterFuture ... done
[17:26:44.980] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:44.980] - nx: 6
[17:26:44.980] - relay: TRUE
[17:26:44.980] - stdout: TRUE
[17:26:44.981] - signal: TRUE
[17:26:44.981] - resignal: FALSE
[17:26:44.981] - force: TRUE
[17:26:44.981] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.981] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:44.981]  - until=2
[17:26:44.982]  - relaying element #2
[17:26:44.982] result() for ClusterFuture ...
[17:26:44.982] - result already collected: FutureResult
[17:26:44.982] result() for ClusterFuture ... done
[17:26:44.982] result() for ClusterFuture ...
[17:26:44.982] - result already collected: FutureResult
[17:26:44.982] result() for ClusterFuture ... done
[17:26:44.983] result() for ClusterFuture ...
[17:26:44.983] - result already collected: FutureResult
[17:26:44.983] result() for ClusterFuture ... done
[17:26:44.983] result() for ClusterFuture ...
[17:26:44.983] - result already collected: FutureResult
[17:26:44.983] result() for ClusterFuture ... done
[17:26:44.984] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.984] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.984] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:44.984]  length: 4 (resolved future 2)
[17:26:44.984] Future #3
[17:26:44.984] result() for ClusterFuture ...
[17:26:44.985] - result already collected: FutureResult
[17:26:44.985] result() for ClusterFuture ... done
[17:26:44.985] result() for ClusterFuture ...
[17:26:44.985] - result already collected: FutureResult
[17:26:44.985] result() for ClusterFuture ... done
[17:26:44.986] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:44.986] - nx: 6
[17:26:44.986] - relay: TRUE
[17:26:44.986] - stdout: TRUE
[17:26:44.986] - signal: TRUE
[17:26:44.986] - resignal: FALSE
[17:26:44.986] - force: TRUE
[17:26:44.987] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.987] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:44.987]  - until=3
[17:26:44.987]  - relaying element #3
[17:26:44.987] result() for ClusterFuture ...
[17:26:44.987] - result already collected: FutureResult
[17:26:44.988] result() for ClusterFuture ... done
[17:26:44.988] result() for ClusterFuture ...
[17:26:44.988] - result already collected: FutureResult
[17:26:44.988] result() for ClusterFuture ... done
[17:26:44.988] result() for ClusterFuture ...
[17:26:44.988] - result already collected: FutureResult
[17:26:44.989] result() for ClusterFuture ... done
[17:26:44.989] result() for ClusterFuture ...
[17:26:44.989] - result already collected: FutureResult
[17:26:44.989] result() for ClusterFuture ... done
[17:26:44.989] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.989] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.990] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:44.990]  length: 3 (resolved future 3)
[17:26:44.990] signalConditionsASAP(NULL, pos=4) ...
[17:26:44.990] - nx: 6
[17:26:44.990] - relay: TRUE
[17:26:44.990] - stdout: TRUE
[17:26:44.990] - signal: TRUE
[17:26:44.991] - resignal: FALSE
[17:26:44.991] - force: TRUE
[17:26:44.991] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.991] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.991]  - until=5
[17:26:44.991]  - relaying element #5
[17:26:44.992] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.992] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.992] signalConditionsASAP(NULL, pos=4) ... done
[17:26:44.992]  length: 2 (resolved future 4)
[17:26:44.992] signalConditionsASAP(NULL, pos=5) ...
[17:26:44.992] - nx: 6
[17:26:44.993] - relay: TRUE
[17:26:44.993] - stdout: TRUE
[17:26:44.993] - signal: TRUE
[17:26:44.993] - resignal: FALSE
[17:26:44.993] - force: TRUE
[17:26:44.993] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:44.993] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.994]  - until=6
[17:26:44.994]  - relaying element #6
[17:26:44.994] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.994] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.994] signalConditionsASAP(NULL, pos=5) ... done
[17:26:44.994]  length: 1 (resolved future 5)
[17:26:44.995] signalConditionsASAP(numeric, pos=6) ...
[17:26:44.995] - nx: 6
[17:26:44.995] - relay: TRUE
[17:26:44.995] - stdout: TRUE
[17:26:44.995] - signal: TRUE
[17:26:44.995] - resignal: FALSE
[17:26:44.995] - force: TRUE
[17:26:44.996] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:44.996] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.996]  - until=6
[17:26:44.996] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.996] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.996] signalConditionsASAP(numeric, pos=6) ... done
[17:26:44.997]  length: 0 (resolved future 6)
[17:26:44.997] Relaying remaining futures
[17:26:44.997] signalConditionsASAP(NULL, pos=0) ...
[17:26:44.997] - nx: 6
[17:26:44.997] - relay: TRUE
[17:26:44.997] - stdout: TRUE
[17:26:44.997] - signal: TRUE
[17:26:44.998] - resignal: FALSE
[17:26:44.998] - force: TRUE
[17:26:44.998] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.998] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[17:26:44.998] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:44.999] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:44.999] signalConditionsASAP(NULL, pos=0) ... done
[17:26:44.999] resolve() on list ... DONE
[17:26:44.999] result() for ClusterFuture ...
[17:26:44.999] - result already collected: FutureResult
[17:26:44.999] result() for ClusterFuture ... done
[17:26:44.999] result() for ClusterFuture ...
[17:26:45.000] - result already collected: FutureResult
[17:26:45.000] result() for ClusterFuture ... done
[17:26:45.000] result() for ClusterFuture ...
[17:26:45.000] - result already collected: FutureResult
[17:26:45.000] result() for ClusterFuture ... done
[17:26:45.000] result() for ClusterFuture ...
[17:26:45.001] - result already collected: FutureResult
[17:26:45.001] result() for ClusterFuture ... done
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
 - attr(*, "dim")= int [1:4] 2 1 3 1
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
*** futures() - list ... DONE
Type of object: environment
Type of future: multisession
[17:26:45.005] plan(): Setting new future strategy stack:
[17:26:45.006] List of future strategies:
[17:26:45.006] 1. multisession:
[17:26:45.006]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:45.006]    - tweaked: FALSE
[17:26:45.006]    - call: plan(strategy)
[17:26:45.006] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:45.007] multisession:
[17:26:45.007] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:45.007] - tweaked: FALSE
[17:26:45.007] - call: plan(strategy)
[17:26:45.009] getGlobalsAndPackages() ...
[17:26:45.009] Not searching for globals
[17:26:45.009] - globals: [0] <none>
[17:26:45.010] getGlobalsAndPackages() ... DONE
[17:26:45.010] [local output] makeClusterPSOCK() ...
[17:26:45.012] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:45.015] [local output] Base port: 34716
[17:26:45.015] [local output] Getting setup options for 2 cluster nodes ...
[17:26:45.015] [local output]  - Node 1 of 2 ...
[17:26:45.016] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:45.017] [local output] Rscript port: 34716

[17:26:45.018] [local output]  - Node 2 of 2 ...
[17:26:45.018] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:45.019] [local output] Rscript port: 34716

[17:26:45.020] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:45.020] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:45.021] [local output] Setting up PSOCK nodes in parallel
[17:26:45.021] List of 36
[17:26:45.021]  $ worker          : chr "localhost"
[17:26:45.021]   ..- attr(*, "localhost")= logi TRUE
[17:26:45.021]  $ master          : chr "localhost"
[17:26:45.021]  $ port            : int 34716
[17:26:45.021]  $ connectTimeout  : num 120
[17:26:45.021]  $ timeout         : num 120
[17:26:45.021]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:45.021]  $ homogeneous     : logi TRUE
[17:26:45.021]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futures.R:105464:CRANWIN3:CRAN\""| __truncated__
[17:26:45.021]  $ rscript_envs    : NULL
[17:26:45.021]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:45.021]  $ rscript_startup : NULL
[17:26:45.021]  $ rscript_sh      : chr "cmd"
[17:26:45.021]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:45.021]  $ methods         : logi TRUE
[17:26:45.021]  $ socketOptions   : chr "no-delay"
[17:26:45.021]  $ useXDR          : logi FALSE
[17:26:45.021]  $ outfile         : chr "/dev/null"
[17:26:45.021]  $ renice          : int NA
[17:26:45.021]  $ rshcmd          : NULL
[17:26:45.021]  $ user            : chr(0) 
[17:26:45.021]  $ revtunnel       : logi FALSE
[17:26:45.021]  $ rshlogfile      : NULL
[17:26:45.021]  $ rshopts         : chr(0) 
[17:26:45.021]  $ rank            : int 1
[17:26:45.021]  $ manual          : logi FALSE
[17:26:45.021]  $ dryrun          : logi FALSE
[17:26:45.021]  $ quiet           : logi FALSE
[17:26:45.021]  $ setup_strategy  : chr "parallel"
[17:26:45.021]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:45.021]  $ pidfile         : chr "D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf8ef42f81.pid"
[17:26:45.021]  $ rshcmd_label    : NULL
[17:26:45.021]  $ rsh_call        : NULL
[17:26:45.021]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:45.021]  $ localMachine    : logi TRUE
[17:26:45.021]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:45.021]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:45.021]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:45.021]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:45.021]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:45.021]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:26:45.021]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:45.021]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:45.021]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:45.021]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:45.021]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:45.021]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:45.021]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:45.021]  $ arguments       :List of 28
[17:26:45.021]   ..$ worker          : chr "localhost"
[17:26:45.021]   ..$ master          : NULL
[17:26:45.021]   ..$ port            : int 34716
[17:26:45.021]   ..$ connectTimeout  : num 120
[17:26:45.021]   ..$ timeout         : num 120
[17:26:45.021]   ..$ rscript         : NULL
[17:26:45.021]   ..$ homogeneous     : NULL
[17:26:45.021]   ..$ rscript_args    : NULL
[17:26:45.021]   ..$ rscript_envs    : NULL
[17:26:45.021]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:45.021]   ..$ rscript_startup : NULL
[17:26:45.021]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:26:45.021]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:45.021]   ..$ methods         : logi TRUE
[17:26:45.021]   ..$ socketOptions   : chr "no-delay"
[17:26:45.021]   ..$ useXDR          : logi FALSE
[17:26:45.021]   ..$ outfile         : chr "/dev/null"
[17:26:45.021]   ..$ renice          : int NA
[17:26:45.021]   ..$ rshcmd          : NULL
[17:26:45.021]   ..$ user            : NULL
[17:26:45.021]   ..$ revtunnel       : logi NA
[17:26:45.021]   ..$ rshlogfile      : NULL
[17:26:45.021]   ..$ rshopts         : NULL
[17:26:45.021]   ..$ rank            : int 1
[17:26:45.021]   ..$ manual          : logi FALSE
[17:26:45.021]   ..$ dryrun          : logi FALSE
[17:26:45.021]   ..$ quiet           : logi FALSE
[17:26:45.021]   ..$ setup_strategy  : chr "parallel"
[17:26:45.021]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:45.042] [local output] System call to launch all workers:
[17:26:45.042] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futures.R:105464:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf8ef42f81.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=34716 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:45.042] [local output] Starting PSOCK main server
[17:26:45.048] [local output] Workers launched
[17:26:45.048] [local output] Waiting for workers to connect back
[17:26:45.048]  - [local output] 0 workers out of 2 ready
[17:26:45.208]  - [local output] 0 workers out of 2 ready
[17:26:45.209]  - [local output] 1 workers out of 2 ready
[17:26:45.214]  - [local output] 1 workers out of 2 ready
[17:26:45.214]  - [local output] 2 workers out of 2 ready
[17:26:45.214] [local output] Launching of workers completed
[17:26:45.215] [local output] Collecting session information from workers
[17:26:45.215] [local output]  - Worker #1 of 2
[17:26:45.216] [local output]  - Worker #2 of 2
[17:26:45.216] [local output] makeClusterPSOCK() ... done
[17:26:45.228] Packages needed by the future expression (n = 0): <none>
[17:26:45.228] Packages needed by future strategies (n = 0): <none>
[17:26:45.229] {
[17:26:45.229]     {
[17:26:45.229]         {
[17:26:45.229]             ...future.startTime <- base::Sys.time()
[17:26:45.229]             {
[17:26:45.229]                 {
[17:26:45.229]                   {
[17:26:45.229]                     {
[17:26:45.229]                       base::local({
[17:26:45.229]                         has_future <- base::requireNamespace("future", 
[17:26:45.229]                           quietly = TRUE)
[17:26:45.229]                         if (has_future) {
[17:26:45.229]                           ns <- base::getNamespace("future")
[17:26:45.229]                           version <- ns[[".package"]][["version"]]
[17:26:45.229]                           if (is.null(version)) 
[17:26:45.229]                             version <- utils::packageVersion("future")
[17:26:45.229]                         }
[17:26:45.229]                         else {
[17:26:45.229]                           version <- NULL
[17:26:45.229]                         }
[17:26:45.229]                         if (!has_future || version < "1.8.0") {
[17:26:45.229]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.229]                             "", base::R.version$version.string), 
[17:26:45.229]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.229]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.229]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.229]                               "release", "version")], collapse = " "), 
[17:26:45.229]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.229]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.229]                             info)
[17:26:45.229]                           info <- base::paste(info, collapse = "; ")
[17:26:45.229]                           if (!has_future) {
[17:26:45.229]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.229]                               info)
[17:26:45.229]                           }
[17:26:45.229]                           else {
[17:26:45.229]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.229]                               info, version)
[17:26:45.229]                           }
[17:26:45.229]                           base::stop(msg)
[17:26:45.229]                         }
[17:26:45.229]                       })
[17:26:45.229]                     }
[17:26:45.229]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.229]                     base::options(mc.cores = 1L)
[17:26:45.229]                   }
[17:26:45.229]                   ...future.strategy.old <- future::plan("list")
[17:26:45.229]                   options(future.plan = NULL)
[17:26:45.229]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.229]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.229]                 }
[17:26:45.229]                 ...future.workdir <- getwd()
[17:26:45.229]             }
[17:26:45.229]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.229]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.229]         }
[17:26:45.229]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.229]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.229]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.229]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.229]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.229]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.229]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.229]             base::names(...future.oldOptions))
[17:26:45.229]     }
[17:26:45.229]     if (FALSE) {
[17:26:45.229]     }
[17:26:45.229]     else {
[17:26:45.229]         if (TRUE) {
[17:26:45.229]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.229]                 open = "w")
[17:26:45.229]         }
[17:26:45.229]         else {
[17:26:45.229]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.229]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.229]         }
[17:26:45.229]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.229]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.229]             base::sink(type = "output", split = FALSE)
[17:26:45.229]             base::close(...future.stdout)
[17:26:45.229]         }, add = TRUE)
[17:26:45.229]     }
[17:26:45.229]     ...future.frame <- base::sys.nframe()
[17:26:45.229]     ...future.conditions <- base::list()
[17:26:45.229]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.229]     if (FALSE) {
[17:26:45.229]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.229]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.229]     }
[17:26:45.229]     ...future.result <- base::tryCatch({
[17:26:45.229]         base::withCallingHandlers({
[17:26:45.229]             ...future.value <- base::withVisible(base::local({
[17:26:45.229]                 ...future.makeSendCondition <- base::local({
[17:26:45.229]                   sendCondition <- NULL
[17:26:45.229]                   function(frame = 1L) {
[17:26:45.229]                     if (is.function(sendCondition)) 
[17:26:45.229]                       return(sendCondition)
[17:26:45.229]                     ns <- getNamespace("parallel")
[17:26:45.229]                     if (exists("sendData", mode = "function", 
[17:26:45.229]                       envir = ns)) {
[17:26:45.229]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.229]                         envir = ns)
[17:26:45.229]                       envir <- sys.frame(frame)
[17:26:45.229]                       master <- NULL
[17:26:45.229]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.229]                         !identical(envir, emptyenv())) {
[17:26:45.229]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.229]                           inherits = FALSE)) {
[17:26:45.229]                           master <- get("master", mode = "list", 
[17:26:45.229]                             envir = envir, inherits = FALSE)
[17:26:45.229]                           if (inherits(master, c("SOCKnode", 
[17:26:45.229]                             "SOCK0node"))) {
[17:26:45.229]                             sendCondition <<- function(cond) {
[17:26:45.229]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.229]                                 success = TRUE)
[17:26:45.229]                               parallel_sendData(master, data)
[17:26:45.229]                             }
[17:26:45.229]                             return(sendCondition)
[17:26:45.229]                           }
[17:26:45.229]                         }
[17:26:45.229]                         frame <- frame + 1L
[17:26:45.229]                         envir <- sys.frame(frame)
[17:26:45.229]                       }
[17:26:45.229]                     }
[17:26:45.229]                     sendCondition <<- function(cond) NULL
[17:26:45.229]                   }
[17:26:45.229]                 })
[17:26:45.229]                 withCallingHandlers({
[17:26:45.229]                   NA
[17:26:45.229]                 }, immediateCondition = function(cond) {
[17:26:45.229]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.229]                   sendCondition(cond)
[17:26:45.229]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.229]                   {
[17:26:45.229]                     inherits <- base::inherits
[17:26:45.229]                     invokeRestart <- base::invokeRestart
[17:26:45.229]                     is.null <- base::is.null
[17:26:45.229]                     muffled <- FALSE
[17:26:45.229]                     if (inherits(cond, "message")) {
[17:26:45.229]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.229]                       if (muffled) 
[17:26:45.229]                         invokeRestart("muffleMessage")
[17:26:45.229]                     }
[17:26:45.229]                     else if (inherits(cond, "warning")) {
[17:26:45.229]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.229]                       if (muffled) 
[17:26:45.229]                         invokeRestart("muffleWarning")
[17:26:45.229]                     }
[17:26:45.229]                     else if (inherits(cond, "condition")) {
[17:26:45.229]                       if (!is.null(pattern)) {
[17:26:45.229]                         computeRestarts <- base::computeRestarts
[17:26:45.229]                         grepl <- base::grepl
[17:26:45.229]                         restarts <- computeRestarts(cond)
[17:26:45.229]                         for (restart in restarts) {
[17:26:45.229]                           name <- restart$name
[17:26:45.229]                           if (is.null(name)) 
[17:26:45.229]                             next
[17:26:45.229]                           if (!grepl(pattern, name)) 
[17:26:45.229]                             next
[17:26:45.229]                           invokeRestart(restart)
[17:26:45.229]                           muffled <- TRUE
[17:26:45.229]                           break
[17:26:45.229]                         }
[17:26:45.229]                       }
[17:26:45.229]                     }
[17:26:45.229]                     invisible(muffled)
[17:26:45.229]                   }
[17:26:45.229]                   muffleCondition(cond)
[17:26:45.229]                 })
[17:26:45.229]             }))
[17:26:45.229]             future::FutureResult(value = ...future.value$value, 
[17:26:45.229]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.229]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.229]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.229]                     ...future.globalenv.names))
[17:26:45.229]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.229]         }, condition = base::local({
[17:26:45.229]             c <- base::c
[17:26:45.229]             inherits <- base::inherits
[17:26:45.229]             invokeRestart <- base::invokeRestart
[17:26:45.229]             length <- base::length
[17:26:45.229]             list <- base::list
[17:26:45.229]             seq.int <- base::seq.int
[17:26:45.229]             signalCondition <- base::signalCondition
[17:26:45.229]             sys.calls <- base::sys.calls
[17:26:45.229]             `[[` <- base::`[[`
[17:26:45.229]             `+` <- base::`+`
[17:26:45.229]             `<<-` <- base::`<<-`
[17:26:45.229]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.229]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.229]                   3L)]
[17:26:45.229]             }
[17:26:45.229]             function(cond) {
[17:26:45.229]                 is_error <- inherits(cond, "error")
[17:26:45.229]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.229]                   NULL)
[17:26:45.229]                 if (is_error) {
[17:26:45.229]                   sessionInformation <- function() {
[17:26:45.229]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.229]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.229]                       search = base::search(), system = base::Sys.info())
[17:26:45.229]                   }
[17:26:45.229]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.229]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.229]                     cond$call), session = sessionInformation(), 
[17:26:45.229]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.229]                   signalCondition(cond)
[17:26:45.229]                 }
[17:26:45.229]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.229]                 "immediateCondition"))) {
[17:26:45.229]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.229]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.229]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.229]                   if (TRUE && !signal) {
[17:26:45.229]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.229]                     {
[17:26:45.229]                       inherits <- base::inherits
[17:26:45.229]                       invokeRestart <- base::invokeRestart
[17:26:45.229]                       is.null <- base::is.null
[17:26:45.229]                       muffled <- FALSE
[17:26:45.229]                       if (inherits(cond, "message")) {
[17:26:45.229]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.229]                         if (muffled) 
[17:26:45.229]                           invokeRestart("muffleMessage")
[17:26:45.229]                       }
[17:26:45.229]                       else if (inherits(cond, "warning")) {
[17:26:45.229]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.229]                         if (muffled) 
[17:26:45.229]                           invokeRestart("muffleWarning")
[17:26:45.229]                       }
[17:26:45.229]                       else if (inherits(cond, "condition")) {
[17:26:45.229]                         if (!is.null(pattern)) {
[17:26:45.229]                           computeRestarts <- base::computeRestarts
[17:26:45.229]                           grepl <- base::grepl
[17:26:45.229]                           restarts <- computeRestarts(cond)
[17:26:45.229]                           for (restart in restarts) {
[17:26:45.229]                             name <- restart$name
[17:26:45.229]                             if (is.null(name)) 
[17:26:45.229]                               next
[17:26:45.229]                             if (!grepl(pattern, name)) 
[17:26:45.229]                               next
[17:26:45.229]                             invokeRestart(restart)
[17:26:45.229]                             muffled <- TRUE
[17:26:45.229]                             break
[17:26:45.229]                           }
[17:26:45.229]                         }
[17:26:45.229]                       }
[17:26:45.229]                       invisible(muffled)
[17:26:45.229]                     }
[17:26:45.229]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.229]                   }
[17:26:45.229]                 }
[17:26:45.229]                 else {
[17:26:45.229]                   if (TRUE) {
[17:26:45.229]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.229]                     {
[17:26:45.229]                       inherits <- base::inherits
[17:26:45.229]                       invokeRestart <- base::invokeRestart
[17:26:45.229]                       is.null <- base::is.null
[17:26:45.229]                       muffled <- FALSE
[17:26:45.229]                       if (inherits(cond, "message")) {
[17:26:45.229]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.229]                         if (muffled) 
[17:26:45.229]                           invokeRestart("muffleMessage")
[17:26:45.229]                       }
[17:26:45.229]                       else if (inherits(cond, "warning")) {
[17:26:45.229]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.229]                         if (muffled) 
[17:26:45.229]                           invokeRestart("muffleWarning")
[17:26:45.229]                       }
[17:26:45.229]                       else if (inherits(cond, "condition")) {
[17:26:45.229]                         if (!is.null(pattern)) {
[17:26:45.229]                           computeRestarts <- base::computeRestarts
[17:26:45.229]                           grepl <- base::grepl
[17:26:45.229]                           restarts <- computeRestarts(cond)
[17:26:45.229]                           for (restart in restarts) {
[17:26:45.229]                             name <- restart$name
[17:26:45.229]                             if (is.null(name)) 
[17:26:45.229]                               next
[17:26:45.229]                             if (!grepl(pattern, name)) 
[17:26:45.229]                               next
[17:26:45.229]                             invokeRestart(restart)
[17:26:45.229]                             muffled <- TRUE
[17:26:45.229]                             break
[17:26:45.229]                           }
[17:26:45.229]                         }
[17:26:45.229]                       }
[17:26:45.229]                       invisible(muffled)
[17:26:45.229]                     }
[17:26:45.229]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.229]                   }
[17:26:45.229]                 }
[17:26:45.229]             }
[17:26:45.229]         }))
[17:26:45.229]     }, error = function(ex) {
[17:26:45.229]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.229]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.229]                 ...future.rng), started = ...future.startTime, 
[17:26:45.229]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.229]             version = "1.8"), class = "FutureResult")
[17:26:45.229]     }, finally = {
[17:26:45.229]         if (!identical(...future.workdir, getwd())) 
[17:26:45.229]             setwd(...future.workdir)
[17:26:45.229]         {
[17:26:45.229]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.229]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.229]             }
[17:26:45.229]             base::options(...future.oldOptions)
[17:26:45.229]             if (.Platform$OS.type == "windows") {
[17:26:45.229]                 old_names <- names(...future.oldEnvVars)
[17:26:45.229]                 envs <- base::Sys.getenv()
[17:26:45.229]                 names <- names(envs)
[17:26:45.229]                 common <- intersect(names, old_names)
[17:26:45.229]                 added <- setdiff(names, old_names)
[17:26:45.229]                 removed <- setdiff(old_names, names)
[17:26:45.229]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.229]                   envs[common]]
[17:26:45.229]                 NAMES <- toupper(changed)
[17:26:45.229]                 args <- list()
[17:26:45.229]                 for (kk in seq_along(NAMES)) {
[17:26:45.229]                   name <- changed[[kk]]
[17:26:45.229]                   NAME <- NAMES[[kk]]
[17:26:45.229]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.229]                     next
[17:26:45.229]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.229]                 }
[17:26:45.229]                 NAMES <- toupper(added)
[17:26:45.229]                 for (kk in seq_along(NAMES)) {
[17:26:45.229]                   name <- added[[kk]]
[17:26:45.229]                   NAME <- NAMES[[kk]]
[17:26:45.229]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.229]                     next
[17:26:45.229]                   args[[name]] <- ""
[17:26:45.229]                 }
[17:26:45.229]                 NAMES <- toupper(removed)
[17:26:45.229]                 for (kk in seq_along(NAMES)) {
[17:26:45.229]                   name <- removed[[kk]]
[17:26:45.229]                   NAME <- NAMES[[kk]]
[17:26:45.229]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.229]                     next
[17:26:45.229]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.229]                 }
[17:26:45.229]                 if (length(args) > 0) 
[17:26:45.229]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.229]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.229]             }
[17:26:45.229]             else {
[17:26:45.229]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.229]             }
[17:26:45.229]             {
[17:26:45.229]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.229]                   0L) {
[17:26:45.229]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.229]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.229]                   base::options(opts)
[17:26:45.229]                 }
[17:26:45.229]                 {
[17:26:45.229]                   {
[17:26:45.229]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.229]                     NULL
[17:26:45.229]                   }
[17:26:45.229]                   options(future.plan = NULL)
[17:26:45.229]                   if (is.na(NA_character_)) 
[17:26:45.229]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.229]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.229]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.229]                     .init = FALSE)
[17:26:45.229]                 }
[17:26:45.229]             }
[17:26:45.229]         }
[17:26:45.229]     })
[17:26:45.229]     if (TRUE) {
[17:26:45.229]         base::sink(type = "output", split = FALSE)
[17:26:45.229]         if (TRUE) {
[17:26:45.229]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.229]         }
[17:26:45.229]         else {
[17:26:45.229]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.229]         }
[17:26:45.229]         base::close(...future.stdout)
[17:26:45.229]         ...future.stdout <- NULL
[17:26:45.229]     }
[17:26:45.229]     ...future.result$conditions <- ...future.conditions
[17:26:45.229]     ...future.result$finished <- base::Sys.time()
[17:26:45.229]     ...future.result
[17:26:45.229] }
[17:26:45.310] MultisessionFuture started
[17:26:45.311] result() for ClusterFuture ...
[17:26:45.311] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.311] - Validating connection of MultisessionFuture
[17:26:45.362] - received message: FutureResult
[17:26:45.363] - Received FutureResult
[17:26:45.363] - Erased future from FutureRegistry
[17:26:45.363] result() for ClusterFuture ...
[17:26:45.363] - result already collected: FutureResult
[17:26:45.363] result() for ClusterFuture ... done
[17:26:45.363] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.364] result() for ClusterFuture ... done
[17:26:45.364] result() for ClusterFuture ...
[17:26:45.364] - result already collected: FutureResult
[17:26:45.364] result() for ClusterFuture ... done
[17:26:45.364] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:45.369] plan(): nbrOfWorkers() = 2
Dimensions: NULL
[17:26:45.369] getGlobalsAndPackages() ...
[17:26:45.369] Searching for globals...
[17:26:45.369] 
[17:26:45.370] Searching for globals ... DONE
[17:26:45.370] - globals: [0] <none>
[17:26:45.370] getGlobalsAndPackages() ... DONE
[17:26:45.370] run() for 'Future' ...
[17:26:45.370] - state: 'created'
[17:26:45.371] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.385] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.385] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.385]   - Field: 'node'
[17:26:45.385]   - Field: 'label'
[17:26:45.385]   - Field: 'local'
[17:26:45.386]   - Field: 'owner'
[17:26:45.386]   - Field: 'envir'
[17:26:45.386]   - Field: 'workers'
[17:26:45.386]   - Field: 'packages'
[17:26:45.386]   - Field: 'gc'
[17:26:45.386]   - Field: 'conditions'
[17:26:45.387]   - Field: 'persistent'
[17:26:45.387]   - Field: 'expr'
[17:26:45.387]   - Field: 'uuid'
[17:26:45.387]   - Field: 'seed'
[17:26:45.387]   - Field: 'version'
[17:26:45.388]   - Field: 'result'
[17:26:45.388]   - Field: 'asynchronous'
[17:26:45.388]   - Field: 'calls'
[17:26:45.388]   - Field: 'globals'
[17:26:45.388]   - Field: 'stdout'
[17:26:45.388]   - Field: 'earlySignal'
[17:26:45.389]   - Field: 'lazy'
[17:26:45.389]   - Field: 'state'
[17:26:45.389] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.389] - Launch lazy future ...
[17:26:45.389] Packages needed by the future expression (n = 0): <none>
[17:26:45.390] Packages needed by future strategies (n = 0): <none>
[17:26:45.390] {
[17:26:45.390]     {
[17:26:45.390]         {
[17:26:45.390]             ...future.startTime <- base::Sys.time()
[17:26:45.390]             {
[17:26:45.390]                 {
[17:26:45.390]                   {
[17:26:45.390]                     {
[17:26:45.390]                       base::local({
[17:26:45.390]                         has_future <- base::requireNamespace("future", 
[17:26:45.390]                           quietly = TRUE)
[17:26:45.390]                         if (has_future) {
[17:26:45.390]                           ns <- base::getNamespace("future")
[17:26:45.390]                           version <- ns[[".package"]][["version"]]
[17:26:45.390]                           if (is.null(version)) 
[17:26:45.390]                             version <- utils::packageVersion("future")
[17:26:45.390]                         }
[17:26:45.390]                         else {
[17:26:45.390]                           version <- NULL
[17:26:45.390]                         }
[17:26:45.390]                         if (!has_future || version < "1.8.0") {
[17:26:45.390]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.390]                             "", base::R.version$version.string), 
[17:26:45.390]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.390]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.390]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.390]                               "release", "version")], collapse = " "), 
[17:26:45.390]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.390]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.390]                             info)
[17:26:45.390]                           info <- base::paste(info, collapse = "; ")
[17:26:45.390]                           if (!has_future) {
[17:26:45.390]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.390]                               info)
[17:26:45.390]                           }
[17:26:45.390]                           else {
[17:26:45.390]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.390]                               info, version)
[17:26:45.390]                           }
[17:26:45.390]                           base::stop(msg)
[17:26:45.390]                         }
[17:26:45.390]                       })
[17:26:45.390]                     }
[17:26:45.390]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.390]                     base::options(mc.cores = 1L)
[17:26:45.390]                   }
[17:26:45.390]                   ...future.strategy.old <- future::plan("list")
[17:26:45.390]                   options(future.plan = NULL)
[17:26:45.390]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.390]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.390]                 }
[17:26:45.390]                 ...future.workdir <- getwd()
[17:26:45.390]             }
[17:26:45.390]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.390]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.390]         }
[17:26:45.390]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.390]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.390]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.390]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.390]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.390]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.390]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.390]             base::names(...future.oldOptions))
[17:26:45.390]     }
[17:26:45.390]     if (FALSE) {
[17:26:45.390]     }
[17:26:45.390]     else {
[17:26:45.390]         if (TRUE) {
[17:26:45.390]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.390]                 open = "w")
[17:26:45.390]         }
[17:26:45.390]         else {
[17:26:45.390]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.390]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.390]         }
[17:26:45.390]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.390]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.390]             base::sink(type = "output", split = FALSE)
[17:26:45.390]             base::close(...future.stdout)
[17:26:45.390]         }, add = TRUE)
[17:26:45.390]     }
[17:26:45.390]     ...future.frame <- base::sys.nframe()
[17:26:45.390]     ...future.conditions <- base::list()
[17:26:45.390]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.390]     if (FALSE) {
[17:26:45.390]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.390]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.390]     }
[17:26:45.390]     ...future.result <- base::tryCatch({
[17:26:45.390]         base::withCallingHandlers({
[17:26:45.390]             ...future.value <- base::withVisible(base::local({
[17:26:45.390]                 ...future.makeSendCondition <- base::local({
[17:26:45.390]                   sendCondition <- NULL
[17:26:45.390]                   function(frame = 1L) {
[17:26:45.390]                     if (is.function(sendCondition)) 
[17:26:45.390]                       return(sendCondition)
[17:26:45.390]                     ns <- getNamespace("parallel")
[17:26:45.390]                     if (exists("sendData", mode = "function", 
[17:26:45.390]                       envir = ns)) {
[17:26:45.390]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.390]                         envir = ns)
[17:26:45.390]                       envir <- sys.frame(frame)
[17:26:45.390]                       master <- NULL
[17:26:45.390]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.390]                         !identical(envir, emptyenv())) {
[17:26:45.390]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.390]                           inherits = FALSE)) {
[17:26:45.390]                           master <- get("master", mode = "list", 
[17:26:45.390]                             envir = envir, inherits = FALSE)
[17:26:45.390]                           if (inherits(master, c("SOCKnode", 
[17:26:45.390]                             "SOCK0node"))) {
[17:26:45.390]                             sendCondition <<- function(cond) {
[17:26:45.390]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.390]                                 success = TRUE)
[17:26:45.390]                               parallel_sendData(master, data)
[17:26:45.390]                             }
[17:26:45.390]                             return(sendCondition)
[17:26:45.390]                           }
[17:26:45.390]                         }
[17:26:45.390]                         frame <- frame + 1L
[17:26:45.390]                         envir <- sys.frame(frame)
[17:26:45.390]                       }
[17:26:45.390]                     }
[17:26:45.390]                     sendCondition <<- function(cond) NULL
[17:26:45.390]                   }
[17:26:45.390]                 })
[17:26:45.390]                 withCallingHandlers({
[17:26:45.390]                   2
[17:26:45.390]                 }, immediateCondition = function(cond) {
[17:26:45.390]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.390]                   sendCondition(cond)
[17:26:45.390]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.390]                   {
[17:26:45.390]                     inherits <- base::inherits
[17:26:45.390]                     invokeRestart <- base::invokeRestart
[17:26:45.390]                     is.null <- base::is.null
[17:26:45.390]                     muffled <- FALSE
[17:26:45.390]                     if (inherits(cond, "message")) {
[17:26:45.390]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.390]                       if (muffled) 
[17:26:45.390]                         invokeRestart("muffleMessage")
[17:26:45.390]                     }
[17:26:45.390]                     else if (inherits(cond, "warning")) {
[17:26:45.390]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.390]                       if (muffled) 
[17:26:45.390]                         invokeRestart("muffleWarning")
[17:26:45.390]                     }
[17:26:45.390]                     else if (inherits(cond, "condition")) {
[17:26:45.390]                       if (!is.null(pattern)) {
[17:26:45.390]                         computeRestarts <- base::computeRestarts
[17:26:45.390]                         grepl <- base::grepl
[17:26:45.390]                         restarts <- computeRestarts(cond)
[17:26:45.390]                         for (restart in restarts) {
[17:26:45.390]                           name <- restart$name
[17:26:45.390]                           if (is.null(name)) 
[17:26:45.390]                             next
[17:26:45.390]                           if (!grepl(pattern, name)) 
[17:26:45.390]                             next
[17:26:45.390]                           invokeRestart(restart)
[17:26:45.390]                           muffled <- TRUE
[17:26:45.390]                           break
[17:26:45.390]                         }
[17:26:45.390]                       }
[17:26:45.390]                     }
[17:26:45.390]                     invisible(muffled)
[17:26:45.390]                   }
[17:26:45.390]                   muffleCondition(cond)
[17:26:45.390]                 })
[17:26:45.390]             }))
[17:26:45.390]             future::FutureResult(value = ...future.value$value, 
[17:26:45.390]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.390]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.390]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.390]                     ...future.globalenv.names))
[17:26:45.390]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.390]         }, condition = base::local({
[17:26:45.390]             c <- base::c
[17:26:45.390]             inherits <- base::inherits
[17:26:45.390]             invokeRestart <- base::invokeRestart
[17:26:45.390]             length <- base::length
[17:26:45.390]             list <- base::list
[17:26:45.390]             seq.int <- base::seq.int
[17:26:45.390]             signalCondition <- base::signalCondition
[17:26:45.390]             sys.calls <- base::sys.calls
[17:26:45.390]             `[[` <- base::`[[`
[17:26:45.390]             `+` <- base::`+`
[17:26:45.390]             `<<-` <- base::`<<-`
[17:26:45.390]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.390]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.390]                   3L)]
[17:26:45.390]             }
[17:26:45.390]             function(cond) {
[17:26:45.390]                 is_error <- inherits(cond, "error")
[17:26:45.390]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.390]                   NULL)
[17:26:45.390]                 if (is_error) {
[17:26:45.390]                   sessionInformation <- function() {
[17:26:45.390]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.390]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.390]                       search = base::search(), system = base::Sys.info())
[17:26:45.390]                   }
[17:26:45.390]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.390]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.390]                     cond$call), session = sessionInformation(), 
[17:26:45.390]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.390]                   signalCondition(cond)
[17:26:45.390]                 }
[17:26:45.390]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.390]                 "immediateCondition"))) {
[17:26:45.390]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.390]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.390]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.390]                   if (TRUE && !signal) {
[17:26:45.390]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.390]                     {
[17:26:45.390]                       inherits <- base::inherits
[17:26:45.390]                       invokeRestart <- base::invokeRestart
[17:26:45.390]                       is.null <- base::is.null
[17:26:45.390]                       muffled <- FALSE
[17:26:45.390]                       if (inherits(cond, "message")) {
[17:26:45.390]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.390]                         if (muffled) 
[17:26:45.390]                           invokeRestart("muffleMessage")
[17:26:45.390]                       }
[17:26:45.390]                       else if (inherits(cond, "warning")) {
[17:26:45.390]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.390]                         if (muffled) 
[17:26:45.390]                           invokeRestart("muffleWarning")
[17:26:45.390]                       }
[17:26:45.390]                       else if (inherits(cond, "condition")) {
[17:26:45.390]                         if (!is.null(pattern)) {
[17:26:45.390]                           computeRestarts <- base::computeRestarts
[17:26:45.390]                           grepl <- base::grepl
[17:26:45.390]                           restarts <- computeRestarts(cond)
[17:26:45.390]                           for (restart in restarts) {
[17:26:45.390]                             name <- restart$name
[17:26:45.390]                             if (is.null(name)) 
[17:26:45.390]                               next
[17:26:45.390]                             if (!grepl(pattern, name)) 
[17:26:45.390]                               next
[17:26:45.390]                             invokeRestart(restart)
[17:26:45.390]                             muffled <- TRUE
[17:26:45.390]                             break
[17:26:45.390]                           }
[17:26:45.390]                         }
[17:26:45.390]                       }
[17:26:45.390]                       invisible(muffled)
[17:26:45.390]                     }
[17:26:45.390]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.390]                   }
[17:26:45.390]                 }
[17:26:45.390]                 else {
[17:26:45.390]                   if (TRUE) {
[17:26:45.390]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.390]                     {
[17:26:45.390]                       inherits <- base::inherits
[17:26:45.390]                       invokeRestart <- base::invokeRestart
[17:26:45.390]                       is.null <- base::is.null
[17:26:45.390]                       muffled <- FALSE
[17:26:45.390]                       if (inherits(cond, "message")) {
[17:26:45.390]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.390]                         if (muffled) 
[17:26:45.390]                           invokeRestart("muffleMessage")
[17:26:45.390]                       }
[17:26:45.390]                       else if (inherits(cond, "warning")) {
[17:26:45.390]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.390]                         if (muffled) 
[17:26:45.390]                           invokeRestart("muffleWarning")
[17:26:45.390]                       }
[17:26:45.390]                       else if (inherits(cond, "condition")) {
[17:26:45.390]                         if (!is.null(pattern)) {
[17:26:45.390]                           computeRestarts <- base::computeRestarts
[17:26:45.390]                           grepl <- base::grepl
[17:26:45.390]                           restarts <- computeRestarts(cond)
[17:26:45.390]                           for (restart in restarts) {
[17:26:45.390]                             name <- restart$name
[17:26:45.390]                             if (is.null(name)) 
[17:26:45.390]                               next
[17:26:45.390]                             if (!grepl(pattern, name)) 
[17:26:45.390]                               next
[17:26:45.390]                             invokeRestart(restart)
[17:26:45.390]                             muffled <- TRUE
[17:26:45.390]                             break
[17:26:45.390]                           }
[17:26:45.390]                         }
[17:26:45.390]                       }
[17:26:45.390]                       invisible(muffled)
[17:26:45.390]                     }
[17:26:45.390]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.390]                   }
[17:26:45.390]                 }
[17:26:45.390]             }
[17:26:45.390]         }))
[17:26:45.390]     }, error = function(ex) {
[17:26:45.390]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.390]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.390]                 ...future.rng), started = ...future.startTime, 
[17:26:45.390]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.390]             version = "1.8"), class = "FutureResult")
[17:26:45.390]     }, finally = {
[17:26:45.390]         if (!identical(...future.workdir, getwd())) 
[17:26:45.390]             setwd(...future.workdir)
[17:26:45.390]         {
[17:26:45.390]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.390]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.390]             }
[17:26:45.390]             base::options(...future.oldOptions)
[17:26:45.390]             if (.Platform$OS.type == "windows") {
[17:26:45.390]                 old_names <- names(...future.oldEnvVars)
[17:26:45.390]                 envs <- base::Sys.getenv()
[17:26:45.390]                 names <- names(envs)
[17:26:45.390]                 common <- intersect(names, old_names)
[17:26:45.390]                 added <- setdiff(names, old_names)
[17:26:45.390]                 removed <- setdiff(old_names, names)
[17:26:45.390]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.390]                   envs[common]]
[17:26:45.390]                 NAMES <- toupper(changed)
[17:26:45.390]                 args <- list()
[17:26:45.390]                 for (kk in seq_along(NAMES)) {
[17:26:45.390]                   name <- changed[[kk]]
[17:26:45.390]                   NAME <- NAMES[[kk]]
[17:26:45.390]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.390]                     next
[17:26:45.390]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.390]                 }
[17:26:45.390]                 NAMES <- toupper(added)
[17:26:45.390]                 for (kk in seq_along(NAMES)) {
[17:26:45.390]                   name <- added[[kk]]
[17:26:45.390]                   NAME <- NAMES[[kk]]
[17:26:45.390]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.390]                     next
[17:26:45.390]                   args[[name]] <- ""
[17:26:45.390]                 }
[17:26:45.390]                 NAMES <- toupper(removed)
[17:26:45.390]                 for (kk in seq_along(NAMES)) {
[17:26:45.390]                   name <- removed[[kk]]
[17:26:45.390]                   NAME <- NAMES[[kk]]
[17:26:45.390]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.390]                     next
[17:26:45.390]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.390]                 }
[17:26:45.390]                 if (length(args) > 0) 
[17:26:45.390]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.390]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.390]             }
[17:26:45.390]             else {
[17:26:45.390]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.390]             }
[17:26:45.390]             {
[17:26:45.390]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.390]                   0L) {
[17:26:45.390]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.390]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.390]                   base::options(opts)
[17:26:45.390]                 }
[17:26:45.390]                 {
[17:26:45.390]                   {
[17:26:45.390]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.390]                     NULL
[17:26:45.390]                   }
[17:26:45.390]                   options(future.plan = NULL)
[17:26:45.390]                   if (is.na(NA_character_)) 
[17:26:45.390]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.390]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.390]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.390]                     .init = FALSE)
[17:26:45.390]                 }
[17:26:45.390]             }
[17:26:45.390]         }
[17:26:45.390]     })
[17:26:45.390]     if (TRUE) {
[17:26:45.390]         base::sink(type = "output", split = FALSE)
[17:26:45.390]         if (TRUE) {
[17:26:45.390]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.390]         }
[17:26:45.390]         else {
[17:26:45.390]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.390]         }
[17:26:45.390]         base::close(...future.stdout)
[17:26:45.390]         ...future.stdout <- NULL
[17:26:45.390]     }
[17:26:45.390]     ...future.result$conditions <- ...future.conditions
[17:26:45.390]     ...future.result$finished <- base::Sys.time()
[17:26:45.390]     ...future.result
[17:26:45.390] }
[17:26:45.396] MultisessionFuture started
[17:26:45.396] - Launch lazy future ... done
[17:26:45.396] run() for 'MultisessionFuture' ... done
[17:26:45.396] getGlobalsAndPackages() ...
[17:26:45.396] Searching for globals...
[17:26:45.397] 
[17:26:45.397] Searching for globals ... DONE
[17:26:45.397] - globals: [0] <none>
[17:26:45.397] getGlobalsAndPackages() ... DONE
[17:26:45.397] run() for 'Future' ...
[17:26:45.398] - state: 'created'
[17:26:45.398] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.412] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.412] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.412]   - Field: 'node'
[17:26:45.412]   - Field: 'label'
[17:26:45.412]   - Field: 'local'
[17:26:45.413]   - Field: 'owner'
[17:26:45.413]   - Field: 'envir'
[17:26:45.413]   - Field: 'workers'
[17:26:45.413]   - Field: 'packages'
[17:26:45.413]   - Field: 'gc'
[17:26:45.413]   - Field: 'conditions'
[17:26:45.414]   - Field: 'persistent'
[17:26:45.414]   - Field: 'expr'
[17:26:45.414]   - Field: 'uuid'
[17:26:45.414]   - Field: 'seed'
[17:26:45.414]   - Field: 'version'
[17:26:45.415]   - Field: 'result'
[17:26:45.415]   - Field: 'asynchronous'
[17:26:45.415]   - Field: 'calls'
[17:26:45.415]   - Field: 'globals'
[17:26:45.415]   - Field: 'stdout'
[17:26:45.415]   - Field: 'earlySignal'
[17:26:45.416]   - Field: 'lazy'
[17:26:45.416]   - Field: 'state'
[17:26:45.416] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.416] - Launch lazy future ...
[17:26:45.416] Packages needed by the future expression (n = 0): <none>
[17:26:45.417] Packages needed by future strategies (n = 0): <none>
[17:26:45.417] {
[17:26:45.417]     {
[17:26:45.417]         {
[17:26:45.417]             ...future.startTime <- base::Sys.time()
[17:26:45.417]             {
[17:26:45.417]                 {
[17:26:45.417]                   {
[17:26:45.417]                     {
[17:26:45.417]                       base::local({
[17:26:45.417]                         has_future <- base::requireNamespace("future", 
[17:26:45.417]                           quietly = TRUE)
[17:26:45.417]                         if (has_future) {
[17:26:45.417]                           ns <- base::getNamespace("future")
[17:26:45.417]                           version <- ns[[".package"]][["version"]]
[17:26:45.417]                           if (is.null(version)) 
[17:26:45.417]                             version <- utils::packageVersion("future")
[17:26:45.417]                         }
[17:26:45.417]                         else {
[17:26:45.417]                           version <- NULL
[17:26:45.417]                         }
[17:26:45.417]                         if (!has_future || version < "1.8.0") {
[17:26:45.417]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.417]                             "", base::R.version$version.string), 
[17:26:45.417]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.417]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.417]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.417]                               "release", "version")], collapse = " "), 
[17:26:45.417]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.417]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.417]                             info)
[17:26:45.417]                           info <- base::paste(info, collapse = "; ")
[17:26:45.417]                           if (!has_future) {
[17:26:45.417]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.417]                               info)
[17:26:45.417]                           }
[17:26:45.417]                           else {
[17:26:45.417]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.417]                               info, version)
[17:26:45.417]                           }
[17:26:45.417]                           base::stop(msg)
[17:26:45.417]                         }
[17:26:45.417]                       })
[17:26:45.417]                     }
[17:26:45.417]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.417]                     base::options(mc.cores = 1L)
[17:26:45.417]                   }
[17:26:45.417]                   ...future.strategy.old <- future::plan("list")
[17:26:45.417]                   options(future.plan = NULL)
[17:26:45.417]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.417]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.417]                 }
[17:26:45.417]                 ...future.workdir <- getwd()
[17:26:45.417]             }
[17:26:45.417]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.417]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.417]         }
[17:26:45.417]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.417]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.417]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.417]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.417]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.417]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.417]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.417]             base::names(...future.oldOptions))
[17:26:45.417]     }
[17:26:45.417]     if (FALSE) {
[17:26:45.417]     }
[17:26:45.417]     else {
[17:26:45.417]         if (TRUE) {
[17:26:45.417]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.417]                 open = "w")
[17:26:45.417]         }
[17:26:45.417]         else {
[17:26:45.417]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.417]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.417]         }
[17:26:45.417]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.417]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.417]             base::sink(type = "output", split = FALSE)
[17:26:45.417]             base::close(...future.stdout)
[17:26:45.417]         }, add = TRUE)
[17:26:45.417]     }
[17:26:45.417]     ...future.frame <- base::sys.nframe()
[17:26:45.417]     ...future.conditions <- base::list()
[17:26:45.417]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.417]     if (FALSE) {
[17:26:45.417]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.417]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.417]     }
[17:26:45.417]     ...future.result <- base::tryCatch({
[17:26:45.417]         base::withCallingHandlers({
[17:26:45.417]             ...future.value <- base::withVisible(base::local({
[17:26:45.417]                 ...future.makeSendCondition <- base::local({
[17:26:45.417]                   sendCondition <- NULL
[17:26:45.417]                   function(frame = 1L) {
[17:26:45.417]                     if (is.function(sendCondition)) 
[17:26:45.417]                       return(sendCondition)
[17:26:45.417]                     ns <- getNamespace("parallel")
[17:26:45.417]                     if (exists("sendData", mode = "function", 
[17:26:45.417]                       envir = ns)) {
[17:26:45.417]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.417]                         envir = ns)
[17:26:45.417]                       envir <- sys.frame(frame)
[17:26:45.417]                       master <- NULL
[17:26:45.417]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.417]                         !identical(envir, emptyenv())) {
[17:26:45.417]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.417]                           inherits = FALSE)) {
[17:26:45.417]                           master <- get("master", mode = "list", 
[17:26:45.417]                             envir = envir, inherits = FALSE)
[17:26:45.417]                           if (inherits(master, c("SOCKnode", 
[17:26:45.417]                             "SOCK0node"))) {
[17:26:45.417]                             sendCondition <<- function(cond) {
[17:26:45.417]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.417]                                 success = TRUE)
[17:26:45.417]                               parallel_sendData(master, data)
[17:26:45.417]                             }
[17:26:45.417]                             return(sendCondition)
[17:26:45.417]                           }
[17:26:45.417]                         }
[17:26:45.417]                         frame <- frame + 1L
[17:26:45.417]                         envir <- sys.frame(frame)
[17:26:45.417]                       }
[17:26:45.417]                     }
[17:26:45.417]                     sendCondition <<- function(cond) NULL
[17:26:45.417]                   }
[17:26:45.417]                 })
[17:26:45.417]                 withCallingHandlers({
[17:26:45.417]                   NULL
[17:26:45.417]                 }, immediateCondition = function(cond) {
[17:26:45.417]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.417]                   sendCondition(cond)
[17:26:45.417]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.417]                   {
[17:26:45.417]                     inherits <- base::inherits
[17:26:45.417]                     invokeRestart <- base::invokeRestart
[17:26:45.417]                     is.null <- base::is.null
[17:26:45.417]                     muffled <- FALSE
[17:26:45.417]                     if (inherits(cond, "message")) {
[17:26:45.417]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.417]                       if (muffled) 
[17:26:45.417]                         invokeRestart("muffleMessage")
[17:26:45.417]                     }
[17:26:45.417]                     else if (inherits(cond, "warning")) {
[17:26:45.417]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.417]                       if (muffled) 
[17:26:45.417]                         invokeRestart("muffleWarning")
[17:26:45.417]                     }
[17:26:45.417]                     else if (inherits(cond, "condition")) {
[17:26:45.417]                       if (!is.null(pattern)) {
[17:26:45.417]                         computeRestarts <- base::computeRestarts
[17:26:45.417]                         grepl <- base::grepl
[17:26:45.417]                         restarts <- computeRestarts(cond)
[17:26:45.417]                         for (restart in restarts) {
[17:26:45.417]                           name <- restart$name
[17:26:45.417]                           if (is.null(name)) 
[17:26:45.417]                             next
[17:26:45.417]                           if (!grepl(pattern, name)) 
[17:26:45.417]                             next
[17:26:45.417]                           invokeRestart(restart)
[17:26:45.417]                           muffled <- TRUE
[17:26:45.417]                           break
[17:26:45.417]                         }
[17:26:45.417]                       }
[17:26:45.417]                     }
[17:26:45.417]                     invisible(muffled)
[17:26:45.417]                   }
[17:26:45.417]                   muffleCondition(cond)
[17:26:45.417]                 })
[17:26:45.417]             }))
[17:26:45.417]             future::FutureResult(value = ...future.value$value, 
[17:26:45.417]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.417]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.417]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.417]                     ...future.globalenv.names))
[17:26:45.417]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.417]         }, condition = base::local({
[17:26:45.417]             c <- base::c
[17:26:45.417]             inherits <- base::inherits
[17:26:45.417]             invokeRestart <- base::invokeRestart
[17:26:45.417]             length <- base::length
[17:26:45.417]             list <- base::list
[17:26:45.417]             seq.int <- base::seq.int
[17:26:45.417]             signalCondition <- base::signalCondition
[17:26:45.417]             sys.calls <- base::sys.calls
[17:26:45.417]             `[[` <- base::`[[`
[17:26:45.417]             `+` <- base::`+`
[17:26:45.417]             `<<-` <- base::`<<-`
[17:26:45.417]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.417]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.417]                   3L)]
[17:26:45.417]             }
[17:26:45.417]             function(cond) {
[17:26:45.417]                 is_error <- inherits(cond, "error")
[17:26:45.417]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.417]                   NULL)
[17:26:45.417]                 if (is_error) {
[17:26:45.417]                   sessionInformation <- function() {
[17:26:45.417]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.417]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.417]                       search = base::search(), system = base::Sys.info())
[17:26:45.417]                   }
[17:26:45.417]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.417]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.417]                     cond$call), session = sessionInformation(), 
[17:26:45.417]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.417]                   signalCondition(cond)
[17:26:45.417]                 }
[17:26:45.417]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.417]                 "immediateCondition"))) {
[17:26:45.417]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.417]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.417]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.417]                   if (TRUE && !signal) {
[17:26:45.417]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.417]                     {
[17:26:45.417]                       inherits <- base::inherits
[17:26:45.417]                       invokeRestart <- base::invokeRestart
[17:26:45.417]                       is.null <- base::is.null
[17:26:45.417]                       muffled <- FALSE
[17:26:45.417]                       if (inherits(cond, "message")) {
[17:26:45.417]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.417]                         if (muffled) 
[17:26:45.417]                           invokeRestart("muffleMessage")
[17:26:45.417]                       }
[17:26:45.417]                       else if (inherits(cond, "warning")) {
[17:26:45.417]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.417]                         if (muffled) 
[17:26:45.417]                           invokeRestart("muffleWarning")
[17:26:45.417]                       }
[17:26:45.417]                       else if (inherits(cond, "condition")) {
[17:26:45.417]                         if (!is.null(pattern)) {
[17:26:45.417]                           computeRestarts <- base::computeRestarts
[17:26:45.417]                           grepl <- base::grepl
[17:26:45.417]                           restarts <- computeRestarts(cond)
[17:26:45.417]                           for (restart in restarts) {
[17:26:45.417]                             name <- restart$name
[17:26:45.417]                             if (is.null(name)) 
[17:26:45.417]                               next
[17:26:45.417]                             if (!grepl(pattern, name)) 
[17:26:45.417]                               next
[17:26:45.417]                             invokeRestart(restart)
[17:26:45.417]                             muffled <- TRUE
[17:26:45.417]                             break
[17:26:45.417]                           }
[17:26:45.417]                         }
[17:26:45.417]                       }
[17:26:45.417]                       invisible(muffled)
[17:26:45.417]                     }
[17:26:45.417]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.417]                   }
[17:26:45.417]                 }
[17:26:45.417]                 else {
[17:26:45.417]                   if (TRUE) {
[17:26:45.417]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.417]                     {
[17:26:45.417]                       inherits <- base::inherits
[17:26:45.417]                       invokeRestart <- base::invokeRestart
[17:26:45.417]                       is.null <- base::is.null
[17:26:45.417]                       muffled <- FALSE
[17:26:45.417]                       if (inherits(cond, "message")) {
[17:26:45.417]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.417]                         if (muffled) 
[17:26:45.417]                           invokeRestart("muffleMessage")
[17:26:45.417]                       }
[17:26:45.417]                       else if (inherits(cond, "warning")) {
[17:26:45.417]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.417]                         if (muffled) 
[17:26:45.417]                           invokeRestart("muffleWarning")
[17:26:45.417]                       }
[17:26:45.417]                       else if (inherits(cond, "condition")) {
[17:26:45.417]                         if (!is.null(pattern)) {
[17:26:45.417]                           computeRestarts <- base::computeRestarts
[17:26:45.417]                           grepl <- base::grepl
[17:26:45.417]                           restarts <- computeRestarts(cond)
[17:26:45.417]                           for (restart in restarts) {
[17:26:45.417]                             name <- restart$name
[17:26:45.417]                             if (is.null(name)) 
[17:26:45.417]                               next
[17:26:45.417]                             if (!grepl(pattern, name)) 
[17:26:45.417]                               next
[17:26:45.417]                             invokeRestart(restart)
[17:26:45.417]                             muffled <- TRUE
[17:26:45.417]                             break
[17:26:45.417]                           }
[17:26:45.417]                         }
[17:26:45.417]                       }
[17:26:45.417]                       invisible(muffled)
[17:26:45.417]                     }
[17:26:45.417]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.417]                   }
[17:26:45.417]                 }
[17:26:45.417]             }
[17:26:45.417]         }))
[17:26:45.417]     }, error = function(ex) {
[17:26:45.417]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.417]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.417]                 ...future.rng), started = ...future.startTime, 
[17:26:45.417]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.417]             version = "1.8"), class = "FutureResult")
[17:26:45.417]     }, finally = {
[17:26:45.417]         if (!identical(...future.workdir, getwd())) 
[17:26:45.417]             setwd(...future.workdir)
[17:26:45.417]         {
[17:26:45.417]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.417]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.417]             }
[17:26:45.417]             base::options(...future.oldOptions)
[17:26:45.417]             if (.Platform$OS.type == "windows") {
[17:26:45.417]                 old_names <- names(...future.oldEnvVars)
[17:26:45.417]                 envs <- base::Sys.getenv()
[17:26:45.417]                 names <- names(envs)
[17:26:45.417]                 common <- intersect(names, old_names)
[17:26:45.417]                 added <- setdiff(names, old_names)
[17:26:45.417]                 removed <- setdiff(old_names, names)
[17:26:45.417]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.417]                   envs[common]]
[17:26:45.417]                 NAMES <- toupper(changed)
[17:26:45.417]                 args <- list()
[17:26:45.417]                 for (kk in seq_along(NAMES)) {
[17:26:45.417]                   name <- changed[[kk]]
[17:26:45.417]                   NAME <- NAMES[[kk]]
[17:26:45.417]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.417]                     next
[17:26:45.417]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.417]                 }
[17:26:45.417]                 NAMES <- toupper(added)
[17:26:45.417]                 for (kk in seq_along(NAMES)) {
[17:26:45.417]                   name <- added[[kk]]
[17:26:45.417]                   NAME <- NAMES[[kk]]
[17:26:45.417]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.417]                     next
[17:26:45.417]                   args[[name]] <- ""
[17:26:45.417]                 }
[17:26:45.417]                 NAMES <- toupper(removed)
[17:26:45.417]                 for (kk in seq_along(NAMES)) {
[17:26:45.417]                   name <- removed[[kk]]
[17:26:45.417]                   NAME <- NAMES[[kk]]
[17:26:45.417]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.417]                     next
[17:26:45.417]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.417]                 }
[17:26:45.417]                 if (length(args) > 0) 
[17:26:45.417]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.417]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.417]             }
[17:26:45.417]             else {
[17:26:45.417]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.417]             }
[17:26:45.417]             {
[17:26:45.417]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.417]                   0L) {
[17:26:45.417]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.417]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.417]                   base::options(opts)
[17:26:45.417]                 }
[17:26:45.417]                 {
[17:26:45.417]                   {
[17:26:45.417]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.417]                     NULL
[17:26:45.417]                   }
[17:26:45.417]                   options(future.plan = NULL)
[17:26:45.417]                   if (is.na(NA_character_)) 
[17:26:45.417]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.417]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.417]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.417]                     .init = FALSE)
[17:26:45.417]                 }
[17:26:45.417]             }
[17:26:45.417]         }
[17:26:45.417]     })
[17:26:45.417]     if (TRUE) {
[17:26:45.417]         base::sink(type = "output", split = FALSE)
[17:26:45.417]         if (TRUE) {
[17:26:45.417]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.417]         }
[17:26:45.417]         else {
[17:26:45.417]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.417]         }
[17:26:45.417]         base::close(...future.stdout)
[17:26:45.417]         ...future.stdout <- NULL
[17:26:45.417]     }
[17:26:45.417]     ...future.result$conditions <- ...future.conditions
[17:26:45.417]     ...future.result$finished <- base::Sys.time()
[17:26:45.417]     ...future.result
[17:26:45.417] }
[17:26:45.498] MultisessionFuture started
[17:26:45.499] - Launch lazy future ... done
[17:26:45.499] run() for 'MultisessionFuture' ... done
[17:26:45.499] getGlobalsAndPackages() ...
[17:26:45.499] Searching for globals...
[17:26:45.500] - globals found: [1] '{'
[17:26:45.500] Searching for globals ... DONE
[17:26:45.501] Resolving globals: FALSE
[17:26:45.501] 
[17:26:45.501] 
[17:26:45.501] getGlobalsAndPackages() ... DONE
[17:26:45.502] run() for 'Future' ...
[17:26:45.502] - state: 'created'
[17:26:45.502] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.517] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.518] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.518]   - Field: 'node'
[17:26:45.518]   - Field: 'label'
[17:26:45.518]   - Field: 'local'
[17:26:45.518]   - Field: 'owner'
[17:26:45.518]   - Field: 'envir'
[17:26:45.519]   - Field: 'workers'
[17:26:45.519]   - Field: 'packages'
[17:26:45.519]   - Field: 'gc'
[17:26:45.519]   - Field: 'conditions'
[17:26:45.519]   - Field: 'persistent'
[17:26:45.520]   - Field: 'expr'
[17:26:45.520]   - Field: 'uuid'
[17:26:45.520]   - Field: 'seed'
[17:26:45.520]   - Field: 'version'
[17:26:45.520]   - Field: 'result'
[17:26:45.520]   - Field: 'asynchronous'
[17:26:45.521]   - Field: 'calls'
[17:26:45.521]   - Field: 'globals'
[17:26:45.521]   - Field: 'stdout'
[17:26:45.521]   - Field: 'earlySignal'
[17:26:45.521]   - Field: 'lazy'
[17:26:45.522]   - Field: 'state'
[17:26:45.522] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.522] - Launch lazy future ...
[17:26:45.522] Packages needed by the future expression (n = 0): <none>
[17:26:45.522] Packages needed by future strategies (n = 0): <none>
[17:26:45.523] {
[17:26:45.523]     {
[17:26:45.523]         {
[17:26:45.523]             ...future.startTime <- base::Sys.time()
[17:26:45.523]             {
[17:26:45.523]                 {
[17:26:45.523]                   {
[17:26:45.523]                     {
[17:26:45.523]                       base::local({
[17:26:45.523]                         has_future <- base::requireNamespace("future", 
[17:26:45.523]                           quietly = TRUE)
[17:26:45.523]                         if (has_future) {
[17:26:45.523]                           ns <- base::getNamespace("future")
[17:26:45.523]                           version <- ns[[".package"]][["version"]]
[17:26:45.523]                           if (is.null(version)) 
[17:26:45.523]                             version <- utils::packageVersion("future")
[17:26:45.523]                         }
[17:26:45.523]                         else {
[17:26:45.523]                           version <- NULL
[17:26:45.523]                         }
[17:26:45.523]                         if (!has_future || version < "1.8.0") {
[17:26:45.523]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.523]                             "", base::R.version$version.string), 
[17:26:45.523]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.523]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.523]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.523]                               "release", "version")], collapse = " "), 
[17:26:45.523]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.523]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.523]                             info)
[17:26:45.523]                           info <- base::paste(info, collapse = "; ")
[17:26:45.523]                           if (!has_future) {
[17:26:45.523]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.523]                               info)
[17:26:45.523]                           }
[17:26:45.523]                           else {
[17:26:45.523]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.523]                               info, version)
[17:26:45.523]                           }
[17:26:45.523]                           base::stop(msg)
[17:26:45.523]                         }
[17:26:45.523]                       })
[17:26:45.523]                     }
[17:26:45.523]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.523]                     base::options(mc.cores = 1L)
[17:26:45.523]                   }
[17:26:45.523]                   ...future.strategy.old <- future::plan("list")
[17:26:45.523]                   options(future.plan = NULL)
[17:26:45.523]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.523]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.523]                 }
[17:26:45.523]                 ...future.workdir <- getwd()
[17:26:45.523]             }
[17:26:45.523]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.523]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.523]         }
[17:26:45.523]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.523]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.523]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.523]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.523]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.523]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.523]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.523]             base::names(...future.oldOptions))
[17:26:45.523]     }
[17:26:45.523]     if (FALSE) {
[17:26:45.523]     }
[17:26:45.523]     else {
[17:26:45.523]         if (TRUE) {
[17:26:45.523]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.523]                 open = "w")
[17:26:45.523]         }
[17:26:45.523]         else {
[17:26:45.523]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.523]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.523]         }
[17:26:45.523]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.523]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.523]             base::sink(type = "output", split = FALSE)
[17:26:45.523]             base::close(...future.stdout)
[17:26:45.523]         }, add = TRUE)
[17:26:45.523]     }
[17:26:45.523]     ...future.frame <- base::sys.nframe()
[17:26:45.523]     ...future.conditions <- base::list()
[17:26:45.523]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.523]     if (FALSE) {
[17:26:45.523]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.523]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.523]     }
[17:26:45.523]     ...future.result <- base::tryCatch({
[17:26:45.523]         base::withCallingHandlers({
[17:26:45.523]             ...future.value <- base::withVisible(base::local({
[17:26:45.523]                 ...future.makeSendCondition <- base::local({
[17:26:45.523]                   sendCondition <- NULL
[17:26:45.523]                   function(frame = 1L) {
[17:26:45.523]                     if (is.function(sendCondition)) 
[17:26:45.523]                       return(sendCondition)
[17:26:45.523]                     ns <- getNamespace("parallel")
[17:26:45.523]                     if (exists("sendData", mode = "function", 
[17:26:45.523]                       envir = ns)) {
[17:26:45.523]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.523]                         envir = ns)
[17:26:45.523]                       envir <- sys.frame(frame)
[17:26:45.523]                       master <- NULL
[17:26:45.523]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.523]                         !identical(envir, emptyenv())) {
[17:26:45.523]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.523]                           inherits = FALSE)) {
[17:26:45.523]                           master <- get("master", mode = "list", 
[17:26:45.523]                             envir = envir, inherits = FALSE)
[17:26:45.523]                           if (inherits(master, c("SOCKnode", 
[17:26:45.523]                             "SOCK0node"))) {
[17:26:45.523]                             sendCondition <<- function(cond) {
[17:26:45.523]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.523]                                 success = TRUE)
[17:26:45.523]                               parallel_sendData(master, data)
[17:26:45.523]                             }
[17:26:45.523]                             return(sendCondition)
[17:26:45.523]                           }
[17:26:45.523]                         }
[17:26:45.523]                         frame <- frame + 1L
[17:26:45.523]                         envir <- sys.frame(frame)
[17:26:45.523]                       }
[17:26:45.523]                     }
[17:26:45.523]                     sendCondition <<- function(cond) NULL
[17:26:45.523]                   }
[17:26:45.523]                 })
[17:26:45.523]                 withCallingHandlers({
[17:26:45.523]                   {
[17:26:45.523]                     4
[17:26:45.523]                   }
[17:26:45.523]                 }, immediateCondition = function(cond) {
[17:26:45.523]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.523]                   sendCondition(cond)
[17:26:45.523]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.523]                   {
[17:26:45.523]                     inherits <- base::inherits
[17:26:45.523]                     invokeRestart <- base::invokeRestart
[17:26:45.523]                     is.null <- base::is.null
[17:26:45.523]                     muffled <- FALSE
[17:26:45.523]                     if (inherits(cond, "message")) {
[17:26:45.523]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.523]                       if (muffled) 
[17:26:45.523]                         invokeRestart("muffleMessage")
[17:26:45.523]                     }
[17:26:45.523]                     else if (inherits(cond, "warning")) {
[17:26:45.523]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.523]                       if (muffled) 
[17:26:45.523]                         invokeRestart("muffleWarning")
[17:26:45.523]                     }
[17:26:45.523]                     else if (inherits(cond, "condition")) {
[17:26:45.523]                       if (!is.null(pattern)) {
[17:26:45.523]                         computeRestarts <- base::computeRestarts
[17:26:45.523]                         grepl <- base::grepl
[17:26:45.523]                         restarts <- computeRestarts(cond)
[17:26:45.523]                         for (restart in restarts) {
[17:26:45.523]                           name <- restart$name
[17:26:45.523]                           if (is.null(name)) 
[17:26:45.523]                             next
[17:26:45.523]                           if (!grepl(pattern, name)) 
[17:26:45.523]                             next
[17:26:45.523]                           invokeRestart(restart)
[17:26:45.523]                           muffled <- TRUE
[17:26:45.523]                           break
[17:26:45.523]                         }
[17:26:45.523]                       }
[17:26:45.523]                     }
[17:26:45.523]                     invisible(muffled)
[17:26:45.523]                   }
[17:26:45.523]                   muffleCondition(cond)
[17:26:45.523]                 })
[17:26:45.523]             }))
[17:26:45.523]             future::FutureResult(value = ...future.value$value, 
[17:26:45.523]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.523]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.523]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.523]                     ...future.globalenv.names))
[17:26:45.523]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.523]         }, condition = base::local({
[17:26:45.523]             c <- base::c
[17:26:45.523]             inherits <- base::inherits
[17:26:45.523]             invokeRestart <- base::invokeRestart
[17:26:45.523]             length <- base::length
[17:26:45.523]             list <- base::list
[17:26:45.523]             seq.int <- base::seq.int
[17:26:45.523]             signalCondition <- base::signalCondition
[17:26:45.523]             sys.calls <- base::sys.calls
[17:26:45.523]             `[[` <- base::`[[`
[17:26:45.523]             `+` <- base::`+`
[17:26:45.523]             `<<-` <- base::`<<-`
[17:26:45.523]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.523]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.523]                   3L)]
[17:26:45.523]             }
[17:26:45.523]             function(cond) {
[17:26:45.523]                 is_error <- inherits(cond, "error")
[17:26:45.523]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.523]                   NULL)
[17:26:45.523]                 if (is_error) {
[17:26:45.523]                   sessionInformation <- function() {
[17:26:45.523]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.523]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.523]                       search = base::search(), system = base::Sys.info())
[17:26:45.523]                   }
[17:26:45.523]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.523]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.523]                     cond$call), session = sessionInformation(), 
[17:26:45.523]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.523]                   signalCondition(cond)
[17:26:45.523]                 }
[17:26:45.523]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.523]                 "immediateCondition"))) {
[17:26:45.523]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.523]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.523]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.523]                   if (TRUE && !signal) {
[17:26:45.523]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.523]                     {
[17:26:45.523]                       inherits <- base::inherits
[17:26:45.523]                       invokeRestart <- base::invokeRestart
[17:26:45.523]                       is.null <- base::is.null
[17:26:45.523]                       muffled <- FALSE
[17:26:45.523]                       if (inherits(cond, "message")) {
[17:26:45.523]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.523]                         if (muffled) 
[17:26:45.523]                           invokeRestart("muffleMessage")
[17:26:45.523]                       }
[17:26:45.523]                       else if (inherits(cond, "warning")) {
[17:26:45.523]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.523]                         if (muffled) 
[17:26:45.523]                           invokeRestart("muffleWarning")
[17:26:45.523]                       }
[17:26:45.523]                       else if (inherits(cond, "condition")) {
[17:26:45.523]                         if (!is.null(pattern)) {
[17:26:45.523]                           computeRestarts <- base::computeRestarts
[17:26:45.523]                           grepl <- base::grepl
[17:26:45.523]                           restarts <- computeRestarts(cond)
[17:26:45.523]                           for (restart in restarts) {
[17:26:45.523]                             name <- restart$name
[17:26:45.523]                             if (is.null(name)) 
[17:26:45.523]                               next
[17:26:45.523]                             if (!grepl(pattern, name)) 
[17:26:45.523]                               next
[17:26:45.523]                             invokeRestart(restart)
[17:26:45.523]                             muffled <- TRUE
[17:26:45.523]                             break
[17:26:45.523]                           }
[17:26:45.523]                         }
[17:26:45.523]                       }
[17:26:45.523]                       invisible(muffled)
[17:26:45.523]                     }
[17:26:45.523]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.523]                   }
[17:26:45.523]                 }
[17:26:45.523]                 else {
[17:26:45.523]                   if (TRUE) {
[17:26:45.523]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.523]                     {
[17:26:45.523]                       inherits <- base::inherits
[17:26:45.523]                       invokeRestart <- base::invokeRestart
[17:26:45.523]                       is.null <- base::is.null
[17:26:45.523]                       muffled <- FALSE
[17:26:45.523]                       if (inherits(cond, "message")) {
[17:26:45.523]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.523]                         if (muffled) 
[17:26:45.523]                           invokeRestart("muffleMessage")
[17:26:45.523]                       }
[17:26:45.523]                       else if (inherits(cond, "warning")) {
[17:26:45.523]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.523]                         if (muffled) 
[17:26:45.523]                           invokeRestart("muffleWarning")
[17:26:45.523]                       }
[17:26:45.523]                       else if (inherits(cond, "condition")) {
[17:26:45.523]                         if (!is.null(pattern)) {
[17:26:45.523]                           computeRestarts <- base::computeRestarts
[17:26:45.523]                           grepl <- base::grepl
[17:26:45.523]                           restarts <- computeRestarts(cond)
[17:26:45.523]                           for (restart in restarts) {
[17:26:45.523]                             name <- restart$name
[17:26:45.523]                             if (is.null(name)) 
[17:26:45.523]                               next
[17:26:45.523]                             if (!grepl(pattern, name)) 
[17:26:45.523]                               next
[17:26:45.523]                             invokeRestart(restart)
[17:26:45.523]                             muffled <- TRUE
[17:26:45.523]                             break
[17:26:45.523]                           }
[17:26:45.523]                         }
[17:26:45.523]                       }
[17:26:45.523]                       invisible(muffled)
[17:26:45.523]                     }
[17:26:45.523]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.523]                   }
[17:26:45.523]                 }
[17:26:45.523]             }
[17:26:45.523]         }))
[17:26:45.523]     }, error = function(ex) {
[17:26:45.523]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.523]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.523]                 ...future.rng), started = ...future.startTime, 
[17:26:45.523]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.523]             version = "1.8"), class = "FutureResult")
[17:26:45.523]     }, finally = {
[17:26:45.523]         if (!identical(...future.workdir, getwd())) 
[17:26:45.523]             setwd(...future.workdir)
[17:26:45.523]         {
[17:26:45.523]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.523]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.523]             }
[17:26:45.523]             base::options(...future.oldOptions)
[17:26:45.523]             if (.Platform$OS.type == "windows") {
[17:26:45.523]                 old_names <- names(...future.oldEnvVars)
[17:26:45.523]                 envs <- base::Sys.getenv()
[17:26:45.523]                 names <- names(envs)
[17:26:45.523]                 common <- intersect(names, old_names)
[17:26:45.523]                 added <- setdiff(names, old_names)
[17:26:45.523]                 removed <- setdiff(old_names, names)
[17:26:45.523]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.523]                   envs[common]]
[17:26:45.523]                 NAMES <- toupper(changed)
[17:26:45.523]                 args <- list()
[17:26:45.523]                 for (kk in seq_along(NAMES)) {
[17:26:45.523]                   name <- changed[[kk]]
[17:26:45.523]                   NAME <- NAMES[[kk]]
[17:26:45.523]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.523]                     next
[17:26:45.523]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.523]                 }
[17:26:45.523]                 NAMES <- toupper(added)
[17:26:45.523]                 for (kk in seq_along(NAMES)) {
[17:26:45.523]                   name <- added[[kk]]
[17:26:45.523]                   NAME <- NAMES[[kk]]
[17:26:45.523]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.523]                     next
[17:26:45.523]                   args[[name]] <- ""
[17:26:45.523]                 }
[17:26:45.523]                 NAMES <- toupper(removed)
[17:26:45.523]                 for (kk in seq_along(NAMES)) {
[17:26:45.523]                   name <- removed[[kk]]
[17:26:45.523]                   NAME <- NAMES[[kk]]
[17:26:45.523]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.523]                     next
[17:26:45.523]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.523]                 }
[17:26:45.523]                 if (length(args) > 0) 
[17:26:45.523]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.523]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.523]             }
[17:26:45.523]             else {
[17:26:45.523]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.523]             }
[17:26:45.523]             {
[17:26:45.523]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.523]                   0L) {
[17:26:45.523]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.523]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.523]                   base::options(opts)
[17:26:45.523]                 }
[17:26:45.523]                 {
[17:26:45.523]                   {
[17:26:45.523]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.523]                     NULL
[17:26:45.523]                   }
[17:26:45.523]                   options(future.plan = NULL)
[17:26:45.523]                   if (is.na(NA_character_)) 
[17:26:45.523]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.523]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.523]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.523]                     .init = FALSE)
[17:26:45.523]                 }
[17:26:45.523]             }
[17:26:45.523]         }
[17:26:45.523]     })
[17:26:45.523]     if (TRUE) {
[17:26:45.523]         base::sink(type = "output", split = FALSE)
[17:26:45.523]         if (TRUE) {
[17:26:45.523]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.523]         }
[17:26:45.523]         else {
[17:26:45.523]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.523]         }
[17:26:45.523]         base::close(...future.stdout)
[17:26:45.523]         ...future.stdout <- NULL
[17:26:45.523]     }
[17:26:45.523]     ...future.result$conditions <- ...future.conditions
[17:26:45.523]     ...future.result$finished <- base::Sys.time()
[17:26:45.523]     ...future.result
[17:26:45.523] }
[17:26:45.528] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:45.548] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.548] - Validating connection of MultisessionFuture
[17:26:45.548] - received message: FutureResult
[17:26:45.549] - Received FutureResult
[17:26:45.549] - Erased future from FutureRegistry
[17:26:45.549] result() for ClusterFuture ...
[17:26:45.549] - result already collected: FutureResult
[17:26:45.549] result() for ClusterFuture ... done
[17:26:45.550] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.550] result() for ClusterFuture ...
[17:26:45.550] - result already collected: FutureResult
[17:26:45.550] result() for ClusterFuture ... done
[17:26:45.550] result() for ClusterFuture ...
[17:26:45.550] - result already collected: FutureResult
[17:26:45.551] result() for ClusterFuture ... done
[17:26:45.552] MultisessionFuture started
[17:26:45.552] - Launch lazy future ... done
[17:26:45.552] run() for 'MultisessionFuture' ... done
<environment: 0x000002230dd64680> 
<environment: 0x000002230f6639d0> 
[17:26:45.554] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.554] - Validating connection of MultisessionFuture
[17:26:45.555] - received message: FutureResult
[17:26:45.555] - Received FutureResult
[17:26:45.555] - Erased future from FutureRegistry
[17:26:45.555] result() for ClusterFuture ...
[17:26:45.555] - result already collected: FutureResult
[17:26:45.556] result() for ClusterFuture ... done
[17:26:45.556] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.565] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.566] - Validating connection of MultisessionFuture
[17:26:45.566] - received message: FutureResult
[17:26:45.566] - Received FutureResult
[17:26:45.566] - Erased future from FutureRegistry
[17:26:45.566] result() for ClusterFuture ...
[17:26:45.567] - result already collected: FutureResult
[17:26:45.567] result() for ClusterFuture ... done
[17:26:45.567] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:45.568] resolve() on environment ...
[17:26:45.569]  recursive: 0
[17:26:45.569]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:45.569] signalConditionsASAP(numeric, pos=1) ...
[17:26:45.570] - nx: 4
[17:26:45.570] - relay: TRUE
[17:26:45.570] - stdout: TRUE
[17:26:45.570] - signal: TRUE
[17:26:45.570] - resignal: FALSE
[17:26:45.570] - force: TRUE
[17:26:45.570] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.571] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.571]  - until=2
[17:26:45.571]  - relaying element #2
[17:26:45.571] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:45.571] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.571] signalConditionsASAP(NULL, pos=1) ... done
[17:26:45.572]  length: 3 (resolved future 1)
[17:26:45.572] Future #2
[17:26:45.572] result() for ClusterFuture ...
[17:26:45.572] - result already collected: FutureResult
[17:26:45.572] result() for ClusterFuture ... done
[17:26:45.572] result() for ClusterFuture ...
[17:26:45.573] - result already collected: FutureResult
[17:26:45.573] result() for ClusterFuture ... done
[17:26:45.573] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:45.573] - nx: 4
[17:26:45.573] - relay: TRUE
[17:26:45.573] - stdout: TRUE
[17:26:45.574] - signal: TRUE
[17:26:45.574] - resignal: FALSE
[17:26:45.574] - force: TRUE
[17:26:45.574] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:45.574] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.574]  - until=2
[17:26:45.574]  - relaying element #2
[17:26:45.575] result() for ClusterFuture ...
[17:26:45.575] - result already collected: FutureResult
[17:26:45.575] result() for ClusterFuture ... done
[17:26:45.575] result() for ClusterFuture ...
[17:26:45.575] - result already collected: FutureResult
[17:26:45.575] result() for ClusterFuture ... done
[17:26:45.576] result() for ClusterFuture ...
[17:26:45.576] - result already collected: FutureResult
[17:26:45.576] result() for ClusterFuture ... done
[17:26:45.576] result() for ClusterFuture ...
[17:26:45.576] - result already collected: FutureResult
[17:26:45.576] result() for ClusterFuture ... done
[17:26:45.577] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:45.577] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:45.577] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:45.577]  length: 2 (resolved future 2)
[17:26:45.577] Future #3
[17:26:45.577] result() for ClusterFuture ...
[17:26:45.578] - result already collected: FutureResult
[17:26:45.578] result() for ClusterFuture ... done
[17:26:45.578] result() for ClusterFuture ...
[17:26:45.578] - result already collected: FutureResult
[17:26:45.578] result() for ClusterFuture ... done
[17:26:45.578] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:45.579] - nx: 4
[17:26:45.579] - relay: TRUE
[17:26:45.579] - stdout: TRUE
[17:26:45.579] - signal: TRUE
[17:26:45.579] - resignal: FALSE
[17:26:45.580] - force: TRUE
[17:26:45.581] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:45.581] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:45.581]  - until=3
[17:26:45.581]  - relaying element #3
[17:26:45.582] result() for ClusterFuture ...
[17:26:45.582] - result already collected: FutureResult
[17:26:45.582] result() for ClusterFuture ... done
[17:26:45.582] result() for ClusterFuture ...
[17:26:45.582] - result already collected: FutureResult
[17:26:45.583] result() for ClusterFuture ... done
[17:26:45.583] result() for ClusterFuture ...
[17:26:45.583] - result already collected: FutureResult
[17:26:45.583] result() for ClusterFuture ... done
[17:26:45.583] result() for ClusterFuture ...
[17:26:45.584] - result already collected: FutureResult
[17:26:45.584] result() for ClusterFuture ... done
[17:26:45.584] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:45.584] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:45.584] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:45.585]  length: 1 (resolved future 3)
[17:26:45.585] Future #4
[17:26:45.585] result() for ClusterFuture ...
[17:26:45.585] - result already collected: FutureResult
[17:26:45.585] result() for ClusterFuture ... done
[17:26:45.586] result() for ClusterFuture ...
[17:26:45.586] - result already collected: FutureResult
[17:26:45.586] result() for ClusterFuture ... done
[17:26:45.586] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:45.586] - nx: 4
[17:26:45.587] - relay: TRUE
[17:26:45.587] - stdout: TRUE
[17:26:45.587] - signal: TRUE
[17:26:45.587] - resignal: FALSE
[17:26:45.587] - force: TRUE
[17:26:45.587] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:45.587] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:45.588]  - until=4
[17:26:45.588]  - relaying element #4
[17:26:45.588] result() for ClusterFuture ...
[17:26:45.588] - result already collected: FutureResult
[17:26:45.588] result() for ClusterFuture ... done
[17:26:45.589] result() for ClusterFuture ...
[17:26:45.589] - result already collected: FutureResult
[17:26:45.589] result() for ClusterFuture ... done
[17:26:45.589] result() for ClusterFuture ...
[17:26:45.589] - result already collected: FutureResult
[17:26:45.589] result() for ClusterFuture ... done
[17:26:45.590] result() for ClusterFuture ...
[17:26:45.590] - result already collected: FutureResult
[17:26:45.590] result() for ClusterFuture ... done
[17:26:45.590] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.590] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:45.590] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:45.591]  length: 0 (resolved future 4)
[17:26:45.591] Relaying remaining futures
[17:26:45.591] signalConditionsASAP(NULL, pos=0) ...
[17:26:45.591] - nx: 4
[17:26:45.591] - relay: TRUE
[17:26:45.592] - stdout: TRUE
[17:26:45.592] - signal: TRUE
[17:26:45.592] - resignal: FALSE
[17:26:45.592] - force: TRUE
[17:26:45.592] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.592] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:45.593] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.593] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:45.593] signalConditionsASAP(NULL, pos=0) ... done
[17:26:45.593] resolve() on environment ... DONE
[17:26:45.593] result() for ClusterFuture ...
[17:26:45.594] - result already collected: FutureResult
[17:26:45.594] result() for ClusterFuture ... done
[17:26:45.594] result() for ClusterFuture ...
[17:26:45.594] - result already collected: FutureResult
[17:26:45.594] result() for ClusterFuture ... done
[17:26:45.594] result() for ClusterFuture ...
[17:26:45.595] - result already collected: FutureResult
[17:26:45.595] result() for ClusterFuture ... done
[17:26:45.595] result() for ClusterFuture ...
[17:26:45.595] - result already collected: FutureResult
[17:26:45.595] result() for ClusterFuture ... done
[17:26:45.596] result() for ClusterFuture ...
[17:26:45.596] - result already collected: FutureResult
[17:26:45.596] result() for ClusterFuture ... done
[17:26:45.596] result() for ClusterFuture ...
[17:26:45.596] - result already collected: FutureResult
[17:26:45.597] result() for ClusterFuture ... done
<environment: 0x000002230f997cd8> 
Dimensions: c(1, 6)
[17:26:45.597] getGlobalsAndPackages() ...
[17:26:45.598] Searching for globals...
[17:26:45.598] 
[17:26:45.599] Searching for globals ... DONE
[17:26:45.599] - globals: [0] <none>
[17:26:45.599] getGlobalsAndPackages() ... DONE
[17:26:45.599] run() for 'Future' ...
[17:26:45.600] - state: 'created'
[17:26:45.600] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.616] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.616] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.616]   - Field: 'node'
[17:26:45.617]   - Field: 'label'
[17:26:45.617]   - Field: 'local'
[17:26:45.617]   - Field: 'owner'
[17:26:45.617]   - Field: 'envir'
[17:26:45.617]   - Field: 'workers'
[17:26:45.618]   - Field: 'packages'
[17:26:45.618]   - Field: 'gc'
[17:26:45.618]   - Field: 'conditions'
[17:26:45.618]   - Field: 'persistent'
[17:26:45.618]   - Field: 'expr'
[17:26:45.619]   - Field: 'uuid'
[17:26:45.619]   - Field: 'seed'
[17:26:45.619]   - Field: 'version'
[17:26:45.619]   - Field: 'result'
[17:26:45.619]   - Field: 'asynchronous'
[17:26:45.620]   - Field: 'calls'
[17:26:45.620]   - Field: 'globals'
[17:26:45.620]   - Field: 'stdout'
[17:26:45.620]   - Field: 'earlySignal'
[17:26:45.620]   - Field: 'lazy'
[17:26:45.621]   - Field: 'state'
[17:26:45.621] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.621] - Launch lazy future ...
[17:26:45.621] Packages needed by the future expression (n = 0): <none>
[17:26:45.622] Packages needed by future strategies (n = 0): <none>
[17:26:45.623] {
[17:26:45.623]     {
[17:26:45.623]         {
[17:26:45.623]             ...future.startTime <- base::Sys.time()
[17:26:45.623]             {
[17:26:45.623]                 {
[17:26:45.623]                   {
[17:26:45.623]                     {
[17:26:45.623]                       base::local({
[17:26:45.623]                         has_future <- base::requireNamespace("future", 
[17:26:45.623]                           quietly = TRUE)
[17:26:45.623]                         if (has_future) {
[17:26:45.623]                           ns <- base::getNamespace("future")
[17:26:45.623]                           version <- ns[[".package"]][["version"]]
[17:26:45.623]                           if (is.null(version)) 
[17:26:45.623]                             version <- utils::packageVersion("future")
[17:26:45.623]                         }
[17:26:45.623]                         else {
[17:26:45.623]                           version <- NULL
[17:26:45.623]                         }
[17:26:45.623]                         if (!has_future || version < "1.8.0") {
[17:26:45.623]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.623]                             "", base::R.version$version.string), 
[17:26:45.623]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.623]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.623]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.623]                               "release", "version")], collapse = " "), 
[17:26:45.623]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.623]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.623]                             info)
[17:26:45.623]                           info <- base::paste(info, collapse = "; ")
[17:26:45.623]                           if (!has_future) {
[17:26:45.623]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.623]                               info)
[17:26:45.623]                           }
[17:26:45.623]                           else {
[17:26:45.623]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.623]                               info, version)
[17:26:45.623]                           }
[17:26:45.623]                           base::stop(msg)
[17:26:45.623]                         }
[17:26:45.623]                       })
[17:26:45.623]                     }
[17:26:45.623]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.623]                     base::options(mc.cores = 1L)
[17:26:45.623]                   }
[17:26:45.623]                   ...future.strategy.old <- future::plan("list")
[17:26:45.623]                   options(future.plan = NULL)
[17:26:45.623]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.623]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.623]                 }
[17:26:45.623]                 ...future.workdir <- getwd()
[17:26:45.623]             }
[17:26:45.623]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.623]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.623]         }
[17:26:45.623]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.623]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.623]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.623]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.623]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.623]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.623]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.623]             base::names(...future.oldOptions))
[17:26:45.623]     }
[17:26:45.623]     if (FALSE) {
[17:26:45.623]     }
[17:26:45.623]     else {
[17:26:45.623]         if (TRUE) {
[17:26:45.623]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.623]                 open = "w")
[17:26:45.623]         }
[17:26:45.623]         else {
[17:26:45.623]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.623]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.623]         }
[17:26:45.623]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.623]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.623]             base::sink(type = "output", split = FALSE)
[17:26:45.623]             base::close(...future.stdout)
[17:26:45.623]         }, add = TRUE)
[17:26:45.623]     }
[17:26:45.623]     ...future.frame <- base::sys.nframe()
[17:26:45.623]     ...future.conditions <- base::list()
[17:26:45.623]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.623]     if (FALSE) {
[17:26:45.623]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.623]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.623]     }
[17:26:45.623]     ...future.result <- base::tryCatch({
[17:26:45.623]         base::withCallingHandlers({
[17:26:45.623]             ...future.value <- base::withVisible(base::local({
[17:26:45.623]                 ...future.makeSendCondition <- base::local({
[17:26:45.623]                   sendCondition <- NULL
[17:26:45.623]                   function(frame = 1L) {
[17:26:45.623]                     if (is.function(sendCondition)) 
[17:26:45.623]                       return(sendCondition)
[17:26:45.623]                     ns <- getNamespace("parallel")
[17:26:45.623]                     if (exists("sendData", mode = "function", 
[17:26:45.623]                       envir = ns)) {
[17:26:45.623]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.623]                         envir = ns)
[17:26:45.623]                       envir <- sys.frame(frame)
[17:26:45.623]                       master <- NULL
[17:26:45.623]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.623]                         !identical(envir, emptyenv())) {
[17:26:45.623]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.623]                           inherits = FALSE)) {
[17:26:45.623]                           master <- get("master", mode = "list", 
[17:26:45.623]                             envir = envir, inherits = FALSE)
[17:26:45.623]                           if (inherits(master, c("SOCKnode", 
[17:26:45.623]                             "SOCK0node"))) {
[17:26:45.623]                             sendCondition <<- function(cond) {
[17:26:45.623]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.623]                                 success = TRUE)
[17:26:45.623]                               parallel_sendData(master, data)
[17:26:45.623]                             }
[17:26:45.623]                             return(sendCondition)
[17:26:45.623]                           }
[17:26:45.623]                         }
[17:26:45.623]                         frame <- frame + 1L
[17:26:45.623]                         envir <- sys.frame(frame)
[17:26:45.623]                       }
[17:26:45.623]                     }
[17:26:45.623]                     sendCondition <<- function(cond) NULL
[17:26:45.623]                   }
[17:26:45.623]                 })
[17:26:45.623]                 withCallingHandlers({
[17:26:45.623]                   2
[17:26:45.623]                 }, immediateCondition = function(cond) {
[17:26:45.623]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.623]                   sendCondition(cond)
[17:26:45.623]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.623]                   {
[17:26:45.623]                     inherits <- base::inherits
[17:26:45.623]                     invokeRestart <- base::invokeRestart
[17:26:45.623]                     is.null <- base::is.null
[17:26:45.623]                     muffled <- FALSE
[17:26:45.623]                     if (inherits(cond, "message")) {
[17:26:45.623]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.623]                       if (muffled) 
[17:26:45.623]                         invokeRestart("muffleMessage")
[17:26:45.623]                     }
[17:26:45.623]                     else if (inherits(cond, "warning")) {
[17:26:45.623]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.623]                       if (muffled) 
[17:26:45.623]                         invokeRestart("muffleWarning")
[17:26:45.623]                     }
[17:26:45.623]                     else if (inherits(cond, "condition")) {
[17:26:45.623]                       if (!is.null(pattern)) {
[17:26:45.623]                         computeRestarts <- base::computeRestarts
[17:26:45.623]                         grepl <- base::grepl
[17:26:45.623]                         restarts <- computeRestarts(cond)
[17:26:45.623]                         for (restart in restarts) {
[17:26:45.623]                           name <- restart$name
[17:26:45.623]                           if (is.null(name)) 
[17:26:45.623]                             next
[17:26:45.623]                           if (!grepl(pattern, name)) 
[17:26:45.623]                             next
[17:26:45.623]                           invokeRestart(restart)
[17:26:45.623]                           muffled <- TRUE
[17:26:45.623]                           break
[17:26:45.623]                         }
[17:26:45.623]                       }
[17:26:45.623]                     }
[17:26:45.623]                     invisible(muffled)
[17:26:45.623]                   }
[17:26:45.623]                   muffleCondition(cond)
[17:26:45.623]                 })
[17:26:45.623]             }))
[17:26:45.623]             future::FutureResult(value = ...future.value$value, 
[17:26:45.623]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.623]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.623]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.623]                     ...future.globalenv.names))
[17:26:45.623]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.623]         }, condition = base::local({
[17:26:45.623]             c <- base::c
[17:26:45.623]             inherits <- base::inherits
[17:26:45.623]             invokeRestart <- base::invokeRestart
[17:26:45.623]             length <- base::length
[17:26:45.623]             list <- base::list
[17:26:45.623]             seq.int <- base::seq.int
[17:26:45.623]             signalCondition <- base::signalCondition
[17:26:45.623]             sys.calls <- base::sys.calls
[17:26:45.623]             `[[` <- base::`[[`
[17:26:45.623]             `+` <- base::`+`
[17:26:45.623]             `<<-` <- base::`<<-`
[17:26:45.623]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.623]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.623]                   3L)]
[17:26:45.623]             }
[17:26:45.623]             function(cond) {
[17:26:45.623]                 is_error <- inherits(cond, "error")
[17:26:45.623]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.623]                   NULL)
[17:26:45.623]                 if (is_error) {
[17:26:45.623]                   sessionInformation <- function() {
[17:26:45.623]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.623]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.623]                       search = base::search(), system = base::Sys.info())
[17:26:45.623]                   }
[17:26:45.623]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.623]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.623]                     cond$call), session = sessionInformation(), 
[17:26:45.623]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.623]                   signalCondition(cond)
[17:26:45.623]                 }
[17:26:45.623]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.623]                 "immediateCondition"))) {
[17:26:45.623]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.623]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.623]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.623]                   if (TRUE && !signal) {
[17:26:45.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.623]                     {
[17:26:45.623]                       inherits <- base::inherits
[17:26:45.623]                       invokeRestart <- base::invokeRestart
[17:26:45.623]                       is.null <- base::is.null
[17:26:45.623]                       muffled <- FALSE
[17:26:45.623]                       if (inherits(cond, "message")) {
[17:26:45.623]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.623]                         if (muffled) 
[17:26:45.623]                           invokeRestart("muffleMessage")
[17:26:45.623]                       }
[17:26:45.623]                       else if (inherits(cond, "warning")) {
[17:26:45.623]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.623]                         if (muffled) 
[17:26:45.623]                           invokeRestart("muffleWarning")
[17:26:45.623]                       }
[17:26:45.623]                       else if (inherits(cond, "condition")) {
[17:26:45.623]                         if (!is.null(pattern)) {
[17:26:45.623]                           computeRestarts <- base::computeRestarts
[17:26:45.623]                           grepl <- base::grepl
[17:26:45.623]                           restarts <- computeRestarts(cond)
[17:26:45.623]                           for (restart in restarts) {
[17:26:45.623]                             name <- restart$name
[17:26:45.623]                             if (is.null(name)) 
[17:26:45.623]                               next
[17:26:45.623]                             if (!grepl(pattern, name)) 
[17:26:45.623]                               next
[17:26:45.623]                             invokeRestart(restart)
[17:26:45.623]                             muffled <- TRUE
[17:26:45.623]                             break
[17:26:45.623]                           }
[17:26:45.623]                         }
[17:26:45.623]                       }
[17:26:45.623]                       invisible(muffled)
[17:26:45.623]                     }
[17:26:45.623]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.623]                   }
[17:26:45.623]                 }
[17:26:45.623]                 else {
[17:26:45.623]                   if (TRUE) {
[17:26:45.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.623]                     {
[17:26:45.623]                       inherits <- base::inherits
[17:26:45.623]                       invokeRestart <- base::invokeRestart
[17:26:45.623]                       is.null <- base::is.null
[17:26:45.623]                       muffled <- FALSE
[17:26:45.623]                       if (inherits(cond, "message")) {
[17:26:45.623]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.623]                         if (muffled) 
[17:26:45.623]                           invokeRestart("muffleMessage")
[17:26:45.623]                       }
[17:26:45.623]                       else if (inherits(cond, "warning")) {
[17:26:45.623]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.623]                         if (muffled) 
[17:26:45.623]                           invokeRestart("muffleWarning")
[17:26:45.623]                       }
[17:26:45.623]                       else if (inherits(cond, "condition")) {
[17:26:45.623]                         if (!is.null(pattern)) {
[17:26:45.623]                           computeRestarts <- base::computeRestarts
[17:26:45.623]                           grepl <- base::grepl
[17:26:45.623]                           restarts <- computeRestarts(cond)
[17:26:45.623]                           for (restart in restarts) {
[17:26:45.623]                             name <- restart$name
[17:26:45.623]                             if (is.null(name)) 
[17:26:45.623]                               next
[17:26:45.623]                             if (!grepl(pattern, name)) 
[17:26:45.623]                               next
[17:26:45.623]                             invokeRestart(restart)
[17:26:45.623]                             muffled <- TRUE
[17:26:45.623]                             break
[17:26:45.623]                           }
[17:26:45.623]                         }
[17:26:45.623]                       }
[17:26:45.623]                       invisible(muffled)
[17:26:45.623]                     }
[17:26:45.623]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.623]                   }
[17:26:45.623]                 }
[17:26:45.623]             }
[17:26:45.623]         }))
[17:26:45.623]     }, error = function(ex) {
[17:26:45.623]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.623]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.623]                 ...future.rng), started = ...future.startTime, 
[17:26:45.623]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.623]             version = "1.8"), class = "FutureResult")
[17:26:45.623]     }, finally = {
[17:26:45.623]         if (!identical(...future.workdir, getwd())) 
[17:26:45.623]             setwd(...future.workdir)
[17:26:45.623]         {
[17:26:45.623]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.623]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.623]             }
[17:26:45.623]             base::options(...future.oldOptions)
[17:26:45.623]             if (.Platform$OS.type == "windows") {
[17:26:45.623]                 old_names <- names(...future.oldEnvVars)
[17:26:45.623]                 envs <- base::Sys.getenv()
[17:26:45.623]                 names <- names(envs)
[17:26:45.623]                 common <- intersect(names, old_names)
[17:26:45.623]                 added <- setdiff(names, old_names)
[17:26:45.623]                 removed <- setdiff(old_names, names)
[17:26:45.623]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.623]                   envs[common]]
[17:26:45.623]                 NAMES <- toupper(changed)
[17:26:45.623]                 args <- list()
[17:26:45.623]                 for (kk in seq_along(NAMES)) {
[17:26:45.623]                   name <- changed[[kk]]
[17:26:45.623]                   NAME <- NAMES[[kk]]
[17:26:45.623]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.623]                     next
[17:26:45.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.623]                 }
[17:26:45.623]                 NAMES <- toupper(added)
[17:26:45.623]                 for (kk in seq_along(NAMES)) {
[17:26:45.623]                   name <- added[[kk]]
[17:26:45.623]                   NAME <- NAMES[[kk]]
[17:26:45.623]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.623]                     next
[17:26:45.623]                   args[[name]] <- ""
[17:26:45.623]                 }
[17:26:45.623]                 NAMES <- toupper(removed)
[17:26:45.623]                 for (kk in seq_along(NAMES)) {
[17:26:45.623]                   name <- removed[[kk]]
[17:26:45.623]                   NAME <- NAMES[[kk]]
[17:26:45.623]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.623]                     next
[17:26:45.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.623]                 }
[17:26:45.623]                 if (length(args) > 0) 
[17:26:45.623]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.623]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.623]             }
[17:26:45.623]             else {
[17:26:45.623]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.623]             }
[17:26:45.623]             {
[17:26:45.623]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.623]                   0L) {
[17:26:45.623]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.623]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.623]                   base::options(opts)
[17:26:45.623]                 }
[17:26:45.623]                 {
[17:26:45.623]                   {
[17:26:45.623]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.623]                     NULL
[17:26:45.623]                   }
[17:26:45.623]                   options(future.plan = NULL)
[17:26:45.623]                   if (is.na(NA_character_)) 
[17:26:45.623]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.623]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.623]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.623]                     .init = FALSE)
[17:26:45.623]                 }
[17:26:45.623]             }
[17:26:45.623]         }
[17:26:45.623]     })
[17:26:45.623]     if (TRUE) {
[17:26:45.623]         base::sink(type = "output", split = FALSE)
[17:26:45.623]         if (TRUE) {
[17:26:45.623]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.623]         }
[17:26:45.623]         else {
[17:26:45.623]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.623]         }
[17:26:45.623]         base::close(...future.stdout)
[17:26:45.623]         ...future.stdout <- NULL
[17:26:45.623]     }
[17:26:45.623]     ...future.result$conditions <- ...future.conditions
[17:26:45.623]     ...future.result$finished <- base::Sys.time()
[17:26:45.623]     ...future.result
[17:26:45.623] }
[17:26:45.630] MultisessionFuture started
[17:26:45.630] - Launch lazy future ... done
[17:26:45.630] run() for 'MultisessionFuture' ... done
[17:26:45.630] getGlobalsAndPackages() ...
[17:26:45.630] Searching for globals...
[17:26:45.631] 
[17:26:45.631] Searching for globals ... DONE
[17:26:45.631] - globals: [0] <none>
[17:26:45.632] getGlobalsAndPackages() ... DONE
[17:26:45.632] run() for 'Future' ...
[17:26:45.632] - state: 'created'
[17:26:45.632] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.648] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.648] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.648]   - Field: 'node'
[17:26:45.648]   - Field: 'label'
[17:26:45.649]   - Field: 'local'
[17:26:45.649]   - Field: 'owner'
[17:26:45.649]   - Field: 'envir'
[17:26:45.649]   - Field: 'workers'
[17:26:45.649]   - Field: 'packages'
[17:26:45.649]   - Field: 'gc'
[17:26:45.650]   - Field: 'conditions'
[17:26:45.650]   - Field: 'persistent'
[17:26:45.650]   - Field: 'expr'
[17:26:45.650]   - Field: 'uuid'
[17:26:45.650]   - Field: 'seed'
[17:26:45.651]   - Field: 'version'
[17:26:45.651]   - Field: 'result'
[17:26:45.651]   - Field: 'asynchronous'
[17:26:45.651]   - Field: 'calls'
[17:26:45.651]   - Field: 'globals'
[17:26:45.651]   - Field: 'stdout'
[17:26:45.652]   - Field: 'earlySignal'
[17:26:45.652]   - Field: 'lazy'
[17:26:45.652]   - Field: 'state'
[17:26:45.652] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.652] - Launch lazy future ...
[17:26:45.653] Packages needed by the future expression (n = 0): <none>
[17:26:45.653] Packages needed by future strategies (n = 0): <none>
[17:26:45.654] {
[17:26:45.654]     {
[17:26:45.654]         {
[17:26:45.654]             ...future.startTime <- base::Sys.time()
[17:26:45.654]             {
[17:26:45.654]                 {
[17:26:45.654]                   {
[17:26:45.654]                     {
[17:26:45.654]                       base::local({
[17:26:45.654]                         has_future <- base::requireNamespace("future", 
[17:26:45.654]                           quietly = TRUE)
[17:26:45.654]                         if (has_future) {
[17:26:45.654]                           ns <- base::getNamespace("future")
[17:26:45.654]                           version <- ns[[".package"]][["version"]]
[17:26:45.654]                           if (is.null(version)) 
[17:26:45.654]                             version <- utils::packageVersion("future")
[17:26:45.654]                         }
[17:26:45.654]                         else {
[17:26:45.654]                           version <- NULL
[17:26:45.654]                         }
[17:26:45.654]                         if (!has_future || version < "1.8.0") {
[17:26:45.654]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.654]                             "", base::R.version$version.string), 
[17:26:45.654]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.654]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.654]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.654]                               "release", "version")], collapse = " "), 
[17:26:45.654]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.654]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.654]                             info)
[17:26:45.654]                           info <- base::paste(info, collapse = "; ")
[17:26:45.654]                           if (!has_future) {
[17:26:45.654]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.654]                               info)
[17:26:45.654]                           }
[17:26:45.654]                           else {
[17:26:45.654]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.654]                               info, version)
[17:26:45.654]                           }
[17:26:45.654]                           base::stop(msg)
[17:26:45.654]                         }
[17:26:45.654]                       })
[17:26:45.654]                     }
[17:26:45.654]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.654]                     base::options(mc.cores = 1L)
[17:26:45.654]                   }
[17:26:45.654]                   ...future.strategy.old <- future::plan("list")
[17:26:45.654]                   options(future.plan = NULL)
[17:26:45.654]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.654]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.654]                 }
[17:26:45.654]                 ...future.workdir <- getwd()
[17:26:45.654]             }
[17:26:45.654]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.654]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.654]         }
[17:26:45.654]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.654]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.654]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.654]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.654]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.654]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.654]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.654]             base::names(...future.oldOptions))
[17:26:45.654]     }
[17:26:45.654]     if (FALSE) {
[17:26:45.654]     }
[17:26:45.654]     else {
[17:26:45.654]         if (TRUE) {
[17:26:45.654]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.654]                 open = "w")
[17:26:45.654]         }
[17:26:45.654]         else {
[17:26:45.654]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.654]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.654]         }
[17:26:45.654]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.654]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.654]             base::sink(type = "output", split = FALSE)
[17:26:45.654]             base::close(...future.stdout)
[17:26:45.654]         }, add = TRUE)
[17:26:45.654]     }
[17:26:45.654]     ...future.frame <- base::sys.nframe()
[17:26:45.654]     ...future.conditions <- base::list()
[17:26:45.654]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.654]     if (FALSE) {
[17:26:45.654]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.654]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.654]     }
[17:26:45.654]     ...future.result <- base::tryCatch({
[17:26:45.654]         base::withCallingHandlers({
[17:26:45.654]             ...future.value <- base::withVisible(base::local({
[17:26:45.654]                 ...future.makeSendCondition <- base::local({
[17:26:45.654]                   sendCondition <- NULL
[17:26:45.654]                   function(frame = 1L) {
[17:26:45.654]                     if (is.function(sendCondition)) 
[17:26:45.654]                       return(sendCondition)
[17:26:45.654]                     ns <- getNamespace("parallel")
[17:26:45.654]                     if (exists("sendData", mode = "function", 
[17:26:45.654]                       envir = ns)) {
[17:26:45.654]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.654]                         envir = ns)
[17:26:45.654]                       envir <- sys.frame(frame)
[17:26:45.654]                       master <- NULL
[17:26:45.654]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.654]                         !identical(envir, emptyenv())) {
[17:26:45.654]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.654]                           inherits = FALSE)) {
[17:26:45.654]                           master <- get("master", mode = "list", 
[17:26:45.654]                             envir = envir, inherits = FALSE)
[17:26:45.654]                           if (inherits(master, c("SOCKnode", 
[17:26:45.654]                             "SOCK0node"))) {
[17:26:45.654]                             sendCondition <<- function(cond) {
[17:26:45.654]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.654]                                 success = TRUE)
[17:26:45.654]                               parallel_sendData(master, data)
[17:26:45.654]                             }
[17:26:45.654]                             return(sendCondition)
[17:26:45.654]                           }
[17:26:45.654]                         }
[17:26:45.654]                         frame <- frame + 1L
[17:26:45.654]                         envir <- sys.frame(frame)
[17:26:45.654]                       }
[17:26:45.654]                     }
[17:26:45.654]                     sendCondition <<- function(cond) NULL
[17:26:45.654]                   }
[17:26:45.654]                 })
[17:26:45.654]                 withCallingHandlers({
[17:26:45.654]                   NULL
[17:26:45.654]                 }, immediateCondition = function(cond) {
[17:26:45.654]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.654]                   sendCondition(cond)
[17:26:45.654]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.654]                   {
[17:26:45.654]                     inherits <- base::inherits
[17:26:45.654]                     invokeRestart <- base::invokeRestart
[17:26:45.654]                     is.null <- base::is.null
[17:26:45.654]                     muffled <- FALSE
[17:26:45.654]                     if (inherits(cond, "message")) {
[17:26:45.654]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.654]                       if (muffled) 
[17:26:45.654]                         invokeRestart("muffleMessage")
[17:26:45.654]                     }
[17:26:45.654]                     else if (inherits(cond, "warning")) {
[17:26:45.654]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.654]                       if (muffled) 
[17:26:45.654]                         invokeRestart("muffleWarning")
[17:26:45.654]                     }
[17:26:45.654]                     else if (inherits(cond, "condition")) {
[17:26:45.654]                       if (!is.null(pattern)) {
[17:26:45.654]                         computeRestarts <- base::computeRestarts
[17:26:45.654]                         grepl <- base::grepl
[17:26:45.654]                         restarts <- computeRestarts(cond)
[17:26:45.654]                         for (restart in restarts) {
[17:26:45.654]                           name <- restart$name
[17:26:45.654]                           if (is.null(name)) 
[17:26:45.654]                             next
[17:26:45.654]                           if (!grepl(pattern, name)) 
[17:26:45.654]                             next
[17:26:45.654]                           invokeRestart(restart)
[17:26:45.654]                           muffled <- TRUE
[17:26:45.654]                           break
[17:26:45.654]                         }
[17:26:45.654]                       }
[17:26:45.654]                     }
[17:26:45.654]                     invisible(muffled)
[17:26:45.654]                   }
[17:26:45.654]                   muffleCondition(cond)
[17:26:45.654]                 })
[17:26:45.654]             }))
[17:26:45.654]             future::FutureResult(value = ...future.value$value, 
[17:26:45.654]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.654]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.654]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.654]                     ...future.globalenv.names))
[17:26:45.654]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.654]         }, condition = base::local({
[17:26:45.654]             c <- base::c
[17:26:45.654]             inherits <- base::inherits
[17:26:45.654]             invokeRestart <- base::invokeRestart
[17:26:45.654]             length <- base::length
[17:26:45.654]             list <- base::list
[17:26:45.654]             seq.int <- base::seq.int
[17:26:45.654]             signalCondition <- base::signalCondition
[17:26:45.654]             sys.calls <- base::sys.calls
[17:26:45.654]             `[[` <- base::`[[`
[17:26:45.654]             `+` <- base::`+`
[17:26:45.654]             `<<-` <- base::`<<-`
[17:26:45.654]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.654]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.654]                   3L)]
[17:26:45.654]             }
[17:26:45.654]             function(cond) {
[17:26:45.654]                 is_error <- inherits(cond, "error")
[17:26:45.654]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.654]                   NULL)
[17:26:45.654]                 if (is_error) {
[17:26:45.654]                   sessionInformation <- function() {
[17:26:45.654]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.654]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.654]                       search = base::search(), system = base::Sys.info())
[17:26:45.654]                   }
[17:26:45.654]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.654]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.654]                     cond$call), session = sessionInformation(), 
[17:26:45.654]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.654]                   signalCondition(cond)
[17:26:45.654]                 }
[17:26:45.654]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.654]                 "immediateCondition"))) {
[17:26:45.654]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.654]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.654]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.654]                   if (TRUE && !signal) {
[17:26:45.654]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.654]                     {
[17:26:45.654]                       inherits <- base::inherits
[17:26:45.654]                       invokeRestart <- base::invokeRestart
[17:26:45.654]                       is.null <- base::is.null
[17:26:45.654]                       muffled <- FALSE
[17:26:45.654]                       if (inherits(cond, "message")) {
[17:26:45.654]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.654]                         if (muffled) 
[17:26:45.654]                           invokeRestart("muffleMessage")
[17:26:45.654]                       }
[17:26:45.654]                       else if (inherits(cond, "warning")) {
[17:26:45.654]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.654]                         if (muffled) 
[17:26:45.654]                           invokeRestart("muffleWarning")
[17:26:45.654]                       }
[17:26:45.654]                       else if (inherits(cond, "condition")) {
[17:26:45.654]                         if (!is.null(pattern)) {
[17:26:45.654]                           computeRestarts <- base::computeRestarts
[17:26:45.654]                           grepl <- base::grepl
[17:26:45.654]                           restarts <- computeRestarts(cond)
[17:26:45.654]                           for (restart in restarts) {
[17:26:45.654]                             name <- restart$name
[17:26:45.654]                             if (is.null(name)) 
[17:26:45.654]                               next
[17:26:45.654]                             if (!grepl(pattern, name)) 
[17:26:45.654]                               next
[17:26:45.654]                             invokeRestart(restart)
[17:26:45.654]                             muffled <- TRUE
[17:26:45.654]                             break
[17:26:45.654]                           }
[17:26:45.654]                         }
[17:26:45.654]                       }
[17:26:45.654]                       invisible(muffled)
[17:26:45.654]                     }
[17:26:45.654]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.654]                   }
[17:26:45.654]                 }
[17:26:45.654]                 else {
[17:26:45.654]                   if (TRUE) {
[17:26:45.654]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.654]                     {
[17:26:45.654]                       inherits <- base::inherits
[17:26:45.654]                       invokeRestart <- base::invokeRestart
[17:26:45.654]                       is.null <- base::is.null
[17:26:45.654]                       muffled <- FALSE
[17:26:45.654]                       if (inherits(cond, "message")) {
[17:26:45.654]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.654]                         if (muffled) 
[17:26:45.654]                           invokeRestart("muffleMessage")
[17:26:45.654]                       }
[17:26:45.654]                       else if (inherits(cond, "warning")) {
[17:26:45.654]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.654]                         if (muffled) 
[17:26:45.654]                           invokeRestart("muffleWarning")
[17:26:45.654]                       }
[17:26:45.654]                       else if (inherits(cond, "condition")) {
[17:26:45.654]                         if (!is.null(pattern)) {
[17:26:45.654]                           computeRestarts <- base::computeRestarts
[17:26:45.654]                           grepl <- base::grepl
[17:26:45.654]                           restarts <- computeRestarts(cond)
[17:26:45.654]                           for (restart in restarts) {
[17:26:45.654]                             name <- restart$name
[17:26:45.654]                             if (is.null(name)) 
[17:26:45.654]                               next
[17:26:45.654]                             if (!grepl(pattern, name)) 
[17:26:45.654]                               next
[17:26:45.654]                             invokeRestart(restart)
[17:26:45.654]                             muffled <- TRUE
[17:26:45.654]                             break
[17:26:45.654]                           }
[17:26:45.654]                         }
[17:26:45.654]                       }
[17:26:45.654]                       invisible(muffled)
[17:26:45.654]                     }
[17:26:45.654]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.654]                   }
[17:26:45.654]                 }
[17:26:45.654]             }
[17:26:45.654]         }))
[17:26:45.654]     }, error = function(ex) {
[17:26:45.654]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.654]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.654]                 ...future.rng), started = ...future.startTime, 
[17:26:45.654]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.654]             version = "1.8"), class = "FutureResult")
[17:26:45.654]     }, finally = {
[17:26:45.654]         if (!identical(...future.workdir, getwd())) 
[17:26:45.654]             setwd(...future.workdir)
[17:26:45.654]         {
[17:26:45.654]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.654]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.654]             }
[17:26:45.654]             base::options(...future.oldOptions)
[17:26:45.654]             if (.Platform$OS.type == "windows") {
[17:26:45.654]                 old_names <- names(...future.oldEnvVars)
[17:26:45.654]                 envs <- base::Sys.getenv()
[17:26:45.654]                 names <- names(envs)
[17:26:45.654]                 common <- intersect(names, old_names)
[17:26:45.654]                 added <- setdiff(names, old_names)
[17:26:45.654]                 removed <- setdiff(old_names, names)
[17:26:45.654]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.654]                   envs[common]]
[17:26:45.654]                 NAMES <- toupper(changed)
[17:26:45.654]                 args <- list()
[17:26:45.654]                 for (kk in seq_along(NAMES)) {
[17:26:45.654]                   name <- changed[[kk]]
[17:26:45.654]                   NAME <- NAMES[[kk]]
[17:26:45.654]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.654]                     next
[17:26:45.654]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.654]                 }
[17:26:45.654]                 NAMES <- toupper(added)
[17:26:45.654]                 for (kk in seq_along(NAMES)) {
[17:26:45.654]                   name <- added[[kk]]
[17:26:45.654]                   NAME <- NAMES[[kk]]
[17:26:45.654]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.654]                     next
[17:26:45.654]                   args[[name]] <- ""
[17:26:45.654]                 }
[17:26:45.654]                 NAMES <- toupper(removed)
[17:26:45.654]                 for (kk in seq_along(NAMES)) {
[17:26:45.654]                   name <- removed[[kk]]
[17:26:45.654]                   NAME <- NAMES[[kk]]
[17:26:45.654]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.654]                     next
[17:26:45.654]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.654]                 }
[17:26:45.654]                 if (length(args) > 0) 
[17:26:45.654]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.654]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.654]             }
[17:26:45.654]             else {
[17:26:45.654]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.654]             }
[17:26:45.654]             {
[17:26:45.654]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.654]                   0L) {
[17:26:45.654]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.654]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.654]                   base::options(opts)
[17:26:45.654]                 }
[17:26:45.654]                 {
[17:26:45.654]                   {
[17:26:45.654]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.654]                     NULL
[17:26:45.654]                   }
[17:26:45.654]                   options(future.plan = NULL)
[17:26:45.654]                   if (is.na(NA_character_)) 
[17:26:45.654]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.654]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.654]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.654]                     .init = FALSE)
[17:26:45.654]                 }
[17:26:45.654]             }
[17:26:45.654]         }
[17:26:45.654]     })
[17:26:45.654]     if (TRUE) {
[17:26:45.654]         base::sink(type = "output", split = FALSE)
[17:26:45.654]         if (TRUE) {
[17:26:45.654]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.654]         }
[17:26:45.654]         else {
[17:26:45.654]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.654]         }
[17:26:45.654]         base::close(...future.stdout)
[17:26:45.654]         ...future.stdout <- NULL
[17:26:45.654]     }
[17:26:45.654]     ...future.result$conditions <- ...future.conditions
[17:26:45.654]     ...future.result$finished <- base::Sys.time()
[17:26:45.654]     ...future.result
[17:26:45.654] }
[17:26:45.660] MultisessionFuture started
[17:26:45.660] - Launch lazy future ... done
[17:26:45.660] run() for 'MultisessionFuture' ... done
[17:26:45.661] getGlobalsAndPackages() ...
[17:26:45.661] Searching for globals...
[17:26:45.662] - globals found: [1] '{'
[17:26:45.662] Searching for globals ... DONE
[17:26:45.662] Resolving globals: FALSE
[17:26:45.662] 
[17:26:45.663] 
[17:26:45.663] getGlobalsAndPackages() ... DONE
[17:26:45.663] run() for 'Future' ...
[17:26:45.663] - state: 'created'
[17:26:45.663] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.678] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.678] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.678]   - Field: 'node'
[17:26:45.678]   - Field: 'label'
[17:26:45.678]   - Field: 'local'
[17:26:45.679]   - Field: 'owner'
[17:26:45.679]   - Field: 'envir'
[17:26:45.679]   - Field: 'workers'
[17:26:45.679]   - Field: 'packages'
[17:26:45.679]   - Field: 'gc'
[17:26:45.679]   - Field: 'conditions'
[17:26:45.680]   - Field: 'persistent'
[17:26:45.680]   - Field: 'expr'
[17:26:45.680]   - Field: 'uuid'
[17:26:45.680]   - Field: 'seed'
[17:26:45.680]   - Field: 'version'
[17:26:45.681]   - Field: 'result'
[17:26:45.681]   - Field: 'asynchronous'
[17:26:45.681]   - Field: 'calls'
[17:26:45.685]   - Field: 'globals'
[17:26:45.685]   - Field: 'stdout'
[17:26:45.685]   - Field: 'earlySignal'
[17:26:45.685]   - Field: 'lazy'
[17:26:45.686]   - Field: 'state'
[17:26:45.686] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.686] - Launch lazy future ...
[17:26:45.686] Packages needed by the future expression (n = 0): <none>
[17:26:45.687] Packages needed by future strategies (n = 0): <none>
[17:26:45.687] {
[17:26:45.687]     {
[17:26:45.687]         {
[17:26:45.687]             ...future.startTime <- base::Sys.time()
[17:26:45.687]             {
[17:26:45.687]                 {
[17:26:45.687]                   {
[17:26:45.687]                     {
[17:26:45.687]                       base::local({
[17:26:45.687]                         has_future <- base::requireNamespace("future", 
[17:26:45.687]                           quietly = TRUE)
[17:26:45.687]                         if (has_future) {
[17:26:45.687]                           ns <- base::getNamespace("future")
[17:26:45.687]                           version <- ns[[".package"]][["version"]]
[17:26:45.687]                           if (is.null(version)) 
[17:26:45.687]                             version <- utils::packageVersion("future")
[17:26:45.687]                         }
[17:26:45.687]                         else {
[17:26:45.687]                           version <- NULL
[17:26:45.687]                         }
[17:26:45.687]                         if (!has_future || version < "1.8.0") {
[17:26:45.687]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.687]                             "", base::R.version$version.string), 
[17:26:45.687]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.687]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.687]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.687]                               "release", "version")], collapse = " "), 
[17:26:45.687]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.687]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.687]                             info)
[17:26:45.687]                           info <- base::paste(info, collapse = "; ")
[17:26:45.687]                           if (!has_future) {
[17:26:45.687]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.687]                               info)
[17:26:45.687]                           }
[17:26:45.687]                           else {
[17:26:45.687]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.687]                               info, version)
[17:26:45.687]                           }
[17:26:45.687]                           base::stop(msg)
[17:26:45.687]                         }
[17:26:45.687]                       })
[17:26:45.687]                     }
[17:26:45.687]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.687]                     base::options(mc.cores = 1L)
[17:26:45.687]                   }
[17:26:45.687]                   ...future.strategy.old <- future::plan("list")
[17:26:45.687]                   options(future.plan = NULL)
[17:26:45.687]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.687]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.687]                 }
[17:26:45.687]                 ...future.workdir <- getwd()
[17:26:45.687]             }
[17:26:45.687]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.687]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.687]         }
[17:26:45.687]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.687]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.687]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.687]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.687]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.687]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.687]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.687]             base::names(...future.oldOptions))
[17:26:45.687]     }
[17:26:45.687]     if (FALSE) {
[17:26:45.687]     }
[17:26:45.687]     else {
[17:26:45.687]         if (TRUE) {
[17:26:45.687]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.687]                 open = "w")
[17:26:45.687]         }
[17:26:45.687]         else {
[17:26:45.687]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.687]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.687]         }
[17:26:45.687]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.687]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.687]             base::sink(type = "output", split = FALSE)
[17:26:45.687]             base::close(...future.stdout)
[17:26:45.687]         }, add = TRUE)
[17:26:45.687]     }
[17:26:45.687]     ...future.frame <- base::sys.nframe()
[17:26:45.687]     ...future.conditions <- base::list()
[17:26:45.687]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.687]     if (FALSE) {
[17:26:45.687]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.687]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.687]     }
[17:26:45.687]     ...future.result <- base::tryCatch({
[17:26:45.687]         base::withCallingHandlers({
[17:26:45.687]             ...future.value <- base::withVisible(base::local({
[17:26:45.687]                 ...future.makeSendCondition <- base::local({
[17:26:45.687]                   sendCondition <- NULL
[17:26:45.687]                   function(frame = 1L) {
[17:26:45.687]                     if (is.function(sendCondition)) 
[17:26:45.687]                       return(sendCondition)
[17:26:45.687]                     ns <- getNamespace("parallel")
[17:26:45.687]                     if (exists("sendData", mode = "function", 
[17:26:45.687]                       envir = ns)) {
[17:26:45.687]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.687]                         envir = ns)
[17:26:45.687]                       envir <- sys.frame(frame)
[17:26:45.687]                       master <- NULL
[17:26:45.687]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.687]                         !identical(envir, emptyenv())) {
[17:26:45.687]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.687]                           inherits = FALSE)) {
[17:26:45.687]                           master <- get("master", mode = "list", 
[17:26:45.687]                             envir = envir, inherits = FALSE)
[17:26:45.687]                           if (inherits(master, c("SOCKnode", 
[17:26:45.687]                             "SOCK0node"))) {
[17:26:45.687]                             sendCondition <<- function(cond) {
[17:26:45.687]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.687]                                 success = TRUE)
[17:26:45.687]                               parallel_sendData(master, data)
[17:26:45.687]                             }
[17:26:45.687]                             return(sendCondition)
[17:26:45.687]                           }
[17:26:45.687]                         }
[17:26:45.687]                         frame <- frame + 1L
[17:26:45.687]                         envir <- sys.frame(frame)
[17:26:45.687]                       }
[17:26:45.687]                     }
[17:26:45.687]                     sendCondition <<- function(cond) NULL
[17:26:45.687]                   }
[17:26:45.687]                 })
[17:26:45.687]                 withCallingHandlers({
[17:26:45.687]                   {
[17:26:45.687]                     4
[17:26:45.687]                   }
[17:26:45.687]                 }, immediateCondition = function(cond) {
[17:26:45.687]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.687]                   sendCondition(cond)
[17:26:45.687]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.687]                   {
[17:26:45.687]                     inherits <- base::inherits
[17:26:45.687]                     invokeRestart <- base::invokeRestart
[17:26:45.687]                     is.null <- base::is.null
[17:26:45.687]                     muffled <- FALSE
[17:26:45.687]                     if (inherits(cond, "message")) {
[17:26:45.687]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.687]                       if (muffled) 
[17:26:45.687]                         invokeRestart("muffleMessage")
[17:26:45.687]                     }
[17:26:45.687]                     else if (inherits(cond, "warning")) {
[17:26:45.687]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.687]                       if (muffled) 
[17:26:45.687]                         invokeRestart("muffleWarning")
[17:26:45.687]                     }
[17:26:45.687]                     else if (inherits(cond, "condition")) {
[17:26:45.687]                       if (!is.null(pattern)) {
[17:26:45.687]                         computeRestarts <- base::computeRestarts
[17:26:45.687]                         grepl <- base::grepl
[17:26:45.687]                         restarts <- computeRestarts(cond)
[17:26:45.687]                         for (restart in restarts) {
[17:26:45.687]                           name <- restart$name
[17:26:45.687]                           if (is.null(name)) 
[17:26:45.687]                             next
[17:26:45.687]                           if (!grepl(pattern, name)) 
[17:26:45.687]                             next
[17:26:45.687]                           invokeRestart(restart)
[17:26:45.687]                           muffled <- TRUE
[17:26:45.687]                           break
[17:26:45.687]                         }
[17:26:45.687]                       }
[17:26:45.687]                     }
[17:26:45.687]                     invisible(muffled)
[17:26:45.687]                   }
[17:26:45.687]                   muffleCondition(cond)
[17:26:45.687]                 })
[17:26:45.687]             }))
[17:26:45.687]             future::FutureResult(value = ...future.value$value, 
[17:26:45.687]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.687]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.687]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.687]                     ...future.globalenv.names))
[17:26:45.687]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.687]         }, condition = base::local({
[17:26:45.687]             c <- base::c
[17:26:45.687]             inherits <- base::inherits
[17:26:45.687]             invokeRestart <- base::invokeRestart
[17:26:45.687]             length <- base::length
[17:26:45.687]             list <- base::list
[17:26:45.687]             seq.int <- base::seq.int
[17:26:45.687]             signalCondition <- base::signalCondition
[17:26:45.687]             sys.calls <- base::sys.calls
[17:26:45.687]             `[[` <- base::`[[`
[17:26:45.687]             `+` <- base::`+`
[17:26:45.687]             `<<-` <- base::`<<-`
[17:26:45.687]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.687]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.687]                   3L)]
[17:26:45.687]             }
[17:26:45.687]             function(cond) {
[17:26:45.687]                 is_error <- inherits(cond, "error")
[17:26:45.687]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.687]                   NULL)
[17:26:45.687]                 if (is_error) {
[17:26:45.687]                   sessionInformation <- function() {
[17:26:45.687]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.687]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.687]                       search = base::search(), system = base::Sys.info())
[17:26:45.687]                   }
[17:26:45.687]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.687]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.687]                     cond$call), session = sessionInformation(), 
[17:26:45.687]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.687]                   signalCondition(cond)
[17:26:45.687]                 }
[17:26:45.687]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.687]                 "immediateCondition"))) {
[17:26:45.687]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.687]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.687]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.687]                   if (TRUE && !signal) {
[17:26:45.687]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.687]                     {
[17:26:45.687]                       inherits <- base::inherits
[17:26:45.687]                       invokeRestart <- base::invokeRestart
[17:26:45.687]                       is.null <- base::is.null
[17:26:45.687]                       muffled <- FALSE
[17:26:45.687]                       if (inherits(cond, "message")) {
[17:26:45.687]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.687]                         if (muffled) 
[17:26:45.687]                           invokeRestart("muffleMessage")
[17:26:45.687]                       }
[17:26:45.687]                       else if (inherits(cond, "warning")) {
[17:26:45.687]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.687]                         if (muffled) 
[17:26:45.687]                           invokeRestart("muffleWarning")
[17:26:45.687]                       }
[17:26:45.687]                       else if (inherits(cond, "condition")) {
[17:26:45.687]                         if (!is.null(pattern)) {
[17:26:45.687]                           computeRestarts <- base::computeRestarts
[17:26:45.687]                           grepl <- base::grepl
[17:26:45.687]                           restarts <- computeRestarts(cond)
[17:26:45.687]                           for (restart in restarts) {
[17:26:45.687]                             name <- restart$name
[17:26:45.687]                             if (is.null(name)) 
[17:26:45.687]                               next
[17:26:45.687]                             if (!grepl(pattern, name)) 
[17:26:45.687]                               next
[17:26:45.687]                             invokeRestart(restart)
[17:26:45.687]                             muffled <- TRUE
[17:26:45.687]                             break
[17:26:45.687]                           }
[17:26:45.687]                         }
[17:26:45.687]                       }
[17:26:45.687]                       invisible(muffled)
[17:26:45.687]                     }
[17:26:45.687]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.687]                   }
[17:26:45.687]                 }
[17:26:45.687]                 else {
[17:26:45.687]                   if (TRUE) {
[17:26:45.687]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.687]                     {
[17:26:45.687]                       inherits <- base::inherits
[17:26:45.687]                       invokeRestart <- base::invokeRestart
[17:26:45.687]                       is.null <- base::is.null
[17:26:45.687]                       muffled <- FALSE
[17:26:45.687]                       if (inherits(cond, "message")) {
[17:26:45.687]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.687]                         if (muffled) 
[17:26:45.687]                           invokeRestart("muffleMessage")
[17:26:45.687]                       }
[17:26:45.687]                       else if (inherits(cond, "warning")) {
[17:26:45.687]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.687]                         if (muffled) 
[17:26:45.687]                           invokeRestart("muffleWarning")
[17:26:45.687]                       }
[17:26:45.687]                       else if (inherits(cond, "condition")) {
[17:26:45.687]                         if (!is.null(pattern)) {
[17:26:45.687]                           computeRestarts <- base::computeRestarts
[17:26:45.687]                           grepl <- base::grepl
[17:26:45.687]                           restarts <- computeRestarts(cond)
[17:26:45.687]                           for (restart in restarts) {
[17:26:45.687]                             name <- restart$name
[17:26:45.687]                             if (is.null(name)) 
[17:26:45.687]                               next
[17:26:45.687]                             if (!grepl(pattern, name)) 
[17:26:45.687]                               next
[17:26:45.687]                             invokeRestart(restart)
[17:26:45.687]                             muffled <- TRUE
[17:26:45.687]                             break
[17:26:45.687]                           }
[17:26:45.687]                         }
[17:26:45.687]                       }
[17:26:45.687]                       invisible(muffled)
[17:26:45.687]                     }
[17:26:45.687]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.687]                   }
[17:26:45.687]                 }
[17:26:45.687]             }
[17:26:45.687]         }))
[17:26:45.687]     }, error = function(ex) {
[17:26:45.687]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.687]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.687]                 ...future.rng), started = ...future.startTime, 
[17:26:45.687]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.687]             version = "1.8"), class = "FutureResult")
[17:26:45.687]     }, finally = {
[17:26:45.687]         if (!identical(...future.workdir, getwd())) 
[17:26:45.687]             setwd(...future.workdir)
[17:26:45.687]         {
[17:26:45.687]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.687]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.687]             }
[17:26:45.687]             base::options(...future.oldOptions)
[17:26:45.687]             if (.Platform$OS.type == "windows") {
[17:26:45.687]                 old_names <- names(...future.oldEnvVars)
[17:26:45.687]                 envs <- base::Sys.getenv()
[17:26:45.687]                 names <- names(envs)
[17:26:45.687]                 common <- intersect(names, old_names)
[17:26:45.687]                 added <- setdiff(names, old_names)
[17:26:45.687]                 removed <- setdiff(old_names, names)
[17:26:45.687]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.687]                   envs[common]]
[17:26:45.687]                 NAMES <- toupper(changed)
[17:26:45.687]                 args <- list()
[17:26:45.687]                 for (kk in seq_along(NAMES)) {
[17:26:45.687]                   name <- changed[[kk]]
[17:26:45.687]                   NAME <- NAMES[[kk]]
[17:26:45.687]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.687]                     next
[17:26:45.687]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.687]                 }
[17:26:45.687]                 NAMES <- toupper(added)
[17:26:45.687]                 for (kk in seq_along(NAMES)) {
[17:26:45.687]                   name <- added[[kk]]
[17:26:45.687]                   NAME <- NAMES[[kk]]
[17:26:45.687]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.687]                     next
[17:26:45.687]                   args[[name]] <- ""
[17:26:45.687]                 }
[17:26:45.687]                 NAMES <- toupper(removed)
[17:26:45.687]                 for (kk in seq_along(NAMES)) {
[17:26:45.687]                   name <- removed[[kk]]
[17:26:45.687]                   NAME <- NAMES[[kk]]
[17:26:45.687]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.687]                     next
[17:26:45.687]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.687]                 }
[17:26:45.687]                 if (length(args) > 0) 
[17:26:45.687]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.687]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.687]             }
[17:26:45.687]             else {
[17:26:45.687]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.687]             }
[17:26:45.687]             {
[17:26:45.687]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.687]                   0L) {
[17:26:45.687]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.687]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.687]                   base::options(opts)
[17:26:45.687]                 }
[17:26:45.687]                 {
[17:26:45.687]                   {
[17:26:45.687]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.687]                     NULL
[17:26:45.687]                   }
[17:26:45.687]                   options(future.plan = NULL)
[17:26:45.687]                   if (is.na(NA_character_)) 
[17:26:45.687]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.687]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.687]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.687]                     .init = FALSE)
[17:26:45.687]                 }
[17:26:45.687]             }
[17:26:45.687]         }
[17:26:45.687]     })
[17:26:45.687]     if (TRUE) {
[17:26:45.687]         base::sink(type = "output", split = FALSE)
[17:26:45.687]         if (TRUE) {
[17:26:45.687]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.687]         }
[17:26:45.687]         else {
[17:26:45.687]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.687]         }
[17:26:45.687]         base::close(...future.stdout)
[17:26:45.687]         ...future.stdout <- NULL
[17:26:45.687]     }
[17:26:45.687]     ...future.result$conditions <- ...future.conditions
[17:26:45.687]     ...future.result$finished <- base::Sys.time()
[17:26:45.687]     ...future.result
[17:26:45.687] }
[17:26:45.692] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:45.715] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.715] - Validating connection of MultisessionFuture
[17:26:45.715] - received message: FutureResult
[17:26:45.715] - Received FutureResult
[17:26:45.716] - Erased future from FutureRegistry
[17:26:45.716] result() for ClusterFuture ...
[17:26:45.716] - result already collected: FutureResult
[17:26:45.716] result() for ClusterFuture ... done
[17:26:45.716] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.716] result() for ClusterFuture ...
[17:26:45.717] - result already collected: FutureResult
[17:26:45.717] result() for ClusterFuture ... done
[17:26:45.717] result() for ClusterFuture ...
[17:26:45.717] - result already collected: FutureResult
[17:26:45.717] result() for ClusterFuture ... done
[17:26:45.719] MultisessionFuture started
[17:26:45.719] - Launch lazy future ... done
[17:26:45.719] run() for 'MultisessionFuture' ... done
<environment: 0x000002231039fd10> 
<environment: 0x000002230b961730> 
[17:26:45.721] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.721] - Validating connection of MultisessionFuture
[17:26:45.722] - received message: FutureResult
[17:26:45.722] - Received FutureResult
[17:26:45.722] - Erased future from FutureRegistry
[17:26:45.722] result() for ClusterFuture ...
[17:26:45.722] - result already collected: FutureResult
[17:26:45.723] result() for ClusterFuture ... done
[17:26:45.723] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.733] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.733] - Validating connection of MultisessionFuture
[17:26:45.734] - received message: FutureResult
[17:26:45.734] - Received FutureResult
[17:26:45.734] - Erased future from FutureRegistry
[17:26:45.734] result() for ClusterFuture ...
[17:26:45.734] - result already collected: FutureResult
[17:26:45.735] result() for ClusterFuture ... done
[17:26:45.735] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:45.737] resolve() on environment ...
[17:26:45.737]  recursive: 0
[17:26:45.738]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:45.738] signalConditionsASAP(numeric, pos=1) ...
[17:26:45.738] - nx: 4
[17:26:45.738] - relay: TRUE
[17:26:45.738] - stdout: TRUE
[17:26:45.739] - signal: TRUE
[17:26:45.739] - resignal: FALSE
[17:26:45.739] - force: TRUE
[17:26:45.739] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.739] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.739]  - until=2
[17:26:45.740]  - relaying element #2
[17:26:45.740] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:45.740] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.740] signalConditionsASAP(NULL, pos=1) ... done
[17:26:45.740]  length: 3 (resolved future 1)
[17:26:45.741] Future #2
[17:26:45.741] result() for ClusterFuture ...
[17:26:45.741] - result already collected: FutureResult
[17:26:45.741] result() for ClusterFuture ... done
[17:26:45.741] result() for ClusterFuture ...
[17:26:45.742] - result already collected: FutureResult
[17:26:45.742] result() for ClusterFuture ... done
[17:26:45.742] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:45.742] - nx: 4
[17:26:45.742] - relay: TRUE
[17:26:45.742] - stdout: TRUE
[17:26:45.743] - signal: TRUE
[17:26:45.743] - resignal: FALSE
[17:26:45.743] - force: TRUE
[17:26:45.743] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:45.743] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.744]  - until=2
[17:26:45.744]  - relaying element #2
[17:26:45.744] result() for ClusterFuture ...
[17:26:45.744] - result already collected: FutureResult
[17:26:45.744] result() for ClusterFuture ... done
[17:26:45.744] result() for ClusterFuture ...
[17:26:45.745] - result already collected: FutureResult
[17:26:45.745] result() for ClusterFuture ... done
[17:26:45.745] result() for ClusterFuture ...
[17:26:45.745] - result already collected: FutureResult
[17:26:45.745] result() for ClusterFuture ... done
[17:26:45.746] result() for ClusterFuture ...
[17:26:45.746] - result already collected: FutureResult
[17:26:45.746] result() for ClusterFuture ... done
[17:26:45.746] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:45.746] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:45.746] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:45.747]  length: 2 (resolved future 2)
[17:26:45.747] Future #3
[17:26:45.747] result() for ClusterFuture ...
[17:26:45.747] - result already collected: FutureResult
[17:26:45.747] result() for ClusterFuture ... done
[17:26:45.747] result() for ClusterFuture ...
[17:26:45.748] - result already collected: FutureResult
[17:26:45.748] result() for ClusterFuture ... done
[17:26:45.748] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:45.748] - nx: 4
[17:26:45.748] - relay: TRUE
[17:26:45.748] - stdout: TRUE
[17:26:45.748] - signal: TRUE
[17:26:45.749] - resignal: FALSE
[17:26:45.749] - force: TRUE
[17:26:45.749] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:45.749] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:45.749]  - until=3
[17:26:45.749]  - relaying element #3
[17:26:45.750] result() for ClusterFuture ...
[17:26:45.750] - result already collected: FutureResult
[17:26:45.750] result() for ClusterFuture ... done
[17:26:45.750] result() for ClusterFuture ...
[17:26:45.750] - result already collected: FutureResult
[17:26:45.750] result() for ClusterFuture ... done
[17:26:45.751] result() for ClusterFuture ...
[17:26:45.751] - result already collected: FutureResult
[17:26:45.751] result() for ClusterFuture ... done
[17:26:45.751] result() for ClusterFuture ...
[17:26:45.751] - result already collected: FutureResult
[17:26:45.751] result() for ClusterFuture ... done
[17:26:45.752] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:45.752] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:45.752] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:45.752]  length: 1 (resolved future 3)
[17:26:45.752] Future #4
[17:26:45.752] result() for ClusterFuture ...
[17:26:45.753] - result already collected: FutureResult
[17:26:45.753] result() for ClusterFuture ... done
[17:26:45.753] result() for ClusterFuture ...
[17:26:45.753] - result already collected: FutureResult
[17:26:45.753] result() for ClusterFuture ... done
[17:26:45.753] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:45.754] - nx: 4
[17:26:45.754] - relay: TRUE
[17:26:45.754] - stdout: TRUE
[17:26:45.754] - signal: TRUE
[17:26:45.754] - resignal: FALSE
[17:26:45.754] - force: TRUE
[17:26:45.755] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:45.755] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:45.755]  - until=4
[17:26:45.755]  - relaying element #4
[17:26:45.755] result() for ClusterFuture ...
[17:26:45.755] - result already collected: FutureResult
[17:26:45.756] result() for ClusterFuture ... done
[17:26:45.756] result() for ClusterFuture ...
[17:26:45.756] - result already collected: FutureResult
[17:26:45.756] result() for ClusterFuture ... done
[17:26:45.756] result() for ClusterFuture ...
[17:26:45.756] - result already collected: FutureResult
[17:26:45.757] result() for ClusterFuture ... done
[17:26:45.757] result() for ClusterFuture ...
[17:26:45.757] - result already collected: FutureResult
[17:26:45.757] result() for ClusterFuture ... done
[17:26:45.757] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.757] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:45.758] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:45.758]  length: 0 (resolved future 4)
[17:26:45.758] Relaying remaining futures
[17:26:45.758] signalConditionsASAP(NULL, pos=0) ...
[17:26:45.758] - nx: 4
[17:26:45.758] - relay: TRUE
[17:26:45.759] - stdout: TRUE
[17:26:45.759] - signal: TRUE
[17:26:45.759] - resignal: FALSE
[17:26:45.759] - force: TRUE
[17:26:45.759] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.759] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:45.760] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.760] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:45.760] signalConditionsASAP(NULL, pos=0) ... done
[17:26:45.760] resolve() on environment ... DONE
[17:26:45.760] result() for ClusterFuture ...
[17:26:45.760] - result already collected: FutureResult
[17:26:45.761] result() for ClusterFuture ... done
[17:26:45.761] result() for ClusterFuture ...
[17:26:45.761] - result already collected: FutureResult
[17:26:45.761] result() for ClusterFuture ... done
[17:26:45.761] result() for ClusterFuture ...
[17:26:45.761] - result already collected: FutureResult
[17:26:45.762] result() for ClusterFuture ... done
[17:26:45.762] result() for ClusterFuture ...
[17:26:45.762] - result already collected: FutureResult
[17:26:45.762] result() for ClusterFuture ... done
[17:26:45.762] result() for ClusterFuture ...
[17:26:45.762] - result already collected: FutureResult
[17:26:45.762] result() for ClusterFuture ... done
[17:26:45.763] result() for ClusterFuture ...
[17:26:45.763] - result already collected: FutureResult
[17:26:45.763] result() for ClusterFuture ... done
<environment: 0x000002230b6b9a38> 
Dimensions: c(2, 3)
[17:26:45.764] getGlobalsAndPackages() ...
[17:26:45.764] Searching for globals...
[17:26:45.764] 
[17:26:45.764] Searching for globals ... DONE
[17:26:45.765] - globals: [0] <none>
[17:26:45.765] getGlobalsAndPackages() ... DONE
[17:26:45.765] run() for 'Future' ...
[17:26:45.765] - state: 'created'
[17:26:45.765] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.780] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.780] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.780]   - Field: 'node'
[17:26:45.780]   - Field: 'label'
[17:26:45.780]   - Field: 'local'
[17:26:45.781]   - Field: 'owner'
[17:26:45.781]   - Field: 'envir'
[17:26:45.781]   - Field: 'workers'
[17:26:45.781]   - Field: 'packages'
[17:26:45.782]   - Field: 'gc'
[17:26:45.782]   - Field: 'conditions'
[17:26:45.782]   - Field: 'persistent'
[17:26:45.782]   - Field: 'expr'
[17:26:45.782]   - Field: 'uuid'
[17:26:45.783]   - Field: 'seed'
[17:26:45.783]   - Field: 'version'
[17:26:45.783]   - Field: 'result'
[17:26:45.783]   - Field: 'asynchronous'
[17:26:45.783]   - Field: 'calls'
[17:26:45.784]   - Field: 'globals'
[17:26:45.784]   - Field: 'stdout'
[17:26:45.784]   - Field: 'earlySignal'
[17:26:45.784]   - Field: 'lazy'
[17:26:45.785]   - Field: 'state'
[17:26:45.785] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.785] - Launch lazy future ...
[17:26:45.785] Packages needed by the future expression (n = 0): <none>
[17:26:45.786] Packages needed by future strategies (n = 0): <none>
[17:26:45.787] {
[17:26:45.787]     {
[17:26:45.787]         {
[17:26:45.787]             ...future.startTime <- base::Sys.time()
[17:26:45.787]             {
[17:26:45.787]                 {
[17:26:45.787]                   {
[17:26:45.787]                     {
[17:26:45.787]                       base::local({
[17:26:45.787]                         has_future <- base::requireNamespace("future", 
[17:26:45.787]                           quietly = TRUE)
[17:26:45.787]                         if (has_future) {
[17:26:45.787]                           ns <- base::getNamespace("future")
[17:26:45.787]                           version <- ns[[".package"]][["version"]]
[17:26:45.787]                           if (is.null(version)) 
[17:26:45.787]                             version <- utils::packageVersion("future")
[17:26:45.787]                         }
[17:26:45.787]                         else {
[17:26:45.787]                           version <- NULL
[17:26:45.787]                         }
[17:26:45.787]                         if (!has_future || version < "1.8.0") {
[17:26:45.787]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.787]                             "", base::R.version$version.string), 
[17:26:45.787]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.787]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.787]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.787]                               "release", "version")], collapse = " "), 
[17:26:45.787]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.787]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.787]                             info)
[17:26:45.787]                           info <- base::paste(info, collapse = "; ")
[17:26:45.787]                           if (!has_future) {
[17:26:45.787]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.787]                               info)
[17:26:45.787]                           }
[17:26:45.787]                           else {
[17:26:45.787]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.787]                               info, version)
[17:26:45.787]                           }
[17:26:45.787]                           base::stop(msg)
[17:26:45.787]                         }
[17:26:45.787]                       })
[17:26:45.787]                     }
[17:26:45.787]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.787]                     base::options(mc.cores = 1L)
[17:26:45.787]                   }
[17:26:45.787]                   ...future.strategy.old <- future::plan("list")
[17:26:45.787]                   options(future.plan = NULL)
[17:26:45.787]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.787]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.787]                 }
[17:26:45.787]                 ...future.workdir <- getwd()
[17:26:45.787]             }
[17:26:45.787]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.787]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.787]         }
[17:26:45.787]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.787]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.787]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.787]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.787]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.787]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.787]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.787]             base::names(...future.oldOptions))
[17:26:45.787]     }
[17:26:45.787]     if (FALSE) {
[17:26:45.787]     }
[17:26:45.787]     else {
[17:26:45.787]         if (TRUE) {
[17:26:45.787]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.787]                 open = "w")
[17:26:45.787]         }
[17:26:45.787]         else {
[17:26:45.787]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.787]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.787]         }
[17:26:45.787]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.787]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.787]             base::sink(type = "output", split = FALSE)
[17:26:45.787]             base::close(...future.stdout)
[17:26:45.787]         }, add = TRUE)
[17:26:45.787]     }
[17:26:45.787]     ...future.frame <- base::sys.nframe()
[17:26:45.787]     ...future.conditions <- base::list()
[17:26:45.787]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.787]     if (FALSE) {
[17:26:45.787]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.787]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.787]     }
[17:26:45.787]     ...future.result <- base::tryCatch({
[17:26:45.787]         base::withCallingHandlers({
[17:26:45.787]             ...future.value <- base::withVisible(base::local({
[17:26:45.787]                 ...future.makeSendCondition <- base::local({
[17:26:45.787]                   sendCondition <- NULL
[17:26:45.787]                   function(frame = 1L) {
[17:26:45.787]                     if (is.function(sendCondition)) 
[17:26:45.787]                       return(sendCondition)
[17:26:45.787]                     ns <- getNamespace("parallel")
[17:26:45.787]                     if (exists("sendData", mode = "function", 
[17:26:45.787]                       envir = ns)) {
[17:26:45.787]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.787]                         envir = ns)
[17:26:45.787]                       envir <- sys.frame(frame)
[17:26:45.787]                       master <- NULL
[17:26:45.787]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.787]                         !identical(envir, emptyenv())) {
[17:26:45.787]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.787]                           inherits = FALSE)) {
[17:26:45.787]                           master <- get("master", mode = "list", 
[17:26:45.787]                             envir = envir, inherits = FALSE)
[17:26:45.787]                           if (inherits(master, c("SOCKnode", 
[17:26:45.787]                             "SOCK0node"))) {
[17:26:45.787]                             sendCondition <<- function(cond) {
[17:26:45.787]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.787]                                 success = TRUE)
[17:26:45.787]                               parallel_sendData(master, data)
[17:26:45.787]                             }
[17:26:45.787]                             return(sendCondition)
[17:26:45.787]                           }
[17:26:45.787]                         }
[17:26:45.787]                         frame <- frame + 1L
[17:26:45.787]                         envir <- sys.frame(frame)
[17:26:45.787]                       }
[17:26:45.787]                     }
[17:26:45.787]                     sendCondition <<- function(cond) NULL
[17:26:45.787]                   }
[17:26:45.787]                 })
[17:26:45.787]                 withCallingHandlers({
[17:26:45.787]                   2
[17:26:45.787]                 }, immediateCondition = function(cond) {
[17:26:45.787]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.787]                   sendCondition(cond)
[17:26:45.787]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.787]                   {
[17:26:45.787]                     inherits <- base::inherits
[17:26:45.787]                     invokeRestart <- base::invokeRestart
[17:26:45.787]                     is.null <- base::is.null
[17:26:45.787]                     muffled <- FALSE
[17:26:45.787]                     if (inherits(cond, "message")) {
[17:26:45.787]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.787]                       if (muffled) 
[17:26:45.787]                         invokeRestart("muffleMessage")
[17:26:45.787]                     }
[17:26:45.787]                     else if (inherits(cond, "warning")) {
[17:26:45.787]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.787]                       if (muffled) 
[17:26:45.787]                         invokeRestart("muffleWarning")
[17:26:45.787]                     }
[17:26:45.787]                     else if (inherits(cond, "condition")) {
[17:26:45.787]                       if (!is.null(pattern)) {
[17:26:45.787]                         computeRestarts <- base::computeRestarts
[17:26:45.787]                         grepl <- base::grepl
[17:26:45.787]                         restarts <- computeRestarts(cond)
[17:26:45.787]                         for (restart in restarts) {
[17:26:45.787]                           name <- restart$name
[17:26:45.787]                           if (is.null(name)) 
[17:26:45.787]                             next
[17:26:45.787]                           if (!grepl(pattern, name)) 
[17:26:45.787]                             next
[17:26:45.787]                           invokeRestart(restart)
[17:26:45.787]                           muffled <- TRUE
[17:26:45.787]                           break
[17:26:45.787]                         }
[17:26:45.787]                       }
[17:26:45.787]                     }
[17:26:45.787]                     invisible(muffled)
[17:26:45.787]                   }
[17:26:45.787]                   muffleCondition(cond)
[17:26:45.787]                 })
[17:26:45.787]             }))
[17:26:45.787]             future::FutureResult(value = ...future.value$value, 
[17:26:45.787]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.787]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.787]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.787]                     ...future.globalenv.names))
[17:26:45.787]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.787]         }, condition = base::local({
[17:26:45.787]             c <- base::c
[17:26:45.787]             inherits <- base::inherits
[17:26:45.787]             invokeRestart <- base::invokeRestart
[17:26:45.787]             length <- base::length
[17:26:45.787]             list <- base::list
[17:26:45.787]             seq.int <- base::seq.int
[17:26:45.787]             signalCondition <- base::signalCondition
[17:26:45.787]             sys.calls <- base::sys.calls
[17:26:45.787]             `[[` <- base::`[[`
[17:26:45.787]             `+` <- base::`+`
[17:26:45.787]             `<<-` <- base::`<<-`
[17:26:45.787]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.787]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.787]                   3L)]
[17:26:45.787]             }
[17:26:45.787]             function(cond) {
[17:26:45.787]                 is_error <- inherits(cond, "error")
[17:26:45.787]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.787]                   NULL)
[17:26:45.787]                 if (is_error) {
[17:26:45.787]                   sessionInformation <- function() {
[17:26:45.787]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.787]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.787]                       search = base::search(), system = base::Sys.info())
[17:26:45.787]                   }
[17:26:45.787]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.787]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.787]                     cond$call), session = sessionInformation(), 
[17:26:45.787]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.787]                   signalCondition(cond)
[17:26:45.787]                 }
[17:26:45.787]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.787]                 "immediateCondition"))) {
[17:26:45.787]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.787]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.787]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.787]                   if (TRUE && !signal) {
[17:26:45.787]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.787]                     {
[17:26:45.787]                       inherits <- base::inherits
[17:26:45.787]                       invokeRestart <- base::invokeRestart
[17:26:45.787]                       is.null <- base::is.null
[17:26:45.787]                       muffled <- FALSE
[17:26:45.787]                       if (inherits(cond, "message")) {
[17:26:45.787]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.787]                         if (muffled) 
[17:26:45.787]                           invokeRestart("muffleMessage")
[17:26:45.787]                       }
[17:26:45.787]                       else if (inherits(cond, "warning")) {
[17:26:45.787]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.787]                         if (muffled) 
[17:26:45.787]                           invokeRestart("muffleWarning")
[17:26:45.787]                       }
[17:26:45.787]                       else if (inherits(cond, "condition")) {
[17:26:45.787]                         if (!is.null(pattern)) {
[17:26:45.787]                           computeRestarts <- base::computeRestarts
[17:26:45.787]                           grepl <- base::grepl
[17:26:45.787]                           restarts <- computeRestarts(cond)
[17:26:45.787]                           for (restart in restarts) {
[17:26:45.787]                             name <- restart$name
[17:26:45.787]                             if (is.null(name)) 
[17:26:45.787]                               next
[17:26:45.787]                             if (!grepl(pattern, name)) 
[17:26:45.787]                               next
[17:26:45.787]                             invokeRestart(restart)
[17:26:45.787]                             muffled <- TRUE
[17:26:45.787]                             break
[17:26:45.787]                           }
[17:26:45.787]                         }
[17:26:45.787]                       }
[17:26:45.787]                       invisible(muffled)
[17:26:45.787]                     }
[17:26:45.787]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.787]                   }
[17:26:45.787]                 }
[17:26:45.787]                 else {
[17:26:45.787]                   if (TRUE) {
[17:26:45.787]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.787]                     {
[17:26:45.787]                       inherits <- base::inherits
[17:26:45.787]                       invokeRestart <- base::invokeRestart
[17:26:45.787]                       is.null <- base::is.null
[17:26:45.787]                       muffled <- FALSE
[17:26:45.787]                       if (inherits(cond, "message")) {
[17:26:45.787]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.787]                         if (muffled) 
[17:26:45.787]                           invokeRestart("muffleMessage")
[17:26:45.787]                       }
[17:26:45.787]                       else if (inherits(cond, "warning")) {
[17:26:45.787]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.787]                         if (muffled) 
[17:26:45.787]                           invokeRestart("muffleWarning")
[17:26:45.787]                       }
[17:26:45.787]                       else if (inherits(cond, "condition")) {
[17:26:45.787]                         if (!is.null(pattern)) {
[17:26:45.787]                           computeRestarts <- base::computeRestarts
[17:26:45.787]                           grepl <- base::grepl
[17:26:45.787]                           restarts <- computeRestarts(cond)
[17:26:45.787]                           for (restart in restarts) {
[17:26:45.787]                             name <- restart$name
[17:26:45.787]                             if (is.null(name)) 
[17:26:45.787]                               next
[17:26:45.787]                             if (!grepl(pattern, name)) 
[17:26:45.787]                               next
[17:26:45.787]                             invokeRestart(restart)
[17:26:45.787]                             muffled <- TRUE
[17:26:45.787]                             break
[17:26:45.787]                           }
[17:26:45.787]                         }
[17:26:45.787]                       }
[17:26:45.787]                       invisible(muffled)
[17:26:45.787]                     }
[17:26:45.787]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.787]                   }
[17:26:45.787]                 }
[17:26:45.787]             }
[17:26:45.787]         }))
[17:26:45.787]     }, error = function(ex) {
[17:26:45.787]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.787]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.787]                 ...future.rng), started = ...future.startTime, 
[17:26:45.787]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.787]             version = "1.8"), class = "FutureResult")
[17:26:45.787]     }, finally = {
[17:26:45.787]         if (!identical(...future.workdir, getwd())) 
[17:26:45.787]             setwd(...future.workdir)
[17:26:45.787]         {
[17:26:45.787]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.787]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.787]             }
[17:26:45.787]             base::options(...future.oldOptions)
[17:26:45.787]             if (.Platform$OS.type == "windows") {
[17:26:45.787]                 old_names <- names(...future.oldEnvVars)
[17:26:45.787]                 envs <- base::Sys.getenv()
[17:26:45.787]                 names <- names(envs)
[17:26:45.787]                 common <- intersect(names, old_names)
[17:26:45.787]                 added <- setdiff(names, old_names)
[17:26:45.787]                 removed <- setdiff(old_names, names)
[17:26:45.787]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.787]                   envs[common]]
[17:26:45.787]                 NAMES <- toupper(changed)
[17:26:45.787]                 args <- list()
[17:26:45.787]                 for (kk in seq_along(NAMES)) {
[17:26:45.787]                   name <- changed[[kk]]
[17:26:45.787]                   NAME <- NAMES[[kk]]
[17:26:45.787]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.787]                     next
[17:26:45.787]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.787]                 }
[17:26:45.787]                 NAMES <- toupper(added)
[17:26:45.787]                 for (kk in seq_along(NAMES)) {
[17:26:45.787]                   name <- added[[kk]]
[17:26:45.787]                   NAME <- NAMES[[kk]]
[17:26:45.787]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.787]                     next
[17:26:45.787]                   args[[name]] <- ""
[17:26:45.787]                 }
[17:26:45.787]                 NAMES <- toupper(removed)
[17:26:45.787]                 for (kk in seq_along(NAMES)) {
[17:26:45.787]                   name <- removed[[kk]]
[17:26:45.787]                   NAME <- NAMES[[kk]]
[17:26:45.787]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.787]                     next
[17:26:45.787]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.787]                 }
[17:26:45.787]                 if (length(args) > 0) 
[17:26:45.787]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.787]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.787]             }
[17:26:45.787]             else {
[17:26:45.787]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.787]             }
[17:26:45.787]             {
[17:26:45.787]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.787]                   0L) {
[17:26:45.787]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.787]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.787]                   base::options(opts)
[17:26:45.787]                 }
[17:26:45.787]                 {
[17:26:45.787]                   {
[17:26:45.787]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.787]                     NULL
[17:26:45.787]                   }
[17:26:45.787]                   options(future.plan = NULL)
[17:26:45.787]                   if (is.na(NA_character_)) 
[17:26:45.787]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.787]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.787]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.787]                     .init = FALSE)
[17:26:45.787]                 }
[17:26:45.787]             }
[17:26:45.787]         }
[17:26:45.787]     })
[17:26:45.787]     if (TRUE) {
[17:26:45.787]         base::sink(type = "output", split = FALSE)
[17:26:45.787]         if (TRUE) {
[17:26:45.787]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.787]         }
[17:26:45.787]         else {
[17:26:45.787]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.787]         }
[17:26:45.787]         base::close(...future.stdout)
[17:26:45.787]         ...future.stdout <- NULL
[17:26:45.787]     }
[17:26:45.787]     ...future.result$conditions <- ...future.conditions
[17:26:45.787]     ...future.result$finished <- base::Sys.time()
[17:26:45.787]     ...future.result
[17:26:45.787] }
[17:26:45.793] MultisessionFuture started
[17:26:45.793] - Launch lazy future ... done
[17:26:45.793] run() for 'MultisessionFuture' ... done
[17:26:45.794] getGlobalsAndPackages() ...
[17:26:45.794] Searching for globals...
[17:26:45.794] 
[17:26:45.795] Searching for globals ... DONE
[17:26:45.795] - globals: [0] <none>
[17:26:45.795] getGlobalsAndPackages() ... DONE
[17:26:45.795] run() for 'Future' ...
[17:26:45.796] - state: 'created'
[17:26:45.796] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.811] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.811] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.811]   - Field: 'node'
[17:26:45.812]   - Field: 'label'
[17:26:45.812]   - Field: 'local'
[17:26:45.812]   - Field: 'owner'
[17:26:45.812]   - Field: 'envir'
[17:26:45.813]   - Field: 'workers'
[17:26:45.813]   - Field: 'packages'
[17:26:45.813]   - Field: 'gc'
[17:26:45.813]   - Field: 'conditions'
[17:26:45.814]   - Field: 'persistent'
[17:26:45.814]   - Field: 'expr'
[17:26:45.814]   - Field: 'uuid'
[17:26:45.814]   - Field: 'seed'
[17:26:45.814]   - Field: 'version'
[17:26:45.815]   - Field: 'result'
[17:26:45.815]   - Field: 'asynchronous'
[17:26:45.815]   - Field: 'calls'
[17:26:45.815]   - Field: 'globals'
[17:26:45.816]   - Field: 'stdout'
[17:26:45.816]   - Field: 'earlySignal'
[17:26:45.816]   - Field: 'lazy'
[17:26:45.816]   - Field: 'state'
[17:26:45.817] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.817] - Launch lazy future ...
[17:26:45.817] Packages needed by the future expression (n = 0): <none>
[17:26:45.818] Packages needed by future strategies (n = 0): <none>
[17:26:45.818] {
[17:26:45.818]     {
[17:26:45.818]         {
[17:26:45.818]             ...future.startTime <- base::Sys.time()
[17:26:45.818]             {
[17:26:45.818]                 {
[17:26:45.818]                   {
[17:26:45.818]                     {
[17:26:45.818]                       base::local({
[17:26:45.818]                         has_future <- base::requireNamespace("future", 
[17:26:45.818]                           quietly = TRUE)
[17:26:45.818]                         if (has_future) {
[17:26:45.818]                           ns <- base::getNamespace("future")
[17:26:45.818]                           version <- ns[[".package"]][["version"]]
[17:26:45.818]                           if (is.null(version)) 
[17:26:45.818]                             version <- utils::packageVersion("future")
[17:26:45.818]                         }
[17:26:45.818]                         else {
[17:26:45.818]                           version <- NULL
[17:26:45.818]                         }
[17:26:45.818]                         if (!has_future || version < "1.8.0") {
[17:26:45.818]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.818]                             "", base::R.version$version.string), 
[17:26:45.818]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.818]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.818]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.818]                               "release", "version")], collapse = " "), 
[17:26:45.818]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.818]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.818]                             info)
[17:26:45.818]                           info <- base::paste(info, collapse = "; ")
[17:26:45.818]                           if (!has_future) {
[17:26:45.818]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.818]                               info)
[17:26:45.818]                           }
[17:26:45.818]                           else {
[17:26:45.818]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.818]                               info, version)
[17:26:45.818]                           }
[17:26:45.818]                           base::stop(msg)
[17:26:45.818]                         }
[17:26:45.818]                       })
[17:26:45.818]                     }
[17:26:45.818]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.818]                     base::options(mc.cores = 1L)
[17:26:45.818]                   }
[17:26:45.818]                   ...future.strategy.old <- future::plan("list")
[17:26:45.818]                   options(future.plan = NULL)
[17:26:45.818]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.818]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.818]                 }
[17:26:45.818]                 ...future.workdir <- getwd()
[17:26:45.818]             }
[17:26:45.818]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.818]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.818]         }
[17:26:45.818]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.818]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.818]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.818]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.818]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.818]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.818]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.818]             base::names(...future.oldOptions))
[17:26:45.818]     }
[17:26:45.818]     if (FALSE) {
[17:26:45.818]     }
[17:26:45.818]     else {
[17:26:45.818]         if (TRUE) {
[17:26:45.818]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.818]                 open = "w")
[17:26:45.818]         }
[17:26:45.818]         else {
[17:26:45.818]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.818]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.818]         }
[17:26:45.818]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.818]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.818]             base::sink(type = "output", split = FALSE)
[17:26:45.818]             base::close(...future.stdout)
[17:26:45.818]         }, add = TRUE)
[17:26:45.818]     }
[17:26:45.818]     ...future.frame <- base::sys.nframe()
[17:26:45.818]     ...future.conditions <- base::list()
[17:26:45.818]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.818]     if (FALSE) {
[17:26:45.818]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.818]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.818]     }
[17:26:45.818]     ...future.result <- base::tryCatch({
[17:26:45.818]         base::withCallingHandlers({
[17:26:45.818]             ...future.value <- base::withVisible(base::local({
[17:26:45.818]                 ...future.makeSendCondition <- base::local({
[17:26:45.818]                   sendCondition <- NULL
[17:26:45.818]                   function(frame = 1L) {
[17:26:45.818]                     if (is.function(sendCondition)) 
[17:26:45.818]                       return(sendCondition)
[17:26:45.818]                     ns <- getNamespace("parallel")
[17:26:45.818]                     if (exists("sendData", mode = "function", 
[17:26:45.818]                       envir = ns)) {
[17:26:45.818]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.818]                         envir = ns)
[17:26:45.818]                       envir <- sys.frame(frame)
[17:26:45.818]                       master <- NULL
[17:26:45.818]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.818]                         !identical(envir, emptyenv())) {
[17:26:45.818]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.818]                           inherits = FALSE)) {
[17:26:45.818]                           master <- get("master", mode = "list", 
[17:26:45.818]                             envir = envir, inherits = FALSE)
[17:26:45.818]                           if (inherits(master, c("SOCKnode", 
[17:26:45.818]                             "SOCK0node"))) {
[17:26:45.818]                             sendCondition <<- function(cond) {
[17:26:45.818]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.818]                                 success = TRUE)
[17:26:45.818]                               parallel_sendData(master, data)
[17:26:45.818]                             }
[17:26:45.818]                             return(sendCondition)
[17:26:45.818]                           }
[17:26:45.818]                         }
[17:26:45.818]                         frame <- frame + 1L
[17:26:45.818]                         envir <- sys.frame(frame)
[17:26:45.818]                       }
[17:26:45.818]                     }
[17:26:45.818]                     sendCondition <<- function(cond) NULL
[17:26:45.818]                   }
[17:26:45.818]                 })
[17:26:45.818]                 withCallingHandlers({
[17:26:45.818]                   NULL
[17:26:45.818]                 }, immediateCondition = function(cond) {
[17:26:45.818]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.818]                   sendCondition(cond)
[17:26:45.818]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.818]                   {
[17:26:45.818]                     inherits <- base::inherits
[17:26:45.818]                     invokeRestart <- base::invokeRestart
[17:26:45.818]                     is.null <- base::is.null
[17:26:45.818]                     muffled <- FALSE
[17:26:45.818]                     if (inherits(cond, "message")) {
[17:26:45.818]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.818]                       if (muffled) 
[17:26:45.818]                         invokeRestart("muffleMessage")
[17:26:45.818]                     }
[17:26:45.818]                     else if (inherits(cond, "warning")) {
[17:26:45.818]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.818]                       if (muffled) 
[17:26:45.818]                         invokeRestart("muffleWarning")
[17:26:45.818]                     }
[17:26:45.818]                     else if (inherits(cond, "condition")) {
[17:26:45.818]                       if (!is.null(pattern)) {
[17:26:45.818]                         computeRestarts <- base::computeRestarts
[17:26:45.818]                         grepl <- base::grepl
[17:26:45.818]                         restarts <- computeRestarts(cond)
[17:26:45.818]                         for (restart in restarts) {
[17:26:45.818]                           name <- restart$name
[17:26:45.818]                           if (is.null(name)) 
[17:26:45.818]                             next
[17:26:45.818]                           if (!grepl(pattern, name)) 
[17:26:45.818]                             next
[17:26:45.818]                           invokeRestart(restart)
[17:26:45.818]                           muffled <- TRUE
[17:26:45.818]                           break
[17:26:45.818]                         }
[17:26:45.818]                       }
[17:26:45.818]                     }
[17:26:45.818]                     invisible(muffled)
[17:26:45.818]                   }
[17:26:45.818]                   muffleCondition(cond)
[17:26:45.818]                 })
[17:26:45.818]             }))
[17:26:45.818]             future::FutureResult(value = ...future.value$value, 
[17:26:45.818]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.818]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.818]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.818]                     ...future.globalenv.names))
[17:26:45.818]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.818]         }, condition = base::local({
[17:26:45.818]             c <- base::c
[17:26:45.818]             inherits <- base::inherits
[17:26:45.818]             invokeRestart <- base::invokeRestart
[17:26:45.818]             length <- base::length
[17:26:45.818]             list <- base::list
[17:26:45.818]             seq.int <- base::seq.int
[17:26:45.818]             signalCondition <- base::signalCondition
[17:26:45.818]             sys.calls <- base::sys.calls
[17:26:45.818]             `[[` <- base::`[[`
[17:26:45.818]             `+` <- base::`+`
[17:26:45.818]             `<<-` <- base::`<<-`
[17:26:45.818]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.818]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.818]                   3L)]
[17:26:45.818]             }
[17:26:45.818]             function(cond) {
[17:26:45.818]                 is_error <- inherits(cond, "error")
[17:26:45.818]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.818]                   NULL)
[17:26:45.818]                 if (is_error) {
[17:26:45.818]                   sessionInformation <- function() {
[17:26:45.818]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.818]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.818]                       search = base::search(), system = base::Sys.info())
[17:26:45.818]                   }
[17:26:45.818]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.818]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.818]                     cond$call), session = sessionInformation(), 
[17:26:45.818]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.818]                   signalCondition(cond)
[17:26:45.818]                 }
[17:26:45.818]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.818]                 "immediateCondition"))) {
[17:26:45.818]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.818]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.818]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.818]                   if (TRUE && !signal) {
[17:26:45.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.818]                     {
[17:26:45.818]                       inherits <- base::inherits
[17:26:45.818]                       invokeRestart <- base::invokeRestart
[17:26:45.818]                       is.null <- base::is.null
[17:26:45.818]                       muffled <- FALSE
[17:26:45.818]                       if (inherits(cond, "message")) {
[17:26:45.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.818]                         if (muffled) 
[17:26:45.818]                           invokeRestart("muffleMessage")
[17:26:45.818]                       }
[17:26:45.818]                       else if (inherits(cond, "warning")) {
[17:26:45.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.818]                         if (muffled) 
[17:26:45.818]                           invokeRestart("muffleWarning")
[17:26:45.818]                       }
[17:26:45.818]                       else if (inherits(cond, "condition")) {
[17:26:45.818]                         if (!is.null(pattern)) {
[17:26:45.818]                           computeRestarts <- base::computeRestarts
[17:26:45.818]                           grepl <- base::grepl
[17:26:45.818]                           restarts <- computeRestarts(cond)
[17:26:45.818]                           for (restart in restarts) {
[17:26:45.818]                             name <- restart$name
[17:26:45.818]                             if (is.null(name)) 
[17:26:45.818]                               next
[17:26:45.818]                             if (!grepl(pattern, name)) 
[17:26:45.818]                               next
[17:26:45.818]                             invokeRestart(restart)
[17:26:45.818]                             muffled <- TRUE
[17:26:45.818]                             break
[17:26:45.818]                           }
[17:26:45.818]                         }
[17:26:45.818]                       }
[17:26:45.818]                       invisible(muffled)
[17:26:45.818]                     }
[17:26:45.818]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.818]                   }
[17:26:45.818]                 }
[17:26:45.818]                 else {
[17:26:45.818]                   if (TRUE) {
[17:26:45.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.818]                     {
[17:26:45.818]                       inherits <- base::inherits
[17:26:45.818]                       invokeRestart <- base::invokeRestart
[17:26:45.818]                       is.null <- base::is.null
[17:26:45.818]                       muffled <- FALSE
[17:26:45.818]                       if (inherits(cond, "message")) {
[17:26:45.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.818]                         if (muffled) 
[17:26:45.818]                           invokeRestart("muffleMessage")
[17:26:45.818]                       }
[17:26:45.818]                       else if (inherits(cond, "warning")) {
[17:26:45.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.818]                         if (muffled) 
[17:26:45.818]                           invokeRestart("muffleWarning")
[17:26:45.818]                       }
[17:26:45.818]                       else if (inherits(cond, "condition")) {
[17:26:45.818]                         if (!is.null(pattern)) {
[17:26:45.818]                           computeRestarts <- base::computeRestarts
[17:26:45.818]                           grepl <- base::grepl
[17:26:45.818]                           restarts <- computeRestarts(cond)
[17:26:45.818]                           for (restart in restarts) {
[17:26:45.818]                             name <- restart$name
[17:26:45.818]                             if (is.null(name)) 
[17:26:45.818]                               next
[17:26:45.818]                             if (!grepl(pattern, name)) 
[17:26:45.818]                               next
[17:26:45.818]                             invokeRestart(restart)
[17:26:45.818]                             muffled <- TRUE
[17:26:45.818]                             break
[17:26:45.818]                           }
[17:26:45.818]                         }
[17:26:45.818]                       }
[17:26:45.818]                       invisible(muffled)
[17:26:45.818]                     }
[17:26:45.818]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.818]                   }
[17:26:45.818]                 }
[17:26:45.818]             }
[17:26:45.818]         }))
[17:26:45.818]     }, error = function(ex) {
[17:26:45.818]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.818]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.818]                 ...future.rng), started = ...future.startTime, 
[17:26:45.818]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.818]             version = "1.8"), class = "FutureResult")
[17:26:45.818]     }, finally = {
[17:26:45.818]         if (!identical(...future.workdir, getwd())) 
[17:26:45.818]             setwd(...future.workdir)
[17:26:45.818]         {
[17:26:45.818]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.818]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.818]             }
[17:26:45.818]             base::options(...future.oldOptions)
[17:26:45.818]             if (.Platform$OS.type == "windows") {
[17:26:45.818]                 old_names <- names(...future.oldEnvVars)
[17:26:45.818]                 envs <- base::Sys.getenv()
[17:26:45.818]                 names <- names(envs)
[17:26:45.818]                 common <- intersect(names, old_names)
[17:26:45.818]                 added <- setdiff(names, old_names)
[17:26:45.818]                 removed <- setdiff(old_names, names)
[17:26:45.818]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.818]                   envs[common]]
[17:26:45.818]                 NAMES <- toupper(changed)
[17:26:45.818]                 args <- list()
[17:26:45.818]                 for (kk in seq_along(NAMES)) {
[17:26:45.818]                   name <- changed[[kk]]
[17:26:45.818]                   NAME <- NAMES[[kk]]
[17:26:45.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.818]                     next
[17:26:45.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.818]                 }
[17:26:45.818]                 NAMES <- toupper(added)
[17:26:45.818]                 for (kk in seq_along(NAMES)) {
[17:26:45.818]                   name <- added[[kk]]
[17:26:45.818]                   NAME <- NAMES[[kk]]
[17:26:45.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.818]                     next
[17:26:45.818]                   args[[name]] <- ""
[17:26:45.818]                 }
[17:26:45.818]                 NAMES <- toupper(removed)
[17:26:45.818]                 for (kk in seq_along(NAMES)) {
[17:26:45.818]                   name <- removed[[kk]]
[17:26:45.818]                   NAME <- NAMES[[kk]]
[17:26:45.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.818]                     next
[17:26:45.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.818]                 }
[17:26:45.818]                 if (length(args) > 0) 
[17:26:45.818]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.818]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.818]             }
[17:26:45.818]             else {
[17:26:45.818]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.818]             }
[17:26:45.818]             {
[17:26:45.818]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.818]                   0L) {
[17:26:45.818]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.818]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.818]                   base::options(opts)
[17:26:45.818]                 }
[17:26:45.818]                 {
[17:26:45.818]                   {
[17:26:45.818]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.818]                     NULL
[17:26:45.818]                   }
[17:26:45.818]                   options(future.plan = NULL)
[17:26:45.818]                   if (is.na(NA_character_)) 
[17:26:45.818]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.818]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.818]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.818]                     .init = FALSE)
[17:26:45.818]                 }
[17:26:45.818]             }
[17:26:45.818]         }
[17:26:45.818]     })
[17:26:45.818]     if (TRUE) {
[17:26:45.818]         base::sink(type = "output", split = FALSE)
[17:26:45.818]         if (TRUE) {
[17:26:45.818]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.818]         }
[17:26:45.818]         else {
[17:26:45.818]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.818]         }
[17:26:45.818]         base::close(...future.stdout)
[17:26:45.818]         ...future.stdout <- NULL
[17:26:45.818]     }
[17:26:45.818]     ...future.result$conditions <- ...future.conditions
[17:26:45.818]     ...future.result$finished <- base::Sys.time()
[17:26:45.818]     ...future.result
[17:26:45.818] }
[17:26:45.824] MultisessionFuture started
[17:26:45.824] - Launch lazy future ... done
[17:26:45.825] run() for 'MultisessionFuture' ... done
[17:26:45.825] getGlobalsAndPackages() ...
[17:26:45.826] Searching for globals...
[17:26:45.827] - globals found: [1] '{'
[17:26:45.827] Searching for globals ... DONE
[17:26:45.827] Resolving globals: FALSE
[17:26:45.828] 
[17:26:45.828] 
[17:26:45.828] getGlobalsAndPackages() ... DONE
[17:26:45.828] run() for 'Future' ...
[17:26:45.829] - state: 'created'
[17:26:45.829] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.843] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.843] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.844]   - Field: 'node'
[17:26:45.844]   - Field: 'label'
[17:26:45.844]   - Field: 'local'
[17:26:45.844]   - Field: 'owner'
[17:26:45.844]   - Field: 'envir'
[17:26:45.845]   - Field: 'workers'
[17:26:45.845]   - Field: 'packages'
[17:26:45.845]   - Field: 'gc'
[17:26:45.845]   - Field: 'conditions'
[17:26:45.845]   - Field: 'persistent'
[17:26:45.845]   - Field: 'expr'
[17:26:45.846]   - Field: 'uuid'
[17:26:45.846]   - Field: 'seed'
[17:26:45.846]   - Field: 'version'
[17:26:45.846]   - Field: 'result'
[17:26:45.846]   - Field: 'asynchronous'
[17:26:45.847]   - Field: 'calls'
[17:26:45.847]   - Field: 'globals'
[17:26:45.847]   - Field: 'stdout'
[17:26:45.847]   - Field: 'earlySignal'
[17:26:45.847]   - Field: 'lazy'
[17:26:45.847]   - Field: 'state'
[17:26:45.848] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.848] - Launch lazy future ...
[17:26:45.848] Packages needed by the future expression (n = 0): <none>
[17:26:45.848] Packages needed by future strategies (n = 0): <none>
[17:26:45.849] {
[17:26:45.849]     {
[17:26:45.849]         {
[17:26:45.849]             ...future.startTime <- base::Sys.time()
[17:26:45.849]             {
[17:26:45.849]                 {
[17:26:45.849]                   {
[17:26:45.849]                     {
[17:26:45.849]                       base::local({
[17:26:45.849]                         has_future <- base::requireNamespace("future", 
[17:26:45.849]                           quietly = TRUE)
[17:26:45.849]                         if (has_future) {
[17:26:45.849]                           ns <- base::getNamespace("future")
[17:26:45.849]                           version <- ns[[".package"]][["version"]]
[17:26:45.849]                           if (is.null(version)) 
[17:26:45.849]                             version <- utils::packageVersion("future")
[17:26:45.849]                         }
[17:26:45.849]                         else {
[17:26:45.849]                           version <- NULL
[17:26:45.849]                         }
[17:26:45.849]                         if (!has_future || version < "1.8.0") {
[17:26:45.849]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.849]                             "", base::R.version$version.string), 
[17:26:45.849]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.849]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.849]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.849]                               "release", "version")], collapse = " "), 
[17:26:45.849]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.849]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.849]                             info)
[17:26:45.849]                           info <- base::paste(info, collapse = "; ")
[17:26:45.849]                           if (!has_future) {
[17:26:45.849]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.849]                               info)
[17:26:45.849]                           }
[17:26:45.849]                           else {
[17:26:45.849]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.849]                               info, version)
[17:26:45.849]                           }
[17:26:45.849]                           base::stop(msg)
[17:26:45.849]                         }
[17:26:45.849]                       })
[17:26:45.849]                     }
[17:26:45.849]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.849]                     base::options(mc.cores = 1L)
[17:26:45.849]                   }
[17:26:45.849]                   ...future.strategy.old <- future::plan("list")
[17:26:45.849]                   options(future.plan = NULL)
[17:26:45.849]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.849]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.849]                 }
[17:26:45.849]                 ...future.workdir <- getwd()
[17:26:45.849]             }
[17:26:45.849]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.849]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.849]         }
[17:26:45.849]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.849]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.849]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.849]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.849]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.849]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.849]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.849]             base::names(...future.oldOptions))
[17:26:45.849]     }
[17:26:45.849]     if (FALSE) {
[17:26:45.849]     }
[17:26:45.849]     else {
[17:26:45.849]         if (TRUE) {
[17:26:45.849]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.849]                 open = "w")
[17:26:45.849]         }
[17:26:45.849]         else {
[17:26:45.849]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.849]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.849]         }
[17:26:45.849]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.849]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.849]             base::sink(type = "output", split = FALSE)
[17:26:45.849]             base::close(...future.stdout)
[17:26:45.849]         }, add = TRUE)
[17:26:45.849]     }
[17:26:45.849]     ...future.frame <- base::sys.nframe()
[17:26:45.849]     ...future.conditions <- base::list()
[17:26:45.849]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.849]     if (FALSE) {
[17:26:45.849]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.849]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.849]     }
[17:26:45.849]     ...future.result <- base::tryCatch({
[17:26:45.849]         base::withCallingHandlers({
[17:26:45.849]             ...future.value <- base::withVisible(base::local({
[17:26:45.849]                 ...future.makeSendCondition <- base::local({
[17:26:45.849]                   sendCondition <- NULL
[17:26:45.849]                   function(frame = 1L) {
[17:26:45.849]                     if (is.function(sendCondition)) 
[17:26:45.849]                       return(sendCondition)
[17:26:45.849]                     ns <- getNamespace("parallel")
[17:26:45.849]                     if (exists("sendData", mode = "function", 
[17:26:45.849]                       envir = ns)) {
[17:26:45.849]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.849]                         envir = ns)
[17:26:45.849]                       envir <- sys.frame(frame)
[17:26:45.849]                       master <- NULL
[17:26:45.849]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.849]                         !identical(envir, emptyenv())) {
[17:26:45.849]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.849]                           inherits = FALSE)) {
[17:26:45.849]                           master <- get("master", mode = "list", 
[17:26:45.849]                             envir = envir, inherits = FALSE)
[17:26:45.849]                           if (inherits(master, c("SOCKnode", 
[17:26:45.849]                             "SOCK0node"))) {
[17:26:45.849]                             sendCondition <<- function(cond) {
[17:26:45.849]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.849]                                 success = TRUE)
[17:26:45.849]                               parallel_sendData(master, data)
[17:26:45.849]                             }
[17:26:45.849]                             return(sendCondition)
[17:26:45.849]                           }
[17:26:45.849]                         }
[17:26:45.849]                         frame <- frame + 1L
[17:26:45.849]                         envir <- sys.frame(frame)
[17:26:45.849]                       }
[17:26:45.849]                     }
[17:26:45.849]                     sendCondition <<- function(cond) NULL
[17:26:45.849]                   }
[17:26:45.849]                 })
[17:26:45.849]                 withCallingHandlers({
[17:26:45.849]                   {
[17:26:45.849]                     4
[17:26:45.849]                   }
[17:26:45.849]                 }, immediateCondition = function(cond) {
[17:26:45.849]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.849]                   sendCondition(cond)
[17:26:45.849]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.849]                   {
[17:26:45.849]                     inherits <- base::inherits
[17:26:45.849]                     invokeRestart <- base::invokeRestart
[17:26:45.849]                     is.null <- base::is.null
[17:26:45.849]                     muffled <- FALSE
[17:26:45.849]                     if (inherits(cond, "message")) {
[17:26:45.849]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.849]                       if (muffled) 
[17:26:45.849]                         invokeRestart("muffleMessage")
[17:26:45.849]                     }
[17:26:45.849]                     else if (inherits(cond, "warning")) {
[17:26:45.849]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.849]                       if (muffled) 
[17:26:45.849]                         invokeRestart("muffleWarning")
[17:26:45.849]                     }
[17:26:45.849]                     else if (inherits(cond, "condition")) {
[17:26:45.849]                       if (!is.null(pattern)) {
[17:26:45.849]                         computeRestarts <- base::computeRestarts
[17:26:45.849]                         grepl <- base::grepl
[17:26:45.849]                         restarts <- computeRestarts(cond)
[17:26:45.849]                         for (restart in restarts) {
[17:26:45.849]                           name <- restart$name
[17:26:45.849]                           if (is.null(name)) 
[17:26:45.849]                             next
[17:26:45.849]                           if (!grepl(pattern, name)) 
[17:26:45.849]                             next
[17:26:45.849]                           invokeRestart(restart)
[17:26:45.849]                           muffled <- TRUE
[17:26:45.849]                           break
[17:26:45.849]                         }
[17:26:45.849]                       }
[17:26:45.849]                     }
[17:26:45.849]                     invisible(muffled)
[17:26:45.849]                   }
[17:26:45.849]                   muffleCondition(cond)
[17:26:45.849]                 })
[17:26:45.849]             }))
[17:26:45.849]             future::FutureResult(value = ...future.value$value, 
[17:26:45.849]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.849]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.849]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.849]                     ...future.globalenv.names))
[17:26:45.849]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.849]         }, condition = base::local({
[17:26:45.849]             c <- base::c
[17:26:45.849]             inherits <- base::inherits
[17:26:45.849]             invokeRestart <- base::invokeRestart
[17:26:45.849]             length <- base::length
[17:26:45.849]             list <- base::list
[17:26:45.849]             seq.int <- base::seq.int
[17:26:45.849]             signalCondition <- base::signalCondition
[17:26:45.849]             sys.calls <- base::sys.calls
[17:26:45.849]             `[[` <- base::`[[`
[17:26:45.849]             `+` <- base::`+`
[17:26:45.849]             `<<-` <- base::`<<-`
[17:26:45.849]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.849]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.849]                   3L)]
[17:26:45.849]             }
[17:26:45.849]             function(cond) {
[17:26:45.849]                 is_error <- inherits(cond, "error")
[17:26:45.849]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.849]                   NULL)
[17:26:45.849]                 if (is_error) {
[17:26:45.849]                   sessionInformation <- function() {
[17:26:45.849]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.849]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.849]                       search = base::search(), system = base::Sys.info())
[17:26:45.849]                   }
[17:26:45.849]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.849]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.849]                     cond$call), session = sessionInformation(), 
[17:26:45.849]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.849]                   signalCondition(cond)
[17:26:45.849]                 }
[17:26:45.849]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.849]                 "immediateCondition"))) {
[17:26:45.849]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.849]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.849]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.849]                   if (TRUE && !signal) {
[17:26:45.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.849]                     {
[17:26:45.849]                       inherits <- base::inherits
[17:26:45.849]                       invokeRestart <- base::invokeRestart
[17:26:45.849]                       is.null <- base::is.null
[17:26:45.849]                       muffled <- FALSE
[17:26:45.849]                       if (inherits(cond, "message")) {
[17:26:45.849]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.849]                         if (muffled) 
[17:26:45.849]                           invokeRestart("muffleMessage")
[17:26:45.849]                       }
[17:26:45.849]                       else if (inherits(cond, "warning")) {
[17:26:45.849]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.849]                         if (muffled) 
[17:26:45.849]                           invokeRestart("muffleWarning")
[17:26:45.849]                       }
[17:26:45.849]                       else if (inherits(cond, "condition")) {
[17:26:45.849]                         if (!is.null(pattern)) {
[17:26:45.849]                           computeRestarts <- base::computeRestarts
[17:26:45.849]                           grepl <- base::grepl
[17:26:45.849]                           restarts <- computeRestarts(cond)
[17:26:45.849]                           for (restart in restarts) {
[17:26:45.849]                             name <- restart$name
[17:26:45.849]                             if (is.null(name)) 
[17:26:45.849]                               next
[17:26:45.849]                             if (!grepl(pattern, name)) 
[17:26:45.849]                               next
[17:26:45.849]                             invokeRestart(restart)
[17:26:45.849]                             muffled <- TRUE
[17:26:45.849]                             break
[17:26:45.849]                           }
[17:26:45.849]                         }
[17:26:45.849]                       }
[17:26:45.849]                       invisible(muffled)
[17:26:45.849]                     }
[17:26:45.849]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.849]                   }
[17:26:45.849]                 }
[17:26:45.849]                 else {
[17:26:45.849]                   if (TRUE) {
[17:26:45.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.849]                     {
[17:26:45.849]                       inherits <- base::inherits
[17:26:45.849]                       invokeRestart <- base::invokeRestart
[17:26:45.849]                       is.null <- base::is.null
[17:26:45.849]                       muffled <- FALSE
[17:26:45.849]                       if (inherits(cond, "message")) {
[17:26:45.849]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.849]                         if (muffled) 
[17:26:45.849]                           invokeRestart("muffleMessage")
[17:26:45.849]                       }
[17:26:45.849]                       else if (inherits(cond, "warning")) {
[17:26:45.849]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.849]                         if (muffled) 
[17:26:45.849]                           invokeRestart("muffleWarning")
[17:26:45.849]                       }
[17:26:45.849]                       else if (inherits(cond, "condition")) {
[17:26:45.849]                         if (!is.null(pattern)) {
[17:26:45.849]                           computeRestarts <- base::computeRestarts
[17:26:45.849]                           grepl <- base::grepl
[17:26:45.849]                           restarts <- computeRestarts(cond)
[17:26:45.849]                           for (restart in restarts) {
[17:26:45.849]                             name <- restart$name
[17:26:45.849]                             if (is.null(name)) 
[17:26:45.849]                               next
[17:26:45.849]                             if (!grepl(pattern, name)) 
[17:26:45.849]                               next
[17:26:45.849]                             invokeRestart(restart)
[17:26:45.849]                             muffled <- TRUE
[17:26:45.849]                             break
[17:26:45.849]                           }
[17:26:45.849]                         }
[17:26:45.849]                       }
[17:26:45.849]                       invisible(muffled)
[17:26:45.849]                     }
[17:26:45.849]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.849]                   }
[17:26:45.849]                 }
[17:26:45.849]             }
[17:26:45.849]         }))
[17:26:45.849]     }, error = function(ex) {
[17:26:45.849]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.849]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.849]                 ...future.rng), started = ...future.startTime, 
[17:26:45.849]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.849]             version = "1.8"), class = "FutureResult")
[17:26:45.849]     }, finally = {
[17:26:45.849]         if (!identical(...future.workdir, getwd())) 
[17:26:45.849]             setwd(...future.workdir)
[17:26:45.849]         {
[17:26:45.849]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.849]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.849]             }
[17:26:45.849]             base::options(...future.oldOptions)
[17:26:45.849]             if (.Platform$OS.type == "windows") {
[17:26:45.849]                 old_names <- names(...future.oldEnvVars)
[17:26:45.849]                 envs <- base::Sys.getenv()
[17:26:45.849]                 names <- names(envs)
[17:26:45.849]                 common <- intersect(names, old_names)
[17:26:45.849]                 added <- setdiff(names, old_names)
[17:26:45.849]                 removed <- setdiff(old_names, names)
[17:26:45.849]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.849]                   envs[common]]
[17:26:45.849]                 NAMES <- toupper(changed)
[17:26:45.849]                 args <- list()
[17:26:45.849]                 for (kk in seq_along(NAMES)) {
[17:26:45.849]                   name <- changed[[kk]]
[17:26:45.849]                   NAME <- NAMES[[kk]]
[17:26:45.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.849]                     next
[17:26:45.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.849]                 }
[17:26:45.849]                 NAMES <- toupper(added)
[17:26:45.849]                 for (kk in seq_along(NAMES)) {
[17:26:45.849]                   name <- added[[kk]]
[17:26:45.849]                   NAME <- NAMES[[kk]]
[17:26:45.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.849]                     next
[17:26:45.849]                   args[[name]] <- ""
[17:26:45.849]                 }
[17:26:45.849]                 NAMES <- toupper(removed)
[17:26:45.849]                 for (kk in seq_along(NAMES)) {
[17:26:45.849]                   name <- removed[[kk]]
[17:26:45.849]                   NAME <- NAMES[[kk]]
[17:26:45.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.849]                     next
[17:26:45.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.849]                 }
[17:26:45.849]                 if (length(args) > 0) 
[17:26:45.849]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.849]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.849]             }
[17:26:45.849]             else {
[17:26:45.849]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.849]             }
[17:26:45.849]             {
[17:26:45.849]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.849]                   0L) {
[17:26:45.849]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.849]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.849]                   base::options(opts)
[17:26:45.849]                 }
[17:26:45.849]                 {
[17:26:45.849]                   {
[17:26:45.849]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.849]                     NULL
[17:26:45.849]                   }
[17:26:45.849]                   options(future.plan = NULL)
[17:26:45.849]                   if (is.na(NA_character_)) 
[17:26:45.849]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.849]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.849]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.849]                     .init = FALSE)
[17:26:45.849]                 }
[17:26:45.849]             }
[17:26:45.849]         }
[17:26:45.849]     })
[17:26:45.849]     if (TRUE) {
[17:26:45.849]         base::sink(type = "output", split = FALSE)
[17:26:45.849]         if (TRUE) {
[17:26:45.849]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.849]         }
[17:26:45.849]         else {
[17:26:45.849]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.849]         }
[17:26:45.849]         base::close(...future.stdout)
[17:26:45.849]         ...future.stdout <- NULL
[17:26:45.849]     }
[17:26:45.849]     ...future.result$conditions <- ...future.conditions
[17:26:45.849]     ...future.result$finished <- base::Sys.time()
[17:26:45.849]     ...future.result
[17:26:45.849] }
[17:26:45.854] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:45.876] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.876] - Validating connection of MultisessionFuture
[17:26:45.876] - received message: FutureResult
[17:26:45.877] - Received FutureResult
[17:26:45.877] - Erased future from FutureRegistry
[17:26:45.877] result() for ClusterFuture ...
[17:26:45.877] - result already collected: FutureResult
[17:26:45.877] result() for ClusterFuture ... done
[17:26:45.878] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.878] result() for ClusterFuture ...
[17:26:45.878] - result already collected: FutureResult
[17:26:45.878] result() for ClusterFuture ... done
[17:26:45.878] result() for ClusterFuture ...
[17:26:45.878] - result already collected: FutureResult
[17:26:45.879] result() for ClusterFuture ... done
[17:26:45.880] MultisessionFuture started
[17:26:45.880] - Launch lazy future ... done
[17:26:45.880] run() for 'MultisessionFuture' ... done
<environment: 0x000002230fb8f760> 
<environment: 0x0000022310d5f080> 
[17:26:45.882] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.882] - Validating connection of MultisessionFuture
[17:26:45.883] - received message: FutureResult
[17:26:45.883] - Received FutureResult
[17:26:45.883] - Erased future from FutureRegistry
[17:26:45.883] result() for ClusterFuture ...
[17:26:45.883] - result already collected: FutureResult
[17:26:45.883] result() for ClusterFuture ... done
[17:26:45.884] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:45.894] receiveMessageFromWorker() for ClusterFuture ...
[17:26:45.894] - Validating connection of MultisessionFuture
[17:26:45.895] - received message: FutureResult
[17:26:45.895] - Received FutureResult
[17:26:45.895] - Erased future from FutureRegistry
[17:26:45.895] result() for ClusterFuture ...
[17:26:45.895] - result already collected: FutureResult
[17:26:45.896] result() for ClusterFuture ... done
[17:26:45.896] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:45.897] resolve() on environment ...
[17:26:45.897]  recursive: 0
[17:26:45.898]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:45.898] signalConditionsASAP(numeric, pos=1) ...
[17:26:45.898] - nx: 4
[17:26:45.898] - relay: TRUE
[17:26:45.899] - stdout: TRUE
[17:26:45.899] - signal: TRUE
[17:26:45.899] - resignal: FALSE
[17:26:45.899] - force: TRUE
[17:26:45.899] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.899] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.900]  - until=2
[17:26:45.900]  - relaying element #2
[17:26:45.900] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:45.900] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.900] signalConditionsASAP(NULL, pos=1) ... done
[17:26:45.900]  length: 3 (resolved future 1)
[17:26:45.901] Future #2
[17:26:45.901] result() for ClusterFuture ...
[17:26:45.901] - result already collected: FutureResult
[17:26:45.901] result() for ClusterFuture ... done
[17:26:45.901] result() for ClusterFuture ...
[17:26:45.901] - result already collected: FutureResult
[17:26:45.901] result() for ClusterFuture ... done
[17:26:45.902] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:45.902] - nx: 4
[17:26:45.902] - relay: TRUE
[17:26:45.902] - stdout: TRUE
[17:26:45.902] - signal: TRUE
[17:26:45.902] - resignal: FALSE
[17:26:45.903] - force: TRUE
[17:26:45.903] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:45.903] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:45.903]  - until=2
[17:26:45.903]  - relaying element #2
[17:26:45.907] result() for ClusterFuture ...
[17:26:45.907] - result already collected: FutureResult
[17:26:45.907] result() for ClusterFuture ... done
[17:26:45.907] result() for ClusterFuture ...
[17:26:45.908] - result already collected: FutureResult
[17:26:45.908] result() for ClusterFuture ... done
[17:26:45.908] result() for ClusterFuture ...
[17:26:45.908] - result already collected: FutureResult
[17:26:45.908] result() for ClusterFuture ... done
[17:26:45.909] result() for ClusterFuture ...
[17:26:45.909] - result already collected: FutureResult
[17:26:45.909] result() for ClusterFuture ... done
[17:26:45.909] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:45.909] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:45.909] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:45.910]  length: 2 (resolved future 2)
[17:26:45.910] Future #3
[17:26:45.910] result() for ClusterFuture ...
[17:26:45.910] - result already collected: FutureResult
[17:26:45.910] result() for ClusterFuture ... done
[17:26:45.910] result() for ClusterFuture ...
[17:26:45.911] - result already collected: FutureResult
[17:26:45.911] result() for ClusterFuture ... done
[17:26:45.911] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:45.911] - nx: 4
[17:26:45.911] - relay: TRUE
[17:26:45.911] - stdout: TRUE
[17:26:45.911] - signal: TRUE
[17:26:45.912] - resignal: FALSE
[17:26:45.912] - force: TRUE
[17:26:45.912] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:45.912] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:45.912]  - until=3
[17:26:45.912]  - relaying element #3
[17:26:45.913] result() for ClusterFuture ...
[17:26:45.913] - result already collected: FutureResult
[17:26:45.913] result() for ClusterFuture ... done
[17:26:45.913] result() for ClusterFuture ...
[17:26:45.913] - result already collected: FutureResult
[17:26:45.913] result() for ClusterFuture ... done
[17:26:45.914] result() for ClusterFuture ...
[17:26:45.914] - result already collected: FutureResult
[17:26:45.914] result() for ClusterFuture ... done
[17:26:45.914] result() for ClusterFuture ...
[17:26:45.914] - result already collected: FutureResult
[17:26:45.914] result() for ClusterFuture ... done
[17:26:45.914] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:45.915] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:45.915] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:45.915]  length: 1 (resolved future 3)
[17:26:45.915] Future #4
[17:26:45.915] result() for ClusterFuture ...
[17:26:45.916] - result already collected: FutureResult
[17:26:45.916] result() for ClusterFuture ... done
[17:26:45.916] result() for ClusterFuture ...
[17:26:45.916] - result already collected: FutureResult
[17:26:45.916] result() for ClusterFuture ... done
[17:26:45.916] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:45.917] - nx: 4
[17:26:45.917] - relay: TRUE
[17:26:45.917] - stdout: TRUE
[17:26:45.917] - signal: TRUE
[17:26:45.917] - resignal: FALSE
[17:26:45.917] - force: TRUE
[17:26:45.917] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:45.918] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:45.918]  - until=4
[17:26:45.918]  - relaying element #4
[17:26:45.918] result() for ClusterFuture ...
[17:26:45.918] - result already collected: FutureResult
[17:26:45.918] result() for ClusterFuture ... done
[17:26:45.919] result() for ClusterFuture ...
[17:26:45.919] - result already collected: FutureResult
[17:26:45.919] result() for ClusterFuture ... done
[17:26:45.919] result() for ClusterFuture ...
[17:26:45.919] - result already collected: FutureResult
[17:26:45.919] result() for ClusterFuture ... done
[17:26:45.920] result() for ClusterFuture ...
[17:26:45.920] - result already collected: FutureResult
[17:26:45.920] result() for ClusterFuture ... done
[17:26:45.920] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.920] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:45.920] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:45.921]  length: 0 (resolved future 4)
[17:26:45.921] Relaying remaining futures
[17:26:45.921] signalConditionsASAP(NULL, pos=0) ...
[17:26:45.921] - nx: 4
[17:26:45.921] - relay: TRUE
[17:26:45.921] - stdout: TRUE
[17:26:45.921] - signal: TRUE
[17:26:45.922] - resignal: FALSE
[17:26:45.922] - force: TRUE
[17:26:45.922] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.922] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:45.922] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:45.922] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:45.923] signalConditionsASAP(NULL, pos=0) ... done
[17:26:45.923] resolve() on environment ... DONE
[17:26:45.923] result() for ClusterFuture ...
[17:26:45.923] - result already collected: FutureResult
[17:26:45.923] result() for ClusterFuture ... done
[17:26:45.923] result() for ClusterFuture ...
[17:26:45.924] - result already collected: FutureResult
[17:26:45.924] result() for ClusterFuture ... done
[17:26:45.924] result() for ClusterFuture ...
[17:26:45.924] - result already collected: FutureResult
[17:26:45.924] result() for ClusterFuture ... done
[17:26:45.925] result() for ClusterFuture ...
[17:26:45.925] - result already collected: FutureResult
[17:26:45.925] result() for ClusterFuture ... done
[17:26:45.925] result() for ClusterFuture ...
[17:26:45.925] - result already collected: FutureResult
[17:26:45.925] result() for ClusterFuture ... done
[17:26:45.926] result() for ClusterFuture ...
[17:26:45.926] - result already collected: FutureResult
[17:26:45.926] result() for ClusterFuture ... done
<environment: 0x0000022310fa9b30> 
Dimensions: c(2, 3, 1)
[17:26:45.926] getGlobalsAndPackages() ...
[17:26:45.927] Searching for globals...
[17:26:45.927] 
[17:26:45.927] Searching for globals ... DONE
[17:26:45.927] - globals: [0] <none>
[17:26:45.928] getGlobalsAndPackages() ... DONE
[17:26:45.928] run() for 'Future' ...
[17:26:45.928] - state: 'created'
[17:26:45.928] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.942] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.943] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.943]   - Field: 'node'
[17:26:45.943]   - Field: 'label'
[17:26:45.943]   - Field: 'local'
[17:26:45.943]   - Field: 'owner'
[17:26:45.944]   - Field: 'envir'
[17:26:45.944]   - Field: 'workers'
[17:26:45.944]   - Field: 'packages'
[17:26:45.944]   - Field: 'gc'
[17:26:45.944]   - Field: 'conditions'
[17:26:45.945]   - Field: 'persistent'
[17:26:45.945]   - Field: 'expr'
[17:26:45.945]   - Field: 'uuid'
[17:26:45.945]   - Field: 'seed'
[17:26:45.945]   - Field: 'version'
[17:26:45.945]   - Field: 'result'
[17:26:45.946]   - Field: 'asynchronous'
[17:26:45.946]   - Field: 'calls'
[17:26:45.946]   - Field: 'globals'
[17:26:45.946]   - Field: 'stdout'
[17:26:45.946]   - Field: 'earlySignal'
[17:26:45.947]   - Field: 'lazy'
[17:26:45.947]   - Field: 'state'
[17:26:45.947] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.947] - Launch lazy future ...
[17:26:45.947] Packages needed by the future expression (n = 0): <none>
[17:26:45.948] Packages needed by future strategies (n = 0): <none>
[17:26:45.948] {
[17:26:45.948]     {
[17:26:45.948]         {
[17:26:45.948]             ...future.startTime <- base::Sys.time()
[17:26:45.948]             {
[17:26:45.948]                 {
[17:26:45.948]                   {
[17:26:45.948]                     {
[17:26:45.948]                       base::local({
[17:26:45.948]                         has_future <- base::requireNamespace("future", 
[17:26:45.948]                           quietly = TRUE)
[17:26:45.948]                         if (has_future) {
[17:26:45.948]                           ns <- base::getNamespace("future")
[17:26:45.948]                           version <- ns[[".package"]][["version"]]
[17:26:45.948]                           if (is.null(version)) 
[17:26:45.948]                             version <- utils::packageVersion("future")
[17:26:45.948]                         }
[17:26:45.948]                         else {
[17:26:45.948]                           version <- NULL
[17:26:45.948]                         }
[17:26:45.948]                         if (!has_future || version < "1.8.0") {
[17:26:45.948]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.948]                             "", base::R.version$version.string), 
[17:26:45.948]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.948]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.948]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.948]                               "release", "version")], collapse = " "), 
[17:26:45.948]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.948]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.948]                             info)
[17:26:45.948]                           info <- base::paste(info, collapse = "; ")
[17:26:45.948]                           if (!has_future) {
[17:26:45.948]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.948]                               info)
[17:26:45.948]                           }
[17:26:45.948]                           else {
[17:26:45.948]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.948]                               info, version)
[17:26:45.948]                           }
[17:26:45.948]                           base::stop(msg)
[17:26:45.948]                         }
[17:26:45.948]                       })
[17:26:45.948]                     }
[17:26:45.948]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.948]                     base::options(mc.cores = 1L)
[17:26:45.948]                   }
[17:26:45.948]                   ...future.strategy.old <- future::plan("list")
[17:26:45.948]                   options(future.plan = NULL)
[17:26:45.948]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.948]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.948]                 }
[17:26:45.948]                 ...future.workdir <- getwd()
[17:26:45.948]             }
[17:26:45.948]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.948]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.948]         }
[17:26:45.948]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.948]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.948]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.948]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.948]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.948]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.948]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.948]             base::names(...future.oldOptions))
[17:26:45.948]     }
[17:26:45.948]     if (FALSE) {
[17:26:45.948]     }
[17:26:45.948]     else {
[17:26:45.948]         if (TRUE) {
[17:26:45.948]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.948]                 open = "w")
[17:26:45.948]         }
[17:26:45.948]         else {
[17:26:45.948]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.948]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.948]         }
[17:26:45.948]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.948]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.948]             base::sink(type = "output", split = FALSE)
[17:26:45.948]             base::close(...future.stdout)
[17:26:45.948]         }, add = TRUE)
[17:26:45.948]     }
[17:26:45.948]     ...future.frame <- base::sys.nframe()
[17:26:45.948]     ...future.conditions <- base::list()
[17:26:45.948]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.948]     if (FALSE) {
[17:26:45.948]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.948]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.948]     }
[17:26:45.948]     ...future.result <- base::tryCatch({
[17:26:45.948]         base::withCallingHandlers({
[17:26:45.948]             ...future.value <- base::withVisible(base::local({
[17:26:45.948]                 ...future.makeSendCondition <- base::local({
[17:26:45.948]                   sendCondition <- NULL
[17:26:45.948]                   function(frame = 1L) {
[17:26:45.948]                     if (is.function(sendCondition)) 
[17:26:45.948]                       return(sendCondition)
[17:26:45.948]                     ns <- getNamespace("parallel")
[17:26:45.948]                     if (exists("sendData", mode = "function", 
[17:26:45.948]                       envir = ns)) {
[17:26:45.948]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.948]                         envir = ns)
[17:26:45.948]                       envir <- sys.frame(frame)
[17:26:45.948]                       master <- NULL
[17:26:45.948]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.948]                         !identical(envir, emptyenv())) {
[17:26:45.948]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.948]                           inherits = FALSE)) {
[17:26:45.948]                           master <- get("master", mode = "list", 
[17:26:45.948]                             envir = envir, inherits = FALSE)
[17:26:45.948]                           if (inherits(master, c("SOCKnode", 
[17:26:45.948]                             "SOCK0node"))) {
[17:26:45.948]                             sendCondition <<- function(cond) {
[17:26:45.948]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.948]                                 success = TRUE)
[17:26:45.948]                               parallel_sendData(master, data)
[17:26:45.948]                             }
[17:26:45.948]                             return(sendCondition)
[17:26:45.948]                           }
[17:26:45.948]                         }
[17:26:45.948]                         frame <- frame + 1L
[17:26:45.948]                         envir <- sys.frame(frame)
[17:26:45.948]                       }
[17:26:45.948]                     }
[17:26:45.948]                     sendCondition <<- function(cond) NULL
[17:26:45.948]                   }
[17:26:45.948]                 })
[17:26:45.948]                 withCallingHandlers({
[17:26:45.948]                   2
[17:26:45.948]                 }, immediateCondition = function(cond) {
[17:26:45.948]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.948]                   sendCondition(cond)
[17:26:45.948]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.948]                   {
[17:26:45.948]                     inherits <- base::inherits
[17:26:45.948]                     invokeRestart <- base::invokeRestart
[17:26:45.948]                     is.null <- base::is.null
[17:26:45.948]                     muffled <- FALSE
[17:26:45.948]                     if (inherits(cond, "message")) {
[17:26:45.948]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.948]                       if (muffled) 
[17:26:45.948]                         invokeRestart("muffleMessage")
[17:26:45.948]                     }
[17:26:45.948]                     else if (inherits(cond, "warning")) {
[17:26:45.948]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.948]                       if (muffled) 
[17:26:45.948]                         invokeRestart("muffleWarning")
[17:26:45.948]                     }
[17:26:45.948]                     else if (inherits(cond, "condition")) {
[17:26:45.948]                       if (!is.null(pattern)) {
[17:26:45.948]                         computeRestarts <- base::computeRestarts
[17:26:45.948]                         grepl <- base::grepl
[17:26:45.948]                         restarts <- computeRestarts(cond)
[17:26:45.948]                         for (restart in restarts) {
[17:26:45.948]                           name <- restart$name
[17:26:45.948]                           if (is.null(name)) 
[17:26:45.948]                             next
[17:26:45.948]                           if (!grepl(pattern, name)) 
[17:26:45.948]                             next
[17:26:45.948]                           invokeRestart(restart)
[17:26:45.948]                           muffled <- TRUE
[17:26:45.948]                           break
[17:26:45.948]                         }
[17:26:45.948]                       }
[17:26:45.948]                     }
[17:26:45.948]                     invisible(muffled)
[17:26:45.948]                   }
[17:26:45.948]                   muffleCondition(cond)
[17:26:45.948]                 })
[17:26:45.948]             }))
[17:26:45.948]             future::FutureResult(value = ...future.value$value, 
[17:26:45.948]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.948]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.948]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.948]                     ...future.globalenv.names))
[17:26:45.948]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.948]         }, condition = base::local({
[17:26:45.948]             c <- base::c
[17:26:45.948]             inherits <- base::inherits
[17:26:45.948]             invokeRestart <- base::invokeRestart
[17:26:45.948]             length <- base::length
[17:26:45.948]             list <- base::list
[17:26:45.948]             seq.int <- base::seq.int
[17:26:45.948]             signalCondition <- base::signalCondition
[17:26:45.948]             sys.calls <- base::sys.calls
[17:26:45.948]             `[[` <- base::`[[`
[17:26:45.948]             `+` <- base::`+`
[17:26:45.948]             `<<-` <- base::`<<-`
[17:26:45.948]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.948]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.948]                   3L)]
[17:26:45.948]             }
[17:26:45.948]             function(cond) {
[17:26:45.948]                 is_error <- inherits(cond, "error")
[17:26:45.948]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.948]                   NULL)
[17:26:45.948]                 if (is_error) {
[17:26:45.948]                   sessionInformation <- function() {
[17:26:45.948]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.948]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.948]                       search = base::search(), system = base::Sys.info())
[17:26:45.948]                   }
[17:26:45.948]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.948]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.948]                     cond$call), session = sessionInformation(), 
[17:26:45.948]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.948]                   signalCondition(cond)
[17:26:45.948]                 }
[17:26:45.948]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.948]                 "immediateCondition"))) {
[17:26:45.948]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.948]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.948]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.948]                   if (TRUE && !signal) {
[17:26:45.948]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.948]                     {
[17:26:45.948]                       inherits <- base::inherits
[17:26:45.948]                       invokeRestart <- base::invokeRestart
[17:26:45.948]                       is.null <- base::is.null
[17:26:45.948]                       muffled <- FALSE
[17:26:45.948]                       if (inherits(cond, "message")) {
[17:26:45.948]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.948]                         if (muffled) 
[17:26:45.948]                           invokeRestart("muffleMessage")
[17:26:45.948]                       }
[17:26:45.948]                       else if (inherits(cond, "warning")) {
[17:26:45.948]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.948]                         if (muffled) 
[17:26:45.948]                           invokeRestart("muffleWarning")
[17:26:45.948]                       }
[17:26:45.948]                       else if (inherits(cond, "condition")) {
[17:26:45.948]                         if (!is.null(pattern)) {
[17:26:45.948]                           computeRestarts <- base::computeRestarts
[17:26:45.948]                           grepl <- base::grepl
[17:26:45.948]                           restarts <- computeRestarts(cond)
[17:26:45.948]                           for (restart in restarts) {
[17:26:45.948]                             name <- restart$name
[17:26:45.948]                             if (is.null(name)) 
[17:26:45.948]                               next
[17:26:45.948]                             if (!grepl(pattern, name)) 
[17:26:45.948]                               next
[17:26:45.948]                             invokeRestart(restart)
[17:26:45.948]                             muffled <- TRUE
[17:26:45.948]                             break
[17:26:45.948]                           }
[17:26:45.948]                         }
[17:26:45.948]                       }
[17:26:45.948]                       invisible(muffled)
[17:26:45.948]                     }
[17:26:45.948]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.948]                   }
[17:26:45.948]                 }
[17:26:45.948]                 else {
[17:26:45.948]                   if (TRUE) {
[17:26:45.948]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.948]                     {
[17:26:45.948]                       inherits <- base::inherits
[17:26:45.948]                       invokeRestart <- base::invokeRestart
[17:26:45.948]                       is.null <- base::is.null
[17:26:45.948]                       muffled <- FALSE
[17:26:45.948]                       if (inherits(cond, "message")) {
[17:26:45.948]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.948]                         if (muffled) 
[17:26:45.948]                           invokeRestart("muffleMessage")
[17:26:45.948]                       }
[17:26:45.948]                       else if (inherits(cond, "warning")) {
[17:26:45.948]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.948]                         if (muffled) 
[17:26:45.948]                           invokeRestart("muffleWarning")
[17:26:45.948]                       }
[17:26:45.948]                       else if (inherits(cond, "condition")) {
[17:26:45.948]                         if (!is.null(pattern)) {
[17:26:45.948]                           computeRestarts <- base::computeRestarts
[17:26:45.948]                           grepl <- base::grepl
[17:26:45.948]                           restarts <- computeRestarts(cond)
[17:26:45.948]                           for (restart in restarts) {
[17:26:45.948]                             name <- restart$name
[17:26:45.948]                             if (is.null(name)) 
[17:26:45.948]                               next
[17:26:45.948]                             if (!grepl(pattern, name)) 
[17:26:45.948]                               next
[17:26:45.948]                             invokeRestart(restart)
[17:26:45.948]                             muffled <- TRUE
[17:26:45.948]                             break
[17:26:45.948]                           }
[17:26:45.948]                         }
[17:26:45.948]                       }
[17:26:45.948]                       invisible(muffled)
[17:26:45.948]                     }
[17:26:45.948]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.948]                   }
[17:26:45.948]                 }
[17:26:45.948]             }
[17:26:45.948]         }))
[17:26:45.948]     }, error = function(ex) {
[17:26:45.948]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.948]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.948]                 ...future.rng), started = ...future.startTime, 
[17:26:45.948]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.948]             version = "1.8"), class = "FutureResult")
[17:26:45.948]     }, finally = {
[17:26:45.948]         if (!identical(...future.workdir, getwd())) 
[17:26:45.948]             setwd(...future.workdir)
[17:26:45.948]         {
[17:26:45.948]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.948]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.948]             }
[17:26:45.948]             base::options(...future.oldOptions)
[17:26:45.948]             if (.Platform$OS.type == "windows") {
[17:26:45.948]                 old_names <- names(...future.oldEnvVars)
[17:26:45.948]                 envs <- base::Sys.getenv()
[17:26:45.948]                 names <- names(envs)
[17:26:45.948]                 common <- intersect(names, old_names)
[17:26:45.948]                 added <- setdiff(names, old_names)
[17:26:45.948]                 removed <- setdiff(old_names, names)
[17:26:45.948]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.948]                   envs[common]]
[17:26:45.948]                 NAMES <- toupper(changed)
[17:26:45.948]                 args <- list()
[17:26:45.948]                 for (kk in seq_along(NAMES)) {
[17:26:45.948]                   name <- changed[[kk]]
[17:26:45.948]                   NAME <- NAMES[[kk]]
[17:26:45.948]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.948]                     next
[17:26:45.948]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.948]                 }
[17:26:45.948]                 NAMES <- toupper(added)
[17:26:45.948]                 for (kk in seq_along(NAMES)) {
[17:26:45.948]                   name <- added[[kk]]
[17:26:45.948]                   NAME <- NAMES[[kk]]
[17:26:45.948]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.948]                     next
[17:26:45.948]                   args[[name]] <- ""
[17:26:45.948]                 }
[17:26:45.948]                 NAMES <- toupper(removed)
[17:26:45.948]                 for (kk in seq_along(NAMES)) {
[17:26:45.948]                   name <- removed[[kk]]
[17:26:45.948]                   NAME <- NAMES[[kk]]
[17:26:45.948]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.948]                     next
[17:26:45.948]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.948]                 }
[17:26:45.948]                 if (length(args) > 0) 
[17:26:45.948]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.948]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.948]             }
[17:26:45.948]             else {
[17:26:45.948]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.948]             }
[17:26:45.948]             {
[17:26:45.948]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.948]                   0L) {
[17:26:45.948]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.948]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.948]                   base::options(opts)
[17:26:45.948]                 }
[17:26:45.948]                 {
[17:26:45.948]                   {
[17:26:45.948]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.948]                     NULL
[17:26:45.948]                   }
[17:26:45.948]                   options(future.plan = NULL)
[17:26:45.948]                   if (is.na(NA_character_)) 
[17:26:45.948]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.948]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.948]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.948]                     .init = FALSE)
[17:26:45.948]                 }
[17:26:45.948]             }
[17:26:45.948]         }
[17:26:45.948]     })
[17:26:45.948]     if (TRUE) {
[17:26:45.948]         base::sink(type = "output", split = FALSE)
[17:26:45.948]         if (TRUE) {
[17:26:45.948]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.948]         }
[17:26:45.948]         else {
[17:26:45.948]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.948]         }
[17:26:45.948]         base::close(...future.stdout)
[17:26:45.948]         ...future.stdout <- NULL
[17:26:45.948]     }
[17:26:45.948]     ...future.result$conditions <- ...future.conditions
[17:26:45.948]     ...future.result$finished <- base::Sys.time()
[17:26:45.948]     ...future.result
[17:26:45.948] }
[17:26:45.954] MultisessionFuture started
[17:26:45.954] - Launch lazy future ... done
[17:26:45.954] run() for 'MultisessionFuture' ... done
[17:26:45.954] getGlobalsAndPackages() ...
[17:26:45.955] Searching for globals...
[17:26:45.955] 
[17:26:45.955] Searching for globals ... DONE
[17:26:45.956] - globals: [0] <none>
[17:26:45.956] getGlobalsAndPackages() ... DONE
[17:26:45.956] run() for 'Future' ...
[17:26:45.956] - state: 'created'
[17:26:45.956] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:45.972] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:45.972] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:45.972]   - Field: 'node'
[17:26:45.973]   - Field: 'label'
[17:26:45.973]   - Field: 'local'
[17:26:45.973]   - Field: 'owner'
[17:26:45.973]   - Field: 'envir'
[17:26:45.973]   - Field: 'workers'
[17:26:45.974]   - Field: 'packages'
[17:26:45.974]   - Field: 'gc'
[17:26:45.974]   - Field: 'conditions'
[17:26:45.974]   - Field: 'persistent'
[17:26:45.974]   - Field: 'expr'
[17:26:45.975]   - Field: 'uuid'
[17:26:45.975]   - Field: 'seed'
[17:26:45.975]   - Field: 'version'
[17:26:45.975]   - Field: 'result'
[17:26:45.975]   - Field: 'asynchronous'
[17:26:45.975]   - Field: 'calls'
[17:26:45.976]   - Field: 'globals'
[17:26:45.976]   - Field: 'stdout'
[17:26:45.976]   - Field: 'earlySignal'
[17:26:45.976]   - Field: 'lazy'
[17:26:45.976]   - Field: 'state'
[17:26:45.977] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:45.977] - Launch lazy future ...
[17:26:45.977] Packages needed by the future expression (n = 0): <none>
[17:26:45.977] Packages needed by future strategies (n = 0): <none>
[17:26:45.978] {
[17:26:45.978]     {
[17:26:45.978]         {
[17:26:45.978]             ...future.startTime <- base::Sys.time()
[17:26:45.978]             {
[17:26:45.978]                 {
[17:26:45.978]                   {
[17:26:45.978]                     {
[17:26:45.978]                       base::local({
[17:26:45.978]                         has_future <- base::requireNamespace("future", 
[17:26:45.978]                           quietly = TRUE)
[17:26:45.978]                         if (has_future) {
[17:26:45.978]                           ns <- base::getNamespace("future")
[17:26:45.978]                           version <- ns[[".package"]][["version"]]
[17:26:45.978]                           if (is.null(version)) 
[17:26:45.978]                             version <- utils::packageVersion("future")
[17:26:45.978]                         }
[17:26:45.978]                         else {
[17:26:45.978]                           version <- NULL
[17:26:45.978]                         }
[17:26:45.978]                         if (!has_future || version < "1.8.0") {
[17:26:45.978]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:45.978]                             "", base::R.version$version.string), 
[17:26:45.978]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:45.978]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:45.978]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:45.978]                               "release", "version")], collapse = " "), 
[17:26:45.978]                             hostname = base::Sys.info()[["nodename"]])
[17:26:45.978]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:45.978]                             info)
[17:26:45.978]                           info <- base::paste(info, collapse = "; ")
[17:26:45.978]                           if (!has_future) {
[17:26:45.978]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:45.978]                               info)
[17:26:45.978]                           }
[17:26:45.978]                           else {
[17:26:45.978]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:45.978]                               info, version)
[17:26:45.978]                           }
[17:26:45.978]                           base::stop(msg)
[17:26:45.978]                         }
[17:26:45.978]                       })
[17:26:45.978]                     }
[17:26:45.978]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:45.978]                     base::options(mc.cores = 1L)
[17:26:45.978]                   }
[17:26:45.978]                   ...future.strategy.old <- future::plan("list")
[17:26:45.978]                   options(future.plan = NULL)
[17:26:45.978]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.978]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:45.978]                 }
[17:26:45.978]                 ...future.workdir <- getwd()
[17:26:45.978]             }
[17:26:45.978]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:45.978]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:45.978]         }
[17:26:45.978]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:45.978]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:45.978]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:45.978]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:45.978]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:45.978]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:45.978]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:45.978]             base::names(...future.oldOptions))
[17:26:45.978]     }
[17:26:45.978]     if (FALSE) {
[17:26:45.978]     }
[17:26:45.978]     else {
[17:26:45.978]         if (TRUE) {
[17:26:45.978]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:45.978]                 open = "w")
[17:26:45.978]         }
[17:26:45.978]         else {
[17:26:45.978]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:45.978]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:45.978]         }
[17:26:45.978]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:45.978]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:45.978]             base::sink(type = "output", split = FALSE)
[17:26:45.978]             base::close(...future.stdout)
[17:26:45.978]         }, add = TRUE)
[17:26:45.978]     }
[17:26:45.978]     ...future.frame <- base::sys.nframe()
[17:26:45.978]     ...future.conditions <- base::list()
[17:26:45.978]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:45.978]     if (FALSE) {
[17:26:45.978]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:45.978]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:45.978]     }
[17:26:45.978]     ...future.result <- base::tryCatch({
[17:26:45.978]         base::withCallingHandlers({
[17:26:45.978]             ...future.value <- base::withVisible(base::local({
[17:26:45.978]                 ...future.makeSendCondition <- base::local({
[17:26:45.978]                   sendCondition <- NULL
[17:26:45.978]                   function(frame = 1L) {
[17:26:45.978]                     if (is.function(sendCondition)) 
[17:26:45.978]                       return(sendCondition)
[17:26:45.978]                     ns <- getNamespace("parallel")
[17:26:45.978]                     if (exists("sendData", mode = "function", 
[17:26:45.978]                       envir = ns)) {
[17:26:45.978]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:45.978]                         envir = ns)
[17:26:45.978]                       envir <- sys.frame(frame)
[17:26:45.978]                       master <- NULL
[17:26:45.978]                       while (!identical(envir, .GlobalEnv) && 
[17:26:45.978]                         !identical(envir, emptyenv())) {
[17:26:45.978]                         if (exists("master", mode = "list", envir = envir, 
[17:26:45.978]                           inherits = FALSE)) {
[17:26:45.978]                           master <- get("master", mode = "list", 
[17:26:45.978]                             envir = envir, inherits = FALSE)
[17:26:45.978]                           if (inherits(master, c("SOCKnode", 
[17:26:45.978]                             "SOCK0node"))) {
[17:26:45.978]                             sendCondition <<- function(cond) {
[17:26:45.978]                               data <- list(type = "VALUE", value = cond, 
[17:26:45.978]                                 success = TRUE)
[17:26:45.978]                               parallel_sendData(master, data)
[17:26:45.978]                             }
[17:26:45.978]                             return(sendCondition)
[17:26:45.978]                           }
[17:26:45.978]                         }
[17:26:45.978]                         frame <- frame + 1L
[17:26:45.978]                         envir <- sys.frame(frame)
[17:26:45.978]                       }
[17:26:45.978]                     }
[17:26:45.978]                     sendCondition <<- function(cond) NULL
[17:26:45.978]                   }
[17:26:45.978]                 })
[17:26:45.978]                 withCallingHandlers({
[17:26:45.978]                   NULL
[17:26:45.978]                 }, immediateCondition = function(cond) {
[17:26:45.978]                   sendCondition <- ...future.makeSendCondition()
[17:26:45.978]                   sendCondition(cond)
[17:26:45.978]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.978]                   {
[17:26:45.978]                     inherits <- base::inherits
[17:26:45.978]                     invokeRestart <- base::invokeRestart
[17:26:45.978]                     is.null <- base::is.null
[17:26:45.978]                     muffled <- FALSE
[17:26:45.978]                     if (inherits(cond, "message")) {
[17:26:45.978]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:45.978]                       if (muffled) 
[17:26:45.978]                         invokeRestart("muffleMessage")
[17:26:45.978]                     }
[17:26:45.978]                     else if (inherits(cond, "warning")) {
[17:26:45.978]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:45.978]                       if (muffled) 
[17:26:45.978]                         invokeRestart("muffleWarning")
[17:26:45.978]                     }
[17:26:45.978]                     else if (inherits(cond, "condition")) {
[17:26:45.978]                       if (!is.null(pattern)) {
[17:26:45.978]                         computeRestarts <- base::computeRestarts
[17:26:45.978]                         grepl <- base::grepl
[17:26:45.978]                         restarts <- computeRestarts(cond)
[17:26:45.978]                         for (restart in restarts) {
[17:26:45.978]                           name <- restart$name
[17:26:45.978]                           if (is.null(name)) 
[17:26:45.978]                             next
[17:26:45.978]                           if (!grepl(pattern, name)) 
[17:26:45.978]                             next
[17:26:45.978]                           invokeRestart(restart)
[17:26:45.978]                           muffled <- TRUE
[17:26:45.978]                           break
[17:26:45.978]                         }
[17:26:45.978]                       }
[17:26:45.978]                     }
[17:26:45.978]                     invisible(muffled)
[17:26:45.978]                   }
[17:26:45.978]                   muffleCondition(cond)
[17:26:45.978]                 })
[17:26:45.978]             }))
[17:26:45.978]             future::FutureResult(value = ...future.value$value, 
[17:26:45.978]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.978]                   ...future.rng), globalenv = if (FALSE) 
[17:26:45.978]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:45.978]                     ...future.globalenv.names))
[17:26:45.978]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:45.978]         }, condition = base::local({
[17:26:45.978]             c <- base::c
[17:26:45.978]             inherits <- base::inherits
[17:26:45.978]             invokeRestart <- base::invokeRestart
[17:26:45.978]             length <- base::length
[17:26:45.978]             list <- base::list
[17:26:45.978]             seq.int <- base::seq.int
[17:26:45.978]             signalCondition <- base::signalCondition
[17:26:45.978]             sys.calls <- base::sys.calls
[17:26:45.978]             `[[` <- base::`[[`
[17:26:45.978]             `+` <- base::`+`
[17:26:45.978]             `<<-` <- base::`<<-`
[17:26:45.978]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:45.978]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:45.978]                   3L)]
[17:26:45.978]             }
[17:26:45.978]             function(cond) {
[17:26:45.978]                 is_error <- inherits(cond, "error")
[17:26:45.978]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:45.978]                   NULL)
[17:26:45.978]                 if (is_error) {
[17:26:45.978]                   sessionInformation <- function() {
[17:26:45.978]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:45.978]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:45.978]                       search = base::search(), system = base::Sys.info())
[17:26:45.978]                   }
[17:26:45.978]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.978]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:45.978]                     cond$call), session = sessionInformation(), 
[17:26:45.978]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:45.978]                   signalCondition(cond)
[17:26:45.978]                 }
[17:26:45.978]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:45.978]                 "immediateCondition"))) {
[17:26:45.978]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:45.978]                   ...future.conditions[[length(...future.conditions) + 
[17:26:45.978]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:45.978]                   if (TRUE && !signal) {
[17:26:45.978]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.978]                     {
[17:26:45.978]                       inherits <- base::inherits
[17:26:45.978]                       invokeRestart <- base::invokeRestart
[17:26:45.978]                       is.null <- base::is.null
[17:26:45.978]                       muffled <- FALSE
[17:26:45.978]                       if (inherits(cond, "message")) {
[17:26:45.978]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.978]                         if (muffled) 
[17:26:45.978]                           invokeRestart("muffleMessage")
[17:26:45.978]                       }
[17:26:45.978]                       else if (inherits(cond, "warning")) {
[17:26:45.978]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.978]                         if (muffled) 
[17:26:45.978]                           invokeRestart("muffleWarning")
[17:26:45.978]                       }
[17:26:45.978]                       else if (inherits(cond, "condition")) {
[17:26:45.978]                         if (!is.null(pattern)) {
[17:26:45.978]                           computeRestarts <- base::computeRestarts
[17:26:45.978]                           grepl <- base::grepl
[17:26:45.978]                           restarts <- computeRestarts(cond)
[17:26:45.978]                           for (restart in restarts) {
[17:26:45.978]                             name <- restart$name
[17:26:45.978]                             if (is.null(name)) 
[17:26:45.978]                               next
[17:26:45.978]                             if (!grepl(pattern, name)) 
[17:26:45.978]                               next
[17:26:45.978]                             invokeRestart(restart)
[17:26:45.978]                             muffled <- TRUE
[17:26:45.978]                             break
[17:26:45.978]                           }
[17:26:45.978]                         }
[17:26:45.978]                       }
[17:26:45.978]                       invisible(muffled)
[17:26:45.978]                     }
[17:26:45.978]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.978]                   }
[17:26:45.978]                 }
[17:26:45.978]                 else {
[17:26:45.978]                   if (TRUE) {
[17:26:45.978]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:45.978]                     {
[17:26:45.978]                       inherits <- base::inherits
[17:26:45.978]                       invokeRestart <- base::invokeRestart
[17:26:45.978]                       is.null <- base::is.null
[17:26:45.978]                       muffled <- FALSE
[17:26:45.978]                       if (inherits(cond, "message")) {
[17:26:45.978]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:45.978]                         if (muffled) 
[17:26:45.978]                           invokeRestart("muffleMessage")
[17:26:45.978]                       }
[17:26:45.978]                       else if (inherits(cond, "warning")) {
[17:26:45.978]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:45.978]                         if (muffled) 
[17:26:45.978]                           invokeRestart("muffleWarning")
[17:26:45.978]                       }
[17:26:45.978]                       else if (inherits(cond, "condition")) {
[17:26:45.978]                         if (!is.null(pattern)) {
[17:26:45.978]                           computeRestarts <- base::computeRestarts
[17:26:45.978]                           grepl <- base::grepl
[17:26:45.978]                           restarts <- computeRestarts(cond)
[17:26:45.978]                           for (restart in restarts) {
[17:26:45.978]                             name <- restart$name
[17:26:45.978]                             if (is.null(name)) 
[17:26:45.978]                               next
[17:26:45.978]                             if (!grepl(pattern, name)) 
[17:26:45.978]                               next
[17:26:45.978]                             invokeRestart(restart)
[17:26:45.978]                             muffled <- TRUE
[17:26:45.978]                             break
[17:26:45.978]                           }
[17:26:45.978]                         }
[17:26:45.978]                       }
[17:26:45.978]                       invisible(muffled)
[17:26:45.978]                     }
[17:26:45.978]                     muffleCondition(cond, pattern = "^muffle")
[17:26:45.978]                   }
[17:26:45.978]                 }
[17:26:45.978]             }
[17:26:45.978]         }))
[17:26:45.978]     }, error = function(ex) {
[17:26:45.978]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:45.978]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:45.978]                 ...future.rng), started = ...future.startTime, 
[17:26:45.978]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:45.978]             version = "1.8"), class = "FutureResult")
[17:26:45.978]     }, finally = {
[17:26:45.978]         if (!identical(...future.workdir, getwd())) 
[17:26:45.978]             setwd(...future.workdir)
[17:26:45.978]         {
[17:26:45.978]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:45.978]                 ...future.oldOptions$nwarnings <- NULL
[17:26:45.978]             }
[17:26:45.978]             base::options(...future.oldOptions)
[17:26:45.978]             if (.Platform$OS.type == "windows") {
[17:26:45.978]                 old_names <- names(...future.oldEnvVars)
[17:26:45.978]                 envs <- base::Sys.getenv()
[17:26:45.978]                 names <- names(envs)
[17:26:45.978]                 common <- intersect(names, old_names)
[17:26:45.978]                 added <- setdiff(names, old_names)
[17:26:45.978]                 removed <- setdiff(old_names, names)
[17:26:45.978]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:45.978]                   envs[common]]
[17:26:45.978]                 NAMES <- toupper(changed)
[17:26:45.978]                 args <- list()
[17:26:45.978]                 for (kk in seq_along(NAMES)) {
[17:26:45.978]                   name <- changed[[kk]]
[17:26:45.978]                   NAME <- NAMES[[kk]]
[17:26:45.978]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.978]                     next
[17:26:45.978]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.978]                 }
[17:26:45.978]                 NAMES <- toupper(added)
[17:26:45.978]                 for (kk in seq_along(NAMES)) {
[17:26:45.978]                   name <- added[[kk]]
[17:26:45.978]                   NAME <- NAMES[[kk]]
[17:26:45.978]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.978]                     next
[17:26:45.978]                   args[[name]] <- ""
[17:26:45.978]                 }
[17:26:45.978]                 NAMES <- toupper(removed)
[17:26:45.978]                 for (kk in seq_along(NAMES)) {
[17:26:45.978]                   name <- removed[[kk]]
[17:26:45.978]                   NAME <- NAMES[[kk]]
[17:26:45.978]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:45.978]                     next
[17:26:45.978]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:45.978]                 }
[17:26:45.978]                 if (length(args) > 0) 
[17:26:45.978]                   base::do.call(base::Sys.setenv, args = args)
[17:26:45.978]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:45.978]             }
[17:26:45.978]             else {
[17:26:45.978]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:45.978]             }
[17:26:45.978]             {
[17:26:45.978]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:45.978]                   0L) {
[17:26:45.978]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:45.978]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:45.978]                   base::options(opts)
[17:26:45.978]                 }
[17:26:45.978]                 {
[17:26:45.978]                   {
[17:26:45.978]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:45.978]                     NULL
[17:26:45.978]                   }
[17:26:45.978]                   options(future.plan = NULL)
[17:26:45.978]                   if (is.na(NA_character_)) 
[17:26:45.978]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:45.978]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:45.978]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:45.978]                     .init = FALSE)
[17:26:45.978]                 }
[17:26:45.978]             }
[17:26:45.978]         }
[17:26:45.978]     })
[17:26:45.978]     if (TRUE) {
[17:26:45.978]         base::sink(type = "output", split = FALSE)
[17:26:45.978]         if (TRUE) {
[17:26:45.978]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:45.978]         }
[17:26:45.978]         else {
[17:26:45.978]             ...future.result["stdout"] <- base::list(NULL)
[17:26:45.978]         }
[17:26:45.978]         base::close(...future.stdout)
[17:26:45.978]         ...future.stdout <- NULL
[17:26:45.978]     }
[17:26:45.978]     ...future.result$conditions <- ...future.conditions
[17:26:45.978]     ...future.result$finished <- base::Sys.time()
[17:26:45.978]     ...future.result
[17:26:45.978] }
[17:26:45.983] MultisessionFuture started
[17:26:45.984] - Launch lazy future ... done
[17:26:45.984] run() for 'MultisessionFuture' ... done
[17:26:45.984] getGlobalsAndPackages() ...
[17:26:45.984] Searching for globals...
[17:26:45.985] - globals found: [1] '{'
[17:26:45.985] Searching for globals ... DONE
[17:26:45.986] Resolving globals: FALSE
[17:26:45.986] 
[17:26:45.986] 
[17:26:45.986] getGlobalsAndPackages() ... DONE
[17:26:45.987] run() for 'Future' ...
[17:26:45.987] - state: 'created'
[17:26:45.987] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.001] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.001] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.001]   - Field: 'node'
[17:26:46.001]   - Field: 'label'
[17:26:46.001]   - Field: 'local'
[17:26:46.002]   - Field: 'owner'
[17:26:46.002]   - Field: 'envir'
[17:26:46.002]   - Field: 'workers'
[17:26:46.002]   - Field: 'packages'
[17:26:46.002]   - Field: 'gc'
[17:26:46.002]   - Field: 'conditions'
[17:26:46.003]   - Field: 'persistent'
[17:26:46.003]   - Field: 'expr'
[17:26:46.003]   - Field: 'uuid'
[17:26:46.003]   - Field: 'seed'
[17:26:46.003]   - Field: 'version'
[17:26:46.004]   - Field: 'result'
[17:26:46.004]   - Field: 'asynchronous'
[17:26:46.004]   - Field: 'calls'
[17:26:46.004]   - Field: 'globals'
[17:26:46.004]   - Field: 'stdout'
[17:26:46.004]   - Field: 'earlySignal'
[17:26:46.005]   - Field: 'lazy'
[17:26:46.005]   - Field: 'state'
[17:26:46.005] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.005] - Launch lazy future ...
[17:26:46.006] Packages needed by the future expression (n = 0): <none>
[17:26:46.006] Packages needed by future strategies (n = 0): <none>
[17:26:46.006] {
[17:26:46.006]     {
[17:26:46.006]         {
[17:26:46.006]             ...future.startTime <- base::Sys.time()
[17:26:46.006]             {
[17:26:46.006]                 {
[17:26:46.006]                   {
[17:26:46.006]                     {
[17:26:46.006]                       base::local({
[17:26:46.006]                         has_future <- base::requireNamespace("future", 
[17:26:46.006]                           quietly = TRUE)
[17:26:46.006]                         if (has_future) {
[17:26:46.006]                           ns <- base::getNamespace("future")
[17:26:46.006]                           version <- ns[[".package"]][["version"]]
[17:26:46.006]                           if (is.null(version)) 
[17:26:46.006]                             version <- utils::packageVersion("future")
[17:26:46.006]                         }
[17:26:46.006]                         else {
[17:26:46.006]                           version <- NULL
[17:26:46.006]                         }
[17:26:46.006]                         if (!has_future || version < "1.8.0") {
[17:26:46.006]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.006]                             "", base::R.version$version.string), 
[17:26:46.006]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.006]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.006]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.006]                               "release", "version")], collapse = " "), 
[17:26:46.006]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.006]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.006]                             info)
[17:26:46.006]                           info <- base::paste(info, collapse = "; ")
[17:26:46.006]                           if (!has_future) {
[17:26:46.006]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.006]                               info)
[17:26:46.006]                           }
[17:26:46.006]                           else {
[17:26:46.006]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.006]                               info, version)
[17:26:46.006]                           }
[17:26:46.006]                           base::stop(msg)
[17:26:46.006]                         }
[17:26:46.006]                       })
[17:26:46.006]                     }
[17:26:46.006]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.006]                     base::options(mc.cores = 1L)
[17:26:46.006]                   }
[17:26:46.006]                   ...future.strategy.old <- future::plan("list")
[17:26:46.006]                   options(future.plan = NULL)
[17:26:46.006]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.006]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.006]                 }
[17:26:46.006]                 ...future.workdir <- getwd()
[17:26:46.006]             }
[17:26:46.006]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.006]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.006]         }
[17:26:46.006]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.006]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.006]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.006]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.006]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.006]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.006]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.006]             base::names(...future.oldOptions))
[17:26:46.006]     }
[17:26:46.006]     if (FALSE) {
[17:26:46.006]     }
[17:26:46.006]     else {
[17:26:46.006]         if (TRUE) {
[17:26:46.006]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.006]                 open = "w")
[17:26:46.006]         }
[17:26:46.006]         else {
[17:26:46.006]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.006]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.006]         }
[17:26:46.006]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.006]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.006]             base::sink(type = "output", split = FALSE)
[17:26:46.006]             base::close(...future.stdout)
[17:26:46.006]         }, add = TRUE)
[17:26:46.006]     }
[17:26:46.006]     ...future.frame <- base::sys.nframe()
[17:26:46.006]     ...future.conditions <- base::list()
[17:26:46.006]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.006]     if (FALSE) {
[17:26:46.006]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.006]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.006]     }
[17:26:46.006]     ...future.result <- base::tryCatch({
[17:26:46.006]         base::withCallingHandlers({
[17:26:46.006]             ...future.value <- base::withVisible(base::local({
[17:26:46.006]                 ...future.makeSendCondition <- base::local({
[17:26:46.006]                   sendCondition <- NULL
[17:26:46.006]                   function(frame = 1L) {
[17:26:46.006]                     if (is.function(sendCondition)) 
[17:26:46.006]                       return(sendCondition)
[17:26:46.006]                     ns <- getNamespace("parallel")
[17:26:46.006]                     if (exists("sendData", mode = "function", 
[17:26:46.006]                       envir = ns)) {
[17:26:46.006]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.006]                         envir = ns)
[17:26:46.006]                       envir <- sys.frame(frame)
[17:26:46.006]                       master <- NULL
[17:26:46.006]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.006]                         !identical(envir, emptyenv())) {
[17:26:46.006]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.006]                           inherits = FALSE)) {
[17:26:46.006]                           master <- get("master", mode = "list", 
[17:26:46.006]                             envir = envir, inherits = FALSE)
[17:26:46.006]                           if (inherits(master, c("SOCKnode", 
[17:26:46.006]                             "SOCK0node"))) {
[17:26:46.006]                             sendCondition <<- function(cond) {
[17:26:46.006]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.006]                                 success = TRUE)
[17:26:46.006]                               parallel_sendData(master, data)
[17:26:46.006]                             }
[17:26:46.006]                             return(sendCondition)
[17:26:46.006]                           }
[17:26:46.006]                         }
[17:26:46.006]                         frame <- frame + 1L
[17:26:46.006]                         envir <- sys.frame(frame)
[17:26:46.006]                       }
[17:26:46.006]                     }
[17:26:46.006]                     sendCondition <<- function(cond) NULL
[17:26:46.006]                   }
[17:26:46.006]                 })
[17:26:46.006]                 withCallingHandlers({
[17:26:46.006]                   {
[17:26:46.006]                     4
[17:26:46.006]                   }
[17:26:46.006]                 }, immediateCondition = function(cond) {
[17:26:46.006]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.006]                   sendCondition(cond)
[17:26:46.006]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.006]                   {
[17:26:46.006]                     inherits <- base::inherits
[17:26:46.006]                     invokeRestart <- base::invokeRestart
[17:26:46.006]                     is.null <- base::is.null
[17:26:46.006]                     muffled <- FALSE
[17:26:46.006]                     if (inherits(cond, "message")) {
[17:26:46.006]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.006]                       if (muffled) 
[17:26:46.006]                         invokeRestart("muffleMessage")
[17:26:46.006]                     }
[17:26:46.006]                     else if (inherits(cond, "warning")) {
[17:26:46.006]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.006]                       if (muffled) 
[17:26:46.006]                         invokeRestart("muffleWarning")
[17:26:46.006]                     }
[17:26:46.006]                     else if (inherits(cond, "condition")) {
[17:26:46.006]                       if (!is.null(pattern)) {
[17:26:46.006]                         computeRestarts <- base::computeRestarts
[17:26:46.006]                         grepl <- base::grepl
[17:26:46.006]                         restarts <- computeRestarts(cond)
[17:26:46.006]                         for (restart in restarts) {
[17:26:46.006]                           name <- restart$name
[17:26:46.006]                           if (is.null(name)) 
[17:26:46.006]                             next
[17:26:46.006]                           if (!grepl(pattern, name)) 
[17:26:46.006]                             next
[17:26:46.006]                           invokeRestart(restart)
[17:26:46.006]                           muffled <- TRUE
[17:26:46.006]                           break
[17:26:46.006]                         }
[17:26:46.006]                       }
[17:26:46.006]                     }
[17:26:46.006]                     invisible(muffled)
[17:26:46.006]                   }
[17:26:46.006]                   muffleCondition(cond)
[17:26:46.006]                 })
[17:26:46.006]             }))
[17:26:46.006]             future::FutureResult(value = ...future.value$value, 
[17:26:46.006]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.006]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.006]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.006]                     ...future.globalenv.names))
[17:26:46.006]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.006]         }, condition = base::local({
[17:26:46.006]             c <- base::c
[17:26:46.006]             inherits <- base::inherits
[17:26:46.006]             invokeRestart <- base::invokeRestart
[17:26:46.006]             length <- base::length
[17:26:46.006]             list <- base::list
[17:26:46.006]             seq.int <- base::seq.int
[17:26:46.006]             signalCondition <- base::signalCondition
[17:26:46.006]             sys.calls <- base::sys.calls
[17:26:46.006]             `[[` <- base::`[[`
[17:26:46.006]             `+` <- base::`+`
[17:26:46.006]             `<<-` <- base::`<<-`
[17:26:46.006]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.006]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.006]                   3L)]
[17:26:46.006]             }
[17:26:46.006]             function(cond) {
[17:26:46.006]                 is_error <- inherits(cond, "error")
[17:26:46.006]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.006]                   NULL)
[17:26:46.006]                 if (is_error) {
[17:26:46.006]                   sessionInformation <- function() {
[17:26:46.006]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.006]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.006]                       search = base::search(), system = base::Sys.info())
[17:26:46.006]                   }
[17:26:46.006]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.006]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.006]                     cond$call), session = sessionInformation(), 
[17:26:46.006]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.006]                   signalCondition(cond)
[17:26:46.006]                 }
[17:26:46.006]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.006]                 "immediateCondition"))) {
[17:26:46.006]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.006]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.006]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.006]                   if (TRUE && !signal) {
[17:26:46.006]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.006]                     {
[17:26:46.006]                       inherits <- base::inherits
[17:26:46.006]                       invokeRestart <- base::invokeRestart
[17:26:46.006]                       is.null <- base::is.null
[17:26:46.006]                       muffled <- FALSE
[17:26:46.006]                       if (inherits(cond, "message")) {
[17:26:46.006]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.006]                         if (muffled) 
[17:26:46.006]                           invokeRestart("muffleMessage")
[17:26:46.006]                       }
[17:26:46.006]                       else if (inherits(cond, "warning")) {
[17:26:46.006]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.006]                         if (muffled) 
[17:26:46.006]                           invokeRestart("muffleWarning")
[17:26:46.006]                       }
[17:26:46.006]                       else if (inherits(cond, "condition")) {
[17:26:46.006]                         if (!is.null(pattern)) {
[17:26:46.006]                           computeRestarts <- base::computeRestarts
[17:26:46.006]                           grepl <- base::grepl
[17:26:46.006]                           restarts <- computeRestarts(cond)
[17:26:46.006]                           for (restart in restarts) {
[17:26:46.006]                             name <- restart$name
[17:26:46.006]                             if (is.null(name)) 
[17:26:46.006]                               next
[17:26:46.006]                             if (!grepl(pattern, name)) 
[17:26:46.006]                               next
[17:26:46.006]                             invokeRestart(restart)
[17:26:46.006]                             muffled <- TRUE
[17:26:46.006]                             break
[17:26:46.006]                           }
[17:26:46.006]                         }
[17:26:46.006]                       }
[17:26:46.006]                       invisible(muffled)
[17:26:46.006]                     }
[17:26:46.006]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.006]                   }
[17:26:46.006]                 }
[17:26:46.006]                 else {
[17:26:46.006]                   if (TRUE) {
[17:26:46.006]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.006]                     {
[17:26:46.006]                       inherits <- base::inherits
[17:26:46.006]                       invokeRestart <- base::invokeRestart
[17:26:46.006]                       is.null <- base::is.null
[17:26:46.006]                       muffled <- FALSE
[17:26:46.006]                       if (inherits(cond, "message")) {
[17:26:46.006]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.006]                         if (muffled) 
[17:26:46.006]                           invokeRestart("muffleMessage")
[17:26:46.006]                       }
[17:26:46.006]                       else if (inherits(cond, "warning")) {
[17:26:46.006]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.006]                         if (muffled) 
[17:26:46.006]                           invokeRestart("muffleWarning")
[17:26:46.006]                       }
[17:26:46.006]                       else if (inherits(cond, "condition")) {
[17:26:46.006]                         if (!is.null(pattern)) {
[17:26:46.006]                           computeRestarts <- base::computeRestarts
[17:26:46.006]                           grepl <- base::grepl
[17:26:46.006]                           restarts <- computeRestarts(cond)
[17:26:46.006]                           for (restart in restarts) {
[17:26:46.006]                             name <- restart$name
[17:26:46.006]                             if (is.null(name)) 
[17:26:46.006]                               next
[17:26:46.006]                             if (!grepl(pattern, name)) 
[17:26:46.006]                               next
[17:26:46.006]                             invokeRestart(restart)
[17:26:46.006]                             muffled <- TRUE
[17:26:46.006]                             break
[17:26:46.006]                           }
[17:26:46.006]                         }
[17:26:46.006]                       }
[17:26:46.006]                       invisible(muffled)
[17:26:46.006]                     }
[17:26:46.006]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.006]                   }
[17:26:46.006]                 }
[17:26:46.006]             }
[17:26:46.006]         }))
[17:26:46.006]     }, error = function(ex) {
[17:26:46.006]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.006]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.006]                 ...future.rng), started = ...future.startTime, 
[17:26:46.006]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.006]             version = "1.8"), class = "FutureResult")
[17:26:46.006]     }, finally = {
[17:26:46.006]         if (!identical(...future.workdir, getwd())) 
[17:26:46.006]             setwd(...future.workdir)
[17:26:46.006]         {
[17:26:46.006]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.006]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.006]             }
[17:26:46.006]             base::options(...future.oldOptions)
[17:26:46.006]             if (.Platform$OS.type == "windows") {
[17:26:46.006]                 old_names <- names(...future.oldEnvVars)
[17:26:46.006]                 envs <- base::Sys.getenv()
[17:26:46.006]                 names <- names(envs)
[17:26:46.006]                 common <- intersect(names, old_names)
[17:26:46.006]                 added <- setdiff(names, old_names)
[17:26:46.006]                 removed <- setdiff(old_names, names)
[17:26:46.006]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.006]                   envs[common]]
[17:26:46.006]                 NAMES <- toupper(changed)
[17:26:46.006]                 args <- list()
[17:26:46.006]                 for (kk in seq_along(NAMES)) {
[17:26:46.006]                   name <- changed[[kk]]
[17:26:46.006]                   NAME <- NAMES[[kk]]
[17:26:46.006]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.006]                     next
[17:26:46.006]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.006]                 }
[17:26:46.006]                 NAMES <- toupper(added)
[17:26:46.006]                 for (kk in seq_along(NAMES)) {
[17:26:46.006]                   name <- added[[kk]]
[17:26:46.006]                   NAME <- NAMES[[kk]]
[17:26:46.006]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.006]                     next
[17:26:46.006]                   args[[name]] <- ""
[17:26:46.006]                 }
[17:26:46.006]                 NAMES <- toupper(removed)
[17:26:46.006]                 for (kk in seq_along(NAMES)) {
[17:26:46.006]                   name <- removed[[kk]]
[17:26:46.006]                   NAME <- NAMES[[kk]]
[17:26:46.006]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.006]                     next
[17:26:46.006]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.006]                 }
[17:26:46.006]                 if (length(args) > 0) 
[17:26:46.006]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.006]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.006]             }
[17:26:46.006]             else {
[17:26:46.006]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.006]             }
[17:26:46.006]             {
[17:26:46.006]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.006]                   0L) {
[17:26:46.006]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.006]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.006]                   base::options(opts)
[17:26:46.006]                 }
[17:26:46.006]                 {
[17:26:46.006]                   {
[17:26:46.006]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.006]                     NULL
[17:26:46.006]                   }
[17:26:46.006]                   options(future.plan = NULL)
[17:26:46.006]                   if (is.na(NA_character_)) 
[17:26:46.006]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.006]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.006]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.006]                     .init = FALSE)
[17:26:46.006]                 }
[17:26:46.006]             }
[17:26:46.006]         }
[17:26:46.006]     })
[17:26:46.006]     if (TRUE) {
[17:26:46.006]         base::sink(type = "output", split = FALSE)
[17:26:46.006]         if (TRUE) {
[17:26:46.006]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.006]         }
[17:26:46.006]         else {
[17:26:46.006]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.006]         }
[17:26:46.006]         base::close(...future.stdout)
[17:26:46.006]         ...future.stdout <- NULL
[17:26:46.006]     }
[17:26:46.006]     ...future.result$conditions <- ...future.conditions
[17:26:46.006]     ...future.result$finished <- base::Sys.time()
[17:26:46.006]     ...future.result
[17:26:46.006] }
[17:26:46.011] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:46.032] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.032] - Validating connection of MultisessionFuture
[17:26:46.033] - received message: FutureResult
[17:26:46.033] - Received FutureResult
[17:26:46.033] - Erased future from FutureRegistry
[17:26:46.033] result() for ClusterFuture ...
[17:26:46.033] - result already collected: FutureResult
[17:26:46.034] result() for ClusterFuture ... done
[17:26:46.034] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.034] result() for ClusterFuture ...
[17:26:46.034] - result already collected: FutureResult
[17:26:46.034] result() for ClusterFuture ... done
[17:26:46.034] result() for ClusterFuture ...
[17:26:46.035] - result already collected: FutureResult
[17:26:46.035] result() for ClusterFuture ... done
[17:26:46.036] MultisessionFuture started
[17:26:46.036] - Launch lazy future ... done
[17:26:46.036] run() for 'MultisessionFuture' ... done
<environment: 0x000002230d2b6e68> 
<environment: 0x000002230fe08730> 
[17:26:46.038] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.039] - Validating connection of MultisessionFuture
[17:26:46.039] - received message: FutureResult
[17:26:46.039] - Received FutureResult
[17:26:46.039] - Erased future from FutureRegistry
[17:26:46.040] result() for ClusterFuture ...
[17:26:46.040] - result already collected: FutureResult
[17:26:46.040] result() for ClusterFuture ... done
[17:26:46.040] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.050] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.050] - Validating connection of MultisessionFuture
[17:26:46.051] - received message: FutureResult
[17:26:46.051] - Received FutureResult
[17:26:46.051] - Erased future from FutureRegistry
[17:26:46.051] result() for ClusterFuture ...
[17:26:46.051] - result already collected: FutureResult
[17:26:46.052] result() for ClusterFuture ... done
[17:26:46.052] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:46.054] resolve() on environment ...
[17:26:46.054]  recursive: 0
[17:26:46.055]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:46.055] signalConditionsASAP(numeric, pos=1) ...
[17:26:46.055] - nx: 4
[17:26:46.055] - relay: TRUE
[17:26:46.055] - stdout: TRUE
[17:26:46.056] - signal: TRUE
[17:26:46.056] - resignal: FALSE
[17:26:46.056] - force: TRUE
[17:26:46.056] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.056] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.057]  - until=2
[17:26:46.057]  - relaying element #2
[17:26:46.057] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:46.057] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.057] signalConditionsASAP(NULL, pos=1) ... done
[17:26:46.057]  length: 3 (resolved future 1)
[17:26:46.058] Future #2
[17:26:46.058] result() for ClusterFuture ...
[17:26:46.058] - result already collected: FutureResult
[17:26:46.058] result() for ClusterFuture ... done
[17:26:46.058] result() for ClusterFuture ...
[17:26:46.059] - result already collected: FutureResult
[17:26:46.059] result() for ClusterFuture ... done
[17:26:46.059] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:46.059] - nx: 4
[17:26:46.059] - relay: TRUE
[17:26:46.060] - stdout: TRUE
[17:26:46.060] - signal: TRUE
[17:26:46.060] - resignal: FALSE
[17:26:46.060] - force: TRUE
[17:26:46.060] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:46.060] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.061]  - until=2
[17:26:46.061]  - relaying element #2
[17:26:46.061] result() for ClusterFuture ...
[17:26:46.061] - result already collected: FutureResult
[17:26:46.062] result() for ClusterFuture ... done
[17:26:46.062] result() for ClusterFuture ...
[17:26:46.062] - result already collected: FutureResult
[17:26:46.062] result() for ClusterFuture ... done
[17:26:46.062] result() for ClusterFuture ...
[17:26:46.063] - result already collected: FutureResult
[17:26:46.063] result() for ClusterFuture ... done
[17:26:46.063] result() for ClusterFuture ...
[17:26:46.063] - result already collected: FutureResult
[17:26:46.063] result() for ClusterFuture ... done
[17:26:46.064] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:46.064] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:46.064] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:46.064]  length: 2 (resolved future 2)
[17:26:46.064] Future #3
[17:26:46.065] result() for ClusterFuture ...
[17:26:46.065] - result already collected: FutureResult
[17:26:46.065] result() for ClusterFuture ... done
[17:26:46.065] result() for ClusterFuture ...
[17:26:46.065] - result already collected: FutureResult
[17:26:46.066] result() for ClusterFuture ... done
[17:26:46.066] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:46.066] - nx: 4
[17:26:46.066] - relay: TRUE
[17:26:46.066] - stdout: TRUE
[17:26:46.066] - signal: TRUE
[17:26:46.067] - resignal: FALSE
[17:26:46.067] - force: TRUE
[17:26:46.067] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:46.067] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:46.067]  - until=3
[17:26:46.068]  - relaying element #3
[17:26:46.068] result() for ClusterFuture ...
[17:26:46.068] - result already collected: FutureResult
[17:26:46.068] result() for ClusterFuture ... done
[17:26:46.068] result() for ClusterFuture ...
[17:26:46.069] - result already collected: FutureResult
[17:26:46.069] result() for ClusterFuture ... done
[17:26:46.069] result() for ClusterFuture ...
[17:26:46.069] - result already collected: FutureResult
[17:26:46.069] result() for ClusterFuture ... done
[17:26:46.070] result() for ClusterFuture ...
[17:26:46.070] - result already collected: FutureResult
[17:26:46.070] result() for ClusterFuture ... done
[17:26:46.070] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:46.070] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:46.071] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:46.071]  length: 1 (resolved future 3)
[17:26:46.071] Future #4
[17:26:46.071] result() for ClusterFuture ...
[17:26:46.071] - result already collected: FutureResult
[17:26:46.072] result() for ClusterFuture ... done
[17:26:46.072] result() for ClusterFuture ...
[17:26:46.072] - result already collected: FutureResult
[17:26:46.072] result() for ClusterFuture ... done
[17:26:46.072] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:46.073] - nx: 4
[17:26:46.073] - relay: TRUE
[17:26:46.073] - stdout: TRUE
[17:26:46.073] - signal: TRUE
[17:26:46.073] - resignal: FALSE
[17:26:46.074] - force: TRUE
[17:26:46.074] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:46.074] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:46.074]  - until=4
[17:26:46.074]  - relaying element #4
[17:26:46.075] result() for ClusterFuture ...
[17:26:46.075] - result already collected: FutureResult
[17:26:46.075] result() for ClusterFuture ... done
[17:26:46.075] result() for ClusterFuture ...
[17:26:46.075] - result already collected: FutureResult
[17:26:46.076] result() for ClusterFuture ... done
[17:26:46.076] result() for ClusterFuture ...
[17:26:46.076] - result already collected: FutureResult
[17:26:46.076] result() for ClusterFuture ... done
[17:26:46.076] result() for ClusterFuture ...
[17:26:46.077] - result already collected: FutureResult
[17:26:46.077] result() for ClusterFuture ... done
[17:26:46.077] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:46.077] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:46.077] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:46.077]  length: 0 (resolved future 4)
[17:26:46.078] Relaying remaining futures
[17:26:46.078] signalConditionsASAP(NULL, pos=0) ...
[17:26:46.078] - nx: 4
[17:26:46.078] - relay: TRUE
[17:26:46.078] - stdout: TRUE
[17:26:46.079] - signal: TRUE
[17:26:46.079] - resignal: FALSE
[17:26:46.079] - force: TRUE
[17:26:46.079] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:46.079] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:46.080] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:46.080] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:46.080] signalConditionsASAP(NULL, pos=0) ... done
[17:26:46.080] resolve() on environment ... DONE
[17:26:46.080] result() for ClusterFuture ...
[17:26:46.080] - result already collected: FutureResult
[17:26:46.081] result() for ClusterFuture ... done
[17:26:46.081] result() for ClusterFuture ...
[17:26:46.081] - result already collected: FutureResult
[17:26:46.081] result() for ClusterFuture ... done
[17:26:46.081] result() for ClusterFuture ...
[17:26:46.081] - result already collected: FutureResult
[17:26:46.082] result() for ClusterFuture ... done
[17:26:46.082] result() for ClusterFuture ...
[17:26:46.082] - result already collected: FutureResult
[17:26:46.082] result() for ClusterFuture ... done
[17:26:46.082] result() for ClusterFuture ...
[17:26:46.082] - result already collected: FutureResult
[17:26:46.083] result() for ClusterFuture ... done
[17:26:46.083] result() for ClusterFuture ...
[17:26:46.083] - result already collected: FutureResult
[17:26:46.083] result() for ClusterFuture ... done
<environment: 0x000002231007b940> 
Dimensions: c(2, 1, 3, 1)
[17:26:46.084] getGlobalsAndPackages() ...
[17:26:46.084] Searching for globals...
[17:26:46.084] 
[17:26:46.084] Searching for globals ... DONE
[17:26:46.085] - globals: [0] <none>
[17:26:46.085] getGlobalsAndPackages() ... DONE
[17:26:46.085] run() for 'Future' ...
[17:26:46.085] - state: 'created'
[17:26:46.085] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.099] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.099] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.099]   - Field: 'node'
[17:26:46.099]   - Field: 'label'
[17:26:46.100]   - Field: 'local'
[17:26:46.100]   - Field: 'owner'
[17:26:46.100]   - Field: 'envir'
[17:26:46.100]   - Field: 'workers'
[17:26:46.100]   - Field: 'packages'
[17:26:46.101]   - Field: 'gc'
[17:26:46.101]   - Field: 'conditions'
[17:26:46.101]   - Field: 'persistent'
[17:26:46.101]   - Field: 'expr'
[17:26:46.101]   - Field: 'uuid'
[17:26:46.101]   - Field: 'seed'
[17:26:46.102]   - Field: 'version'
[17:26:46.102]   - Field: 'result'
[17:26:46.102]   - Field: 'asynchronous'
[17:26:46.102]   - Field: 'calls'
[17:26:46.102]   - Field: 'globals'
[17:26:46.102]   - Field: 'stdout'
[17:26:46.103]   - Field: 'earlySignal'
[17:26:46.103]   - Field: 'lazy'
[17:26:46.103]   - Field: 'state'
[17:26:46.103] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.103] - Launch lazy future ...
[17:26:46.104] Packages needed by the future expression (n = 0): <none>
[17:26:46.104] Packages needed by future strategies (n = 0): <none>
[17:26:46.104] {
[17:26:46.104]     {
[17:26:46.104]         {
[17:26:46.104]             ...future.startTime <- base::Sys.time()
[17:26:46.104]             {
[17:26:46.104]                 {
[17:26:46.104]                   {
[17:26:46.104]                     {
[17:26:46.104]                       base::local({
[17:26:46.104]                         has_future <- base::requireNamespace("future", 
[17:26:46.104]                           quietly = TRUE)
[17:26:46.104]                         if (has_future) {
[17:26:46.104]                           ns <- base::getNamespace("future")
[17:26:46.104]                           version <- ns[[".package"]][["version"]]
[17:26:46.104]                           if (is.null(version)) 
[17:26:46.104]                             version <- utils::packageVersion("future")
[17:26:46.104]                         }
[17:26:46.104]                         else {
[17:26:46.104]                           version <- NULL
[17:26:46.104]                         }
[17:26:46.104]                         if (!has_future || version < "1.8.0") {
[17:26:46.104]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.104]                             "", base::R.version$version.string), 
[17:26:46.104]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.104]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.104]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.104]                               "release", "version")], collapse = " "), 
[17:26:46.104]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.104]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.104]                             info)
[17:26:46.104]                           info <- base::paste(info, collapse = "; ")
[17:26:46.104]                           if (!has_future) {
[17:26:46.104]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.104]                               info)
[17:26:46.104]                           }
[17:26:46.104]                           else {
[17:26:46.104]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.104]                               info, version)
[17:26:46.104]                           }
[17:26:46.104]                           base::stop(msg)
[17:26:46.104]                         }
[17:26:46.104]                       })
[17:26:46.104]                     }
[17:26:46.104]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.104]                     base::options(mc.cores = 1L)
[17:26:46.104]                   }
[17:26:46.104]                   ...future.strategy.old <- future::plan("list")
[17:26:46.104]                   options(future.plan = NULL)
[17:26:46.104]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.104]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.104]                 }
[17:26:46.104]                 ...future.workdir <- getwd()
[17:26:46.104]             }
[17:26:46.104]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.104]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.104]         }
[17:26:46.104]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.104]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.104]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.104]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.104]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.104]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.104]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.104]             base::names(...future.oldOptions))
[17:26:46.104]     }
[17:26:46.104]     if (FALSE) {
[17:26:46.104]     }
[17:26:46.104]     else {
[17:26:46.104]         if (TRUE) {
[17:26:46.104]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.104]                 open = "w")
[17:26:46.104]         }
[17:26:46.104]         else {
[17:26:46.104]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.104]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.104]         }
[17:26:46.104]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.104]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.104]             base::sink(type = "output", split = FALSE)
[17:26:46.104]             base::close(...future.stdout)
[17:26:46.104]         }, add = TRUE)
[17:26:46.104]     }
[17:26:46.104]     ...future.frame <- base::sys.nframe()
[17:26:46.104]     ...future.conditions <- base::list()
[17:26:46.104]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.104]     if (FALSE) {
[17:26:46.104]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.104]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.104]     }
[17:26:46.104]     ...future.result <- base::tryCatch({
[17:26:46.104]         base::withCallingHandlers({
[17:26:46.104]             ...future.value <- base::withVisible(base::local({
[17:26:46.104]                 ...future.makeSendCondition <- base::local({
[17:26:46.104]                   sendCondition <- NULL
[17:26:46.104]                   function(frame = 1L) {
[17:26:46.104]                     if (is.function(sendCondition)) 
[17:26:46.104]                       return(sendCondition)
[17:26:46.104]                     ns <- getNamespace("parallel")
[17:26:46.104]                     if (exists("sendData", mode = "function", 
[17:26:46.104]                       envir = ns)) {
[17:26:46.104]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.104]                         envir = ns)
[17:26:46.104]                       envir <- sys.frame(frame)
[17:26:46.104]                       master <- NULL
[17:26:46.104]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.104]                         !identical(envir, emptyenv())) {
[17:26:46.104]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.104]                           inherits = FALSE)) {
[17:26:46.104]                           master <- get("master", mode = "list", 
[17:26:46.104]                             envir = envir, inherits = FALSE)
[17:26:46.104]                           if (inherits(master, c("SOCKnode", 
[17:26:46.104]                             "SOCK0node"))) {
[17:26:46.104]                             sendCondition <<- function(cond) {
[17:26:46.104]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.104]                                 success = TRUE)
[17:26:46.104]                               parallel_sendData(master, data)
[17:26:46.104]                             }
[17:26:46.104]                             return(sendCondition)
[17:26:46.104]                           }
[17:26:46.104]                         }
[17:26:46.104]                         frame <- frame + 1L
[17:26:46.104]                         envir <- sys.frame(frame)
[17:26:46.104]                       }
[17:26:46.104]                     }
[17:26:46.104]                     sendCondition <<- function(cond) NULL
[17:26:46.104]                   }
[17:26:46.104]                 })
[17:26:46.104]                 withCallingHandlers({
[17:26:46.104]                   2
[17:26:46.104]                 }, immediateCondition = function(cond) {
[17:26:46.104]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.104]                   sendCondition(cond)
[17:26:46.104]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.104]                   {
[17:26:46.104]                     inherits <- base::inherits
[17:26:46.104]                     invokeRestart <- base::invokeRestart
[17:26:46.104]                     is.null <- base::is.null
[17:26:46.104]                     muffled <- FALSE
[17:26:46.104]                     if (inherits(cond, "message")) {
[17:26:46.104]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.104]                       if (muffled) 
[17:26:46.104]                         invokeRestart("muffleMessage")
[17:26:46.104]                     }
[17:26:46.104]                     else if (inherits(cond, "warning")) {
[17:26:46.104]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.104]                       if (muffled) 
[17:26:46.104]                         invokeRestart("muffleWarning")
[17:26:46.104]                     }
[17:26:46.104]                     else if (inherits(cond, "condition")) {
[17:26:46.104]                       if (!is.null(pattern)) {
[17:26:46.104]                         computeRestarts <- base::computeRestarts
[17:26:46.104]                         grepl <- base::grepl
[17:26:46.104]                         restarts <- computeRestarts(cond)
[17:26:46.104]                         for (restart in restarts) {
[17:26:46.104]                           name <- restart$name
[17:26:46.104]                           if (is.null(name)) 
[17:26:46.104]                             next
[17:26:46.104]                           if (!grepl(pattern, name)) 
[17:26:46.104]                             next
[17:26:46.104]                           invokeRestart(restart)
[17:26:46.104]                           muffled <- TRUE
[17:26:46.104]                           break
[17:26:46.104]                         }
[17:26:46.104]                       }
[17:26:46.104]                     }
[17:26:46.104]                     invisible(muffled)
[17:26:46.104]                   }
[17:26:46.104]                   muffleCondition(cond)
[17:26:46.104]                 })
[17:26:46.104]             }))
[17:26:46.104]             future::FutureResult(value = ...future.value$value, 
[17:26:46.104]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.104]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.104]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.104]                     ...future.globalenv.names))
[17:26:46.104]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.104]         }, condition = base::local({
[17:26:46.104]             c <- base::c
[17:26:46.104]             inherits <- base::inherits
[17:26:46.104]             invokeRestart <- base::invokeRestart
[17:26:46.104]             length <- base::length
[17:26:46.104]             list <- base::list
[17:26:46.104]             seq.int <- base::seq.int
[17:26:46.104]             signalCondition <- base::signalCondition
[17:26:46.104]             sys.calls <- base::sys.calls
[17:26:46.104]             `[[` <- base::`[[`
[17:26:46.104]             `+` <- base::`+`
[17:26:46.104]             `<<-` <- base::`<<-`
[17:26:46.104]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.104]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.104]                   3L)]
[17:26:46.104]             }
[17:26:46.104]             function(cond) {
[17:26:46.104]                 is_error <- inherits(cond, "error")
[17:26:46.104]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.104]                   NULL)
[17:26:46.104]                 if (is_error) {
[17:26:46.104]                   sessionInformation <- function() {
[17:26:46.104]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.104]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.104]                       search = base::search(), system = base::Sys.info())
[17:26:46.104]                   }
[17:26:46.104]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.104]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.104]                     cond$call), session = sessionInformation(), 
[17:26:46.104]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.104]                   signalCondition(cond)
[17:26:46.104]                 }
[17:26:46.104]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.104]                 "immediateCondition"))) {
[17:26:46.104]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.104]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.104]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.104]                   if (TRUE && !signal) {
[17:26:46.104]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.104]                     {
[17:26:46.104]                       inherits <- base::inherits
[17:26:46.104]                       invokeRestart <- base::invokeRestart
[17:26:46.104]                       is.null <- base::is.null
[17:26:46.104]                       muffled <- FALSE
[17:26:46.104]                       if (inherits(cond, "message")) {
[17:26:46.104]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.104]                         if (muffled) 
[17:26:46.104]                           invokeRestart("muffleMessage")
[17:26:46.104]                       }
[17:26:46.104]                       else if (inherits(cond, "warning")) {
[17:26:46.104]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.104]                         if (muffled) 
[17:26:46.104]                           invokeRestart("muffleWarning")
[17:26:46.104]                       }
[17:26:46.104]                       else if (inherits(cond, "condition")) {
[17:26:46.104]                         if (!is.null(pattern)) {
[17:26:46.104]                           computeRestarts <- base::computeRestarts
[17:26:46.104]                           grepl <- base::grepl
[17:26:46.104]                           restarts <- computeRestarts(cond)
[17:26:46.104]                           for (restart in restarts) {
[17:26:46.104]                             name <- restart$name
[17:26:46.104]                             if (is.null(name)) 
[17:26:46.104]                               next
[17:26:46.104]                             if (!grepl(pattern, name)) 
[17:26:46.104]                               next
[17:26:46.104]                             invokeRestart(restart)
[17:26:46.104]                             muffled <- TRUE
[17:26:46.104]                             break
[17:26:46.104]                           }
[17:26:46.104]                         }
[17:26:46.104]                       }
[17:26:46.104]                       invisible(muffled)
[17:26:46.104]                     }
[17:26:46.104]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.104]                   }
[17:26:46.104]                 }
[17:26:46.104]                 else {
[17:26:46.104]                   if (TRUE) {
[17:26:46.104]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.104]                     {
[17:26:46.104]                       inherits <- base::inherits
[17:26:46.104]                       invokeRestart <- base::invokeRestart
[17:26:46.104]                       is.null <- base::is.null
[17:26:46.104]                       muffled <- FALSE
[17:26:46.104]                       if (inherits(cond, "message")) {
[17:26:46.104]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.104]                         if (muffled) 
[17:26:46.104]                           invokeRestart("muffleMessage")
[17:26:46.104]                       }
[17:26:46.104]                       else if (inherits(cond, "warning")) {
[17:26:46.104]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.104]                         if (muffled) 
[17:26:46.104]                           invokeRestart("muffleWarning")
[17:26:46.104]                       }
[17:26:46.104]                       else if (inherits(cond, "condition")) {
[17:26:46.104]                         if (!is.null(pattern)) {
[17:26:46.104]                           computeRestarts <- base::computeRestarts
[17:26:46.104]                           grepl <- base::grepl
[17:26:46.104]                           restarts <- computeRestarts(cond)
[17:26:46.104]                           for (restart in restarts) {
[17:26:46.104]                             name <- restart$name
[17:26:46.104]                             if (is.null(name)) 
[17:26:46.104]                               next
[17:26:46.104]                             if (!grepl(pattern, name)) 
[17:26:46.104]                               next
[17:26:46.104]                             invokeRestart(restart)
[17:26:46.104]                             muffled <- TRUE
[17:26:46.104]                             break
[17:26:46.104]                           }
[17:26:46.104]                         }
[17:26:46.104]                       }
[17:26:46.104]                       invisible(muffled)
[17:26:46.104]                     }
[17:26:46.104]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.104]                   }
[17:26:46.104]                 }
[17:26:46.104]             }
[17:26:46.104]         }))
[17:26:46.104]     }, error = function(ex) {
[17:26:46.104]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.104]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.104]                 ...future.rng), started = ...future.startTime, 
[17:26:46.104]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.104]             version = "1.8"), class = "FutureResult")
[17:26:46.104]     }, finally = {
[17:26:46.104]         if (!identical(...future.workdir, getwd())) 
[17:26:46.104]             setwd(...future.workdir)
[17:26:46.104]         {
[17:26:46.104]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.104]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.104]             }
[17:26:46.104]             base::options(...future.oldOptions)
[17:26:46.104]             if (.Platform$OS.type == "windows") {
[17:26:46.104]                 old_names <- names(...future.oldEnvVars)
[17:26:46.104]                 envs <- base::Sys.getenv()
[17:26:46.104]                 names <- names(envs)
[17:26:46.104]                 common <- intersect(names, old_names)
[17:26:46.104]                 added <- setdiff(names, old_names)
[17:26:46.104]                 removed <- setdiff(old_names, names)
[17:26:46.104]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.104]                   envs[common]]
[17:26:46.104]                 NAMES <- toupper(changed)
[17:26:46.104]                 args <- list()
[17:26:46.104]                 for (kk in seq_along(NAMES)) {
[17:26:46.104]                   name <- changed[[kk]]
[17:26:46.104]                   NAME <- NAMES[[kk]]
[17:26:46.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.104]                     next
[17:26:46.104]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.104]                 }
[17:26:46.104]                 NAMES <- toupper(added)
[17:26:46.104]                 for (kk in seq_along(NAMES)) {
[17:26:46.104]                   name <- added[[kk]]
[17:26:46.104]                   NAME <- NAMES[[kk]]
[17:26:46.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.104]                     next
[17:26:46.104]                   args[[name]] <- ""
[17:26:46.104]                 }
[17:26:46.104]                 NAMES <- toupper(removed)
[17:26:46.104]                 for (kk in seq_along(NAMES)) {
[17:26:46.104]                   name <- removed[[kk]]
[17:26:46.104]                   NAME <- NAMES[[kk]]
[17:26:46.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.104]                     next
[17:26:46.104]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.104]                 }
[17:26:46.104]                 if (length(args) > 0) 
[17:26:46.104]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.104]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.104]             }
[17:26:46.104]             else {
[17:26:46.104]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.104]             }
[17:26:46.104]             {
[17:26:46.104]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.104]                   0L) {
[17:26:46.104]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.104]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.104]                   base::options(opts)
[17:26:46.104]                 }
[17:26:46.104]                 {
[17:26:46.104]                   {
[17:26:46.104]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.104]                     NULL
[17:26:46.104]                   }
[17:26:46.104]                   options(future.plan = NULL)
[17:26:46.104]                   if (is.na(NA_character_)) 
[17:26:46.104]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.104]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.104]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.104]                     .init = FALSE)
[17:26:46.104]                 }
[17:26:46.104]             }
[17:26:46.104]         }
[17:26:46.104]     })
[17:26:46.104]     if (TRUE) {
[17:26:46.104]         base::sink(type = "output", split = FALSE)
[17:26:46.104]         if (TRUE) {
[17:26:46.104]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.104]         }
[17:26:46.104]         else {
[17:26:46.104]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.104]         }
[17:26:46.104]         base::close(...future.stdout)
[17:26:46.104]         ...future.stdout <- NULL
[17:26:46.104]     }
[17:26:46.104]     ...future.result$conditions <- ...future.conditions
[17:26:46.104]     ...future.result$finished <- base::Sys.time()
[17:26:46.104]     ...future.result
[17:26:46.104] }
[17:26:46.110] MultisessionFuture started
[17:26:46.110] - Launch lazy future ... done
[17:26:46.110] run() for 'MultisessionFuture' ... done
[17:26:46.111] getGlobalsAndPackages() ...
[17:26:46.111] Searching for globals...
[17:26:46.111] 
[17:26:46.111] Searching for globals ... DONE
[17:26:46.111] - globals: [0] <none>
[17:26:46.112] getGlobalsAndPackages() ... DONE
[17:26:46.112] run() for 'Future' ...
[17:26:46.112] - state: 'created'
[17:26:46.112] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.137] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.137] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.137]   - Field: 'node'
[17:26:46.137]   - Field: 'label'
[17:26:46.138]   - Field: 'local'
[17:26:46.138]   - Field: 'owner'
[17:26:46.138]   - Field: 'envir'
[17:26:46.138]   - Field: 'workers'
[17:26:46.138]   - Field: 'packages'
[17:26:46.139]   - Field: 'gc'
[17:26:46.139]   - Field: 'conditions'
[17:26:46.139]   - Field: 'persistent'
[17:26:46.139]   - Field: 'expr'
[17:26:46.139]   - Field: 'uuid'
[17:26:46.139]   - Field: 'seed'
[17:26:46.140]   - Field: 'version'
[17:26:46.140]   - Field: 'result'
[17:26:46.140]   - Field: 'asynchronous'
[17:26:46.140]   - Field: 'calls'
[17:26:46.140]   - Field: 'globals'
[17:26:46.140]   - Field: 'stdout'
[17:26:46.141]   - Field: 'earlySignal'
[17:26:46.141]   - Field: 'lazy'
[17:26:46.141]   - Field: 'state'
[17:26:46.141] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.141] - Launch lazy future ...
[17:26:46.142] Packages needed by the future expression (n = 0): <none>
[17:26:46.142] Packages needed by future strategies (n = 0): <none>
[17:26:46.142] {
[17:26:46.142]     {
[17:26:46.142]         {
[17:26:46.142]             ...future.startTime <- base::Sys.time()
[17:26:46.142]             {
[17:26:46.142]                 {
[17:26:46.142]                   {
[17:26:46.142]                     {
[17:26:46.142]                       base::local({
[17:26:46.142]                         has_future <- base::requireNamespace("future", 
[17:26:46.142]                           quietly = TRUE)
[17:26:46.142]                         if (has_future) {
[17:26:46.142]                           ns <- base::getNamespace("future")
[17:26:46.142]                           version <- ns[[".package"]][["version"]]
[17:26:46.142]                           if (is.null(version)) 
[17:26:46.142]                             version <- utils::packageVersion("future")
[17:26:46.142]                         }
[17:26:46.142]                         else {
[17:26:46.142]                           version <- NULL
[17:26:46.142]                         }
[17:26:46.142]                         if (!has_future || version < "1.8.0") {
[17:26:46.142]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.142]                             "", base::R.version$version.string), 
[17:26:46.142]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.142]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.142]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.142]                               "release", "version")], collapse = " "), 
[17:26:46.142]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.142]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.142]                             info)
[17:26:46.142]                           info <- base::paste(info, collapse = "; ")
[17:26:46.142]                           if (!has_future) {
[17:26:46.142]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.142]                               info)
[17:26:46.142]                           }
[17:26:46.142]                           else {
[17:26:46.142]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.142]                               info, version)
[17:26:46.142]                           }
[17:26:46.142]                           base::stop(msg)
[17:26:46.142]                         }
[17:26:46.142]                       })
[17:26:46.142]                     }
[17:26:46.142]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.142]                     base::options(mc.cores = 1L)
[17:26:46.142]                   }
[17:26:46.142]                   ...future.strategy.old <- future::plan("list")
[17:26:46.142]                   options(future.plan = NULL)
[17:26:46.142]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.142]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.142]                 }
[17:26:46.142]                 ...future.workdir <- getwd()
[17:26:46.142]             }
[17:26:46.142]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.142]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.142]         }
[17:26:46.142]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.142]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.142]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.142]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.142]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.142]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.142]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.142]             base::names(...future.oldOptions))
[17:26:46.142]     }
[17:26:46.142]     if (FALSE) {
[17:26:46.142]     }
[17:26:46.142]     else {
[17:26:46.142]         if (TRUE) {
[17:26:46.142]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.142]                 open = "w")
[17:26:46.142]         }
[17:26:46.142]         else {
[17:26:46.142]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.142]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.142]         }
[17:26:46.142]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.142]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.142]             base::sink(type = "output", split = FALSE)
[17:26:46.142]             base::close(...future.stdout)
[17:26:46.142]         }, add = TRUE)
[17:26:46.142]     }
[17:26:46.142]     ...future.frame <- base::sys.nframe()
[17:26:46.142]     ...future.conditions <- base::list()
[17:26:46.142]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.142]     if (FALSE) {
[17:26:46.142]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.142]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.142]     }
[17:26:46.142]     ...future.result <- base::tryCatch({
[17:26:46.142]         base::withCallingHandlers({
[17:26:46.142]             ...future.value <- base::withVisible(base::local({
[17:26:46.142]                 ...future.makeSendCondition <- base::local({
[17:26:46.142]                   sendCondition <- NULL
[17:26:46.142]                   function(frame = 1L) {
[17:26:46.142]                     if (is.function(sendCondition)) 
[17:26:46.142]                       return(sendCondition)
[17:26:46.142]                     ns <- getNamespace("parallel")
[17:26:46.142]                     if (exists("sendData", mode = "function", 
[17:26:46.142]                       envir = ns)) {
[17:26:46.142]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.142]                         envir = ns)
[17:26:46.142]                       envir <- sys.frame(frame)
[17:26:46.142]                       master <- NULL
[17:26:46.142]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.142]                         !identical(envir, emptyenv())) {
[17:26:46.142]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.142]                           inherits = FALSE)) {
[17:26:46.142]                           master <- get("master", mode = "list", 
[17:26:46.142]                             envir = envir, inherits = FALSE)
[17:26:46.142]                           if (inherits(master, c("SOCKnode", 
[17:26:46.142]                             "SOCK0node"))) {
[17:26:46.142]                             sendCondition <<- function(cond) {
[17:26:46.142]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.142]                                 success = TRUE)
[17:26:46.142]                               parallel_sendData(master, data)
[17:26:46.142]                             }
[17:26:46.142]                             return(sendCondition)
[17:26:46.142]                           }
[17:26:46.142]                         }
[17:26:46.142]                         frame <- frame + 1L
[17:26:46.142]                         envir <- sys.frame(frame)
[17:26:46.142]                       }
[17:26:46.142]                     }
[17:26:46.142]                     sendCondition <<- function(cond) NULL
[17:26:46.142]                   }
[17:26:46.142]                 })
[17:26:46.142]                 withCallingHandlers({
[17:26:46.142]                   NULL
[17:26:46.142]                 }, immediateCondition = function(cond) {
[17:26:46.142]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.142]                   sendCondition(cond)
[17:26:46.142]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.142]                   {
[17:26:46.142]                     inherits <- base::inherits
[17:26:46.142]                     invokeRestart <- base::invokeRestart
[17:26:46.142]                     is.null <- base::is.null
[17:26:46.142]                     muffled <- FALSE
[17:26:46.142]                     if (inherits(cond, "message")) {
[17:26:46.142]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.142]                       if (muffled) 
[17:26:46.142]                         invokeRestart("muffleMessage")
[17:26:46.142]                     }
[17:26:46.142]                     else if (inherits(cond, "warning")) {
[17:26:46.142]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.142]                       if (muffled) 
[17:26:46.142]                         invokeRestart("muffleWarning")
[17:26:46.142]                     }
[17:26:46.142]                     else if (inherits(cond, "condition")) {
[17:26:46.142]                       if (!is.null(pattern)) {
[17:26:46.142]                         computeRestarts <- base::computeRestarts
[17:26:46.142]                         grepl <- base::grepl
[17:26:46.142]                         restarts <- computeRestarts(cond)
[17:26:46.142]                         for (restart in restarts) {
[17:26:46.142]                           name <- restart$name
[17:26:46.142]                           if (is.null(name)) 
[17:26:46.142]                             next
[17:26:46.142]                           if (!grepl(pattern, name)) 
[17:26:46.142]                             next
[17:26:46.142]                           invokeRestart(restart)
[17:26:46.142]                           muffled <- TRUE
[17:26:46.142]                           break
[17:26:46.142]                         }
[17:26:46.142]                       }
[17:26:46.142]                     }
[17:26:46.142]                     invisible(muffled)
[17:26:46.142]                   }
[17:26:46.142]                   muffleCondition(cond)
[17:26:46.142]                 })
[17:26:46.142]             }))
[17:26:46.142]             future::FutureResult(value = ...future.value$value, 
[17:26:46.142]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.142]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.142]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.142]                     ...future.globalenv.names))
[17:26:46.142]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.142]         }, condition = base::local({
[17:26:46.142]             c <- base::c
[17:26:46.142]             inherits <- base::inherits
[17:26:46.142]             invokeRestart <- base::invokeRestart
[17:26:46.142]             length <- base::length
[17:26:46.142]             list <- base::list
[17:26:46.142]             seq.int <- base::seq.int
[17:26:46.142]             signalCondition <- base::signalCondition
[17:26:46.142]             sys.calls <- base::sys.calls
[17:26:46.142]             `[[` <- base::`[[`
[17:26:46.142]             `+` <- base::`+`
[17:26:46.142]             `<<-` <- base::`<<-`
[17:26:46.142]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.142]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.142]                   3L)]
[17:26:46.142]             }
[17:26:46.142]             function(cond) {
[17:26:46.142]                 is_error <- inherits(cond, "error")
[17:26:46.142]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.142]                   NULL)
[17:26:46.142]                 if (is_error) {
[17:26:46.142]                   sessionInformation <- function() {
[17:26:46.142]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.142]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.142]                       search = base::search(), system = base::Sys.info())
[17:26:46.142]                   }
[17:26:46.142]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.142]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.142]                     cond$call), session = sessionInformation(), 
[17:26:46.142]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.142]                   signalCondition(cond)
[17:26:46.142]                 }
[17:26:46.142]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.142]                 "immediateCondition"))) {
[17:26:46.142]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.142]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.142]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.142]                   if (TRUE && !signal) {
[17:26:46.142]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.142]                     {
[17:26:46.142]                       inherits <- base::inherits
[17:26:46.142]                       invokeRestart <- base::invokeRestart
[17:26:46.142]                       is.null <- base::is.null
[17:26:46.142]                       muffled <- FALSE
[17:26:46.142]                       if (inherits(cond, "message")) {
[17:26:46.142]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.142]                         if (muffled) 
[17:26:46.142]                           invokeRestart("muffleMessage")
[17:26:46.142]                       }
[17:26:46.142]                       else if (inherits(cond, "warning")) {
[17:26:46.142]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.142]                         if (muffled) 
[17:26:46.142]                           invokeRestart("muffleWarning")
[17:26:46.142]                       }
[17:26:46.142]                       else if (inherits(cond, "condition")) {
[17:26:46.142]                         if (!is.null(pattern)) {
[17:26:46.142]                           computeRestarts <- base::computeRestarts
[17:26:46.142]                           grepl <- base::grepl
[17:26:46.142]                           restarts <- computeRestarts(cond)
[17:26:46.142]                           for (restart in restarts) {
[17:26:46.142]                             name <- restart$name
[17:26:46.142]                             if (is.null(name)) 
[17:26:46.142]                               next
[17:26:46.142]                             if (!grepl(pattern, name)) 
[17:26:46.142]                               next
[17:26:46.142]                             invokeRestart(restart)
[17:26:46.142]                             muffled <- TRUE
[17:26:46.142]                             break
[17:26:46.142]                           }
[17:26:46.142]                         }
[17:26:46.142]                       }
[17:26:46.142]                       invisible(muffled)
[17:26:46.142]                     }
[17:26:46.142]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.142]                   }
[17:26:46.142]                 }
[17:26:46.142]                 else {
[17:26:46.142]                   if (TRUE) {
[17:26:46.142]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.142]                     {
[17:26:46.142]                       inherits <- base::inherits
[17:26:46.142]                       invokeRestart <- base::invokeRestart
[17:26:46.142]                       is.null <- base::is.null
[17:26:46.142]                       muffled <- FALSE
[17:26:46.142]                       if (inherits(cond, "message")) {
[17:26:46.142]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.142]                         if (muffled) 
[17:26:46.142]                           invokeRestart("muffleMessage")
[17:26:46.142]                       }
[17:26:46.142]                       else if (inherits(cond, "warning")) {
[17:26:46.142]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.142]                         if (muffled) 
[17:26:46.142]                           invokeRestart("muffleWarning")
[17:26:46.142]                       }
[17:26:46.142]                       else if (inherits(cond, "condition")) {
[17:26:46.142]                         if (!is.null(pattern)) {
[17:26:46.142]                           computeRestarts <- base::computeRestarts
[17:26:46.142]                           grepl <- base::grepl
[17:26:46.142]                           restarts <- computeRestarts(cond)
[17:26:46.142]                           for (restart in restarts) {
[17:26:46.142]                             name <- restart$name
[17:26:46.142]                             if (is.null(name)) 
[17:26:46.142]                               next
[17:26:46.142]                             if (!grepl(pattern, name)) 
[17:26:46.142]                               next
[17:26:46.142]                             invokeRestart(restart)
[17:26:46.142]                             muffled <- TRUE
[17:26:46.142]                             break
[17:26:46.142]                           }
[17:26:46.142]                         }
[17:26:46.142]                       }
[17:26:46.142]                       invisible(muffled)
[17:26:46.142]                     }
[17:26:46.142]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.142]                   }
[17:26:46.142]                 }
[17:26:46.142]             }
[17:26:46.142]         }))
[17:26:46.142]     }, error = function(ex) {
[17:26:46.142]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.142]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.142]                 ...future.rng), started = ...future.startTime, 
[17:26:46.142]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.142]             version = "1.8"), class = "FutureResult")
[17:26:46.142]     }, finally = {
[17:26:46.142]         if (!identical(...future.workdir, getwd())) 
[17:26:46.142]             setwd(...future.workdir)
[17:26:46.142]         {
[17:26:46.142]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.142]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.142]             }
[17:26:46.142]             base::options(...future.oldOptions)
[17:26:46.142]             if (.Platform$OS.type == "windows") {
[17:26:46.142]                 old_names <- names(...future.oldEnvVars)
[17:26:46.142]                 envs <- base::Sys.getenv()
[17:26:46.142]                 names <- names(envs)
[17:26:46.142]                 common <- intersect(names, old_names)
[17:26:46.142]                 added <- setdiff(names, old_names)
[17:26:46.142]                 removed <- setdiff(old_names, names)
[17:26:46.142]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.142]                   envs[common]]
[17:26:46.142]                 NAMES <- toupper(changed)
[17:26:46.142]                 args <- list()
[17:26:46.142]                 for (kk in seq_along(NAMES)) {
[17:26:46.142]                   name <- changed[[kk]]
[17:26:46.142]                   NAME <- NAMES[[kk]]
[17:26:46.142]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.142]                     next
[17:26:46.142]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.142]                 }
[17:26:46.142]                 NAMES <- toupper(added)
[17:26:46.142]                 for (kk in seq_along(NAMES)) {
[17:26:46.142]                   name <- added[[kk]]
[17:26:46.142]                   NAME <- NAMES[[kk]]
[17:26:46.142]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.142]                     next
[17:26:46.142]                   args[[name]] <- ""
[17:26:46.142]                 }
[17:26:46.142]                 NAMES <- toupper(removed)
[17:26:46.142]                 for (kk in seq_along(NAMES)) {
[17:26:46.142]                   name <- removed[[kk]]
[17:26:46.142]                   NAME <- NAMES[[kk]]
[17:26:46.142]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.142]                     next
[17:26:46.142]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.142]                 }
[17:26:46.142]                 if (length(args) > 0) 
[17:26:46.142]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.142]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.142]             }
[17:26:46.142]             else {
[17:26:46.142]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.142]             }
[17:26:46.142]             {
[17:26:46.142]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.142]                   0L) {
[17:26:46.142]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.142]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.142]                   base::options(opts)
[17:26:46.142]                 }
[17:26:46.142]                 {
[17:26:46.142]                   {
[17:26:46.142]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.142]                     NULL
[17:26:46.142]                   }
[17:26:46.142]                   options(future.plan = NULL)
[17:26:46.142]                   if (is.na(NA_character_)) 
[17:26:46.142]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.142]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.142]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.142]                     .init = FALSE)
[17:26:46.142]                 }
[17:26:46.142]             }
[17:26:46.142]         }
[17:26:46.142]     })
[17:26:46.142]     if (TRUE) {
[17:26:46.142]         base::sink(type = "output", split = FALSE)
[17:26:46.142]         if (TRUE) {
[17:26:46.142]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.142]         }
[17:26:46.142]         else {
[17:26:46.142]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.142]         }
[17:26:46.142]         base::close(...future.stdout)
[17:26:46.142]         ...future.stdout <- NULL
[17:26:46.142]     }
[17:26:46.142]     ...future.result$conditions <- ...future.conditions
[17:26:46.142]     ...future.result$finished <- base::Sys.time()
[17:26:46.142]     ...future.result
[17:26:46.142] }
[17:26:46.148] MultisessionFuture started
[17:26:46.148] - Launch lazy future ... done
[17:26:46.148] run() for 'MultisessionFuture' ... done
[17:26:46.149] getGlobalsAndPackages() ...
[17:26:46.149] Searching for globals...
[17:26:46.150] - globals found: [1] '{'
[17:26:46.150] Searching for globals ... DONE
[17:26:46.150] Resolving globals: FALSE
[17:26:46.151] 
[17:26:46.151] 
[17:26:46.151] getGlobalsAndPackages() ... DONE
[17:26:46.151] run() for 'Future' ...
[17:26:46.151] - state: 'created'
[17:26:46.152] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.165] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.165] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.165]   - Field: 'node'
[17:26:46.166]   - Field: 'label'
[17:26:46.166]   - Field: 'local'
[17:26:46.166]   - Field: 'owner'
[17:26:46.166]   - Field: 'envir'
[17:26:46.166]   - Field: 'workers'
[17:26:46.166]   - Field: 'packages'
[17:26:46.167]   - Field: 'gc'
[17:26:46.167]   - Field: 'conditions'
[17:26:46.167]   - Field: 'persistent'
[17:26:46.167]   - Field: 'expr'
[17:26:46.167]   - Field: 'uuid'
[17:26:46.167]   - Field: 'seed'
[17:26:46.168]   - Field: 'version'
[17:26:46.168]   - Field: 'result'
[17:26:46.168]   - Field: 'asynchronous'
[17:26:46.168]   - Field: 'calls'
[17:26:46.168]   - Field: 'globals'
[17:26:46.169]   - Field: 'stdout'
[17:26:46.169]   - Field: 'earlySignal'
[17:26:46.169]   - Field: 'lazy'
[17:26:46.169]   - Field: 'state'
[17:26:46.169] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.169] - Launch lazy future ...
[17:26:46.170] Packages needed by the future expression (n = 0): <none>
[17:26:46.170] Packages needed by future strategies (n = 0): <none>
[17:26:46.171] {
[17:26:46.171]     {
[17:26:46.171]         {
[17:26:46.171]             ...future.startTime <- base::Sys.time()
[17:26:46.171]             {
[17:26:46.171]                 {
[17:26:46.171]                   {
[17:26:46.171]                     {
[17:26:46.171]                       base::local({
[17:26:46.171]                         has_future <- base::requireNamespace("future", 
[17:26:46.171]                           quietly = TRUE)
[17:26:46.171]                         if (has_future) {
[17:26:46.171]                           ns <- base::getNamespace("future")
[17:26:46.171]                           version <- ns[[".package"]][["version"]]
[17:26:46.171]                           if (is.null(version)) 
[17:26:46.171]                             version <- utils::packageVersion("future")
[17:26:46.171]                         }
[17:26:46.171]                         else {
[17:26:46.171]                           version <- NULL
[17:26:46.171]                         }
[17:26:46.171]                         if (!has_future || version < "1.8.0") {
[17:26:46.171]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.171]                             "", base::R.version$version.string), 
[17:26:46.171]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.171]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.171]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.171]                               "release", "version")], collapse = " "), 
[17:26:46.171]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.171]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.171]                             info)
[17:26:46.171]                           info <- base::paste(info, collapse = "; ")
[17:26:46.171]                           if (!has_future) {
[17:26:46.171]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.171]                               info)
[17:26:46.171]                           }
[17:26:46.171]                           else {
[17:26:46.171]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.171]                               info, version)
[17:26:46.171]                           }
[17:26:46.171]                           base::stop(msg)
[17:26:46.171]                         }
[17:26:46.171]                       })
[17:26:46.171]                     }
[17:26:46.171]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.171]                     base::options(mc.cores = 1L)
[17:26:46.171]                   }
[17:26:46.171]                   ...future.strategy.old <- future::plan("list")
[17:26:46.171]                   options(future.plan = NULL)
[17:26:46.171]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.171]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.171]                 }
[17:26:46.171]                 ...future.workdir <- getwd()
[17:26:46.171]             }
[17:26:46.171]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.171]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.171]         }
[17:26:46.171]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.171]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.171]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.171]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.171]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.171]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.171]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.171]             base::names(...future.oldOptions))
[17:26:46.171]     }
[17:26:46.171]     if (FALSE) {
[17:26:46.171]     }
[17:26:46.171]     else {
[17:26:46.171]         if (TRUE) {
[17:26:46.171]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.171]                 open = "w")
[17:26:46.171]         }
[17:26:46.171]         else {
[17:26:46.171]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.171]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.171]         }
[17:26:46.171]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.171]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.171]             base::sink(type = "output", split = FALSE)
[17:26:46.171]             base::close(...future.stdout)
[17:26:46.171]         }, add = TRUE)
[17:26:46.171]     }
[17:26:46.171]     ...future.frame <- base::sys.nframe()
[17:26:46.171]     ...future.conditions <- base::list()
[17:26:46.171]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.171]     if (FALSE) {
[17:26:46.171]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.171]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.171]     }
[17:26:46.171]     ...future.result <- base::tryCatch({
[17:26:46.171]         base::withCallingHandlers({
[17:26:46.171]             ...future.value <- base::withVisible(base::local({
[17:26:46.171]                 ...future.makeSendCondition <- base::local({
[17:26:46.171]                   sendCondition <- NULL
[17:26:46.171]                   function(frame = 1L) {
[17:26:46.171]                     if (is.function(sendCondition)) 
[17:26:46.171]                       return(sendCondition)
[17:26:46.171]                     ns <- getNamespace("parallel")
[17:26:46.171]                     if (exists("sendData", mode = "function", 
[17:26:46.171]                       envir = ns)) {
[17:26:46.171]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.171]                         envir = ns)
[17:26:46.171]                       envir <- sys.frame(frame)
[17:26:46.171]                       master <- NULL
[17:26:46.171]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.171]                         !identical(envir, emptyenv())) {
[17:26:46.171]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.171]                           inherits = FALSE)) {
[17:26:46.171]                           master <- get("master", mode = "list", 
[17:26:46.171]                             envir = envir, inherits = FALSE)
[17:26:46.171]                           if (inherits(master, c("SOCKnode", 
[17:26:46.171]                             "SOCK0node"))) {
[17:26:46.171]                             sendCondition <<- function(cond) {
[17:26:46.171]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.171]                                 success = TRUE)
[17:26:46.171]                               parallel_sendData(master, data)
[17:26:46.171]                             }
[17:26:46.171]                             return(sendCondition)
[17:26:46.171]                           }
[17:26:46.171]                         }
[17:26:46.171]                         frame <- frame + 1L
[17:26:46.171]                         envir <- sys.frame(frame)
[17:26:46.171]                       }
[17:26:46.171]                     }
[17:26:46.171]                     sendCondition <<- function(cond) NULL
[17:26:46.171]                   }
[17:26:46.171]                 })
[17:26:46.171]                 withCallingHandlers({
[17:26:46.171]                   {
[17:26:46.171]                     4
[17:26:46.171]                   }
[17:26:46.171]                 }, immediateCondition = function(cond) {
[17:26:46.171]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.171]                   sendCondition(cond)
[17:26:46.171]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.171]                   {
[17:26:46.171]                     inherits <- base::inherits
[17:26:46.171]                     invokeRestart <- base::invokeRestart
[17:26:46.171]                     is.null <- base::is.null
[17:26:46.171]                     muffled <- FALSE
[17:26:46.171]                     if (inherits(cond, "message")) {
[17:26:46.171]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.171]                       if (muffled) 
[17:26:46.171]                         invokeRestart("muffleMessage")
[17:26:46.171]                     }
[17:26:46.171]                     else if (inherits(cond, "warning")) {
[17:26:46.171]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.171]                       if (muffled) 
[17:26:46.171]                         invokeRestart("muffleWarning")
[17:26:46.171]                     }
[17:26:46.171]                     else if (inherits(cond, "condition")) {
[17:26:46.171]                       if (!is.null(pattern)) {
[17:26:46.171]                         computeRestarts <- base::computeRestarts
[17:26:46.171]                         grepl <- base::grepl
[17:26:46.171]                         restarts <- computeRestarts(cond)
[17:26:46.171]                         for (restart in restarts) {
[17:26:46.171]                           name <- restart$name
[17:26:46.171]                           if (is.null(name)) 
[17:26:46.171]                             next
[17:26:46.171]                           if (!grepl(pattern, name)) 
[17:26:46.171]                             next
[17:26:46.171]                           invokeRestart(restart)
[17:26:46.171]                           muffled <- TRUE
[17:26:46.171]                           break
[17:26:46.171]                         }
[17:26:46.171]                       }
[17:26:46.171]                     }
[17:26:46.171]                     invisible(muffled)
[17:26:46.171]                   }
[17:26:46.171]                   muffleCondition(cond)
[17:26:46.171]                 })
[17:26:46.171]             }))
[17:26:46.171]             future::FutureResult(value = ...future.value$value, 
[17:26:46.171]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.171]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.171]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.171]                     ...future.globalenv.names))
[17:26:46.171]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.171]         }, condition = base::local({
[17:26:46.171]             c <- base::c
[17:26:46.171]             inherits <- base::inherits
[17:26:46.171]             invokeRestart <- base::invokeRestart
[17:26:46.171]             length <- base::length
[17:26:46.171]             list <- base::list
[17:26:46.171]             seq.int <- base::seq.int
[17:26:46.171]             signalCondition <- base::signalCondition
[17:26:46.171]             sys.calls <- base::sys.calls
[17:26:46.171]             `[[` <- base::`[[`
[17:26:46.171]             `+` <- base::`+`
[17:26:46.171]             `<<-` <- base::`<<-`
[17:26:46.171]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.171]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.171]                   3L)]
[17:26:46.171]             }
[17:26:46.171]             function(cond) {
[17:26:46.171]                 is_error <- inherits(cond, "error")
[17:26:46.171]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.171]                   NULL)
[17:26:46.171]                 if (is_error) {
[17:26:46.171]                   sessionInformation <- function() {
[17:26:46.171]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.171]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.171]                       search = base::search(), system = base::Sys.info())
[17:26:46.171]                   }
[17:26:46.171]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.171]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.171]                     cond$call), session = sessionInformation(), 
[17:26:46.171]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.171]                   signalCondition(cond)
[17:26:46.171]                 }
[17:26:46.171]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.171]                 "immediateCondition"))) {
[17:26:46.171]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.171]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.171]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.171]                   if (TRUE && !signal) {
[17:26:46.171]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.171]                     {
[17:26:46.171]                       inherits <- base::inherits
[17:26:46.171]                       invokeRestart <- base::invokeRestart
[17:26:46.171]                       is.null <- base::is.null
[17:26:46.171]                       muffled <- FALSE
[17:26:46.171]                       if (inherits(cond, "message")) {
[17:26:46.171]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.171]                         if (muffled) 
[17:26:46.171]                           invokeRestart("muffleMessage")
[17:26:46.171]                       }
[17:26:46.171]                       else if (inherits(cond, "warning")) {
[17:26:46.171]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.171]                         if (muffled) 
[17:26:46.171]                           invokeRestart("muffleWarning")
[17:26:46.171]                       }
[17:26:46.171]                       else if (inherits(cond, "condition")) {
[17:26:46.171]                         if (!is.null(pattern)) {
[17:26:46.171]                           computeRestarts <- base::computeRestarts
[17:26:46.171]                           grepl <- base::grepl
[17:26:46.171]                           restarts <- computeRestarts(cond)
[17:26:46.171]                           for (restart in restarts) {
[17:26:46.171]                             name <- restart$name
[17:26:46.171]                             if (is.null(name)) 
[17:26:46.171]                               next
[17:26:46.171]                             if (!grepl(pattern, name)) 
[17:26:46.171]                               next
[17:26:46.171]                             invokeRestart(restart)
[17:26:46.171]                             muffled <- TRUE
[17:26:46.171]                             break
[17:26:46.171]                           }
[17:26:46.171]                         }
[17:26:46.171]                       }
[17:26:46.171]                       invisible(muffled)
[17:26:46.171]                     }
[17:26:46.171]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.171]                   }
[17:26:46.171]                 }
[17:26:46.171]                 else {
[17:26:46.171]                   if (TRUE) {
[17:26:46.171]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.171]                     {
[17:26:46.171]                       inherits <- base::inherits
[17:26:46.171]                       invokeRestart <- base::invokeRestart
[17:26:46.171]                       is.null <- base::is.null
[17:26:46.171]                       muffled <- FALSE
[17:26:46.171]                       if (inherits(cond, "message")) {
[17:26:46.171]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.171]                         if (muffled) 
[17:26:46.171]                           invokeRestart("muffleMessage")
[17:26:46.171]                       }
[17:26:46.171]                       else if (inherits(cond, "warning")) {
[17:26:46.171]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.171]                         if (muffled) 
[17:26:46.171]                           invokeRestart("muffleWarning")
[17:26:46.171]                       }
[17:26:46.171]                       else if (inherits(cond, "condition")) {
[17:26:46.171]                         if (!is.null(pattern)) {
[17:26:46.171]                           computeRestarts <- base::computeRestarts
[17:26:46.171]                           grepl <- base::grepl
[17:26:46.171]                           restarts <- computeRestarts(cond)
[17:26:46.171]                           for (restart in restarts) {
[17:26:46.171]                             name <- restart$name
[17:26:46.171]                             if (is.null(name)) 
[17:26:46.171]                               next
[17:26:46.171]                             if (!grepl(pattern, name)) 
[17:26:46.171]                               next
[17:26:46.171]                             invokeRestart(restart)
[17:26:46.171]                             muffled <- TRUE
[17:26:46.171]                             break
[17:26:46.171]                           }
[17:26:46.171]                         }
[17:26:46.171]                       }
[17:26:46.171]                       invisible(muffled)
[17:26:46.171]                     }
[17:26:46.171]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.171]                   }
[17:26:46.171]                 }
[17:26:46.171]             }
[17:26:46.171]         }))
[17:26:46.171]     }, error = function(ex) {
[17:26:46.171]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.171]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.171]                 ...future.rng), started = ...future.startTime, 
[17:26:46.171]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.171]             version = "1.8"), class = "FutureResult")
[17:26:46.171]     }, finally = {
[17:26:46.171]         if (!identical(...future.workdir, getwd())) 
[17:26:46.171]             setwd(...future.workdir)
[17:26:46.171]         {
[17:26:46.171]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.171]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.171]             }
[17:26:46.171]             base::options(...future.oldOptions)
[17:26:46.171]             if (.Platform$OS.type == "windows") {
[17:26:46.171]                 old_names <- names(...future.oldEnvVars)
[17:26:46.171]                 envs <- base::Sys.getenv()
[17:26:46.171]                 names <- names(envs)
[17:26:46.171]                 common <- intersect(names, old_names)
[17:26:46.171]                 added <- setdiff(names, old_names)
[17:26:46.171]                 removed <- setdiff(old_names, names)
[17:26:46.171]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.171]                   envs[common]]
[17:26:46.171]                 NAMES <- toupper(changed)
[17:26:46.171]                 args <- list()
[17:26:46.171]                 for (kk in seq_along(NAMES)) {
[17:26:46.171]                   name <- changed[[kk]]
[17:26:46.171]                   NAME <- NAMES[[kk]]
[17:26:46.171]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.171]                     next
[17:26:46.171]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.171]                 }
[17:26:46.171]                 NAMES <- toupper(added)
[17:26:46.171]                 for (kk in seq_along(NAMES)) {
[17:26:46.171]                   name <- added[[kk]]
[17:26:46.171]                   NAME <- NAMES[[kk]]
[17:26:46.171]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.171]                     next
[17:26:46.171]                   args[[name]] <- ""
[17:26:46.171]                 }
[17:26:46.171]                 NAMES <- toupper(removed)
[17:26:46.171]                 for (kk in seq_along(NAMES)) {
[17:26:46.171]                   name <- removed[[kk]]
[17:26:46.171]                   NAME <- NAMES[[kk]]
[17:26:46.171]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.171]                     next
[17:26:46.171]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.171]                 }
[17:26:46.171]                 if (length(args) > 0) 
[17:26:46.171]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.171]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.171]             }
[17:26:46.171]             else {
[17:26:46.171]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.171]             }
[17:26:46.171]             {
[17:26:46.171]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.171]                   0L) {
[17:26:46.171]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.171]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.171]                   base::options(opts)
[17:26:46.171]                 }
[17:26:46.171]                 {
[17:26:46.171]                   {
[17:26:46.171]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.171]                     NULL
[17:26:46.171]                   }
[17:26:46.171]                   options(future.plan = NULL)
[17:26:46.171]                   if (is.na(NA_character_)) 
[17:26:46.171]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.171]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.171]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.171]                     .init = FALSE)
[17:26:46.171]                 }
[17:26:46.171]             }
[17:26:46.171]         }
[17:26:46.171]     })
[17:26:46.171]     if (TRUE) {
[17:26:46.171]         base::sink(type = "output", split = FALSE)
[17:26:46.171]         if (TRUE) {
[17:26:46.171]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.171]         }
[17:26:46.171]         else {
[17:26:46.171]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.171]         }
[17:26:46.171]         base::close(...future.stdout)
[17:26:46.171]         ...future.stdout <- NULL
[17:26:46.171]     }
[17:26:46.171]     ...future.result$conditions <- ...future.conditions
[17:26:46.171]     ...future.result$finished <- base::Sys.time()
[17:26:46.171]     ...future.result
[17:26:46.171] }
[17:26:46.175] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:46.188] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.189] - Validating connection of MultisessionFuture
[17:26:46.189] - received message: FutureResult
[17:26:46.189] - Received FutureResult
[17:26:46.189] - Erased future from FutureRegistry
[17:26:46.190] result() for ClusterFuture ...
[17:26:46.190] - result already collected: FutureResult
[17:26:46.190] result() for ClusterFuture ... done
[17:26:46.190] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.190] result() for ClusterFuture ...
[17:26:46.190] - result already collected: FutureResult
[17:26:46.190] result() for ClusterFuture ... done
[17:26:46.191] result() for ClusterFuture ...
[17:26:46.191] - result already collected: FutureResult
[17:26:46.191] result() for ClusterFuture ... done
[17:26:46.192] MultisessionFuture started
[17:26:46.192] - Launch lazy future ... done
[17:26:46.193] run() for 'MultisessionFuture' ... done
<environment: 0x0000022310b30ff0> 
<environment: 0x000002230b9440d0> 
[17:26:46.194] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.195] - Validating connection of MultisessionFuture
[17:26:46.195] - received message: FutureResult
[17:26:46.195] - Received FutureResult
[17:26:46.195] - Erased future from FutureRegistry
[17:26:46.195] result() for ClusterFuture ...
[17:26:46.196] - result already collected: FutureResult
[17:26:46.196] result() for ClusterFuture ... done
[17:26:46.196] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.205] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.206] - Validating connection of MultisessionFuture
[17:26:46.206] - received message: FutureResult
[17:26:46.206] - Received FutureResult
[17:26:46.206] - Erased future from FutureRegistry
[17:26:46.206] result() for ClusterFuture ...
[17:26:46.207] - result already collected: FutureResult
[17:26:46.207] result() for ClusterFuture ... done
[17:26:46.207] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[17:26:46.208] resolve() on environment ...
[17:26:46.209]  recursive: 0
[17:26:46.209]  elements: [4] 'a', 'b', 'c', 'd'
[17:26:46.209] signalConditionsASAP(numeric, pos=1) ...
[17:26:46.210] - nx: 4
[17:26:46.210] - relay: TRUE
[17:26:46.210] - stdout: TRUE
[17:26:46.210] - signal: TRUE
[17:26:46.210] - resignal: FALSE
[17:26:46.210] - force: TRUE
[17:26:46.211] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.211] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.211]  - until=2
[17:26:46.211]  - relaying element #2
[17:26:46.211] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:46.211] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.212] signalConditionsASAP(NULL, pos=1) ... done
[17:26:46.212]  length: 3 (resolved future 1)
[17:26:46.212] Future #2
[17:26:46.212] result() for ClusterFuture ...
[17:26:46.212] - result already collected: FutureResult
[17:26:46.212] result() for ClusterFuture ... done
[17:26:46.213] result() for ClusterFuture ...
[17:26:46.213] - result already collected: FutureResult
[17:26:46.213] result() for ClusterFuture ... done
[17:26:46.213] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:46.213] - nx: 4
[17:26:46.213] - relay: TRUE
[17:26:46.214] - stdout: TRUE
[17:26:46.214] - signal: TRUE
[17:26:46.214] - resignal: FALSE
[17:26:46.214] - force: TRUE
[17:26:46.214] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:26:46.214] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:26:46.214]  - until=2
[17:26:46.215]  - relaying element #2
[17:26:46.215] result() for ClusterFuture ...
[17:26:46.215] - result already collected: FutureResult
[17:26:46.215] result() for ClusterFuture ... done
[17:26:46.215] result() for ClusterFuture ...
[17:26:46.215] - result already collected: FutureResult
[17:26:46.216] result() for ClusterFuture ... done
[17:26:46.216] result() for ClusterFuture ...
[17:26:46.216] - result already collected: FutureResult
[17:26:46.216] result() for ClusterFuture ... done
[17:26:46.216] result() for ClusterFuture ...
[17:26:46.216] - result already collected: FutureResult
[17:26:46.217] result() for ClusterFuture ... done
[17:26:46.217] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:46.217] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:46.217] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:46.217]  length: 2 (resolved future 2)
[17:26:46.218] Future #3
[17:26:46.218] result() for ClusterFuture ...
[17:26:46.218] - result already collected: FutureResult
[17:26:46.218] result() for ClusterFuture ... done
[17:26:46.218] result() for ClusterFuture ...
[17:26:46.218] - result already collected: FutureResult
[17:26:46.219] result() for ClusterFuture ... done
[17:26:46.219] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:46.219] - nx: 4
[17:26:46.219] - relay: TRUE
[17:26:46.219] - stdout: TRUE
[17:26:46.219] - signal: TRUE
[17:26:46.220] - resignal: FALSE
[17:26:46.220] - force: TRUE
[17:26:46.220] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:26:46.220] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[17:26:46.220]  - until=3
[17:26:46.221]  - relaying element #3
[17:26:46.221] result() for ClusterFuture ...
[17:26:46.221] - result already collected: FutureResult
[17:26:46.221] result() for ClusterFuture ... done
[17:26:46.221] result() for ClusterFuture ...
[17:26:46.222] - result already collected: FutureResult
[17:26:46.222] result() for ClusterFuture ... done
[17:26:46.222] result() for ClusterFuture ...
[17:26:46.222] - result already collected: FutureResult
[17:26:46.223] result() for ClusterFuture ... done
[17:26:46.223] result() for ClusterFuture ...
[17:26:46.223] - result already collected: FutureResult
[17:26:46.223] result() for ClusterFuture ... done
[17:26:46.223] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:46.223] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:46.224] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:46.224]  length: 1 (resolved future 3)
[17:26:46.224] Future #4
[17:26:46.224] result() for ClusterFuture ...
[17:26:46.224] - result already collected: FutureResult
[17:26:46.224] result() for ClusterFuture ... done
[17:26:46.225] result() for ClusterFuture ...
[17:26:46.225] - result already collected: FutureResult
[17:26:46.225] result() for ClusterFuture ... done
[17:26:46.225] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:46.225] - nx: 4
[17:26:46.226] - relay: TRUE
[17:26:46.226] - stdout: TRUE
[17:26:46.226] - signal: TRUE
[17:26:46.226] - resignal: FALSE
[17:26:46.226] - force: TRUE
[17:26:46.226] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:26:46.227] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[17:26:46.227]  - until=4
[17:26:46.227]  - relaying element #4
[17:26:46.227] result() for ClusterFuture ...
[17:26:46.227] - result already collected: FutureResult
[17:26:46.227] result() for ClusterFuture ... done
[17:26:46.228] result() for ClusterFuture ...
[17:26:46.228] - result already collected: FutureResult
[17:26:46.228] result() for ClusterFuture ... done
[17:26:46.228] result() for ClusterFuture ...
[17:26:46.228] - result already collected: FutureResult
[17:26:46.229] result() for ClusterFuture ... done
[17:26:46.229] result() for ClusterFuture ...
[17:26:46.229] - result already collected: FutureResult
[17:26:46.229] result() for ClusterFuture ... done
[17:26:46.229] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:46.229] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:46.230] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:46.230]  length: 0 (resolved future 4)
[17:26:46.230] Relaying remaining futures
[17:26:46.230] signalConditionsASAP(NULL, pos=0) ...
[17:26:46.230] - nx: 4
[17:26:46.230] - relay: TRUE
[17:26:46.231] - stdout: TRUE
[17:26:46.231] - signal: TRUE
[17:26:46.231] - resignal: FALSE
[17:26:46.231] - force: TRUE
[17:26:46.231] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:46.231] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[17:26:46.232] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:26:46.232] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[17:26:46.232] signalConditionsASAP(NULL, pos=0) ... done
[17:26:46.232] resolve() on environment ... DONE
[17:26:46.232] result() for ClusterFuture ...
[17:26:46.233] - result already collected: FutureResult
[17:26:46.233] result() for ClusterFuture ... done
[17:26:46.233] result() for ClusterFuture ...
[17:26:46.233] - result already collected: FutureResult
[17:26:46.233] result() for ClusterFuture ... done
[17:26:46.233] result() for ClusterFuture ...
[17:26:46.234] - result already collected: FutureResult
[17:26:46.234] result() for ClusterFuture ... done
[17:26:46.234] result() for ClusterFuture ...
[17:26:46.234] - result already collected: FutureResult
[17:26:46.234] result() for ClusterFuture ... done
[17:26:46.235] result() for ClusterFuture ...
[17:26:46.235] - result already collected: FutureResult
[17:26:46.235] result() for ClusterFuture ... done
[17:26:46.235] result() for ClusterFuture ...
[17:26:46.235] - result already collected: FutureResult
[17:26:46.235] result() for ClusterFuture ... done
<environment: 0x000002230b526ff0> 
*** futures() - environment ... DONE
Type of object: listenv
Type of future: multisession
[17:26:46.236] plan(): Setting new future strategy stack:
[17:26:46.237] List of future strategies:
[17:26:46.237] 1. multisession:
[17:26:46.237]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:46.237]    - tweaked: FALSE
[17:26:46.237]    - call: plan(strategy)
[17:26:46.237] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:46.238] multisession:
[17:26:46.238] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:46.238] - tweaked: FALSE
[17:26:46.238] - call: plan(strategy)
[17:26:46.241] getGlobalsAndPackages() ...
[17:26:46.241] Not searching for globals
[17:26:46.241] - globals: [0] <none>
[17:26:46.241] getGlobalsAndPackages() ... DONE
[17:26:46.242] [local output] makeClusterPSOCK() ...
[17:26:46.244] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:46.247] [local output] Base port: 38706
[17:26:46.247] [local output] Getting setup options for 2 cluster nodes ...
[17:26:46.247] [local output]  - Node 1 of 2 ...
[17:26:46.248] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:46.249] [local output] Rscript port: 38706

[17:26:46.249] [local output]  - Node 2 of 2 ...
[17:26:46.250] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:46.251] [local output] Rscript port: 38706

[17:26:46.252] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:46.252] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:46.252] [local output] Setting up PSOCK nodes in parallel
[17:26:46.252] List of 36
[17:26:46.252]  $ worker          : chr "localhost"
[17:26:46.252]   ..- attr(*, "localhost")= logi TRUE
[17:26:46.252]  $ master          : chr "localhost"
[17:26:46.252]  $ port            : int 38706
[17:26:46.252]  $ connectTimeout  : num 120
[17:26:46.252]  $ timeout         : num 120
[17:26:46.252]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:46.252]  $ homogeneous     : logi TRUE
[17:26:46.252]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futures.R:105464:CRANWIN3:CRAN\""| __truncated__
[17:26:46.252]  $ rscript_envs    : NULL
[17:26:46.252]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:46.252]  $ rscript_startup : NULL
[17:26:46.252]  $ rscript_sh      : chr "cmd"
[17:26:46.252]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:46.252]  $ methods         : logi TRUE
[17:26:46.252]  $ socketOptions   : chr "no-delay"
[17:26:46.252]  $ useXDR          : logi FALSE
[17:26:46.252]  $ outfile         : chr "/dev/null"
[17:26:46.252]  $ renice          : int NA
[17:26:46.252]  $ rshcmd          : NULL
[17:26:46.252]  $ user            : chr(0) 
[17:26:46.252]  $ revtunnel       : logi FALSE
[17:26:46.252]  $ rshlogfile      : NULL
[17:26:46.252]  $ rshopts         : chr(0) 
[17:26:46.252]  $ rank            : int 1
[17:26:46.252]  $ manual          : logi FALSE
[17:26:46.252]  $ dryrun          : logi FALSE
[17:26:46.252]  $ quiet           : logi FALSE
[17:26:46.252]  $ setup_strategy  : chr "parallel"
[17:26:46.252]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:46.252]  $ pidfile         : chr "D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf825e8831.pid"
[17:26:46.252]  $ rshcmd_label    : NULL
[17:26:46.252]  $ rsh_call        : NULL
[17:26:46.252]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:46.252]  $ localMachine    : logi TRUE
[17:26:46.252]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:46.252]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:46.252]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:46.252]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:46.252]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:46.252]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:26:46.252]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:46.252]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:46.252]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:46.252]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:46.252]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:46.252]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:46.252]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:46.252]  $ arguments       :List of 28
[17:26:46.252]   ..$ worker          : chr "localhost"
[17:26:46.252]   ..$ master          : NULL
[17:26:46.252]   ..$ port            : int 38706
[17:26:46.252]   ..$ connectTimeout  : num 120
[17:26:46.252]   ..$ timeout         : num 120
[17:26:46.252]   ..$ rscript         : NULL
[17:26:46.252]   ..$ homogeneous     : NULL
[17:26:46.252]   ..$ rscript_args    : NULL
[17:26:46.252]   ..$ rscript_envs    : NULL
[17:26:46.252]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:46.252]   ..$ rscript_startup : NULL
[17:26:46.252]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:26:46.252]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:46.252]   ..$ methods         : logi TRUE
[17:26:46.252]   ..$ socketOptions   : chr "no-delay"
[17:26:46.252]   ..$ useXDR          : logi FALSE
[17:26:46.252]   ..$ outfile         : chr "/dev/null"
[17:26:46.252]   ..$ renice          : int NA
[17:26:46.252]   ..$ rshcmd          : NULL
[17:26:46.252]   ..$ user            : NULL
[17:26:46.252]   ..$ revtunnel       : logi NA
[17:26:46.252]   ..$ rshlogfile      : NULL
[17:26:46.252]   ..$ rshopts         : NULL
[17:26:46.252]   ..$ rank            : int 1
[17:26:46.252]   ..$ manual          : logi FALSE
[17:26:46.252]   ..$ dryrun          : logi FALSE
[17:26:46.252]   ..$ quiet           : logi FALSE
[17:26:46.252]   ..$ setup_strategy  : chr "parallel"
[17:26:46.252]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:46.273] [local output] System call to launch all workers:
[17:26:46.274] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futures.R:105464:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp02CUDv/worker.rank=1.parallelly.parent=105464.19bf825e8831.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=38706 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:46.274] [local output] Starting PSOCK main server
[17:26:46.279] [local output] Workers launched
[17:26:46.280] [local output] Waiting for workers to connect back
[17:26:46.280]  - [local output] 0 workers out of 2 ready
[17:26:46.439]  - [local output] 0 workers out of 2 ready
[17:26:46.440]  - [local output] 1 workers out of 2 ready
[17:26:46.440]  - [local output] 2 workers out of 2 ready
[17:26:46.441] [local output] Launching of workers completed
[17:26:46.441] [local output] Collecting session information from workers
[17:26:46.442] [local output]  - Worker #1 of 2
[17:26:46.442] [local output]  - Worker #2 of 2
[17:26:46.442] [local output] makeClusterPSOCK() ... done
[17:26:46.455] Packages needed by the future expression (n = 0): <none>
[17:26:46.455] Packages needed by future strategies (n = 0): <none>
[17:26:46.456] {
[17:26:46.456]     {
[17:26:46.456]         {
[17:26:46.456]             ...future.startTime <- base::Sys.time()
[17:26:46.456]             {
[17:26:46.456]                 {
[17:26:46.456]                   {
[17:26:46.456]                     {
[17:26:46.456]                       base::local({
[17:26:46.456]                         has_future <- base::requireNamespace("future", 
[17:26:46.456]                           quietly = TRUE)
[17:26:46.456]                         if (has_future) {
[17:26:46.456]                           ns <- base::getNamespace("future")
[17:26:46.456]                           version <- ns[[".package"]][["version"]]
[17:26:46.456]                           if (is.null(version)) 
[17:26:46.456]                             version <- utils::packageVersion("future")
[17:26:46.456]                         }
[17:26:46.456]                         else {
[17:26:46.456]                           version <- NULL
[17:26:46.456]                         }
[17:26:46.456]                         if (!has_future || version < "1.8.0") {
[17:26:46.456]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.456]                             "", base::R.version$version.string), 
[17:26:46.456]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.456]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.456]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.456]                               "release", "version")], collapse = " "), 
[17:26:46.456]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.456]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.456]                             info)
[17:26:46.456]                           info <- base::paste(info, collapse = "; ")
[17:26:46.456]                           if (!has_future) {
[17:26:46.456]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.456]                               info)
[17:26:46.456]                           }
[17:26:46.456]                           else {
[17:26:46.456]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.456]                               info, version)
[17:26:46.456]                           }
[17:26:46.456]                           base::stop(msg)
[17:26:46.456]                         }
[17:26:46.456]                       })
[17:26:46.456]                     }
[17:26:46.456]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.456]                     base::options(mc.cores = 1L)
[17:26:46.456]                   }
[17:26:46.456]                   ...future.strategy.old <- future::plan("list")
[17:26:46.456]                   options(future.plan = NULL)
[17:26:46.456]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.456]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.456]                 }
[17:26:46.456]                 ...future.workdir <- getwd()
[17:26:46.456]             }
[17:26:46.456]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.456]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.456]         }
[17:26:46.456]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.456]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.456]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.456]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.456]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.456]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.456]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.456]             base::names(...future.oldOptions))
[17:26:46.456]     }
[17:26:46.456]     if (FALSE) {
[17:26:46.456]     }
[17:26:46.456]     else {
[17:26:46.456]         if (TRUE) {
[17:26:46.456]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.456]                 open = "w")
[17:26:46.456]         }
[17:26:46.456]         else {
[17:26:46.456]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.456]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.456]         }
[17:26:46.456]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.456]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.456]             base::sink(type = "output", split = FALSE)
[17:26:46.456]             base::close(...future.stdout)
[17:26:46.456]         }, add = TRUE)
[17:26:46.456]     }
[17:26:46.456]     ...future.frame <- base::sys.nframe()
[17:26:46.456]     ...future.conditions <- base::list()
[17:26:46.456]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.456]     if (FALSE) {
[17:26:46.456]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.456]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.456]     }
[17:26:46.456]     ...future.result <- base::tryCatch({
[17:26:46.456]         base::withCallingHandlers({
[17:26:46.456]             ...future.value <- base::withVisible(base::local({
[17:26:46.456]                 ...future.makeSendCondition <- base::local({
[17:26:46.456]                   sendCondition <- NULL
[17:26:46.456]                   function(frame = 1L) {
[17:26:46.456]                     if (is.function(sendCondition)) 
[17:26:46.456]                       return(sendCondition)
[17:26:46.456]                     ns <- getNamespace("parallel")
[17:26:46.456]                     if (exists("sendData", mode = "function", 
[17:26:46.456]                       envir = ns)) {
[17:26:46.456]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.456]                         envir = ns)
[17:26:46.456]                       envir <- sys.frame(frame)
[17:26:46.456]                       master <- NULL
[17:26:46.456]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.456]                         !identical(envir, emptyenv())) {
[17:26:46.456]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.456]                           inherits = FALSE)) {
[17:26:46.456]                           master <- get("master", mode = "list", 
[17:26:46.456]                             envir = envir, inherits = FALSE)
[17:26:46.456]                           if (inherits(master, c("SOCKnode", 
[17:26:46.456]                             "SOCK0node"))) {
[17:26:46.456]                             sendCondition <<- function(cond) {
[17:26:46.456]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.456]                                 success = TRUE)
[17:26:46.456]                               parallel_sendData(master, data)
[17:26:46.456]                             }
[17:26:46.456]                             return(sendCondition)
[17:26:46.456]                           }
[17:26:46.456]                         }
[17:26:46.456]                         frame <- frame + 1L
[17:26:46.456]                         envir <- sys.frame(frame)
[17:26:46.456]                       }
[17:26:46.456]                     }
[17:26:46.456]                     sendCondition <<- function(cond) NULL
[17:26:46.456]                   }
[17:26:46.456]                 })
[17:26:46.456]                 withCallingHandlers({
[17:26:46.456]                   NA
[17:26:46.456]                 }, immediateCondition = function(cond) {
[17:26:46.456]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.456]                   sendCondition(cond)
[17:26:46.456]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.456]                   {
[17:26:46.456]                     inherits <- base::inherits
[17:26:46.456]                     invokeRestart <- base::invokeRestart
[17:26:46.456]                     is.null <- base::is.null
[17:26:46.456]                     muffled <- FALSE
[17:26:46.456]                     if (inherits(cond, "message")) {
[17:26:46.456]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.456]                       if (muffled) 
[17:26:46.456]                         invokeRestart("muffleMessage")
[17:26:46.456]                     }
[17:26:46.456]                     else if (inherits(cond, "warning")) {
[17:26:46.456]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.456]                       if (muffled) 
[17:26:46.456]                         invokeRestart("muffleWarning")
[17:26:46.456]                     }
[17:26:46.456]                     else if (inherits(cond, "condition")) {
[17:26:46.456]                       if (!is.null(pattern)) {
[17:26:46.456]                         computeRestarts <- base::computeRestarts
[17:26:46.456]                         grepl <- base::grepl
[17:26:46.456]                         restarts <- computeRestarts(cond)
[17:26:46.456]                         for (restart in restarts) {
[17:26:46.456]                           name <- restart$name
[17:26:46.456]                           if (is.null(name)) 
[17:26:46.456]                             next
[17:26:46.456]                           if (!grepl(pattern, name)) 
[17:26:46.456]                             next
[17:26:46.456]                           invokeRestart(restart)
[17:26:46.456]                           muffled <- TRUE
[17:26:46.456]                           break
[17:26:46.456]                         }
[17:26:46.456]                       }
[17:26:46.456]                     }
[17:26:46.456]                     invisible(muffled)
[17:26:46.456]                   }
[17:26:46.456]                   muffleCondition(cond)
[17:26:46.456]                 })
[17:26:46.456]             }))
[17:26:46.456]             future::FutureResult(value = ...future.value$value, 
[17:26:46.456]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.456]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.456]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.456]                     ...future.globalenv.names))
[17:26:46.456]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.456]         }, condition = base::local({
[17:26:46.456]             c <- base::c
[17:26:46.456]             inherits <- base::inherits
[17:26:46.456]             invokeRestart <- base::invokeRestart
[17:26:46.456]             length <- base::length
[17:26:46.456]             list <- base::list
[17:26:46.456]             seq.int <- base::seq.int
[17:26:46.456]             signalCondition <- base::signalCondition
[17:26:46.456]             sys.calls <- base::sys.calls
[17:26:46.456]             `[[` <- base::`[[`
[17:26:46.456]             `+` <- base::`+`
[17:26:46.456]             `<<-` <- base::`<<-`
[17:26:46.456]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.456]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.456]                   3L)]
[17:26:46.456]             }
[17:26:46.456]             function(cond) {
[17:26:46.456]                 is_error <- inherits(cond, "error")
[17:26:46.456]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.456]                   NULL)
[17:26:46.456]                 if (is_error) {
[17:26:46.456]                   sessionInformation <- function() {
[17:26:46.456]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.456]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.456]                       search = base::search(), system = base::Sys.info())
[17:26:46.456]                   }
[17:26:46.456]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.456]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.456]                     cond$call), session = sessionInformation(), 
[17:26:46.456]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.456]                   signalCondition(cond)
[17:26:46.456]                 }
[17:26:46.456]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.456]                 "immediateCondition"))) {
[17:26:46.456]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.456]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.456]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.456]                   if (TRUE && !signal) {
[17:26:46.456]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.456]                     {
[17:26:46.456]                       inherits <- base::inherits
[17:26:46.456]                       invokeRestart <- base::invokeRestart
[17:26:46.456]                       is.null <- base::is.null
[17:26:46.456]                       muffled <- FALSE
[17:26:46.456]                       if (inherits(cond, "message")) {
[17:26:46.456]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.456]                         if (muffled) 
[17:26:46.456]                           invokeRestart("muffleMessage")
[17:26:46.456]                       }
[17:26:46.456]                       else if (inherits(cond, "warning")) {
[17:26:46.456]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.456]                         if (muffled) 
[17:26:46.456]                           invokeRestart("muffleWarning")
[17:26:46.456]                       }
[17:26:46.456]                       else if (inherits(cond, "condition")) {
[17:26:46.456]                         if (!is.null(pattern)) {
[17:26:46.456]                           computeRestarts <- base::computeRestarts
[17:26:46.456]                           grepl <- base::grepl
[17:26:46.456]                           restarts <- computeRestarts(cond)
[17:26:46.456]                           for (restart in restarts) {
[17:26:46.456]                             name <- restart$name
[17:26:46.456]                             if (is.null(name)) 
[17:26:46.456]                               next
[17:26:46.456]                             if (!grepl(pattern, name)) 
[17:26:46.456]                               next
[17:26:46.456]                             invokeRestart(restart)
[17:26:46.456]                             muffled <- TRUE
[17:26:46.456]                             break
[17:26:46.456]                           }
[17:26:46.456]                         }
[17:26:46.456]                       }
[17:26:46.456]                       invisible(muffled)
[17:26:46.456]                     }
[17:26:46.456]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.456]                   }
[17:26:46.456]                 }
[17:26:46.456]                 else {
[17:26:46.456]                   if (TRUE) {
[17:26:46.456]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.456]                     {
[17:26:46.456]                       inherits <- base::inherits
[17:26:46.456]                       invokeRestart <- base::invokeRestart
[17:26:46.456]                       is.null <- base::is.null
[17:26:46.456]                       muffled <- FALSE
[17:26:46.456]                       if (inherits(cond, "message")) {
[17:26:46.456]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.456]                         if (muffled) 
[17:26:46.456]                           invokeRestart("muffleMessage")
[17:26:46.456]                       }
[17:26:46.456]                       else if (inherits(cond, "warning")) {
[17:26:46.456]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.456]                         if (muffled) 
[17:26:46.456]                           invokeRestart("muffleWarning")
[17:26:46.456]                       }
[17:26:46.456]                       else if (inherits(cond, "condition")) {
[17:26:46.456]                         if (!is.null(pattern)) {
[17:26:46.456]                           computeRestarts <- base::computeRestarts
[17:26:46.456]                           grepl <- base::grepl
[17:26:46.456]                           restarts <- computeRestarts(cond)
[17:26:46.456]                           for (restart in restarts) {
[17:26:46.456]                             name <- restart$name
[17:26:46.456]                             if (is.null(name)) 
[17:26:46.456]                               next
[17:26:46.456]                             if (!grepl(pattern, name)) 
[17:26:46.456]                               next
[17:26:46.456]                             invokeRestart(restart)
[17:26:46.456]                             muffled <- TRUE
[17:26:46.456]                             break
[17:26:46.456]                           }
[17:26:46.456]                         }
[17:26:46.456]                       }
[17:26:46.456]                       invisible(muffled)
[17:26:46.456]                     }
[17:26:46.456]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.456]                   }
[17:26:46.456]                 }
[17:26:46.456]             }
[17:26:46.456]         }))
[17:26:46.456]     }, error = function(ex) {
[17:26:46.456]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.456]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.456]                 ...future.rng), started = ...future.startTime, 
[17:26:46.456]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.456]             version = "1.8"), class = "FutureResult")
[17:26:46.456]     }, finally = {
[17:26:46.456]         if (!identical(...future.workdir, getwd())) 
[17:26:46.456]             setwd(...future.workdir)
[17:26:46.456]         {
[17:26:46.456]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.456]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.456]             }
[17:26:46.456]             base::options(...future.oldOptions)
[17:26:46.456]             if (.Platform$OS.type == "windows") {
[17:26:46.456]                 old_names <- names(...future.oldEnvVars)
[17:26:46.456]                 envs <- base::Sys.getenv()
[17:26:46.456]                 names <- names(envs)
[17:26:46.456]                 common <- intersect(names, old_names)
[17:26:46.456]                 added <- setdiff(names, old_names)
[17:26:46.456]                 removed <- setdiff(old_names, names)
[17:26:46.456]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.456]                   envs[common]]
[17:26:46.456]                 NAMES <- toupper(changed)
[17:26:46.456]                 args <- list()
[17:26:46.456]                 for (kk in seq_along(NAMES)) {
[17:26:46.456]                   name <- changed[[kk]]
[17:26:46.456]                   NAME <- NAMES[[kk]]
[17:26:46.456]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.456]                     next
[17:26:46.456]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.456]                 }
[17:26:46.456]                 NAMES <- toupper(added)
[17:26:46.456]                 for (kk in seq_along(NAMES)) {
[17:26:46.456]                   name <- added[[kk]]
[17:26:46.456]                   NAME <- NAMES[[kk]]
[17:26:46.456]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.456]                     next
[17:26:46.456]                   args[[name]] <- ""
[17:26:46.456]                 }
[17:26:46.456]                 NAMES <- toupper(removed)
[17:26:46.456]                 for (kk in seq_along(NAMES)) {
[17:26:46.456]                   name <- removed[[kk]]
[17:26:46.456]                   NAME <- NAMES[[kk]]
[17:26:46.456]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.456]                     next
[17:26:46.456]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.456]                 }
[17:26:46.456]                 if (length(args) > 0) 
[17:26:46.456]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.456]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.456]             }
[17:26:46.456]             else {
[17:26:46.456]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.456]             }
[17:26:46.456]             {
[17:26:46.456]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.456]                   0L) {
[17:26:46.456]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.456]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.456]                   base::options(opts)
[17:26:46.456]                 }
[17:26:46.456]                 {
[17:26:46.456]                   {
[17:26:46.456]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.456]                     NULL
[17:26:46.456]                   }
[17:26:46.456]                   options(future.plan = NULL)
[17:26:46.456]                   if (is.na(NA_character_)) 
[17:26:46.456]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.456]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.456]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.456]                     .init = FALSE)
[17:26:46.456]                 }
[17:26:46.456]             }
[17:26:46.456]         }
[17:26:46.456]     })
[17:26:46.456]     if (TRUE) {
[17:26:46.456]         base::sink(type = "output", split = FALSE)
[17:26:46.456]         if (TRUE) {
[17:26:46.456]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.456]         }
[17:26:46.456]         else {
[17:26:46.456]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.456]         }
[17:26:46.456]         base::close(...future.stdout)
[17:26:46.456]         ...future.stdout <- NULL
[17:26:46.456]     }
[17:26:46.456]     ...future.result$conditions <- ...future.conditions
[17:26:46.456]     ...future.result$finished <- base::Sys.time()
[17:26:46.456]     ...future.result
[17:26:46.456] }
[17:26:46.539] MultisessionFuture started
[17:26:46.540] result() for ClusterFuture ...
[17:26:46.540] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.540] - Validating connection of MultisessionFuture
[17:26:46.592] - received message: FutureResult
[17:26:46.593] - Received FutureResult
[17:26:46.593] - Erased future from FutureRegistry
[17:26:46.593] result() for ClusterFuture ...
[17:26:46.593] - result already collected: FutureResult
[17:26:46.593] result() for ClusterFuture ... done
[17:26:46.593] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.594] result() for ClusterFuture ... done
[17:26:46.594] result() for ClusterFuture ...
[17:26:46.594] - result already collected: FutureResult
[17:26:46.594] result() for ClusterFuture ... done
[17:26:46.594] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:46.600] plan(): nbrOfWorkers() = 2
Dimensions: NULL
[17:26:46.601] getGlobalsAndPackages() ...
[17:26:46.601] Searching for globals...
[17:26:46.601] 
[17:26:46.602] Searching for globals ... DONE
[17:26:46.602] - globals: [0] <none>
[17:26:46.602] getGlobalsAndPackages() ... DONE
[17:26:46.602] run() for 'Future' ...
[17:26:46.603] - state: 'created'
[17:26:46.603] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.617] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.617] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.617]   - Field: 'node'
[17:26:46.617]   - Field: 'label'
[17:26:46.617]   - Field: 'local'
[17:26:46.618]   - Field: 'owner'
[17:26:46.618]   - Field: 'envir'
[17:26:46.618]   - Field: 'workers'
[17:26:46.618]   - Field: 'packages'
[17:26:46.618]   - Field: 'gc'
[17:26:46.618]   - Field: 'conditions'
[17:26:46.619]   - Field: 'persistent'
[17:26:46.619]   - Field: 'expr'
[17:26:46.619]   - Field: 'uuid'
[17:26:46.619]   - Field: 'seed'
[17:26:46.619]   - Field: 'version'
[17:26:46.620]   - Field: 'result'
[17:26:46.620]   - Field: 'asynchronous'
[17:26:46.620]   - Field: 'calls'
[17:26:46.620]   - Field: 'globals'
[17:26:46.620]   - Field: 'stdout'
[17:26:46.620]   - Field: 'earlySignal'
[17:26:46.621]   - Field: 'lazy'
[17:26:46.621]   - Field: 'state'
[17:26:46.621] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.621] - Launch lazy future ...
[17:26:46.621] Packages needed by the future expression (n = 0): <none>
[17:26:46.622] Packages needed by future strategies (n = 0): <none>
[17:26:46.622] {
[17:26:46.622]     {
[17:26:46.622]         {
[17:26:46.622]             ...future.startTime <- base::Sys.time()
[17:26:46.622]             {
[17:26:46.622]                 {
[17:26:46.622]                   {
[17:26:46.622]                     {
[17:26:46.622]                       base::local({
[17:26:46.622]                         has_future <- base::requireNamespace("future", 
[17:26:46.622]                           quietly = TRUE)
[17:26:46.622]                         if (has_future) {
[17:26:46.622]                           ns <- base::getNamespace("future")
[17:26:46.622]                           version <- ns[[".package"]][["version"]]
[17:26:46.622]                           if (is.null(version)) 
[17:26:46.622]                             version <- utils::packageVersion("future")
[17:26:46.622]                         }
[17:26:46.622]                         else {
[17:26:46.622]                           version <- NULL
[17:26:46.622]                         }
[17:26:46.622]                         if (!has_future || version < "1.8.0") {
[17:26:46.622]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.622]                             "", base::R.version$version.string), 
[17:26:46.622]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.622]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.622]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.622]                               "release", "version")], collapse = " "), 
[17:26:46.622]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.622]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.622]                             info)
[17:26:46.622]                           info <- base::paste(info, collapse = "; ")
[17:26:46.622]                           if (!has_future) {
[17:26:46.622]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.622]                               info)
[17:26:46.622]                           }
[17:26:46.622]                           else {
[17:26:46.622]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.622]                               info, version)
[17:26:46.622]                           }
[17:26:46.622]                           base::stop(msg)
[17:26:46.622]                         }
[17:26:46.622]                       })
[17:26:46.622]                     }
[17:26:46.622]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.622]                     base::options(mc.cores = 1L)
[17:26:46.622]                   }
[17:26:46.622]                   ...future.strategy.old <- future::plan("list")
[17:26:46.622]                   options(future.plan = NULL)
[17:26:46.622]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.622]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.622]                 }
[17:26:46.622]                 ...future.workdir <- getwd()
[17:26:46.622]             }
[17:26:46.622]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.622]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.622]         }
[17:26:46.622]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.622]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.622]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.622]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.622]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.622]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.622]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.622]             base::names(...future.oldOptions))
[17:26:46.622]     }
[17:26:46.622]     if (FALSE) {
[17:26:46.622]     }
[17:26:46.622]     else {
[17:26:46.622]         if (TRUE) {
[17:26:46.622]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.622]                 open = "w")
[17:26:46.622]         }
[17:26:46.622]         else {
[17:26:46.622]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.622]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.622]         }
[17:26:46.622]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.622]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.622]             base::sink(type = "output", split = FALSE)
[17:26:46.622]             base::close(...future.stdout)
[17:26:46.622]         }, add = TRUE)
[17:26:46.622]     }
[17:26:46.622]     ...future.frame <- base::sys.nframe()
[17:26:46.622]     ...future.conditions <- base::list()
[17:26:46.622]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.622]     if (FALSE) {
[17:26:46.622]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.622]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.622]     }
[17:26:46.622]     ...future.result <- base::tryCatch({
[17:26:46.622]         base::withCallingHandlers({
[17:26:46.622]             ...future.value <- base::withVisible(base::local({
[17:26:46.622]                 ...future.makeSendCondition <- base::local({
[17:26:46.622]                   sendCondition <- NULL
[17:26:46.622]                   function(frame = 1L) {
[17:26:46.622]                     if (is.function(sendCondition)) 
[17:26:46.622]                       return(sendCondition)
[17:26:46.622]                     ns <- getNamespace("parallel")
[17:26:46.622]                     if (exists("sendData", mode = "function", 
[17:26:46.622]                       envir = ns)) {
[17:26:46.622]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.622]                         envir = ns)
[17:26:46.622]                       envir <- sys.frame(frame)
[17:26:46.622]                       master <- NULL
[17:26:46.622]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.622]                         !identical(envir, emptyenv())) {
[17:26:46.622]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.622]                           inherits = FALSE)) {
[17:26:46.622]                           master <- get("master", mode = "list", 
[17:26:46.622]                             envir = envir, inherits = FALSE)
[17:26:46.622]                           if (inherits(master, c("SOCKnode", 
[17:26:46.622]                             "SOCK0node"))) {
[17:26:46.622]                             sendCondition <<- function(cond) {
[17:26:46.622]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.622]                                 success = TRUE)
[17:26:46.622]                               parallel_sendData(master, data)
[17:26:46.622]                             }
[17:26:46.622]                             return(sendCondition)
[17:26:46.622]                           }
[17:26:46.622]                         }
[17:26:46.622]                         frame <- frame + 1L
[17:26:46.622]                         envir <- sys.frame(frame)
[17:26:46.622]                       }
[17:26:46.622]                     }
[17:26:46.622]                     sendCondition <<- function(cond) NULL
[17:26:46.622]                   }
[17:26:46.622]                 })
[17:26:46.622]                 withCallingHandlers({
[17:26:46.622]                   2
[17:26:46.622]                 }, immediateCondition = function(cond) {
[17:26:46.622]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.622]                   sendCondition(cond)
[17:26:46.622]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.622]                   {
[17:26:46.622]                     inherits <- base::inherits
[17:26:46.622]                     invokeRestart <- base::invokeRestart
[17:26:46.622]                     is.null <- base::is.null
[17:26:46.622]                     muffled <- FALSE
[17:26:46.622]                     if (inherits(cond, "message")) {
[17:26:46.622]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.622]                       if (muffled) 
[17:26:46.622]                         invokeRestart("muffleMessage")
[17:26:46.622]                     }
[17:26:46.622]                     else if (inherits(cond, "warning")) {
[17:26:46.622]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.622]                       if (muffled) 
[17:26:46.622]                         invokeRestart("muffleWarning")
[17:26:46.622]                     }
[17:26:46.622]                     else if (inherits(cond, "condition")) {
[17:26:46.622]                       if (!is.null(pattern)) {
[17:26:46.622]                         computeRestarts <- base::computeRestarts
[17:26:46.622]                         grepl <- base::grepl
[17:26:46.622]                         restarts <- computeRestarts(cond)
[17:26:46.622]                         for (restart in restarts) {
[17:26:46.622]                           name <- restart$name
[17:26:46.622]                           if (is.null(name)) 
[17:26:46.622]                             next
[17:26:46.622]                           if (!grepl(pattern, name)) 
[17:26:46.622]                             next
[17:26:46.622]                           invokeRestart(restart)
[17:26:46.622]                           muffled <- TRUE
[17:26:46.622]                           break
[17:26:46.622]                         }
[17:26:46.622]                       }
[17:26:46.622]                     }
[17:26:46.622]                     invisible(muffled)
[17:26:46.622]                   }
[17:26:46.622]                   muffleCondition(cond)
[17:26:46.622]                 })
[17:26:46.622]             }))
[17:26:46.622]             future::FutureResult(value = ...future.value$value, 
[17:26:46.622]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.622]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.622]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.622]                     ...future.globalenv.names))
[17:26:46.622]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.622]         }, condition = base::local({
[17:26:46.622]             c <- base::c
[17:26:46.622]             inherits <- base::inherits
[17:26:46.622]             invokeRestart <- base::invokeRestart
[17:26:46.622]             length <- base::length
[17:26:46.622]             list <- base::list
[17:26:46.622]             seq.int <- base::seq.int
[17:26:46.622]             signalCondition <- base::signalCondition
[17:26:46.622]             sys.calls <- base::sys.calls
[17:26:46.622]             `[[` <- base::`[[`
[17:26:46.622]             `+` <- base::`+`
[17:26:46.622]             `<<-` <- base::`<<-`
[17:26:46.622]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.622]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.622]                   3L)]
[17:26:46.622]             }
[17:26:46.622]             function(cond) {
[17:26:46.622]                 is_error <- inherits(cond, "error")
[17:26:46.622]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.622]                   NULL)
[17:26:46.622]                 if (is_error) {
[17:26:46.622]                   sessionInformation <- function() {
[17:26:46.622]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.622]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.622]                       search = base::search(), system = base::Sys.info())
[17:26:46.622]                   }
[17:26:46.622]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.622]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.622]                     cond$call), session = sessionInformation(), 
[17:26:46.622]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.622]                   signalCondition(cond)
[17:26:46.622]                 }
[17:26:46.622]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.622]                 "immediateCondition"))) {
[17:26:46.622]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.622]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.622]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.622]                   if (TRUE && !signal) {
[17:26:46.622]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.622]                     {
[17:26:46.622]                       inherits <- base::inherits
[17:26:46.622]                       invokeRestart <- base::invokeRestart
[17:26:46.622]                       is.null <- base::is.null
[17:26:46.622]                       muffled <- FALSE
[17:26:46.622]                       if (inherits(cond, "message")) {
[17:26:46.622]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.622]                         if (muffled) 
[17:26:46.622]                           invokeRestart("muffleMessage")
[17:26:46.622]                       }
[17:26:46.622]                       else if (inherits(cond, "warning")) {
[17:26:46.622]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.622]                         if (muffled) 
[17:26:46.622]                           invokeRestart("muffleWarning")
[17:26:46.622]                       }
[17:26:46.622]                       else if (inherits(cond, "condition")) {
[17:26:46.622]                         if (!is.null(pattern)) {
[17:26:46.622]                           computeRestarts <- base::computeRestarts
[17:26:46.622]                           grepl <- base::grepl
[17:26:46.622]                           restarts <- computeRestarts(cond)
[17:26:46.622]                           for (restart in restarts) {
[17:26:46.622]                             name <- restart$name
[17:26:46.622]                             if (is.null(name)) 
[17:26:46.622]                               next
[17:26:46.622]                             if (!grepl(pattern, name)) 
[17:26:46.622]                               next
[17:26:46.622]                             invokeRestart(restart)
[17:26:46.622]                             muffled <- TRUE
[17:26:46.622]                             break
[17:26:46.622]                           }
[17:26:46.622]                         }
[17:26:46.622]                       }
[17:26:46.622]                       invisible(muffled)
[17:26:46.622]                     }
[17:26:46.622]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.622]                   }
[17:26:46.622]                 }
[17:26:46.622]                 else {
[17:26:46.622]                   if (TRUE) {
[17:26:46.622]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.622]                     {
[17:26:46.622]                       inherits <- base::inherits
[17:26:46.622]                       invokeRestart <- base::invokeRestart
[17:26:46.622]                       is.null <- base::is.null
[17:26:46.622]                       muffled <- FALSE
[17:26:46.622]                       if (inherits(cond, "message")) {
[17:26:46.622]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.622]                         if (muffled) 
[17:26:46.622]                           invokeRestart("muffleMessage")
[17:26:46.622]                       }
[17:26:46.622]                       else if (inherits(cond, "warning")) {
[17:26:46.622]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.622]                         if (muffled) 
[17:26:46.622]                           invokeRestart("muffleWarning")
[17:26:46.622]                       }
[17:26:46.622]                       else if (inherits(cond, "condition")) {
[17:26:46.622]                         if (!is.null(pattern)) {
[17:26:46.622]                           computeRestarts <- base::computeRestarts
[17:26:46.622]                           grepl <- base::grepl
[17:26:46.622]                           restarts <- computeRestarts(cond)
[17:26:46.622]                           for (restart in restarts) {
[17:26:46.622]                             name <- restart$name
[17:26:46.622]                             if (is.null(name)) 
[17:26:46.622]                               next
[17:26:46.622]                             if (!grepl(pattern, name)) 
[17:26:46.622]                               next
[17:26:46.622]                             invokeRestart(restart)
[17:26:46.622]                             muffled <- TRUE
[17:26:46.622]                             break
[17:26:46.622]                           }
[17:26:46.622]                         }
[17:26:46.622]                       }
[17:26:46.622]                       invisible(muffled)
[17:26:46.622]                     }
[17:26:46.622]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.622]                   }
[17:26:46.622]                 }
[17:26:46.622]             }
[17:26:46.622]         }))
[17:26:46.622]     }, error = function(ex) {
[17:26:46.622]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.622]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.622]                 ...future.rng), started = ...future.startTime, 
[17:26:46.622]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.622]             version = "1.8"), class = "FutureResult")
[17:26:46.622]     }, finally = {
[17:26:46.622]         if (!identical(...future.workdir, getwd())) 
[17:26:46.622]             setwd(...future.workdir)
[17:26:46.622]         {
[17:26:46.622]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.622]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.622]             }
[17:26:46.622]             base::options(...future.oldOptions)
[17:26:46.622]             if (.Platform$OS.type == "windows") {
[17:26:46.622]                 old_names <- names(...future.oldEnvVars)
[17:26:46.622]                 envs <- base::Sys.getenv()
[17:26:46.622]                 names <- names(envs)
[17:26:46.622]                 common <- intersect(names, old_names)
[17:26:46.622]                 added <- setdiff(names, old_names)
[17:26:46.622]                 removed <- setdiff(old_names, names)
[17:26:46.622]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.622]                   envs[common]]
[17:26:46.622]                 NAMES <- toupper(changed)
[17:26:46.622]                 args <- list()
[17:26:46.622]                 for (kk in seq_along(NAMES)) {
[17:26:46.622]                   name <- changed[[kk]]
[17:26:46.622]                   NAME <- NAMES[[kk]]
[17:26:46.622]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.622]                     next
[17:26:46.622]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.622]                 }
[17:26:46.622]                 NAMES <- toupper(added)
[17:26:46.622]                 for (kk in seq_along(NAMES)) {
[17:26:46.622]                   name <- added[[kk]]
[17:26:46.622]                   NAME <- NAMES[[kk]]
[17:26:46.622]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.622]                     next
[17:26:46.622]                   args[[name]] <- ""
[17:26:46.622]                 }
[17:26:46.622]                 NAMES <- toupper(removed)
[17:26:46.622]                 for (kk in seq_along(NAMES)) {
[17:26:46.622]                   name <- removed[[kk]]
[17:26:46.622]                   NAME <- NAMES[[kk]]
[17:26:46.622]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.622]                     next
[17:26:46.622]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.622]                 }
[17:26:46.622]                 if (length(args) > 0) 
[17:26:46.622]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.622]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.622]             }
[17:26:46.622]             else {
[17:26:46.622]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.622]             }
[17:26:46.622]             {
[17:26:46.622]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.622]                   0L) {
[17:26:46.622]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.622]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.622]                   base::options(opts)
[17:26:46.622]                 }
[17:26:46.622]                 {
[17:26:46.622]                   {
[17:26:46.622]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.622]                     NULL
[17:26:46.622]                   }
[17:26:46.622]                   options(future.plan = NULL)
[17:26:46.622]                   if (is.na(NA_character_)) 
[17:26:46.622]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.622]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.622]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.622]                     .init = FALSE)
[17:26:46.622]                 }
[17:26:46.622]             }
[17:26:46.622]         }
[17:26:46.622]     })
[17:26:46.622]     if (TRUE) {
[17:26:46.622]         base::sink(type = "output", split = FALSE)
[17:26:46.622]         if (TRUE) {
[17:26:46.622]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.622]         }
[17:26:46.622]         else {
[17:26:46.622]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.622]         }
[17:26:46.622]         base::close(...future.stdout)
[17:26:46.622]         ...future.stdout <- NULL
[17:26:46.622]     }
[17:26:46.622]     ...future.result$conditions <- ...future.conditions
[17:26:46.622]     ...future.result$finished <- base::Sys.time()
[17:26:46.622]     ...future.result
[17:26:46.622] }
[17:26:46.628] MultisessionFuture started
[17:26:46.628] - Launch lazy future ... done
[17:26:46.628] run() for 'MultisessionFuture' ... done
[17:26:46.628] getGlobalsAndPackages() ...
[17:26:46.629] Searching for globals...
[17:26:46.629] 
[17:26:46.629] Searching for globals ... DONE
[17:26:46.629] - globals: [0] <none>
[17:26:46.630] getGlobalsAndPackages() ... DONE
[17:26:46.630] run() for 'Future' ...
[17:26:46.630] - state: 'created'
[17:26:46.630] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.644] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.644] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.644]   - Field: 'node'
[17:26:46.645]   - Field: 'label'
[17:26:46.645]   - Field: 'local'
[17:26:46.645]   - Field: 'owner'
[17:26:46.645]   - Field: 'envir'
[17:26:46.645]   - Field: 'workers'
[17:26:46.645]   - Field: 'packages'
[17:26:46.646]   - Field: 'gc'
[17:26:46.646]   - Field: 'conditions'
[17:26:46.646]   - Field: 'persistent'
[17:26:46.646]   - Field: 'expr'
[17:26:46.646]   - Field: 'uuid'
[17:26:46.647]   - Field: 'seed'
[17:26:46.647]   - Field: 'version'
[17:26:46.647]   - Field: 'result'
[17:26:46.647]   - Field: 'asynchronous'
[17:26:46.647]   - Field: 'calls'
[17:26:46.647]   - Field: 'globals'
[17:26:46.648]   - Field: 'stdout'
[17:26:46.648]   - Field: 'earlySignal'
[17:26:46.648]   - Field: 'lazy'
[17:26:46.648]   - Field: 'state'
[17:26:46.648] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.648] - Launch lazy future ...
[17:26:46.649] Packages needed by the future expression (n = 0): <none>
[17:26:46.649] Packages needed by future strategies (n = 0): <none>
[17:26:46.650] {
[17:26:46.650]     {
[17:26:46.650]         {
[17:26:46.650]             ...future.startTime <- base::Sys.time()
[17:26:46.650]             {
[17:26:46.650]                 {
[17:26:46.650]                   {
[17:26:46.650]                     {
[17:26:46.650]                       base::local({
[17:26:46.650]                         has_future <- base::requireNamespace("future", 
[17:26:46.650]                           quietly = TRUE)
[17:26:46.650]                         if (has_future) {
[17:26:46.650]                           ns <- base::getNamespace("future")
[17:26:46.650]                           version <- ns[[".package"]][["version"]]
[17:26:46.650]                           if (is.null(version)) 
[17:26:46.650]                             version <- utils::packageVersion("future")
[17:26:46.650]                         }
[17:26:46.650]                         else {
[17:26:46.650]                           version <- NULL
[17:26:46.650]                         }
[17:26:46.650]                         if (!has_future || version < "1.8.0") {
[17:26:46.650]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.650]                             "", base::R.version$version.string), 
[17:26:46.650]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.650]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.650]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.650]                               "release", "version")], collapse = " "), 
[17:26:46.650]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.650]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.650]                             info)
[17:26:46.650]                           info <- base::paste(info, collapse = "; ")
[17:26:46.650]                           if (!has_future) {
[17:26:46.650]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.650]                               info)
[17:26:46.650]                           }
[17:26:46.650]                           else {
[17:26:46.650]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.650]                               info, version)
[17:26:46.650]                           }
[17:26:46.650]                           base::stop(msg)
[17:26:46.650]                         }
[17:26:46.650]                       })
[17:26:46.650]                     }
[17:26:46.650]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.650]                     base::options(mc.cores = 1L)
[17:26:46.650]                   }
[17:26:46.650]                   ...future.strategy.old <- future::plan("list")
[17:26:46.650]                   options(future.plan = NULL)
[17:26:46.650]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.650]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.650]                 }
[17:26:46.650]                 ...future.workdir <- getwd()
[17:26:46.650]             }
[17:26:46.650]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.650]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.650]         }
[17:26:46.650]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.650]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.650]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.650]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.650]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.650]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.650]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.650]             base::names(...future.oldOptions))
[17:26:46.650]     }
[17:26:46.650]     if (FALSE) {
[17:26:46.650]     }
[17:26:46.650]     else {
[17:26:46.650]         if (TRUE) {
[17:26:46.650]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.650]                 open = "w")
[17:26:46.650]         }
[17:26:46.650]         else {
[17:26:46.650]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.650]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.650]         }
[17:26:46.650]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.650]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.650]             base::sink(type = "output", split = FALSE)
[17:26:46.650]             base::close(...future.stdout)
[17:26:46.650]         }, add = TRUE)
[17:26:46.650]     }
[17:26:46.650]     ...future.frame <- base::sys.nframe()
[17:26:46.650]     ...future.conditions <- base::list()
[17:26:46.650]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.650]     if (FALSE) {
[17:26:46.650]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.650]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.650]     }
[17:26:46.650]     ...future.result <- base::tryCatch({
[17:26:46.650]         base::withCallingHandlers({
[17:26:46.650]             ...future.value <- base::withVisible(base::local({
[17:26:46.650]                 ...future.makeSendCondition <- base::local({
[17:26:46.650]                   sendCondition <- NULL
[17:26:46.650]                   function(frame = 1L) {
[17:26:46.650]                     if (is.function(sendCondition)) 
[17:26:46.650]                       return(sendCondition)
[17:26:46.650]                     ns <- getNamespace("parallel")
[17:26:46.650]                     if (exists("sendData", mode = "function", 
[17:26:46.650]                       envir = ns)) {
[17:26:46.650]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.650]                         envir = ns)
[17:26:46.650]                       envir <- sys.frame(frame)
[17:26:46.650]                       master <- NULL
[17:26:46.650]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.650]                         !identical(envir, emptyenv())) {
[17:26:46.650]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.650]                           inherits = FALSE)) {
[17:26:46.650]                           master <- get("master", mode = "list", 
[17:26:46.650]                             envir = envir, inherits = FALSE)
[17:26:46.650]                           if (inherits(master, c("SOCKnode", 
[17:26:46.650]                             "SOCK0node"))) {
[17:26:46.650]                             sendCondition <<- function(cond) {
[17:26:46.650]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.650]                                 success = TRUE)
[17:26:46.650]                               parallel_sendData(master, data)
[17:26:46.650]                             }
[17:26:46.650]                             return(sendCondition)
[17:26:46.650]                           }
[17:26:46.650]                         }
[17:26:46.650]                         frame <- frame + 1L
[17:26:46.650]                         envir <- sys.frame(frame)
[17:26:46.650]                       }
[17:26:46.650]                     }
[17:26:46.650]                     sendCondition <<- function(cond) NULL
[17:26:46.650]                   }
[17:26:46.650]                 })
[17:26:46.650]                 withCallingHandlers({
[17:26:46.650]                   NULL
[17:26:46.650]                 }, immediateCondition = function(cond) {
[17:26:46.650]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.650]                   sendCondition(cond)
[17:26:46.650]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.650]                   {
[17:26:46.650]                     inherits <- base::inherits
[17:26:46.650]                     invokeRestart <- base::invokeRestart
[17:26:46.650]                     is.null <- base::is.null
[17:26:46.650]                     muffled <- FALSE
[17:26:46.650]                     if (inherits(cond, "message")) {
[17:26:46.650]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.650]                       if (muffled) 
[17:26:46.650]                         invokeRestart("muffleMessage")
[17:26:46.650]                     }
[17:26:46.650]                     else if (inherits(cond, "warning")) {
[17:26:46.650]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.650]                       if (muffled) 
[17:26:46.650]                         invokeRestart("muffleWarning")
[17:26:46.650]                     }
[17:26:46.650]                     else if (inherits(cond, "condition")) {
[17:26:46.650]                       if (!is.null(pattern)) {
[17:26:46.650]                         computeRestarts <- base::computeRestarts
[17:26:46.650]                         grepl <- base::grepl
[17:26:46.650]                         restarts <- computeRestarts(cond)
[17:26:46.650]                         for (restart in restarts) {
[17:26:46.650]                           name <- restart$name
[17:26:46.650]                           if (is.null(name)) 
[17:26:46.650]                             next
[17:26:46.650]                           if (!grepl(pattern, name)) 
[17:26:46.650]                             next
[17:26:46.650]                           invokeRestart(restart)
[17:26:46.650]                           muffled <- TRUE
[17:26:46.650]                           break
[17:26:46.650]                         }
[17:26:46.650]                       }
[17:26:46.650]                     }
[17:26:46.650]                     invisible(muffled)
[17:26:46.650]                   }
[17:26:46.650]                   muffleCondition(cond)
[17:26:46.650]                 })
[17:26:46.650]             }))
[17:26:46.650]             future::FutureResult(value = ...future.value$value, 
[17:26:46.650]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.650]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.650]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.650]                     ...future.globalenv.names))
[17:26:46.650]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.650]         }, condition = base::local({
[17:26:46.650]             c <- base::c
[17:26:46.650]             inherits <- base::inherits
[17:26:46.650]             invokeRestart <- base::invokeRestart
[17:26:46.650]             length <- base::length
[17:26:46.650]             list <- base::list
[17:26:46.650]             seq.int <- base::seq.int
[17:26:46.650]             signalCondition <- base::signalCondition
[17:26:46.650]             sys.calls <- base::sys.calls
[17:26:46.650]             `[[` <- base::`[[`
[17:26:46.650]             `+` <- base::`+`
[17:26:46.650]             `<<-` <- base::`<<-`
[17:26:46.650]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.650]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.650]                   3L)]
[17:26:46.650]             }
[17:26:46.650]             function(cond) {
[17:26:46.650]                 is_error <- inherits(cond, "error")
[17:26:46.650]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.650]                   NULL)
[17:26:46.650]                 if (is_error) {
[17:26:46.650]                   sessionInformation <- function() {
[17:26:46.650]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.650]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.650]                       search = base::search(), system = base::Sys.info())
[17:26:46.650]                   }
[17:26:46.650]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.650]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.650]                     cond$call), session = sessionInformation(), 
[17:26:46.650]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.650]                   signalCondition(cond)
[17:26:46.650]                 }
[17:26:46.650]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.650]                 "immediateCondition"))) {
[17:26:46.650]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.650]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.650]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.650]                   if (TRUE && !signal) {
[17:26:46.650]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.650]                     {
[17:26:46.650]                       inherits <- base::inherits
[17:26:46.650]                       invokeRestart <- base::invokeRestart
[17:26:46.650]                       is.null <- base::is.null
[17:26:46.650]                       muffled <- FALSE
[17:26:46.650]                       if (inherits(cond, "message")) {
[17:26:46.650]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.650]                         if (muffled) 
[17:26:46.650]                           invokeRestart("muffleMessage")
[17:26:46.650]                       }
[17:26:46.650]                       else if (inherits(cond, "warning")) {
[17:26:46.650]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.650]                         if (muffled) 
[17:26:46.650]                           invokeRestart("muffleWarning")
[17:26:46.650]                       }
[17:26:46.650]                       else if (inherits(cond, "condition")) {
[17:26:46.650]                         if (!is.null(pattern)) {
[17:26:46.650]                           computeRestarts <- base::computeRestarts
[17:26:46.650]                           grepl <- base::grepl
[17:26:46.650]                           restarts <- computeRestarts(cond)
[17:26:46.650]                           for (restart in restarts) {
[17:26:46.650]                             name <- restart$name
[17:26:46.650]                             if (is.null(name)) 
[17:26:46.650]                               next
[17:26:46.650]                             if (!grepl(pattern, name)) 
[17:26:46.650]                               next
[17:26:46.650]                             invokeRestart(restart)
[17:26:46.650]                             muffled <- TRUE
[17:26:46.650]                             break
[17:26:46.650]                           }
[17:26:46.650]                         }
[17:26:46.650]                       }
[17:26:46.650]                       invisible(muffled)
[17:26:46.650]                     }
[17:26:46.650]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.650]                   }
[17:26:46.650]                 }
[17:26:46.650]                 else {
[17:26:46.650]                   if (TRUE) {
[17:26:46.650]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.650]                     {
[17:26:46.650]                       inherits <- base::inherits
[17:26:46.650]                       invokeRestart <- base::invokeRestart
[17:26:46.650]                       is.null <- base::is.null
[17:26:46.650]                       muffled <- FALSE
[17:26:46.650]                       if (inherits(cond, "message")) {
[17:26:46.650]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.650]                         if (muffled) 
[17:26:46.650]                           invokeRestart("muffleMessage")
[17:26:46.650]                       }
[17:26:46.650]                       else if (inherits(cond, "warning")) {
[17:26:46.650]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.650]                         if (muffled) 
[17:26:46.650]                           invokeRestart("muffleWarning")
[17:26:46.650]                       }
[17:26:46.650]                       else if (inherits(cond, "condition")) {
[17:26:46.650]                         if (!is.null(pattern)) {
[17:26:46.650]                           computeRestarts <- base::computeRestarts
[17:26:46.650]                           grepl <- base::grepl
[17:26:46.650]                           restarts <- computeRestarts(cond)
[17:26:46.650]                           for (restart in restarts) {
[17:26:46.650]                             name <- restart$name
[17:26:46.650]                             if (is.null(name)) 
[17:26:46.650]                               next
[17:26:46.650]                             if (!grepl(pattern, name)) 
[17:26:46.650]                               next
[17:26:46.650]                             invokeRestart(restart)
[17:26:46.650]                             muffled <- TRUE
[17:26:46.650]                             break
[17:26:46.650]                           }
[17:26:46.650]                         }
[17:26:46.650]                       }
[17:26:46.650]                       invisible(muffled)
[17:26:46.650]                     }
[17:26:46.650]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.650]                   }
[17:26:46.650]                 }
[17:26:46.650]             }
[17:26:46.650]         }))
[17:26:46.650]     }, error = function(ex) {
[17:26:46.650]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.650]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.650]                 ...future.rng), started = ...future.startTime, 
[17:26:46.650]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.650]             version = "1.8"), class = "FutureResult")
[17:26:46.650]     }, finally = {
[17:26:46.650]         if (!identical(...future.workdir, getwd())) 
[17:26:46.650]             setwd(...future.workdir)
[17:26:46.650]         {
[17:26:46.650]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.650]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.650]             }
[17:26:46.650]             base::options(...future.oldOptions)
[17:26:46.650]             if (.Platform$OS.type == "windows") {
[17:26:46.650]                 old_names <- names(...future.oldEnvVars)
[17:26:46.650]                 envs <- base::Sys.getenv()
[17:26:46.650]                 names <- names(envs)
[17:26:46.650]                 common <- intersect(names, old_names)
[17:26:46.650]                 added <- setdiff(names, old_names)
[17:26:46.650]                 removed <- setdiff(old_names, names)
[17:26:46.650]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.650]                   envs[common]]
[17:26:46.650]                 NAMES <- toupper(changed)
[17:26:46.650]                 args <- list()
[17:26:46.650]                 for (kk in seq_along(NAMES)) {
[17:26:46.650]                   name <- changed[[kk]]
[17:26:46.650]                   NAME <- NAMES[[kk]]
[17:26:46.650]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.650]                     next
[17:26:46.650]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.650]                 }
[17:26:46.650]                 NAMES <- toupper(added)
[17:26:46.650]                 for (kk in seq_along(NAMES)) {
[17:26:46.650]                   name <- added[[kk]]
[17:26:46.650]                   NAME <- NAMES[[kk]]
[17:26:46.650]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.650]                     next
[17:26:46.650]                   args[[name]] <- ""
[17:26:46.650]                 }
[17:26:46.650]                 NAMES <- toupper(removed)
[17:26:46.650]                 for (kk in seq_along(NAMES)) {
[17:26:46.650]                   name <- removed[[kk]]
[17:26:46.650]                   NAME <- NAMES[[kk]]
[17:26:46.650]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.650]                     next
[17:26:46.650]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.650]                 }
[17:26:46.650]                 if (length(args) > 0) 
[17:26:46.650]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.650]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.650]             }
[17:26:46.650]             else {
[17:26:46.650]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.650]             }
[17:26:46.650]             {
[17:26:46.650]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.650]                   0L) {
[17:26:46.650]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.650]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.650]                   base::options(opts)
[17:26:46.650]                 }
[17:26:46.650]                 {
[17:26:46.650]                   {
[17:26:46.650]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.650]                     NULL
[17:26:46.650]                   }
[17:26:46.650]                   options(future.plan = NULL)
[17:26:46.650]                   if (is.na(NA_character_)) 
[17:26:46.650]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.650]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.650]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.650]                     .init = FALSE)
[17:26:46.650]                 }
[17:26:46.650]             }
[17:26:46.650]         }
[17:26:46.650]     })
[17:26:46.650]     if (TRUE) {
[17:26:46.650]         base::sink(type = "output", split = FALSE)
[17:26:46.650]         if (TRUE) {
[17:26:46.650]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.650]         }
[17:26:46.650]         else {
[17:26:46.650]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.650]         }
[17:26:46.650]         base::close(...future.stdout)
[17:26:46.650]         ...future.stdout <- NULL
[17:26:46.650]     }
[17:26:46.650]     ...future.result$conditions <- ...future.conditions
[17:26:46.650]     ...future.result$finished <- base::Sys.time()
[17:26:46.650]     ...future.result
[17:26:46.650] }
[17:26:46.733] MultisessionFuture started
[17:26:46.733] - Launch lazy future ... done
[17:26:46.734] run() for 'MultisessionFuture' ... done
[17:26:46.734] getGlobalsAndPackages() ...
[17:26:46.735] Searching for globals...
[17:26:46.736] - globals found: [1] '{'
[17:26:46.736] Searching for globals ... DONE
[17:26:46.736] Resolving globals: FALSE
[17:26:46.736] 
[17:26:46.737] 
[17:26:46.737] getGlobalsAndPackages() ... DONE
[17:26:46.737] run() for 'Future' ...
[17:26:46.737] - state: 'created'
[17:26:46.738] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.754] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.754] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.754]   - Field: 'node'
[17:26:46.754]   - Field: 'label'
[17:26:46.754]   - Field: 'local'
[17:26:46.755]   - Field: 'owner'
[17:26:46.755]   - Field: 'envir'
[17:26:46.755]   - Field: 'workers'
[17:26:46.755]   - Field: 'packages'
[17:26:46.755]   - Field: 'gc'
[17:26:46.756]   - Field: 'conditions'
[17:26:46.756]   - Field: 'persistent'
[17:26:46.756]   - Field: 'expr'
[17:26:46.756]   - Field: 'uuid'
[17:26:46.756]   - Field: 'seed'
[17:26:46.756]   - Field: 'version'
[17:26:46.757]   - Field: 'result'
[17:26:46.757]   - Field: 'asynchronous'
[17:26:46.757]   - Field: 'calls'
[17:26:46.757]   - Field: 'globals'
[17:26:46.757]   - Field: 'stdout'
[17:26:46.758]   - Field: 'earlySignal'
[17:26:46.758]   - Field: 'lazy'
[17:26:46.758]   - Field: 'state'
[17:26:46.758] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.758] - Launch lazy future ...
[17:26:46.759] Packages needed by the future expression (n = 0): <none>
[17:26:46.759] Packages needed by future strategies (n = 0): <none>
[17:26:46.759] {
[17:26:46.759]     {
[17:26:46.759]         {
[17:26:46.759]             ...future.startTime <- base::Sys.time()
[17:26:46.759]             {
[17:26:46.759]                 {
[17:26:46.759]                   {
[17:26:46.759]                     {
[17:26:46.759]                       base::local({
[17:26:46.759]                         has_future <- base::requireNamespace("future", 
[17:26:46.759]                           quietly = TRUE)
[17:26:46.759]                         if (has_future) {
[17:26:46.759]                           ns <- base::getNamespace("future")
[17:26:46.759]                           version <- ns[[".package"]][["version"]]
[17:26:46.759]                           if (is.null(version)) 
[17:26:46.759]                             version <- utils::packageVersion("future")
[17:26:46.759]                         }
[17:26:46.759]                         else {
[17:26:46.759]                           version <- NULL
[17:26:46.759]                         }
[17:26:46.759]                         if (!has_future || version < "1.8.0") {
[17:26:46.759]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.759]                             "", base::R.version$version.string), 
[17:26:46.759]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.759]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.759]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.759]                               "release", "version")], collapse = " "), 
[17:26:46.759]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.759]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.759]                             info)
[17:26:46.759]                           info <- base::paste(info, collapse = "; ")
[17:26:46.759]                           if (!has_future) {
[17:26:46.759]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.759]                               info)
[17:26:46.759]                           }
[17:26:46.759]                           else {
[17:26:46.759]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.759]                               info, version)
[17:26:46.759]                           }
[17:26:46.759]                           base::stop(msg)
[17:26:46.759]                         }
[17:26:46.759]                       })
[17:26:46.759]                     }
[17:26:46.759]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.759]                     base::options(mc.cores = 1L)
[17:26:46.759]                   }
[17:26:46.759]                   ...future.strategy.old <- future::plan("list")
[17:26:46.759]                   options(future.plan = NULL)
[17:26:46.759]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.759]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.759]                 }
[17:26:46.759]                 ...future.workdir <- getwd()
[17:26:46.759]             }
[17:26:46.759]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.759]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.759]         }
[17:26:46.759]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.759]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.759]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.759]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.759]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.759]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.759]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.759]             base::names(...future.oldOptions))
[17:26:46.759]     }
[17:26:46.759]     if (FALSE) {
[17:26:46.759]     }
[17:26:46.759]     else {
[17:26:46.759]         if (TRUE) {
[17:26:46.759]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.759]                 open = "w")
[17:26:46.759]         }
[17:26:46.759]         else {
[17:26:46.759]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.759]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.759]         }
[17:26:46.759]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.759]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.759]             base::sink(type = "output", split = FALSE)
[17:26:46.759]             base::close(...future.stdout)
[17:26:46.759]         }, add = TRUE)
[17:26:46.759]     }
[17:26:46.759]     ...future.frame <- base::sys.nframe()
[17:26:46.759]     ...future.conditions <- base::list()
[17:26:46.759]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.759]     if (FALSE) {
[17:26:46.759]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.759]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.759]     }
[17:26:46.759]     ...future.result <- base::tryCatch({
[17:26:46.759]         base::withCallingHandlers({
[17:26:46.759]             ...future.value <- base::withVisible(base::local({
[17:26:46.759]                 ...future.makeSendCondition <- base::local({
[17:26:46.759]                   sendCondition <- NULL
[17:26:46.759]                   function(frame = 1L) {
[17:26:46.759]                     if (is.function(sendCondition)) 
[17:26:46.759]                       return(sendCondition)
[17:26:46.759]                     ns <- getNamespace("parallel")
[17:26:46.759]                     if (exists("sendData", mode = "function", 
[17:26:46.759]                       envir = ns)) {
[17:26:46.759]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.759]                         envir = ns)
[17:26:46.759]                       envir <- sys.frame(frame)
[17:26:46.759]                       master <- NULL
[17:26:46.759]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.759]                         !identical(envir, emptyenv())) {
[17:26:46.759]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.759]                           inherits = FALSE)) {
[17:26:46.759]                           master <- get("master", mode = "list", 
[17:26:46.759]                             envir = envir, inherits = FALSE)
[17:26:46.759]                           if (inherits(master, c("SOCKnode", 
[17:26:46.759]                             "SOCK0node"))) {
[17:26:46.759]                             sendCondition <<- function(cond) {
[17:26:46.759]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.759]                                 success = TRUE)
[17:26:46.759]                               parallel_sendData(master, data)
[17:26:46.759]                             }
[17:26:46.759]                             return(sendCondition)
[17:26:46.759]                           }
[17:26:46.759]                         }
[17:26:46.759]                         frame <- frame + 1L
[17:26:46.759]                         envir <- sys.frame(frame)
[17:26:46.759]                       }
[17:26:46.759]                     }
[17:26:46.759]                     sendCondition <<- function(cond) NULL
[17:26:46.759]                   }
[17:26:46.759]                 })
[17:26:46.759]                 withCallingHandlers({
[17:26:46.759]                   {
[17:26:46.759]                     4
[17:26:46.759]                   }
[17:26:46.759]                 }, immediateCondition = function(cond) {
[17:26:46.759]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.759]                   sendCondition(cond)
[17:26:46.759]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.759]                   {
[17:26:46.759]                     inherits <- base::inherits
[17:26:46.759]                     invokeRestart <- base::invokeRestart
[17:26:46.759]                     is.null <- base::is.null
[17:26:46.759]                     muffled <- FALSE
[17:26:46.759]                     if (inherits(cond, "message")) {
[17:26:46.759]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.759]                       if (muffled) 
[17:26:46.759]                         invokeRestart("muffleMessage")
[17:26:46.759]                     }
[17:26:46.759]                     else if (inherits(cond, "warning")) {
[17:26:46.759]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.759]                       if (muffled) 
[17:26:46.759]                         invokeRestart("muffleWarning")
[17:26:46.759]                     }
[17:26:46.759]                     else if (inherits(cond, "condition")) {
[17:26:46.759]                       if (!is.null(pattern)) {
[17:26:46.759]                         computeRestarts <- base::computeRestarts
[17:26:46.759]                         grepl <- base::grepl
[17:26:46.759]                         restarts <- computeRestarts(cond)
[17:26:46.759]                         for (restart in restarts) {
[17:26:46.759]                           name <- restart$name
[17:26:46.759]                           if (is.null(name)) 
[17:26:46.759]                             next
[17:26:46.759]                           if (!grepl(pattern, name)) 
[17:26:46.759]                             next
[17:26:46.759]                           invokeRestart(restart)
[17:26:46.759]                           muffled <- TRUE
[17:26:46.759]                           break
[17:26:46.759]                         }
[17:26:46.759]                       }
[17:26:46.759]                     }
[17:26:46.759]                     invisible(muffled)
[17:26:46.759]                   }
[17:26:46.759]                   muffleCondition(cond)
[17:26:46.759]                 })
[17:26:46.759]             }))
[17:26:46.759]             future::FutureResult(value = ...future.value$value, 
[17:26:46.759]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.759]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.759]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.759]                     ...future.globalenv.names))
[17:26:46.759]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.759]         }, condition = base::local({
[17:26:46.759]             c <- base::c
[17:26:46.759]             inherits <- base::inherits
[17:26:46.759]             invokeRestart <- base::invokeRestart
[17:26:46.759]             length <- base::length
[17:26:46.759]             list <- base::list
[17:26:46.759]             seq.int <- base::seq.int
[17:26:46.759]             signalCondition <- base::signalCondition
[17:26:46.759]             sys.calls <- base::sys.calls
[17:26:46.759]             `[[` <- base::`[[`
[17:26:46.759]             `+` <- base::`+`
[17:26:46.759]             `<<-` <- base::`<<-`
[17:26:46.759]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.759]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.759]                   3L)]
[17:26:46.759]             }
[17:26:46.759]             function(cond) {
[17:26:46.759]                 is_error <- inherits(cond, "error")
[17:26:46.759]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.759]                   NULL)
[17:26:46.759]                 if (is_error) {
[17:26:46.759]                   sessionInformation <- function() {
[17:26:46.759]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.759]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.759]                       search = base::search(), system = base::Sys.info())
[17:26:46.759]                   }
[17:26:46.759]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.759]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.759]                     cond$call), session = sessionInformation(), 
[17:26:46.759]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.759]                   signalCondition(cond)
[17:26:46.759]                 }
[17:26:46.759]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.759]                 "immediateCondition"))) {
[17:26:46.759]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.759]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.759]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.759]                   if (TRUE && !signal) {
[17:26:46.759]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.759]                     {
[17:26:46.759]                       inherits <- base::inherits
[17:26:46.759]                       invokeRestart <- base::invokeRestart
[17:26:46.759]                       is.null <- base::is.null
[17:26:46.759]                       muffled <- FALSE
[17:26:46.759]                       if (inherits(cond, "message")) {
[17:26:46.759]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.759]                         if (muffled) 
[17:26:46.759]                           invokeRestart("muffleMessage")
[17:26:46.759]                       }
[17:26:46.759]                       else if (inherits(cond, "warning")) {
[17:26:46.759]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.759]                         if (muffled) 
[17:26:46.759]                           invokeRestart("muffleWarning")
[17:26:46.759]                       }
[17:26:46.759]                       else if (inherits(cond, "condition")) {
[17:26:46.759]                         if (!is.null(pattern)) {
[17:26:46.759]                           computeRestarts <- base::computeRestarts
[17:26:46.759]                           grepl <- base::grepl
[17:26:46.759]                           restarts <- computeRestarts(cond)
[17:26:46.759]                           for (restart in restarts) {
[17:26:46.759]                             name <- restart$name
[17:26:46.759]                             if (is.null(name)) 
[17:26:46.759]                               next
[17:26:46.759]                             if (!grepl(pattern, name)) 
[17:26:46.759]                               next
[17:26:46.759]                             invokeRestart(restart)
[17:26:46.759]                             muffled <- TRUE
[17:26:46.759]                             break
[17:26:46.759]                           }
[17:26:46.759]                         }
[17:26:46.759]                       }
[17:26:46.759]                       invisible(muffled)
[17:26:46.759]                     }
[17:26:46.759]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.759]                   }
[17:26:46.759]                 }
[17:26:46.759]                 else {
[17:26:46.759]                   if (TRUE) {
[17:26:46.759]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.759]                     {
[17:26:46.759]                       inherits <- base::inherits
[17:26:46.759]                       invokeRestart <- base::invokeRestart
[17:26:46.759]                       is.null <- base::is.null
[17:26:46.759]                       muffled <- FALSE
[17:26:46.759]                       if (inherits(cond, "message")) {
[17:26:46.759]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.759]                         if (muffled) 
[17:26:46.759]                           invokeRestart("muffleMessage")
[17:26:46.759]                       }
[17:26:46.759]                       else if (inherits(cond, "warning")) {
[17:26:46.759]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.759]                         if (muffled) 
[17:26:46.759]                           invokeRestart("muffleWarning")
[17:26:46.759]                       }
[17:26:46.759]                       else if (inherits(cond, "condition")) {
[17:26:46.759]                         if (!is.null(pattern)) {
[17:26:46.759]                           computeRestarts <- base::computeRestarts
[17:26:46.759]                           grepl <- base::grepl
[17:26:46.759]                           restarts <- computeRestarts(cond)
[17:26:46.759]                           for (restart in restarts) {
[17:26:46.759]                             name <- restart$name
[17:26:46.759]                             if (is.null(name)) 
[17:26:46.759]                               next
[17:26:46.759]                             if (!grepl(pattern, name)) 
[17:26:46.759]                               next
[17:26:46.759]                             invokeRestart(restart)
[17:26:46.759]                             muffled <- TRUE
[17:26:46.759]                             break
[17:26:46.759]                           }
[17:26:46.759]                         }
[17:26:46.759]                       }
[17:26:46.759]                       invisible(muffled)
[17:26:46.759]                     }
[17:26:46.759]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.759]                   }
[17:26:46.759]                 }
[17:26:46.759]             }
[17:26:46.759]         }))
[17:26:46.759]     }, error = function(ex) {
[17:26:46.759]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.759]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.759]                 ...future.rng), started = ...future.startTime, 
[17:26:46.759]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.759]             version = "1.8"), class = "FutureResult")
[17:26:46.759]     }, finally = {
[17:26:46.759]         if (!identical(...future.workdir, getwd())) 
[17:26:46.759]             setwd(...future.workdir)
[17:26:46.759]         {
[17:26:46.759]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.759]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.759]             }
[17:26:46.759]             base::options(...future.oldOptions)
[17:26:46.759]             if (.Platform$OS.type == "windows") {
[17:26:46.759]                 old_names <- names(...future.oldEnvVars)
[17:26:46.759]                 envs <- base::Sys.getenv()
[17:26:46.759]                 names <- names(envs)
[17:26:46.759]                 common <- intersect(names, old_names)
[17:26:46.759]                 added <- setdiff(names, old_names)
[17:26:46.759]                 removed <- setdiff(old_names, names)
[17:26:46.759]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.759]                   envs[common]]
[17:26:46.759]                 NAMES <- toupper(changed)
[17:26:46.759]                 args <- list()
[17:26:46.759]                 for (kk in seq_along(NAMES)) {
[17:26:46.759]                   name <- changed[[kk]]
[17:26:46.759]                   NAME <- NAMES[[kk]]
[17:26:46.759]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.759]                     next
[17:26:46.759]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.759]                 }
[17:26:46.759]                 NAMES <- toupper(added)
[17:26:46.759]                 for (kk in seq_along(NAMES)) {
[17:26:46.759]                   name <- added[[kk]]
[17:26:46.759]                   NAME <- NAMES[[kk]]
[17:26:46.759]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.759]                     next
[17:26:46.759]                   args[[name]] <- ""
[17:26:46.759]                 }
[17:26:46.759]                 NAMES <- toupper(removed)
[17:26:46.759]                 for (kk in seq_along(NAMES)) {
[17:26:46.759]                   name <- removed[[kk]]
[17:26:46.759]                   NAME <- NAMES[[kk]]
[17:26:46.759]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.759]                     next
[17:26:46.759]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.759]                 }
[17:26:46.759]                 if (length(args) > 0) 
[17:26:46.759]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.759]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.759]             }
[17:26:46.759]             else {
[17:26:46.759]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.759]             }
[17:26:46.759]             {
[17:26:46.759]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.759]                   0L) {
[17:26:46.759]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.759]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.759]                   base::options(opts)
[17:26:46.759]                 }
[17:26:46.759]                 {
[17:26:46.759]                   {
[17:26:46.759]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.759]                     NULL
[17:26:46.759]                   }
[17:26:46.759]                   options(future.plan = NULL)
[17:26:46.759]                   if (is.na(NA_character_)) 
[17:26:46.759]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.759]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.759]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.759]                     .init = FALSE)
[17:26:46.759]                 }
[17:26:46.759]             }
[17:26:46.759]         }
[17:26:46.759]     })
[17:26:46.759]     if (TRUE) {
[17:26:46.759]         base::sink(type = "output", split = FALSE)
[17:26:46.759]         if (TRUE) {
[17:26:46.759]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.759]         }
[17:26:46.759]         else {
[17:26:46.759]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.759]         }
[17:26:46.759]         base::close(...future.stdout)
[17:26:46.759]         ...future.stdout <- NULL
[17:26:46.759]     }
[17:26:46.759]     ...future.result$conditions <- ...future.conditions
[17:26:46.759]     ...future.result$finished <- base::Sys.time()
[17:26:46.759]     ...future.result
[17:26:46.759] }
[17:26:46.764] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:46.782] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.783] - Validating connection of MultisessionFuture
[17:26:46.783] - received message: FutureResult
[17:26:46.783] - Received FutureResult
[17:26:46.783] - Erased future from FutureRegistry
[17:26:46.783] result() for ClusterFuture ...
[17:26:46.784] - result already collected: FutureResult
[17:26:46.784] result() for ClusterFuture ... done
[17:26:46.784] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.784] result() for ClusterFuture ...
[17:26:46.784] - result already collected: FutureResult
[17:26:46.784] result() for ClusterFuture ... done
[17:26:46.785] result() for ClusterFuture ...
[17:26:46.785] - result already collected: FutureResult
[17:26:46.785] result() for ClusterFuture ... done
[17:26:46.786] MultisessionFuture started
[17:26:46.786] - Launch lazy future ... done
[17:26:46.787] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230cab2308> 
Classes 'listenv', 'environment' <environment: 0x000002230f632b20> 
[17:26:46.790] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.790] - Validating connection of MultisessionFuture
[17:26:46.790] - received message: FutureResult
[17:26:46.791] - Received FutureResult
[17:26:46.791] - Erased future from FutureRegistry
[17:26:46.791] result() for ClusterFuture ...
[17:26:46.791] - result already collected: FutureResult
[17:26:46.791] result() for ClusterFuture ... done
[17:26:46.791] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.801] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.802] - Validating connection of MultisessionFuture
[17:26:46.802] - received message: FutureResult
[17:26:46.802] - Received FutureResult
[17:26:46.802] - Erased future from FutureRegistry
[17:26:46.802] result() for ClusterFuture ...
[17:26:46.803] - result already collected: FutureResult
[17:26:46.803] result() for ClusterFuture ... done
[17:26:46.803] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:46.805] resolve() on list environment ...
[17:26:46.805]  recursive: 0
[17:26:46.806]  length: 6
[17:26:46.806]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:46.806] signalConditionsASAP(numeric, pos=1) ...
[17:26:46.807] - nx: 6
[17:26:46.807] - relay: TRUE
[17:26:46.807] - stdout: TRUE
[17:26:46.807] - signal: TRUE
[17:26:46.807] - resignal: FALSE
[17:26:46.807] - force: TRUE
[17:26:46.808] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.808] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.808]  - until=2
[17:26:46.808]  - relaying element #2
[17:26:46.808] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.808] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.809] signalConditionsASAP(NULL, pos=1) ... done
[17:26:46.809]  length: 5 (resolved future 1)
[17:26:46.809] Future #2
[17:26:46.809] result() for ClusterFuture ...
[17:26:46.809] - result already collected: FutureResult
[17:26:46.809] result() for ClusterFuture ... done
[17:26:46.810] result() for ClusterFuture ...
[17:26:46.810] - result already collected: FutureResult
[17:26:46.810] result() for ClusterFuture ... done
[17:26:46.810] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:46.810] - nx: 6
[17:26:46.810] - relay: TRUE
[17:26:46.811] - stdout: TRUE
[17:26:46.811] - signal: TRUE
[17:26:46.811] - resignal: FALSE
[17:26:46.811] - force: TRUE
[17:26:46.811] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.811] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.811]  - until=2
[17:26:46.812]  - relaying element #2
[17:26:46.812] result() for ClusterFuture ...
[17:26:46.812] - result already collected: FutureResult
[17:26:46.812] result() for ClusterFuture ... done
[17:26:46.812] result() for ClusterFuture ...
[17:26:46.812] - result already collected: FutureResult
[17:26:46.813] result() for ClusterFuture ... done
[17:26:46.813] result() for ClusterFuture ...
[17:26:46.813] - result already collected: FutureResult
[17:26:46.813] result() for ClusterFuture ... done
[17:26:46.813] result() for ClusterFuture ...
[17:26:46.813] - result already collected: FutureResult
[17:26:46.814] result() for ClusterFuture ... done
[17:26:46.814] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.814] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.814] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:46.814]  length: 4 (resolved future 2)
[17:26:46.814] Future #3
[17:26:46.815] result() for ClusterFuture ...
[17:26:46.815] - result already collected: FutureResult
[17:26:46.815] result() for ClusterFuture ... done
[17:26:46.815] result() for ClusterFuture ...
[17:26:46.815] - result already collected: FutureResult
[17:26:46.815] result() for ClusterFuture ... done
[17:26:46.816] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:46.816] - nx: 6
[17:26:46.816] - relay: TRUE
[17:26:46.816] - stdout: TRUE
[17:26:46.816] - signal: TRUE
[17:26:46.816] - resignal: FALSE
[17:26:46.817] - force: TRUE
[17:26:46.817] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.817] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.817]  - until=3
[17:26:46.817]  - relaying element #3
[17:26:46.817] result() for ClusterFuture ...
[17:26:46.818] - result already collected: FutureResult
[17:26:46.818] result() for ClusterFuture ... done
[17:26:46.818] result() for ClusterFuture ...
[17:26:46.818] - result already collected: FutureResult
[17:26:46.818] result() for ClusterFuture ... done
[17:26:46.818] result() for ClusterFuture ...
[17:26:46.818] - result already collected: FutureResult
[17:26:46.819] result() for ClusterFuture ... done
[17:26:46.819] result() for ClusterFuture ...
[17:26:46.819] - result already collected: FutureResult
[17:26:46.819] result() for ClusterFuture ... done
[17:26:46.819] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.819] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.820] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:46.820]  length: 3 (resolved future 3)
[17:26:46.820] Future #4
[17:26:46.820] result() for ClusterFuture ...
[17:26:46.820] - result already collected: FutureResult
[17:26:46.820] result() for ClusterFuture ... done
[17:26:46.821] result() for ClusterFuture ...
[17:26:46.821] - result already collected: FutureResult
[17:26:46.821] result() for ClusterFuture ... done
[17:26:46.821] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:46.821] - nx: 6
[17:26:46.821] - relay: TRUE
[17:26:46.822] - stdout: TRUE
[17:26:46.822] - signal: TRUE
[17:26:46.822] - resignal: FALSE
[17:26:46.822] - force: TRUE
[17:26:46.822] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.822] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.823]  - until=4
[17:26:46.823]  - relaying element #4
[17:26:46.823] result() for ClusterFuture ...
[17:26:46.823] - result already collected: FutureResult
[17:26:46.823] result() for ClusterFuture ... done
[17:26:46.823] result() for ClusterFuture ...
[17:26:46.824] - result already collected: FutureResult
[17:26:46.824] result() for ClusterFuture ... done
[17:26:46.824] result() for ClusterFuture ...
[17:26:46.824] - result already collected: FutureResult
[17:26:46.824] result() for ClusterFuture ... done
[17:26:46.824] result() for ClusterFuture ...
[17:26:46.824] - result already collected: FutureResult
[17:26:46.825] result() for ClusterFuture ... done
[17:26:46.825] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.825] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.825] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:46.825]  length: 2 (resolved future 4)
[17:26:46.825] signalConditionsASAP(NULL, pos=5) ...
[17:26:46.826] - nx: 6
[17:26:46.826] - relay: TRUE
[17:26:46.826] - stdout: TRUE
[17:26:46.826] - signal: TRUE
[17:26:46.826] - resignal: FALSE
[17:26:46.826] - force: TRUE
[17:26:46.827] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.827] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.827]  - until=6
[17:26:46.827]  - relaying element #6
[17:26:46.827] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:46.827] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.828] signalConditionsASAP(NULL, pos=5) ... done
[17:26:46.828]  length: 1 (resolved future 5)
[17:26:46.828] signalConditionsASAP(numeric, pos=6) ...
[17:26:46.828] - nx: 6
[17:26:46.828] - relay: TRUE
[17:26:46.828] - stdout: TRUE
[17:26:46.829] - signal: TRUE
[17:26:46.829] - resignal: FALSE
[17:26:46.829] - force: TRUE
[17:26:46.829] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:46.829] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.829]  - until=6
[17:26:46.830] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:46.830] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.830] signalConditionsASAP(numeric, pos=6) ... done
[17:26:46.830]  length: 0 (resolved future 6)
[17:26:46.830] Relaying remaining futures
[17:26:46.830] signalConditionsASAP(NULL, pos=0) ...
[17:26:46.831] - nx: 6
[17:26:46.831] - relay: TRUE
[17:26:46.831] - stdout: TRUE
[17:26:46.831] - signal: TRUE
[17:26:46.831] - resignal: FALSE
[17:26:46.831] - force: TRUE
[17:26:46.831] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:46.832] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:46.832] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:46.832] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.832] signalConditionsASAP(NULL, pos=0) ... done
[17:26:46.832] resolve() on list environment ... DONE
[17:26:46.833] result() for ClusterFuture ...
[17:26:46.833] - result already collected: FutureResult
[17:26:46.833] result() for ClusterFuture ... done
[17:26:46.833] result() for ClusterFuture ...
[17:26:46.833] - result already collected: FutureResult
[17:26:46.833] result() for ClusterFuture ... done
[17:26:46.834] result() for ClusterFuture ...
[17:26:46.834] - result already collected: FutureResult
[17:26:46.834] result() for ClusterFuture ... done
[17:26:46.834] result() for ClusterFuture ...
[17:26:46.834] - result already collected: FutureResult
[17:26:46.834] result() for ClusterFuture ... done
[17:26:46.835] result() for ClusterFuture ...
[17:26:46.835] - result already collected: FutureResult
[17:26:46.835] result() for ClusterFuture ... done
[17:26:46.835] result() for ClusterFuture ...
[17:26:46.835] - result already collected: FutureResult
[17:26:46.835] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x000002230fa3fcd8> 
Dimensions: c(1, 6)
[17:26:46.836] getGlobalsAndPackages() ...
[17:26:46.836] Searching for globals...
[17:26:46.837] 
[17:26:46.837] Searching for globals ... DONE
[17:26:46.837] - globals: [0] <none>
[17:26:46.837] getGlobalsAndPackages() ... DONE
[17:26:46.838] run() for 'Future' ...
[17:26:46.838] - state: 'created'
[17:26:46.838] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.852] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.852] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.853]   - Field: 'node'
[17:26:46.853]   - Field: 'label'
[17:26:46.853]   - Field: 'local'
[17:26:46.853]   - Field: 'owner'
[17:26:46.853]   - Field: 'envir'
[17:26:46.854]   - Field: 'workers'
[17:26:46.854]   - Field: 'packages'
[17:26:46.854]   - Field: 'gc'
[17:26:46.854]   - Field: 'conditions'
[17:26:46.854]   - Field: 'persistent'
[17:26:46.854]   - Field: 'expr'
[17:26:46.855]   - Field: 'uuid'
[17:26:46.855]   - Field: 'seed'
[17:26:46.855]   - Field: 'version'
[17:26:46.855]   - Field: 'result'
[17:26:46.855]   - Field: 'asynchronous'
[17:26:46.856]   - Field: 'calls'
[17:26:46.856]   - Field: 'globals'
[17:26:46.856]   - Field: 'stdout'
[17:26:46.856]   - Field: 'earlySignal'
[17:26:46.856]   - Field: 'lazy'
[17:26:46.856]   - Field: 'state'
[17:26:46.857] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.857] - Launch lazy future ...
[17:26:46.857] Packages needed by the future expression (n = 0): <none>
[17:26:46.857] Packages needed by future strategies (n = 0): <none>
[17:26:46.858] {
[17:26:46.858]     {
[17:26:46.858]         {
[17:26:46.858]             ...future.startTime <- base::Sys.time()
[17:26:46.858]             {
[17:26:46.858]                 {
[17:26:46.858]                   {
[17:26:46.858]                     {
[17:26:46.858]                       base::local({
[17:26:46.858]                         has_future <- base::requireNamespace("future", 
[17:26:46.858]                           quietly = TRUE)
[17:26:46.858]                         if (has_future) {
[17:26:46.858]                           ns <- base::getNamespace("future")
[17:26:46.858]                           version <- ns[[".package"]][["version"]]
[17:26:46.858]                           if (is.null(version)) 
[17:26:46.858]                             version <- utils::packageVersion("future")
[17:26:46.858]                         }
[17:26:46.858]                         else {
[17:26:46.858]                           version <- NULL
[17:26:46.858]                         }
[17:26:46.858]                         if (!has_future || version < "1.8.0") {
[17:26:46.858]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.858]                             "", base::R.version$version.string), 
[17:26:46.858]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.858]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.858]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.858]                               "release", "version")], collapse = " "), 
[17:26:46.858]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.858]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.858]                             info)
[17:26:46.858]                           info <- base::paste(info, collapse = "; ")
[17:26:46.858]                           if (!has_future) {
[17:26:46.858]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.858]                               info)
[17:26:46.858]                           }
[17:26:46.858]                           else {
[17:26:46.858]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.858]                               info, version)
[17:26:46.858]                           }
[17:26:46.858]                           base::stop(msg)
[17:26:46.858]                         }
[17:26:46.858]                       })
[17:26:46.858]                     }
[17:26:46.858]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.858]                     base::options(mc.cores = 1L)
[17:26:46.858]                   }
[17:26:46.858]                   ...future.strategy.old <- future::plan("list")
[17:26:46.858]                   options(future.plan = NULL)
[17:26:46.858]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.858]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.858]                 }
[17:26:46.858]                 ...future.workdir <- getwd()
[17:26:46.858]             }
[17:26:46.858]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.858]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.858]         }
[17:26:46.858]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.858]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.858]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.858]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.858]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.858]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.858]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.858]             base::names(...future.oldOptions))
[17:26:46.858]     }
[17:26:46.858]     if (FALSE) {
[17:26:46.858]     }
[17:26:46.858]     else {
[17:26:46.858]         if (TRUE) {
[17:26:46.858]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.858]                 open = "w")
[17:26:46.858]         }
[17:26:46.858]         else {
[17:26:46.858]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.858]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.858]         }
[17:26:46.858]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.858]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.858]             base::sink(type = "output", split = FALSE)
[17:26:46.858]             base::close(...future.stdout)
[17:26:46.858]         }, add = TRUE)
[17:26:46.858]     }
[17:26:46.858]     ...future.frame <- base::sys.nframe()
[17:26:46.858]     ...future.conditions <- base::list()
[17:26:46.858]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.858]     if (FALSE) {
[17:26:46.858]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.858]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.858]     }
[17:26:46.858]     ...future.result <- base::tryCatch({
[17:26:46.858]         base::withCallingHandlers({
[17:26:46.858]             ...future.value <- base::withVisible(base::local({
[17:26:46.858]                 ...future.makeSendCondition <- base::local({
[17:26:46.858]                   sendCondition <- NULL
[17:26:46.858]                   function(frame = 1L) {
[17:26:46.858]                     if (is.function(sendCondition)) 
[17:26:46.858]                       return(sendCondition)
[17:26:46.858]                     ns <- getNamespace("parallel")
[17:26:46.858]                     if (exists("sendData", mode = "function", 
[17:26:46.858]                       envir = ns)) {
[17:26:46.858]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.858]                         envir = ns)
[17:26:46.858]                       envir <- sys.frame(frame)
[17:26:46.858]                       master <- NULL
[17:26:46.858]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.858]                         !identical(envir, emptyenv())) {
[17:26:46.858]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.858]                           inherits = FALSE)) {
[17:26:46.858]                           master <- get("master", mode = "list", 
[17:26:46.858]                             envir = envir, inherits = FALSE)
[17:26:46.858]                           if (inherits(master, c("SOCKnode", 
[17:26:46.858]                             "SOCK0node"))) {
[17:26:46.858]                             sendCondition <<- function(cond) {
[17:26:46.858]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.858]                                 success = TRUE)
[17:26:46.858]                               parallel_sendData(master, data)
[17:26:46.858]                             }
[17:26:46.858]                             return(sendCondition)
[17:26:46.858]                           }
[17:26:46.858]                         }
[17:26:46.858]                         frame <- frame + 1L
[17:26:46.858]                         envir <- sys.frame(frame)
[17:26:46.858]                       }
[17:26:46.858]                     }
[17:26:46.858]                     sendCondition <<- function(cond) NULL
[17:26:46.858]                   }
[17:26:46.858]                 })
[17:26:46.858]                 withCallingHandlers({
[17:26:46.858]                   2
[17:26:46.858]                 }, immediateCondition = function(cond) {
[17:26:46.858]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.858]                   sendCondition(cond)
[17:26:46.858]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.858]                   {
[17:26:46.858]                     inherits <- base::inherits
[17:26:46.858]                     invokeRestart <- base::invokeRestart
[17:26:46.858]                     is.null <- base::is.null
[17:26:46.858]                     muffled <- FALSE
[17:26:46.858]                     if (inherits(cond, "message")) {
[17:26:46.858]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.858]                       if (muffled) 
[17:26:46.858]                         invokeRestart("muffleMessage")
[17:26:46.858]                     }
[17:26:46.858]                     else if (inherits(cond, "warning")) {
[17:26:46.858]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.858]                       if (muffled) 
[17:26:46.858]                         invokeRestart("muffleWarning")
[17:26:46.858]                     }
[17:26:46.858]                     else if (inherits(cond, "condition")) {
[17:26:46.858]                       if (!is.null(pattern)) {
[17:26:46.858]                         computeRestarts <- base::computeRestarts
[17:26:46.858]                         grepl <- base::grepl
[17:26:46.858]                         restarts <- computeRestarts(cond)
[17:26:46.858]                         for (restart in restarts) {
[17:26:46.858]                           name <- restart$name
[17:26:46.858]                           if (is.null(name)) 
[17:26:46.858]                             next
[17:26:46.858]                           if (!grepl(pattern, name)) 
[17:26:46.858]                             next
[17:26:46.858]                           invokeRestart(restart)
[17:26:46.858]                           muffled <- TRUE
[17:26:46.858]                           break
[17:26:46.858]                         }
[17:26:46.858]                       }
[17:26:46.858]                     }
[17:26:46.858]                     invisible(muffled)
[17:26:46.858]                   }
[17:26:46.858]                   muffleCondition(cond)
[17:26:46.858]                 })
[17:26:46.858]             }))
[17:26:46.858]             future::FutureResult(value = ...future.value$value, 
[17:26:46.858]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.858]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.858]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.858]                     ...future.globalenv.names))
[17:26:46.858]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.858]         }, condition = base::local({
[17:26:46.858]             c <- base::c
[17:26:46.858]             inherits <- base::inherits
[17:26:46.858]             invokeRestart <- base::invokeRestart
[17:26:46.858]             length <- base::length
[17:26:46.858]             list <- base::list
[17:26:46.858]             seq.int <- base::seq.int
[17:26:46.858]             signalCondition <- base::signalCondition
[17:26:46.858]             sys.calls <- base::sys.calls
[17:26:46.858]             `[[` <- base::`[[`
[17:26:46.858]             `+` <- base::`+`
[17:26:46.858]             `<<-` <- base::`<<-`
[17:26:46.858]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.858]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.858]                   3L)]
[17:26:46.858]             }
[17:26:46.858]             function(cond) {
[17:26:46.858]                 is_error <- inherits(cond, "error")
[17:26:46.858]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.858]                   NULL)
[17:26:46.858]                 if (is_error) {
[17:26:46.858]                   sessionInformation <- function() {
[17:26:46.858]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.858]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.858]                       search = base::search(), system = base::Sys.info())
[17:26:46.858]                   }
[17:26:46.858]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.858]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.858]                     cond$call), session = sessionInformation(), 
[17:26:46.858]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.858]                   signalCondition(cond)
[17:26:46.858]                 }
[17:26:46.858]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.858]                 "immediateCondition"))) {
[17:26:46.858]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.858]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.858]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.858]                   if (TRUE && !signal) {
[17:26:46.858]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.858]                     {
[17:26:46.858]                       inherits <- base::inherits
[17:26:46.858]                       invokeRestart <- base::invokeRestart
[17:26:46.858]                       is.null <- base::is.null
[17:26:46.858]                       muffled <- FALSE
[17:26:46.858]                       if (inherits(cond, "message")) {
[17:26:46.858]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.858]                         if (muffled) 
[17:26:46.858]                           invokeRestart("muffleMessage")
[17:26:46.858]                       }
[17:26:46.858]                       else if (inherits(cond, "warning")) {
[17:26:46.858]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.858]                         if (muffled) 
[17:26:46.858]                           invokeRestart("muffleWarning")
[17:26:46.858]                       }
[17:26:46.858]                       else if (inherits(cond, "condition")) {
[17:26:46.858]                         if (!is.null(pattern)) {
[17:26:46.858]                           computeRestarts <- base::computeRestarts
[17:26:46.858]                           grepl <- base::grepl
[17:26:46.858]                           restarts <- computeRestarts(cond)
[17:26:46.858]                           for (restart in restarts) {
[17:26:46.858]                             name <- restart$name
[17:26:46.858]                             if (is.null(name)) 
[17:26:46.858]                               next
[17:26:46.858]                             if (!grepl(pattern, name)) 
[17:26:46.858]                               next
[17:26:46.858]                             invokeRestart(restart)
[17:26:46.858]                             muffled <- TRUE
[17:26:46.858]                             break
[17:26:46.858]                           }
[17:26:46.858]                         }
[17:26:46.858]                       }
[17:26:46.858]                       invisible(muffled)
[17:26:46.858]                     }
[17:26:46.858]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.858]                   }
[17:26:46.858]                 }
[17:26:46.858]                 else {
[17:26:46.858]                   if (TRUE) {
[17:26:46.858]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.858]                     {
[17:26:46.858]                       inherits <- base::inherits
[17:26:46.858]                       invokeRestart <- base::invokeRestart
[17:26:46.858]                       is.null <- base::is.null
[17:26:46.858]                       muffled <- FALSE
[17:26:46.858]                       if (inherits(cond, "message")) {
[17:26:46.858]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.858]                         if (muffled) 
[17:26:46.858]                           invokeRestart("muffleMessage")
[17:26:46.858]                       }
[17:26:46.858]                       else if (inherits(cond, "warning")) {
[17:26:46.858]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.858]                         if (muffled) 
[17:26:46.858]                           invokeRestart("muffleWarning")
[17:26:46.858]                       }
[17:26:46.858]                       else if (inherits(cond, "condition")) {
[17:26:46.858]                         if (!is.null(pattern)) {
[17:26:46.858]                           computeRestarts <- base::computeRestarts
[17:26:46.858]                           grepl <- base::grepl
[17:26:46.858]                           restarts <- computeRestarts(cond)
[17:26:46.858]                           for (restart in restarts) {
[17:26:46.858]                             name <- restart$name
[17:26:46.858]                             if (is.null(name)) 
[17:26:46.858]                               next
[17:26:46.858]                             if (!grepl(pattern, name)) 
[17:26:46.858]                               next
[17:26:46.858]                             invokeRestart(restart)
[17:26:46.858]                             muffled <- TRUE
[17:26:46.858]                             break
[17:26:46.858]                           }
[17:26:46.858]                         }
[17:26:46.858]                       }
[17:26:46.858]                       invisible(muffled)
[17:26:46.858]                     }
[17:26:46.858]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.858]                   }
[17:26:46.858]                 }
[17:26:46.858]             }
[17:26:46.858]         }))
[17:26:46.858]     }, error = function(ex) {
[17:26:46.858]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.858]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.858]                 ...future.rng), started = ...future.startTime, 
[17:26:46.858]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.858]             version = "1.8"), class = "FutureResult")
[17:26:46.858]     }, finally = {
[17:26:46.858]         if (!identical(...future.workdir, getwd())) 
[17:26:46.858]             setwd(...future.workdir)
[17:26:46.858]         {
[17:26:46.858]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.858]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.858]             }
[17:26:46.858]             base::options(...future.oldOptions)
[17:26:46.858]             if (.Platform$OS.type == "windows") {
[17:26:46.858]                 old_names <- names(...future.oldEnvVars)
[17:26:46.858]                 envs <- base::Sys.getenv()
[17:26:46.858]                 names <- names(envs)
[17:26:46.858]                 common <- intersect(names, old_names)
[17:26:46.858]                 added <- setdiff(names, old_names)
[17:26:46.858]                 removed <- setdiff(old_names, names)
[17:26:46.858]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.858]                   envs[common]]
[17:26:46.858]                 NAMES <- toupper(changed)
[17:26:46.858]                 args <- list()
[17:26:46.858]                 for (kk in seq_along(NAMES)) {
[17:26:46.858]                   name <- changed[[kk]]
[17:26:46.858]                   NAME <- NAMES[[kk]]
[17:26:46.858]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.858]                     next
[17:26:46.858]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.858]                 }
[17:26:46.858]                 NAMES <- toupper(added)
[17:26:46.858]                 for (kk in seq_along(NAMES)) {
[17:26:46.858]                   name <- added[[kk]]
[17:26:46.858]                   NAME <- NAMES[[kk]]
[17:26:46.858]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.858]                     next
[17:26:46.858]                   args[[name]] <- ""
[17:26:46.858]                 }
[17:26:46.858]                 NAMES <- toupper(removed)
[17:26:46.858]                 for (kk in seq_along(NAMES)) {
[17:26:46.858]                   name <- removed[[kk]]
[17:26:46.858]                   NAME <- NAMES[[kk]]
[17:26:46.858]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.858]                     next
[17:26:46.858]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.858]                 }
[17:26:46.858]                 if (length(args) > 0) 
[17:26:46.858]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.858]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.858]             }
[17:26:46.858]             else {
[17:26:46.858]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.858]             }
[17:26:46.858]             {
[17:26:46.858]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.858]                   0L) {
[17:26:46.858]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.858]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.858]                   base::options(opts)
[17:26:46.858]                 }
[17:26:46.858]                 {
[17:26:46.858]                   {
[17:26:46.858]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.858]                     NULL
[17:26:46.858]                   }
[17:26:46.858]                   options(future.plan = NULL)
[17:26:46.858]                   if (is.na(NA_character_)) 
[17:26:46.858]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.858]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.858]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.858]                     .init = FALSE)
[17:26:46.858]                 }
[17:26:46.858]             }
[17:26:46.858]         }
[17:26:46.858]     })
[17:26:46.858]     if (TRUE) {
[17:26:46.858]         base::sink(type = "output", split = FALSE)
[17:26:46.858]         if (TRUE) {
[17:26:46.858]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.858]         }
[17:26:46.858]         else {
[17:26:46.858]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.858]         }
[17:26:46.858]         base::close(...future.stdout)
[17:26:46.858]         ...future.stdout <- NULL
[17:26:46.858]     }
[17:26:46.858]     ...future.result$conditions <- ...future.conditions
[17:26:46.858]     ...future.result$finished <- base::Sys.time()
[17:26:46.858]     ...future.result
[17:26:46.858] }
[17:26:46.864] MultisessionFuture started
[17:26:46.864] - Launch lazy future ... done
[17:26:46.864] run() for 'MultisessionFuture' ... done
[17:26:46.864] getGlobalsAndPackages() ...
[17:26:46.864] Searching for globals...
[17:26:46.865] 
[17:26:46.865] Searching for globals ... DONE
[17:26:46.865] - globals: [0] <none>
[17:26:46.865] getGlobalsAndPackages() ... DONE
[17:26:46.866] run() for 'Future' ...
[17:26:46.866] - state: 'created'
[17:26:46.866] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.880] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.880] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.880]   - Field: 'node'
[17:26:46.881]   - Field: 'label'
[17:26:46.881]   - Field: 'local'
[17:26:46.881]   - Field: 'owner'
[17:26:46.881]   - Field: 'envir'
[17:26:46.881]   - Field: 'workers'
[17:26:46.881]   - Field: 'packages'
[17:26:46.882]   - Field: 'gc'
[17:26:46.882]   - Field: 'conditions'
[17:26:46.882]   - Field: 'persistent'
[17:26:46.882]   - Field: 'expr'
[17:26:46.882]   - Field: 'uuid'
[17:26:46.883]   - Field: 'seed'
[17:26:46.883]   - Field: 'version'
[17:26:46.883]   - Field: 'result'
[17:26:46.883]   - Field: 'asynchronous'
[17:26:46.883]   - Field: 'calls'
[17:26:46.883]   - Field: 'globals'
[17:26:46.884]   - Field: 'stdout'
[17:26:46.884]   - Field: 'earlySignal'
[17:26:46.884]   - Field: 'lazy'
[17:26:46.884]   - Field: 'state'
[17:26:46.884] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.884] - Launch lazy future ...
[17:26:46.885] Packages needed by the future expression (n = 0): <none>
[17:26:46.885] Packages needed by future strategies (n = 0): <none>
[17:26:46.886] {
[17:26:46.886]     {
[17:26:46.886]         {
[17:26:46.886]             ...future.startTime <- base::Sys.time()
[17:26:46.886]             {
[17:26:46.886]                 {
[17:26:46.886]                   {
[17:26:46.886]                     {
[17:26:46.886]                       base::local({
[17:26:46.886]                         has_future <- base::requireNamespace("future", 
[17:26:46.886]                           quietly = TRUE)
[17:26:46.886]                         if (has_future) {
[17:26:46.886]                           ns <- base::getNamespace("future")
[17:26:46.886]                           version <- ns[[".package"]][["version"]]
[17:26:46.886]                           if (is.null(version)) 
[17:26:46.886]                             version <- utils::packageVersion("future")
[17:26:46.886]                         }
[17:26:46.886]                         else {
[17:26:46.886]                           version <- NULL
[17:26:46.886]                         }
[17:26:46.886]                         if (!has_future || version < "1.8.0") {
[17:26:46.886]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.886]                             "", base::R.version$version.string), 
[17:26:46.886]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.886]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.886]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.886]                               "release", "version")], collapse = " "), 
[17:26:46.886]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.886]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.886]                             info)
[17:26:46.886]                           info <- base::paste(info, collapse = "; ")
[17:26:46.886]                           if (!has_future) {
[17:26:46.886]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.886]                               info)
[17:26:46.886]                           }
[17:26:46.886]                           else {
[17:26:46.886]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.886]                               info, version)
[17:26:46.886]                           }
[17:26:46.886]                           base::stop(msg)
[17:26:46.886]                         }
[17:26:46.886]                       })
[17:26:46.886]                     }
[17:26:46.886]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.886]                     base::options(mc.cores = 1L)
[17:26:46.886]                   }
[17:26:46.886]                   ...future.strategy.old <- future::plan("list")
[17:26:46.886]                   options(future.plan = NULL)
[17:26:46.886]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.886]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.886]                 }
[17:26:46.886]                 ...future.workdir <- getwd()
[17:26:46.886]             }
[17:26:46.886]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.886]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.886]         }
[17:26:46.886]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.886]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.886]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.886]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.886]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.886]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.886]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.886]             base::names(...future.oldOptions))
[17:26:46.886]     }
[17:26:46.886]     if (FALSE) {
[17:26:46.886]     }
[17:26:46.886]     else {
[17:26:46.886]         if (TRUE) {
[17:26:46.886]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.886]                 open = "w")
[17:26:46.886]         }
[17:26:46.886]         else {
[17:26:46.886]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.886]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.886]         }
[17:26:46.886]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.886]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.886]             base::sink(type = "output", split = FALSE)
[17:26:46.886]             base::close(...future.stdout)
[17:26:46.886]         }, add = TRUE)
[17:26:46.886]     }
[17:26:46.886]     ...future.frame <- base::sys.nframe()
[17:26:46.886]     ...future.conditions <- base::list()
[17:26:46.886]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.886]     if (FALSE) {
[17:26:46.886]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.886]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.886]     }
[17:26:46.886]     ...future.result <- base::tryCatch({
[17:26:46.886]         base::withCallingHandlers({
[17:26:46.886]             ...future.value <- base::withVisible(base::local({
[17:26:46.886]                 ...future.makeSendCondition <- base::local({
[17:26:46.886]                   sendCondition <- NULL
[17:26:46.886]                   function(frame = 1L) {
[17:26:46.886]                     if (is.function(sendCondition)) 
[17:26:46.886]                       return(sendCondition)
[17:26:46.886]                     ns <- getNamespace("parallel")
[17:26:46.886]                     if (exists("sendData", mode = "function", 
[17:26:46.886]                       envir = ns)) {
[17:26:46.886]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.886]                         envir = ns)
[17:26:46.886]                       envir <- sys.frame(frame)
[17:26:46.886]                       master <- NULL
[17:26:46.886]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.886]                         !identical(envir, emptyenv())) {
[17:26:46.886]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.886]                           inherits = FALSE)) {
[17:26:46.886]                           master <- get("master", mode = "list", 
[17:26:46.886]                             envir = envir, inherits = FALSE)
[17:26:46.886]                           if (inherits(master, c("SOCKnode", 
[17:26:46.886]                             "SOCK0node"))) {
[17:26:46.886]                             sendCondition <<- function(cond) {
[17:26:46.886]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.886]                                 success = TRUE)
[17:26:46.886]                               parallel_sendData(master, data)
[17:26:46.886]                             }
[17:26:46.886]                             return(sendCondition)
[17:26:46.886]                           }
[17:26:46.886]                         }
[17:26:46.886]                         frame <- frame + 1L
[17:26:46.886]                         envir <- sys.frame(frame)
[17:26:46.886]                       }
[17:26:46.886]                     }
[17:26:46.886]                     sendCondition <<- function(cond) NULL
[17:26:46.886]                   }
[17:26:46.886]                 })
[17:26:46.886]                 withCallingHandlers({
[17:26:46.886]                   NULL
[17:26:46.886]                 }, immediateCondition = function(cond) {
[17:26:46.886]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.886]                   sendCondition(cond)
[17:26:46.886]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.886]                   {
[17:26:46.886]                     inherits <- base::inherits
[17:26:46.886]                     invokeRestart <- base::invokeRestart
[17:26:46.886]                     is.null <- base::is.null
[17:26:46.886]                     muffled <- FALSE
[17:26:46.886]                     if (inherits(cond, "message")) {
[17:26:46.886]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.886]                       if (muffled) 
[17:26:46.886]                         invokeRestart("muffleMessage")
[17:26:46.886]                     }
[17:26:46.886]                     else if (inherits(cond, "warning")) {
[17:26:46.886]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.886]                       if (muffled) 
[17:26:46.886]                         invokeRestart("muffleWarning")
[17:26:46.886]                     }
[17:26:46.886]                     else if (inherits(cond, "condition")) {
[17:26:46.886]                       if (!is.null(pattern)) {
[17:26:46.886]                         computeRestarts <- base::computeRestarts
[17:26:46.886]                         grepl <- base::grepl
[17:26:46.886]                         restarts <- computeRestarts(cond)
[17:26:46.886]                         for (restart in restarts) {
[17:26:46.886]                           name <- restart$name
[17:26:46.886]                           if (is.null(name)) 
[17:26:46.886]                             next
[17:26:46.886]                           if (!grepl(pattern, name)) 
[17:26:46.886]                             next
[17:26:46.886]                           invokeRestart(restart)
[17:26:46.886]                           muffled <- TRUE
[17:26:46.886]                           break
[17:26:46.886]                         }
[17:26:46.886]                       }
[17:26:46.886]                     }
[17:26:46.886]                     invisible(muffled)
[17:26:46.886]                   }
[17:26:46.886]                   muffleCondition(cond)
[17:26:46.886]                 })
[17:26:46.886]             }))
[17:26:46.886]             future::FutureResult(value = ...future.value$value, 
[17:26:46.886]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.886]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.886]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.886]                     ...future.globalenv.names))
[17:26:46.886]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.886]         }, condition = base::local({
[17:26:46.886]             c <- base::c
[17:26:46.886]             inherits <- base::inherits
[17:26:46.886]             invokeRestart <- base::invokeRestart
[17:26:46.886]             length <- base::length
[17:26:46.886]             list <- base::list
[17:26:46.886]             seq.int <- base::seq.int
[17:26:46.886]             signalCondition <- base::signalCondition
[17:26:46.886]             sys.calls <- base::sys.calls
[17:26:46.886]             `[[` <- base::`[[`
[17:26:46.886]             `+` <- base::`+`
[17:26:46.886]             `<<-` <- base::`<<-`
[17:26:46.886]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.886]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.886]                   3L)]
[17:26:46.886]             }
[17:26:46.886]             function(cond) {
[17:26:46.886]                 is_error <- inherits(cond, "error")
[17:26:46.886]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.886]                   NULL)
[17:26:46.886]                 if (is_error) {
[17:26:46.886]                   sessionInformation <- function() {
[17:26:46.886]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.886]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.886]                       search = base::search(), system = base::Sys.info())
[17:26:46.886]                   }
[17:26:46.886]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.886]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.886]                     cond$call), session = sessionInformation(), 
[17:26:46.886]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.886]                   signalCondition(cond)
[17:26:46.886]                 }
[17:26:46.886]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.886]                 "immediateCondition"))) {
[17:26:46.886]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.886]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.886]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.886]                   if (TRUE && !signal) {
[17:26:46.886]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.886]                     {
[17:26:46.886]                       inherits <- base::inherits
[17:26:46.886]                       invokeRestart <- base::invokeRestart
[17:26:46.886]                       is.null <- base::is.null
[17:26:46.886]                       muffled <- FALSE
[17:26:46.886]                       if (inherits(cond, "message")) {
[17:26:46.886]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.886]                         if (muffled) 
[17:26:46.886]                           invokeRestart("muffleMessage")
[17:26:46.886]                       }
[17:26:46.886]                       else if (inherits(cond, "warning")) {
[17:26:46.886]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.886]                         if (muffled) 
[17:26:46.886]                           invokeRestart("muffleWarning")
[17:26:46.886]                       }
[17:26:46.886]                       else if (inherits(cond, "condition")) {
[17:26:46.886]                         if (!is.null(pattern)) {
[17:26:46.886]                           computeRestarts <- base::computeRestarts
[17:26:46.886]                           grepl <- base::grepl
[17:26:46.886]                           restarts <- computeRestarts(cond)
[17:26:46.886]                           for (restart in restarts) {
[17:26:46.886]                             name <- restart$name
[17:26:46.886]                             if (is.null(name)) 
[17:26:46.886]                               next
[17:26:46.886]                             if (!grepl(pattern, name)) 
[17:26:46.886]                               next
[17:26:46.886]                             invokeRestart(restart)
[17:26:46.886]                             muffled <- TRUE
[17:26:46.886]                             break
[17:26:46.886]                           }
[17:26:46.886]                         }
[17:26:46.886]                       }
[17:26:46.886]                       invisible(muffled)
[17:26:46.886]                     }
[17:26:46.886]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.886]                   }
[17:26:46.886]                 }
[17:26:46.886]                 else {
[17:26:46.886]                   if (TRUE) {
[17:26:46.886]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.886]                     {
[17:26:46.886]                       inherits <- base::inherits
[17:26:46.886]                       invokeRestart <- base::invokeRestart
[17:26:46.886]                       is.null <- base::is.null
[17:26:46.886]                       muffled <- FALSE
[17:26:46.886]                       if (inherits(cond, "message")) {
[17:26:46.886]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.886]                         if (muffled) 
[17:26:46.886]                           invokeRestart("muffleMessage")
[17:26:46.886]                       }
[17:26:46.886]                       else if (inherits(cond, "warning")) {
[17:26:46.886]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.886]                         if (muffled) 
[17:26:46.886]                           invokeRestart("muffleWarning")
[17:26:46.886]                       }
[17:26:46.886]                       else if (inherits(cond, "condition")) {
[17:26:46.886]                         if (!is.null(pattern)) {
[17:26:46.886]                           computeRestarts <- base::computeRestarts
[17:26:46.886]                           grepl <- base::grepl
[17:26:46.886]                           restarts <- computeRestarts(cond)
[17:26:46.886]                           for (restart in restarts) {
[17:26:46.886]                             name <- restart$name
[17:26:46.886]                             if (is.null(name)) 
[17:26:46.886]                               next
[17:26:46.886]                             if (!grepl(pattern, name)) 
[17:26:46.886]                               next
[17:26:46.886]                             invokeRestart(restart)
[17:26:46.886]                             muffled <- TRUE
[17:26:46.886]                             break
[17:26:46.886]                           }
[17:26:46.886]                         }
[17:26:46.886]                       }
[17:26:46.886]                       invisible(muffled)
[17:26:46.886]                     }
[17:26:46.886]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.886]                   }
[17:26:46.886]                 }
[17:26:46.886]             }
[17:26:46.886]         }))
[17:26:46.886]     }, error = function(ex) {
[17:26:46.886]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.886]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.886]                 ...future.rng), started = ...future.startTime, 
[17:26:46.886]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.886]             version = "1.8"), class = "FutureResult")
[17:26:46.886]     }, finally = {
[17:26:46.886]         if (!identical(...future.workdir, getwd())) 
[17:26:46.886]             setwd(...future.workdir)
[17:26:46.886]         {
[17:26:46.886]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.886]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.886]             }
[17:26:46.886]             base::options(...future.oldOptions)
[17:26:46.886]             if (.Platform$OS.type == "windows") {
[17:26:46.886]                 old_names <- names(...future.oldEnvVars)
[17:26:46.886]                 envs <- base::Sys.getenv()
[17:26:46.886]                 names <- names(envs)
[17:26:46.886]                 common <- intersect(names, old_names)
[17:26:46.886]                 added <- setdiff(names, old_names)
[17:26:46.886]                 removed <- setdiff(old_names, names)
[17:26:46.886]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.886]                   envs[common]]
[17:26:46.886]                 NAMES <- toupper(changed)
[17:26:46.886]                 args <- list()
[17:26:46.886]                 for (kk in seq_along(NAMES)) {
[17:26:46.886]                   name <- changed[[kk]]
[17:26:46.886]                   NAME <- NAMES[[kk]]
[17:26:46.886]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.886]                     next
[17:26:46.886]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.886]                 }
[17:26:46.886]                 NAMES <- toupper(added)
[17:26:46.886]                 for (kk in seq_along(NAMES)) {
[17:26:46.886]                   name <- added[[kk]]
[17:26:46.886]                   NAME <- NAMES[[kk]]
[17:26:46.886]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.886]                     next
[17:26:46.886]                   args[[name]] <- ""
[17:26:46.886]                 }
[17:26:46.886]                 NAMES <- toupper(removed)
[17:26:46.886]                 for (kk in seq_along(NAMES)) {
[17:26:46.886]                   name <- removed[[kk]]
[17:26:46.886]                   NAME <- NAMES[[kk]]
[17:26:46.886]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.886]                     next
[17:26:46.886]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.886]                 }
[17:26:46.886]                 if (length(args) > 0) 
[17:26:46.886]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.886]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.886]             }
[17:26:46.886]             else {
[17:26:46.886]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.886]             }
[17:26:46.886]             {
[17:26:46.886]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.886]                   0L) {
[17:26:46.886]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.886]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.886]                   base::options(opts)
[17:26:46.886]                 }
[17:26:46.886]                 {
[17:26:46.886]                   {
[17:26:46.886]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.886]                     NULL
[17:26:46.886]                   }
[17:26:46.886]                   options(future.plan = NULL)
[17:26:46.886]                   if (is.na(NA_character_)) 
[17:26:46.886]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.886]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.886]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.886]                     .init = FALSE)
[17:26:46.886]                 }
[17:26:46.886]             }
[17:26:46.886]         }
[17:26:46.886]     })
[17:26:46.886]     if (TRUE) {
[17:26:46.886]         base::sink(type = "output", split = FALSE)
[17:26:46.886]         if (TRUE) {
[17:26:46.886]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.886]         }
[17:26:46.886]         else {
[17:26:46.886]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.886]         }
[17:26:46.886]         base::close(...future.stdout)
[17:26:46.886]         ...future.stdout <- NULL
[17:26:46.886]     }
[17:26:46.886]     ...future.result$conditions <- ...future.conditions
[17:26:46.886]     ...future.result$finished <- base::Sys.time()
[17:26:46.886]     ...future.result
[17:26:46.886] }
[17:26:46.894] MultisessionFuture started
[17:26:46.895] - Launch lazy future ... done
[17:26:46.895] run() for 'MultisessionFuture' ... done
[17:26:46.895] getGlobalsAndPackages() ...
[17:26:46.895] Searching for globals...
[17:26:46.896] - globals found: [1] '{'
[17:26:46.896] Searching for globals ... DONE
[17:26:46.897] Resolving globals: FALSE
[17:26:46.897] 
[17:26:46.897] 
[17:26:46.897] getGlobalsAndPackages() ... DONE
[17:26:46.898] run() for 'Future' ...
[17:26:46.898] - state: 'created'
[17:26:46.898] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:46.912] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:46.912] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:46.912]   - Field: 'node'
[17:26:46.912]   - Field: 'label'
[17:26:46.913]   - Field: 'local'
[17:26:46.913]   - Field: 'owner'
[17:26:46.913]   - Field: 'envir'
[17:26:46.913]   - Field: 'workers'
[17:26:46.913]   - Field: 'packages'
[17:26:46.913]   - Field: 'gc'
[17:26:46.914]   - Field: 'conditions'
[17:26:46.914]   - Field: 'persistent'
[17:26:46.914]   - Field: 'expr'
[17:26:46.914]   - Field: 'uuid'
[17:26:46.914]   - Field: 'seed'
[17:26:46.915]   - Field: 'version'
[17:26:46.915]   - Field: 'result'
[17:26:46.915]   - Field: 'asynchronous'
[17:26:46.915]   - Field: 'calls'
[17:26:46.915]   - Field: 'globals'
[17:26:46.915]   - Field: 'stdout'
[17:26:46.916]   - Field: 'earlySignal'
[17:26:46.916]   - Field: 'lazy'
[17:26:46.916]   - Field: 'state'
[17:26:46.916] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:46.916] - Launch lazy future ...
[17:26:46.917] Packages needed by the future expression (n = 0): <none>
[17:26:46.917] Packages needed by future strategies (n = 0): <none>
[17:26:46.917] {
[17:26:46.917]     {
[17:26:46.917]         {
[17:26:46.917]             ...future.startTime <- base::Sys.time()
[17:26:46.917]             {
[17:26:46.917]                 {
[17:26:46.917]                   {
[17:26:46.917]                     {
[17:26:46.917]                       base::local({
[17:26:46.917]                         has_future <- base::requireNamespace("future", 
[17:26:46.917]                           quietly = TRUE)
[17:26:46.917]                         if (has_future) {
[17:26:46.917]                           ns <- base::getNamespace("future")
[17:26:46.917]                           version <- ns[[".package"]][["version"]]
[17:26:46.917]                           if (is.null(version)) 
[17:26:46.917]                             version <- utils::packageVersion("future")
[17:26:46.917]                         }
[17:26:46.917]                         else {
[17:26:46.917]                           version <- NULL
[17:26:46.917]                         }
[17:26:46.917]                         if (!has_future || version < "1.8.0") {
[17:26:46.917]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:46.917]                             "", base::R.version$version.string), 
[17:26:46.917]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:46.917]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:46.917]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:46.917]                               "release", "version")], collapse = " "), 
[17:26:46.917]                             hostname = base::Sys.info()[["nodename"]])
[17:26:46.917]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:46.917]                             info)
[17:26:46.917]                           info <- base::paste(info, collapse = "; ")
[17:26:46.917]                           if (!has_future) {
[17:26:46.917]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:46.917]                               info)
[17:26:46.917]                           }
[17:26:46.917]                           else {
[17:26:46.917]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:46.917]                               info, version)
[17:26:46.917]                           }
[17:26:46.917]                           base::stop(msg)
[17:26:46.917]                         }
[17:26:46.917]                       })
[17:26:46.917]                     }
[17:26:46.917]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:46.917]                     base::options(mc.cores = 1L)
[17:26:46.917]                   }
[17:26:46.917]                   ...future.strategy.old <- future::plan("list")
[17:26:46.917]                   options(future.plan = NULL)
[17:26:46.917]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.917]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:46.917]                 }
[17:26:46.917]                 ...future.workdir <- getwd()
[17:26:46.917]             }
[17:26:46.917]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:46.917]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:46.917]         }
[17:26:46.917]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:46.917]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:46.917]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:46.917]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:46.917]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:46.917]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:46.917]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:46.917]             base::names(...future.oldOptions))
[17:26:46.917]     }
[17:26:46.917]     if (FALSE) {
[17:26:46.917]     }
[17:26:46.917]     else {
[17:26:46.917]         if (TRUE) {
[17:26:46.917]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:46.917]                 open = "w")
[17:26:46.917]         }
[17:26:46.917]         else {
[17:26:46.917]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:46.917]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:46.917]         }
[17:26:46.917]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:46.917]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:46.917]             base::sink(type = "output", split = FALSE)
[17:26:46.917]             base::close(...future.stdout)
[17:26:46.917]         }, add = TRUE)
[17:26:46.917]     }
[17:26:46.917]     ...future.frame <- base::sys.nframe()
[17:26:46.917]     ...future.conditions <- base::list()
[17:26:46.917]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:46.917]     if (FALSE) {
[17:26:46.917]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:46.917]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:46.917]     }
[17:26:46.917]     ...future.result <- base::tryCatch({
[17:26:46.917]         base::withCallingHandlers({
[17:26:46.917]             ...future.value <- base::withVisible(base::local({
[17:26:46.917]                 ...future.makeSendCondition <- base::local({
[17:26:46.917]                   sendCondition <- NULL
[17:26:46.917]                   function(frame = 1L) {
[17:26:46.917]                     if (is.function(sendCondition)) 
[17:26:46.917]                       return(sendCondition)
[17:26:46.917]                     ns <- getNamespace("parallel")
[17:26:46.917]                     if (exists("sendData", mode = "function", 
[17:26:46.917]                       envir = ns)) {
[17:26:46.917]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:46.917]                         envir = ns)
[17:26:46.917]                       envir <- sys.frame(frame)
[17:26:46.917]                       master <- NULL
[17:26:46.917]                       while (!identical(envir, .GlobalEnv) && 
[17:26:46.917]                         !identical(envir, emptyenv())) {
[17:26:46.917]                         if (exists("master", mode = "list", envir = envir, 
[17:26:46.917]                           inherits = FALSE)) {
[17:26:46.917]                           master <- get("master", mode = "list", 
[17:26:46.917]                             envir = envir, inherits = FALSE)
[17:26:46.917]                           if (inherits(master, c("SOCKnode", 
[17:26:46.917]                             "SOCK0node"))) {
[17:26:46.917]                             sendCondition <<- function(cond) {
[17:26:46.917]                               data <- list(type = "VALUE", value = cond, 
[17:26:46.917]                                 success = TRUE)
[17:26:46.917]                               parallel_sendData(master, data)
[17:26:46.917]                             }
[17:26:46.917]                             return(sendCondition)
[17:26:46.917]                           }
[17:26:46.917]                         }
[17:26:46.917]                         frame <- frame + 1L
[17:26:46.917]                         envir <- sys.frame(frame)
[17:26:46.917]                       }
[17:26:46.917]                     }
[17:26:46.917]                     sendCondition <<- function(cond) NULL
[17:26:46.917]                   }
[17:26:46.917]                 })
[17:26:46.917]                 withCallingHandlers({
[17:26:46.917]                   {
[17:26:46.917]                     4
[17:26:46.917]                   }
[17:26:46.917]                 }, immediateCondition = function(cond) {
[17:26:46.917]                   sendCondition <- ...future.makeSendCondition()
[17:26:46.917]                   sendCondition(cond)
[17:26:46.917]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.917]                   {
[17:26:46.917]                     inherits <- base::inherits
[17:26:46.917]                     invokeRestart <- base::invokeRestart
[17:26:46.917]                     is.null <- base::is.null
[17:26:46.917]                     muffled <- FALSE
[17:26:46.917]                     if (inherits(cond, "message")) {
[17:26:46.917]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:46.917]                       if (muffled) 
[17:26:46.917]                         invokeRestart("muffleMessage")
[17:26:46.917]                     }
[17:26:46.917]                     else if (inherits(cond, "warning")) {
[17:26:46.917]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:46.917]                       if (muffled) 
[17:26:46.917]                         invokeRestart("muffleWarning")
[17:26:46.917]                     }
[17:26:46.917]                     else if (inherits(cond, "condition")) {
[17:26:46.917]                       if (!is.null(pattern)) {
[17:26:46.917]                         computeRestarts <- base::computeRestarts
[17:26:46.917]                         grepl <- base::grepl
[17:26:46.917]                         restarts <- computeRestarts(cond)
[17:26:46.917]                         for (restart in restarts) {
[17:26:46.917]                           name <- restart$name
[17:26:46.917]                           if (is.null(name)) 
[17:26:46.917]                             next
[17:26:46.917]                           if (!grepl(pattern, name)) 
[17:26:46.917]                             next
[17:26:46.917]                           invokeRestart(restart)
[17:26:46.917]                           muffled <- TRUE
[17:26:46.917]                           break
[17:26:46.917]                         }
[17:26:46.917]                       }
[17:26:46.917]                     }
[17:26:46.917]                     invisible(muffled)
[17:26:46.917]                   }
[17:26:46.917]                   muffleCondition(cond)
[17:26:46.917]                 })
[17:26:46.917]             }))
[17:26:46.917]             future::FutureResult(value = ...future.value$value, 
[17:26:46.917]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.917]                   ...future.rng), globalenv = if (FALSE) 
[17:26:46.917]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:46.917]                     ...future.globalenv.names))
[17:26:46.917]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:46.917]         }, condition = base::local({
[17:26:46.917]             c <- base::c
[17:26:46.917]             inherits <- base::inherits
[17:26:46.917]             invokeRestart <- base::invokeRestart
[17:26:46.917]             length <- base::length
[17:26:46.917]             list <- base::list
[17:26:46.917]             seq.int <- base::seq.int
[17:26:46.917]             signalCondition <- base::signalCondition
[17:26:46.917]             sys.calls <- base::sys.calls
[17:26:46.917]             `[[` <- base::`[[`
[17:26:46.917]             `+` <- base::`+`
[17:26:46.917]             `<<-` <- base::`<<-`
[17:26:46.917]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:46.917]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:46.917]                   3L)]
[17:26:46.917]             }
[17:26:46.917]             function(cond) {
[17:26:46.917]                 is_error <- inherits(cond, "error")
[17:26:46.917]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:46.917]                   NULL)
[17:26:46.917]                 if (is_error) {
[17:26:46.917]                   sessionInformation <- function() {
[17:26:46.917]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:46.917]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:46.917]                       search = base::search(), system = base::Sys.info())
[17:26:46.917]                   }
[17:26:46.917]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.917]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:46.917]                     cond$call), session = sessionInformation(), 
[17:26:46.917]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:46.917]                   signalCondition(cond)
[17:26:46.917]                 }
[17:26:46.917]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:46.917]                 "immediateCondition"))) {
[17:26:46.917]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:46.917]                   ...future.conditions[[length(...future.conditions) + 
[17:26:46.917]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:46.917]                   if (TRUE && !signal) {
[17:26:46.917]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.917]                     {
[17:26:46.917]                       inherits <- base::inherits
[17:26:46.917]                       invokeRestart <- base::invokeRestart
[17:26:46.917]                       is.null <- base::is.null
[17:26:46.917]                       muffled <- FALSE
[17:26:46.917]                       if (inherits(cond, "message")) {
[17:26:46.917]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.917]                         if (muffled) 
[17:26:46.917]                           invokeRestart("muffleMessage")
[17:26:46.917]                       }
[17:26:46.917]                       else if (inherits(cond, "warning")) {
[17:26:46.917]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.917]                         if (muffled) 
[17:26:46.917]                           invokeRestart("muffleWarning")
[17:26:46.917]                       }
[17:26:46.917]                       else if (inherits(cond, "condition")) {
[17:26:46.917]                         if (!is.null(pattern)) {
[17:26:46.917]                           computeRestarts <- base::computeRestarts
[17:26:46.917]                           grepl <- base::grepl
[17:26:46.917]                           restarts <- computeRestarts(cond)
[17:26:46.917]                           for (restart in restarts) {
[17:26:46.917]                             name <- restart$name
[17:26:46.917]                             if (is.null(name)) 
[17:26:46.917]                               next
[17:26:46.917]                             if (!grepl(pattern, name)) 
[17:26:46.917]                               next
[17:26:46.917]                             invokeRestart(restart)
[17:26:46.917]                             muffled <- TRUE
[17:26:46.917]                             break
[17:26:46.917]                           }
[17:26:46.917]                         }
[17:26:46.917]                       }
[17:26:46.917]                       invisible(muffled)
[17:26:46.917]                     }
[17:26:46.917]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.917]                   }
[17:26:46.917]                 }
[17:26:46.917]                 else {
[17:26:46.917]                   if (TRUE) {
[17:26:46.917]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:46.917]                     {
[17:26:46.917]                       inherits <- base::inherits
[17:26:46.917]                       invokeRestart <- base::invokeRestart
[17:26:46.917]                       is.null <- base::is.null
[17:26:46.917]                       muffled <- FALSE
[17:26:46.917]                       if (inherits(cond, "message")) {
[17:26:46.917]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:46.917]                         if (muffled) 
[17:26:46.917]                           invokeRestart("muffleMessage")
[17:26:46.917]                       }
[17:26:46.917]                       else if (inherits(cond, "warning")) {
[17:26:46.917]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:46.917]                         if (muffled) 
[17:26:46.917]                           invokeRestart("muffleWarning")
[17:26:46.917]                       }
[17:26:46.917]                       else if (inherits(cond, "condition")) {
[17:26:46.917]                         if (!is.null(pattern)) {
[17:26:46.917]                           computeRestarts <- base::computeRestarts
[17:26:46.917]                           grepl <- base::grepl
[17:26:46.917]                           restarts <- computeRestarts(cond)
[17:26:46.917]                           for (restart in restarts) {
[17:26:46.917]                             name <- restart$name
[17:26:46.917]                             if (is.null(name)) 
[17:26:46.917]                               next
[17:26:46.917]                             if (!grepl(pattern, name)) 
[17:26:46.917]                               next
[17:26:46.917]                             invokeRestart(restart)
[17:26:46.917]                             muffled <- TRUE
[17:26:46.917]                             break
[17:26:46.917]                           }
[17:26:46.917]                         }
[17:26:46.917]                       }
[17:26:46.917]                       invisible(muffled)
[17:26:46.917]                     }
[17:26:46.917]                     muffleCondition(cond, pattern = "^muffle")
[17:26:46.917]                   }
[17:26:46.917]                 }
[17:26:46.917]             }
[17:26:46.917]         }))
[17:26:46.917]     }, error = function(ex) {
[17:26:46.917]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:46.917]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:46.917]                 ...future.rng), started = ...future.startTime, 
[17:26:46.917]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:46.917]             version = "1.8"), class = "FutureResult")
[17:26:46.917]     }, finally = {
[17:26:46.917]         if (!identical(...future.workdir, getwd())) 
[17:26:46.917]             setwd(...future.workdir)
[17:26:46.917]         {
[17:26:46.917]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:46.917]                 ...future.oldOptions$nwarnings <- NULL
[17:26:46.917]             }
[17:26:46.917]             base::options(...future.oldOptions)
[17:26:46.917]             if (.Platform$OS.type == "windows") {
[17:26:46.917]                 old_names <- names(...future.oldEnvVars)
[17:26:46.917]                 envs <- base::Sys.getenv()
[17:26:46.917]                 names <- names(envs)
[17:26:46.917]                 common <- intersect(names, old_names)
[17:26:46.917]                 added <- setdiff(names, old_names)
[17:26:46.917]                 removed <- setdiff(old_names, names)
[17:26:46.917]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:46.917]                   envs[common]]
[17:26:46.917]                 NAMES <- toupper(changed)
[17:26:46.917]                 args <- list()
[17:26:46.917]                 for (kk in seq_along(NAMES)) {
[17:26:46.917]                   name <- changed[[kk]]
[17:26:46.917]                   NAME <- NAMES[[kk]]
[17:26:46.917]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.917]                     next
[17:26:46.917]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.917]                 }
[17:26:46.917]                 NAMES <- toupper(added)
[17:26:46.917]                 for (kk in seq_along(NAMES)) {
[17:26:46.917]                   name <- added[[kk]]
[17:26:46.917]                   NAME <- NAMES[[kk]]
[17:26:46.917]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.917]                     next
[17:26:46.917]                   args[[name]] <- ""
[17:26:46.917]                 }
[17:26:46.917]                 NAMES <- toupper(removed)
[17:26:46.917]                 for (kk in seq_along(NAMES)) {
[17:26:46.917]                   name <- removed[[kk]]
[17:26:46.917]                   NAME <- NAMES[[kk]]
[17:26:46.917]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:46.917]                     next
[17:26:46.917]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:46.917]                 }
[17:26:46.917]                 if (length(args) > 0) 
[17:26:46.917]                   base::do.call(base::Sys.setenv, args = args)
[17:26:46.917]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:46.917]             }
[17:26:46.917]             else {
[17:26:46.917]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:46.917]             }
[17:26:46.917]             {
[17:26:46.917]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:46.917]                   0L) {
[17:26:46.917]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:46.917]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:46.917]                   base::options(opts)
[17:26:46.917]                 }
[17:26:46.917]                 {
[17:26:46.917]                   {
[17:26:46.917]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:46.917]                     NULL
[17:26:46.917]                   }
[17:26:46.917]                   options(future.plan = NULL)
[17:26:46.917]                   if (is.na(NA_character_)) 
[17:26:46.917]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:46.917]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:46.917]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:46.917]                     .init = FALSE)
[17:26:46.917]                 }
[17:26:46.917]             }
[17:26:46.917]         }
[17:26:46.917]     })
[17:26:46.917]     if (TRUE) {
[17:26:46.917]         base::sink(type = "output", split = FALSE)
[17:26:46.917]         if (TRUE) {
[17:26:46.917]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:46.917]         }
[17:26:46.917]         else {
[17:26:46.917]             ...future.result["stdout"] <- base::list(NULL)
[17:26:46.917]         }
[17:26:46.917]         base::close(...future.stdout)
[17:26:46.917]         ...future.stdout <- NULL
[17:26:46.917]     }
[17:26:46.917]     ...future.result$conditions <- ...future.conditions
[17:26:46.917]     ...future.result$finished <- base::Sys.time()
[17:26:46.917]     ...future.result
[17:26:46.917] }
[17:26:46.922] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:46.938] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.939] - Validating connection of MultisessionFuture
[17:26:46.939] - received message: FutureResult
[17:26:46.939] - Received FutureResult
[17:26:46.939] - Erased future from FutureRegistry
[17:26:46.939] result() for ClusterFuture ...
[17:26:46.940] - result already collected: FutureResult
[17:26:46.940] result() for ClusterFuture ... done
[17:26:46.940] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.940] result() for ClusterFuture ...
[17:26:46.940] - result already collected: FutureResult
[17:26:46.940] result() for ClusterFuture ... done
[17:26:46.941] result() for ClusterFuture ...
[17:26:46.941] - result already collected: FutureResult
[17:26:46.941] result() for ClusterFuture ... done
[17:26:46.942] MultisessionFuture started
[17:26:46.942] - Launch lazy future ... done
[17:26:46.942] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000022310795f08> 
Classes 'listenv', 'environment' <environment: 0x000002230d31eff0> 
 - attr(*, "dim.")= int [1:2] 1 6
 - attr(*, "dimnames.")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
[17:26:46.947] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.947] - Validating connection of MultisessionFuture
[17:26:46.947] - received message: FutureResult
[17:26:46.947] - Received FutureResult
[17:26:46.948] - Erased future from FutureRegistry
[17:26:46.948] result() for ClusterFuture ...
[17:26:46.948] - result already collected: FutureResult
[17:26:46.948] result() for ClusterFuture ... done
[17:26:46.948] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:46.958] receiveMessageFromWorker() for ClusterFuture ...
[17:26:46.958] - Validating connection of MultisessionFuture
[17:26:46.958] - received message: FutureResult
[17:26:46.958] - Received FutureResult
[17:26:46.959] - Erased future from FutureRegistry
[17:26:46.959] result() for ClusterFuture ...
[17:26:46.959] - result already collected: FutureResult
[17:26:46.959] result() for ClusterFuture ... done
[17:26:46.959] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:46.962] resolve() on list environment ...
[17:26:46.962]  recursive: 0
[17:26:46.963]  length: 6
[17:26:46.964]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:46.964] signalConditionsASAP(numeric, pos=1) ...
[17:26:46.964] - nx: 6
[17:26:46.964] - relay: TRUE
[17:26:46.964] - stdout: TRUE
[17:26:46.964] - signal: TRUE
[17:26:46.965] - resignal: FALSE
[17:26:46.965] - force: TRUE
[17:26:46.965] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.965] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.965]  - until=2
[17:26:46.965]  - relaying element #2
[17:26:46.966] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.966] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.966] signalConditionsASAP(NULL, pos=1) ... done
[17:26:46.966]  length: 5 (resolved future 1)
[17:26:46.966] Future #2
[17:26:46.966] result() for ClusterFuture ...
[17:26:46.967] - result already collected: FutureResult
[17:26:46.967] result() for ClusterFuture ... done
[17:26:46.967] result() for ClusterFuture ...
[17:26:46.967] - result already collected: FutureResult
[17:26:46.967] result() for ClusterFuture ... done
[17:26:46.967] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:46.968] - nx: 6
[17:26:46.968] - relay: TRUE
[17:26:46.968] - stdout: TRUE
[17:26:46.968] - signal: TRUE
[17:26:46.968] - resignal: FALSE
[17:26:46.968] - force: TRUE
[17:26:46.968] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.969] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:46.969]  - until=2
[17:26:46.969]  - relaying element #2
[17:26:46.969] result() for ClusterFuture ...
[17:26:46.969] - result already collected: FutureResult
[17:26:46.969] result() for ClusterFuture ... done
[17:26:46.970] result() for ClusterFuture ...
[17:26:46.970] - result already collected: FutureResult
[17:26:46.970] result() for ClusterFuture ... done
[17:26:46.970] result() for ClusterFuture ...
[17:26:46.970] - result already collected: FutureResult
[17:26:46.970] result() for ClusterFuture ... done
[17:26:46.971] result() for ClusterFuture ...
[17:26:46.971] - result already collected: FutureResult
[17:26:46.971] result() for ClusterFuture ... done
[17:26:46.971] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.971] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.971] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:46.972]  length: 4 (resolved future 2)
[17:26:46.972] Future #3
[17:26:46.972] result() for ClusterFuture ...
[17:26:46.972] - result already collected: FutureResult
[17:26:46.972] result() for ClusterFuture ... done
[17:26:46.972] result() for ClusterFuture ...
[17:26:46.973] - result already collected: FutureResult
[17:26:46.973] result() for ClusterFuture ... done
[17:26:46.973] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:46.973] - nx: 6
[17:26:46.973] - relay: TRUE
[17:26:46.973] - stdout: TRUE
[17:26:46.974] - signal: TRUE
[17:26:46.974] - resignal: FALSE
[17:26:46.974] - force: TRUE
[17:26:46.974] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.974] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:46.974]  - until=3
[17:26:46.975]  - relaying element #3
[17:26:46.975] result() for ClusterFuture ...
[17:26:46.975] - result already collected: FutureResult
[17:26:46.975] result() for ClusterFuture ... done
[17:26:46.975] result() for ClusterFuture ...
[17:26:46.975] - result already collected: FutureResult
[17:26:46.975] result() for ClusterFuture ... done
[17:26:46.976] result() for ClusterFuture ...
[17:26:46.976] - result already collected: FutureResult
[17:26:46.976] result() for ClusterFuture ... done
[17:26:46.976] result() for ClusterFuture ...
[17:26:46.976] - result already collected: FutureResult
[17:26:46.976] result() for ClusterFuture ... done
[17:26:46.977] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.977] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.977] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:46.977]  length: 3 (resolved future 3)
[17:26:46.977] Future #4
[17:26:46.978] result() for ClusterFuture ...
[17:26:46.978] - result already collected: FutureResult
[17:26:46.978] result() for ClusterFuture ... done
[17:26:46.978] result() for ClusterFuture ...
[17:26:46.978] - result already collected: FutureResult
[17:26:46.978] result() for ClusterFuture ... done
[17:26:46.978] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:46.979] - nx: 6
[17:26:46.979] - relay: TRUE
[17:26:46.979] - stdout: TRUE
[17:26:46.979] - signal: TRUE
[17:26:46.979] - resignal: FALSE
[17:26:46.979] - force: TRUE
[17:26:46.980] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.980] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:46.980]  - until=4
[17:26:46.980]  - relaying element #4
[17:26:46.980] result() for ClusterFuture ...
[17:26:46.980] - result already collected: FutureResult
[17:26:46.980] result() for ClusterFuture ... done
[17:26:46.981] result() for ClusterFuture ...
[17:26:46.981] - result already collected: FutureResult
[17:26:46.981] result() for ClusterFuture ... done
[17:26:46.981] result() for ClusterFuture ...
[17:26:46.981] - result already collected: FutureResult
[17:26:46.981] result() for ClusterFuture ... done
[17:26:46.982] result() for ClusterFuture ...
[17:26:46.982] - result already collected: FutureResult
[17:26:46.982] result() for ClusterFuture ... done
[17:26:46.982] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.982] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.982] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:46.983]  length: 2 (resolved future 4)
[17:26:46.983] signalConditionsASAP(NULL, pos=5) ...
[17:26:46.983] - nx: 6
[17:26:46.983] - relay: TRUE
[17:26:46.983] - stdout: TRUE
[17:26:46.983] - signal: TRUE
[17:26:46.984] - resignal: FALSE
[17:26:46.984] - force: TRUE
[17:26:46.984] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.984] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.984]  - until=6
[17:26:46.984]  - relaying element #6
[17:26:46.984] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:46.985] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.985] signalConditionsASAP(NULL, pos=5) ... done
[17:26:46.985]  length: 1 (resolved future 5)
[17:26:46.985] signalConditionsASAP(numeric, pos=6) ...
[17:26:46.985] - nx: 6
[17:26:46.985] - relay: TRUE
[17:26:46.986] - stdout: TRUE
[17:26:46.986] - signal: TRUE
[17:26:46.986] - resignal: FALSE
[17:26:46.986] - force: TRUE
[17:26:46.986] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:46.986] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.987]  - until=6
[17:26:46.987] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:46.987] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.987] signalConditionsASAP(numeric, pos=6) ... done
[17:26:46.987]  length: 0 (resolved future 6)
[17:26:46.987] Relaying remaining futures
[17:26:46.988] signalConditionsASAP(NULL, pos=0) ...
[17:26:46.988] - nx: 6
[17:26:46.988] - relay: TRUE
[17:26:46.988] - stdout: TRUE
[17:26:46.988] - signal: TRUE
[17:26:46.988] - resignal: FALSE
[17:26:46.988] - force: TRUE
[17:26:46.989] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:46.989] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:46.989] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:46.989] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:46.989] signalConditionsASAP(NULL, pos=0) ... done
[17:26:46.989] resolve() on list environment ... DONE
[17:26:46.990] result() for ClusterFuture ...
[17:26:46.990] - result already collected: FutureResult
[17:26:46.990] result() for ClusterFuture ... done
[17:26:46.990] result() for ClusterFuture ...
[17:26:46.990] - result already collected: FutureResult
[17:26:46.990] result() for ClusterFuture ... done
[17:26:46.991] result() for ClusterFuture ...
[17:26:46.991] - result already collected: FutureResult
[17:26:46.991] result() for ClusterFuture ... done
[17:26:46.991] result() for ClusterFuture ...
[17:26:46.991] - result already collected: FutureResult
[17:26:46.991] result() for ClusterFuture ... done
[17:26:46.992] result() for ClusterFuture ...
[17:26:46.992] - result already collected: FutureResult
[17:26:46.992] result() for ClusterFuture ... done
[17:26:46.992] result() for ClusterFuture ...
[17:26:46.992] - result already collected: FutureResult
[17:26:46.993] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x000002230b7aedf0> 
 - attr(*, "dim.")= int [1:2] 1 6
 - attr(*, "dimnames.")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
Dimensions: c(2, 3)
[17:26:46.995] getGlobalsAndPackages() ...
[17:26:46.995] Searching for globals...
[17:26:46.995] 
[17:26:46.995] Searching for globals ... DONE
[17:26:46.996] - globals: [0] <none>
[17:26:46.996] getGlobalsAndPackages() ... DONE
[17:26:46.996] run() for 'Future' ...
[17:26:46.996] - state: 'created'
[17:26:46.996] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.012] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.013] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.013]   - Field: 'node'
[17:26:47.013]   - Field: 'label'
[17:26:47.013]   - Field: 'local'
[17:26:47.014]   - Field: 'owner'
[17:26:47.014]   - Field: 'envir'
[17:26:47.014]   - Field: 'workers'
[17:26:47.014]   - Field: 'packages'
[17:26:47.015]   - Field: 'gc'
[17:26:47.015]   - Field: 'conditions'
[17:26:47.015]   - Field: 'persistent'
[17:26:47.015]   - Field: 'expr'
[17:26:47.015]   - Field: 'uuid'
[17:26:47.016]   - Field: 'seed'
[17:26:47.016]   - Field: 'version'
[17:26:47.016]   - Field: 'result'
[17:26:47.016]   - Field: 'asynchronous'
[17:26:47.016]   - Field: 'calls'
[17:26:47.017]   - Field: 'globals'
[17:26:47.017]   - Field: 'stdout'
[17:26:47.017]   - Field: 'earlySignal'
[17:26:47.017]   - Field: 'lazy'
[17:26:47.017]   - Field: 'state'
[17:26:47.018] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.018] - Launch lazy future ...
[17:26:47.018] Packages needed by the future expression (n = 0): <none>
[17:26:47.019] Packages needed by future strategies (n = 0): <none>
[17:26:47.020] {
[17:26:47.020]     {
[17:26:47.020]         {
[17:26:47.020]             ...future.startTime <- base::Sys.time()
[17:26:47.020]             {
[17:26:47.020]                 {
[17:26:47.020]                   {
[17:26:47.020]                     {
[17:26:47.020]                       base::local({
[17:26:47.020]                         has_future <- base::requireNamespace("future", 
[17:26:47.020]                           quietly = TRUE)
[17:26:47.020]                         if (has_future) {
[17:26:47.020]                           ns <- base::getNamespace("future")
[17:26:47.020]                           version <- ns[[".package"]][["version"]]
[17:26:47.020]                           if (is.null(version)) 
[17:26:47.020]                             version <- utils::packageVersion("future")
[17:26:47.020]                         }
[17:26:47.020]                         else {
[17:26:47.020]                           version <- NULL
[17:26:47.020]                         }
[17:26:47.020]                         if (!has_future || version < "1.8.0") {
[17:26:47.020]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.020]                             "", base::R.version$version.string), 
[17:26:47.020]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.020]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.020]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.020]                               "release", "version")], collapse = " "), 
[17:26:47.020]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.020]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.020]                             info)
[17:26:47.020]                           info <- base::paste(info, collapse = "; ")
[17:26:47.020]                           if (!has_future) {
[17:26:47.020]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.020]                               info)
[17:26:47.020]                           }
[17:26:47.020]                           else {
[17:26:47.020]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.020]                               info, version)
[17:26:47.020]                           }
[17:26:47.020]                           base::stop(msg)
[17:26:47.020]                         }
[17:26:47.020]                       })
[17:26:47.020]                     }
[17:26:47.020]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.020]                     base::options(mc.cores = 1L)
[17:26:47.020]                   }
[17:26:47.020]                   ...future.strategy.old <- future::plan("list")
[17:26:47.020]                   options(future.plan = NULL)
[17:26:47.020]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.020]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.020]                 }
[17:26:47.020]                 ...future.workdir <- getwd()
[17:26:47.020]             }
[17:26:47.020]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.020]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.020]         }
[17:26:47.020]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.020]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.020]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.020]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.020]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.020]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.020]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.020]             base::names(...future.oldOptions))
[17:26:47.020]     }
[17:26:47.020]     if (FALSE) {
[17:26:47.020]     }
[17:26:47.020]     else {
[17:26:47.020]         if (TRUE) {
[17:26:47.020]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.020]                 open = "w")
[17:26:47.020]         }
[17:26:47.020]         else {
[17:26:47.020]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.020]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.020]         }
[17:26:47.020]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.020]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.020]             base::sink(type = "output", split = FALSE)
[17:26:47.020]             base::close(...future.stdout)
[17:26:47.020]         }, add = TRUE)
[17:26:47.020]     }
[17:26:47.020]     ...future.frame <- base::sys.nframe()
[17:26:47.020]     ...future.conditions <- base::list()
[17:26:47.020]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.020]     if (FALSE) {
[17:26:47.020]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.020]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.020]     }
[17:26:47.020]     ...future.result <- base::tryCatch({
[17:26:47.020]         base::withCallingHandlers({
[17:26:47.020]             ...future.value <- base::withVisible(base::local({
[17:26:47.020]                 ...future.makeSendCondition <- base::local({
[17:26:47.020]                   sendCondition <- NULL
[17:26:47.020]                   function(frame = 1L) {
[17:26:47.020]                     if (is.function(sendCondition)) 
[17:26:47.020]                       return(sendCondition)
[17:26:47.020]                     ns <- getNamespace("parallel")
[17:26:47.020]                     if (exists("sendData", mode = "function", 
[17:26:47.020]                       envir = ns)) {
[17:26:47.020]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.020]                         envir = ns)
[17:26:47.020]                       envir <- sys.frame(frame)
[17:26:47.020]                       master <- NULL
[17:26:47.020]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.020]                         !identical(envir, emptyenv())) {
[17:26:47.020]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.020]                           inherits = FALSE)) {
[17:26:47.020]                           master <- get("master", mode = "list", 
[17:26:47.020]                             envir = envir, inherits = FALSE)
[17:26:47.020]                           if (inherits(master, c("SOCKnode", 
[17:26:47.020]                             "SOCK0node"))) {
[17:26:47.020]                             sendCondition <<- function(cond) {
[17:26:47.020]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.020]                                 success = TRUE)
[17:26:47.020]                               parallel_sendData(master, data)
[17:26:47.020]                             }
[17:26:47.020]                             return(sendCondition)
[17:26:47.020]                           }
[17:26:47.020]                         }
[17:26:47.020]                         frame <- frame + 1L
[17:26:47.020]                         envir <- sys.frame(frame)
[17:26:47.020]                       }
[17:26:47.020]                     }
[17:26:47.020]                     sendCondition <<- function(cond) NULL
[17:26:47.020]                   }
[17:26:47.020]                 })
[17:26:47.020]                 withCallingHandlers({
[17:26:47.020]                   2
[17:26:47.020]                 }, immediateCondition = function(cond) {
[17:26:47.020]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.020]                   sendCondition(cond)
[17:26:47.020]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.020]                   {
[17:26:47.020]                     inherits <- base::inherits
[17:26:47.020]                     invokeRestart <- base::invokeRestart
[17:26:47.020]                     is.null <- base::is.null
[17:26:47.020]                     muffled <- FALSE
[17:26:47.020]                     if (inherits(cond, "message")) {
[17:26:47.020]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.020]                       if (muffled) 
[17:26:47.020]                         invokeRestart("muffleMessage")
[17:26:47.020]                     }
[17:26:47.020]                     else if (inherits(cond, "warning")) {
[17:26:47.020]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.020]                       if (muffled) 
[17:26:47.020]                         invokeRestart("muffleWarning")
[17:26:47.020]                     }
[17:26:47.020]                     else if (inherits(cond, "condition")) {
[17:26:47.020]                       if (!is.null(pattern)) {
[17:26:47.020]                         computeRestarts <- base::computeRestarts
[17:26:47.020]                         grepl <- base::grepl
[17:26:47.020]                         restarts <- computeRestarts(cond)
[17:26:47.020]                         for (restart in restarts) {
[17:26:47.020]                           name <- restart$name
[17:26:47.020]                           if (is.null(name)) 
[17:26:47.020]                             next
[17:26:47.020]                           if (!grepl(pattern, name)) 
[17:26:47.020]                             next
[17:26:47.020]                           invokeRestart(restart)
[17:26:47.020]                           muffled <- TRUE
[17:26:47.020]                           break
[17:26:47.020]                         }
[17:26:47.020]                       }
[17:26:47.020]                     }
[17:26:47.020]                     invisible(muffled)
[17:26:47.020]                   }
[17:26:47.020]                   muffleCondition(cond)
[17:26:47.020]                 })
[17:26:47.020]             }))
[17:26:47.020]             future::FutureResult(value = ...future.value$value, 
[17:26:47.020]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.020]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.020]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.020]                     ...future.globalenv.names))
[17:26:47.020]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.020]         }, condition = base::local({
[17:26:47.020]             c <- base::c
[17:26:47.020]             inherits <- base::inherits
[17:26:47.020]             invokeRestart <- base::invokeRestart
[17:26:47.020]             length <- base::length
[17:26:47.020]             list <- base::list
[17:26:47.020]             seq.int <- base::seq.int
[17:26:47.020]             signalCondition <- base::signalCondition
[17:26:47.020]             sys.calls <- base::sys.calls
[17:26:47.020]             `[[` <- base::`[[`
[17:26:47.020]             `+` <- base::`+`
[17:26:47.020]             `<<-` <- base::`<<-`
[17:26:47.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.020]                   3L)]
[17:26:47.020]             }
[17:26:47.020]             function(cond) {
[17:26:47.020]                 is_error <- inherits(cond, "error")
[17:26:47.020]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.020]                   NULL)
[17:26:47.020]                 if (is_error) {
[17:26:47.020]                   sessionInformation <- function() {
[17:26:47.020]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.020]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.020]                       search = base::search(), system = base::Sys.info())
[17:26:47.020]                   }
[17:26:47.020]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.020]                     cond$call), session = sessionInformation(), 
[17:26:47.020]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.020]                   signalCondition(cond)
[17:26:47.020]                 }
[17:26:47.020]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.020]                 "immediateCondition"))) {
[17:26:47.020]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.020]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.020]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.020]                   if (TRUE && !signal) {
[17:26:47.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.020]                     {
[17:26:47.020]                       inherits <- base::inherits
[17:26:47.020]                       invokeRestart <- base::invokeRestart
[17:26:47.020]                       is.null <- base::is.null
[17:26:47.020]                       muffled <- FALSE
[17:26:47.020]                       if (inherits(cond, "message")) {
[17:26:47.020]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.020]                         if (muffled) 
[17:26:47.020]                           invokeRestart("muffleMessage")
[17:26:47.020]                       }
[17:26:47.020]                       else if (inherits(cond, "warning")) {
[17:26:47.020]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.020]                         if (muffled) 
[17:26:47.020]                           invokeRestart("muffleWarning")
[17:26:47.020]                       }
[17:26:47.020]                       else if (inherits(cond, "condition")) {
[17:26:47.020]                         if (!is.null(pattern)) {
[17:26:47.020]                           computeRestarts <- base::computeRestarts
[17:26:47.020]                           grepl <- base::grepl
[17:26:47.020]                           restarts <- computeRestarts(cond)
[17:26:47.020]                           for (restart in restarts) {
[17:26:47.020]                             name <- restart$name
[17:26:47.020]                             if (is.null(name)) 
[17:26:47.020]                               next
[17:26:47.020]                             if (!grepl(pattern, name)) 
[17:26:47.020]                               next
[17:26:47.020]                             invokeRestart(restart)
[17:26:47.020]                             muffled <- TRUE
[17:26:47.020]                             break
[17:26:47.020]                           }
[17:26:47.020]                         }
[17:26:47.020]                       }
[17:26:47.020]                       invisible(muffled)
[17:26:47.020]                     }
[17:26:47.020]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.020]                   }
[17:26:47.020]                 }
[17:26:47.020]                 else {
[17:26:47.020]                   if (TRUE) {
[17:26:47.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.020]                     {
[17:26:47.020]                       inherits <- base::inherits
[17:26:47.020]                       invokeRestart <- base::invokeRestart
[17:26:47.020]                       is.null <- base::is.null
[17:26:47.020]                       muffled <- FALSE
[17:26:47.020]                       if (inherits(cond, "message")) {
[17:26:47.020]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.020]                         if (muffled) 
[17:26:47.020]                           invokeRestart("muffleMessage")
[17:26:47.020]                       }
[17:26:47.020]                       else if (inherits(cond, "warning")) {
[17:26:47.020]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.020]                         if (muffled) 
[17:26:47.020]                           invokeRestart("muffleWarning")
[17:26:47.020]                       }
[17:26:47.020]                       else if (inherits(cond, "condition")) {
[17:26:47.020]                         if (!is.null(pattern)) {
[17:26:47.020]                           computeRestarts <- base::computeRestarts
[17:26:47.020]                           grepl <- base::grepl
[17:26:47.020]                           restarts <- computeRestarts(cond)
[17:26:47.020]                           for (restart in restarts) {
[17:26:47.020]                             name <- restart$name
[17:26:47.020]                             if (is.null(name)) 
[17:26:47.020]                               next
[17:26:47.020]                             if (!grepl(pattern, name)) 
[17:26:47.020]                               next
[17:26:47.020]                             invokeRestart(restart)
[17:26:47.020]                             muffled <- TRUE
[17:26:47.020]                             break
[17:26:47.020]                           }
[17:26:47.020]                         }
[17:26:47.020]                       }
[17:26:47.020]                       invisible(muffled)
[17:26:47.020]                     }
[17:26:47.020]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.020]                   }
[17:26:47.020]                 }
[17:26:47.020]             }
[17:26:47.020]         }))
[17:26:47.020]     }, error = function(ex) {
[17:26:47.020]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.020]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.020]                 ...future.rng), started = ...future.startTime, 
[17:26:47.020]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.020]             version = "1.8"), class = "FutureResult")
[17:26:47.020]     }, finally = {
[17:26:47.020]         if (!identical(...future.workdir, getwd())) 
[17:26:47.020]             setwd(...future.workdir)
[17:26:47.020]         {
[17:26:47.020]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.020]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.020]             }
[17:26:47.020]             base::options(...future.oldOptions)
[17:26:47.020]             if (.Platform$OS.type == "windows") {
[17:26:47.020]                 old_names <- names(...future.oldEnvVars)
[17:26:47.020]                 envs <- base::Sys.getenv()
[17:26:47.020]                 names <- names(envs)
[17:26:47.020]                 common <- intersect(names, old_names)
[17:26:47.020]                 added <- setdiff(names, old_names)
[17:26:47.020]                 removed <- setdiff(old_names, names)
[17:26:47.020]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.020]                   envs[common]]
[17:26:47.020]                 NAMES <- toupper(changed)
[17:26:47.020]                 args <- list()
[17:26:47.020]                 for (kk in seq_along(NAMES)) {
[17:26:47.020]                   name <- changed[[kk]]
[17:26:47.020]                   NAME <- NAMES[[kk]]
[17:26:47.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.020]                     next
[17:26:47.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.020]                 }
[17:26:47.020]                 NAMES <- toupper(added)
[17:26:47.020]                 for (kk in seq_along(NAMES)) {
[17:26:47.020]                   name <- added[[kk]]
[17:26:47.020]                   NAME <- NAMES[[kk]]
[17:26:47.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.020]                     next
[17:26:47.020]                   args[[name]] <- ""
[17:26:47.020]                 }
[17:26:47.020]                 NAMES <- toupper(removed)
[17:26:47.020]                 for (kk in seq_along(NAMES)) {
[17:26:47.020]                   name <- removed[[kk]]
[17:26:47.020]                   NAME <- NAMES[[kk]]
[17:26:47.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.020]                     next
[17:26:47.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.020]                 }
[17:26:47.020]                 if (length(args) > 0) 
[17:26:47.020]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.020]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.020]             }
[17:26:47.020]             else {
[17:26:47.020]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.020]             }
[17:26:47.020]             {
[17:26:47.020]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.020]                   0L) {
[17:26:47.020]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.020]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.020]                   base::options(opts)
[17:26:47.020]                 }
[17:26:47.020]                 {
[17:26:47.020]                   {
[17:26:47.020]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.020]                     NULL
[17:26:47.020]                   }
[17:26:47.020]                   options(future.plan = NULL)
[17:26:47.020]                   if (is.na(NA_character_)) 
[17:26:47.020]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.020]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.020]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.020]                     .init = FALSE)
[17:26:47.020]                 }
[17:26:47.020]             }
[17:26:47.020]         }
[17:26:47.020]     })
[17:26:47.020]     if (TRUE) {
[17:26:47.020]         base::sink(type = "output", split = FALSE)
[17:26:47.020]         if (TRUE) {
[17:26:47.020]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.020]         }
[17:26:47.020]         else {
[17:26:47.020]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.020]         }
[17:26:47.020]         base::close(...future.stdout)
[17:26:47.020]         ...future.stdout <- NULL
[17:26:47.020]     }
[17:26:47.020]     ...future.result$conditions <- ...future.conditions
[17:26:47.020]     ...future.result$finished <- base::Sys.time()
[17:26:47.020]     ...future.result
[17:26:47.020] }
[17:26:47.027] MultisessionFuture started
[17:26:47.027] - Launch lazy future ... done
[17:26:47.027] run() for 'MultisessionFuture' ... done
[17:26:47.028] getGlobalsAndPackages() ...
[17:26:47.028] Searching for globals...
[17:26:47.028] 
[17:26:47.029] Searching for globals ... DONE
[17:26:47.029] - globals: [0] <none>
[17:26:47.029] getGlobalsAndPackages() ... DONE
[17:26:47.029] run() for 'Future' ...
[17:26:47.029] - state: 'created'
[17:26:47.030] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.044] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.044] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.045]   - Field: 'node'
[17:26:47.045]   - Field: 'label'
[17:26:47.045]   - Field: 'local'
[17:26:47.045]   - Field: 'owner'
[17:26:47.045]   - Field: 'envir'
[17:26:47.045]   - Field: 'workers'
[17:26:47.046]   - Field: 'packages'
[17:26:47.046]   - Field: 'gc'
[17:26:47.046]   - Field: 'conditions'
[17:26:47.046]   - Field: 'persistent'
[17:26:47.046]   - Field: 'expr'
[17:26:47.047]   - Field: 'uuid'
[17:26:47.047]   - Field: 'seed'
[17:26:47.047]   - Field: 'version'
[17:26:47.047]   - Field: 'result'
[17:26:47.047]   - Field: 'asynchronous'
[17:26:47.047]   - Field: 'calls'
[17:26:47.048]   - Field: 'globals'
[17:26:47.048]   - Field: 'stdout'
[17:26:47.048]   - Field: 'earlySignal'
[17:26:47.048]   - Field: 'lazy'
[17:26:47.048]   - Field: 'state'
[17:26:47.048] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.049] - Launch lazy future ...
[17:26:47.049] Packages needed by the future expression (n = 0): <none>
[17:26:47.049] Packages needed by future strategies (n = 0): <none>
[17:26:47.050] {
[17:26:47.050]     {
[17:26:47.050]         {
[17:26:47.050]             ...future.startTime <- base::Sys.time()
[17:26:47.050]             {
[17:26:47.050]                 {
[17:26:47.050]                   {
[17:26:47.050]                     {
[17:26:47.050]                       base::local({
[17:26:47.050]                         has_future <- base::requireNamespace("future", 
[17:26:47.050]                           quietly = TRUE)
[17:26:47.050]                         if (has_future) {
[17:26:47.050]                           ns <- base::getNamespace("future")
[17:26:47.050]                           version <- ns[[".package"]][["version"]]
[17:26:47.050]                           if (is.null(version)) 
[17:26:47.050]                             version <- utils::packageVersion("future")
[17:26:47.050]                         }
[17:26:47.050]                         else {
[17:26:47.050]                           version <- NULL
[17:26:47.050]                         }
[17:26:47.050]                         if (!has_future || version < "1.8.0") {
[17:26:47.050]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.050]                             "", base::R.version$version.string), 
[17:26:47.050]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.050]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.050]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.050]                               "release", "version")], collapse = " "), 
[17:26:47.050]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.050]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.050]                             info)
[17:26:47.050]                           info <- base::paste(info, collapse = "; ")
[17:26:47.050]                           if (!has_future) {
[17:26:47.050]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.050]                               info)
[17:26:47.050]                           }
[17:26:47.050]                           else {
[17:26:47.050]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.050]                               info, version)
[17:26:47.050]                           }
[17:26:47.050]                           base::stop(msg)
[17:26:47.050]                         }
[17:26:47.050]                       })
[17:26:47.050]                     }
[17:26:47.050]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.050]                     base::options(mc.cores = 1L)
[17:26:47.050]                   }
[17:26:47.050]                   ...future.strategy.old <- future::plan("list")
[17:26:47.050]                   options(future.plan = NULL)
[17:26:47.050]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.050]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.050]                 }
[17:26:47.050]                 ...future.workdir <- getwd()
[17:26:47.050]             }
[17:26:47.050]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.050]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.050]         }
[17:26:47.050]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.050]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.050]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.050]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.050]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.050]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.050]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.050]             base::names(...future.oldOptions))
[17:26:47.050]     }
[17:26:47.050]     if (FALSE) {
[17:26:47.050]     }
[17:26:47.050]     else {
[17:26:47.050]         if (TRUE) {
[17:26:47.050]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.050]                 open = "w")
[17:26:47.050]         }
[17:26:47.050]         else {
[17:26:47.050]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.050]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.050]         }
[17:26:47.050]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.050]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.050]             base::sink(type = "output", split = FALSE)
[17:26:47.050]             base::close(...future.stdout)
[17:26:47.050]         }, add = TRUE)
[17:26:47.050]     }
[17:26:47.050]     ...future.frame <- base::sys.nframe()
[17:26:47.050]     ...future.conditions <- base::list()
[17:26:47.050]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.050]     if (FALSE) {
[17:26:47.050]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.050]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.050]     }
[17:26:47.050]     ...future.result <- base::tryCatch({
[17:26:47.050]         base::withCallingHandlers({
[17:26:47.050]             ...future.value <- base::withVisible(base::local({
[17:26:47.050]                 ...future.makeSendCondition <- base::local({
[17:26:47.050]                   sendCondition <- NULL
[17:26:47.050]                   function(frame = 1L) {
[17:26:47.050]                     if (is.function(sendCondition)) 
[17:26:47.050]                       return(sendCondition)
[17:26:47.050]                     ns <- getNamespace("parallel")
[17:26:47.050]                     if (exists("sendData", mode = "function", 
[17:26:47.050]                       envir = ns)) {
[17:26:47.050]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.050]                         envir = ns)
[17:26:47.050]                       envir <- sys.frame(frame)
[17:26:47.050]                       master <- NULL
[17:26:47.050]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.050]                         !identical(envir, emptyenv())) {
[17:26:47.050]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.050]                           inherits = FALSE)) {
[17:26:47.050]                           master <- get("master", mode = "list", 
[17:26:47.050]                             envir = envir, inherits = FALSE)
[17:26:47.050]                           if (inherits(master, c("SOCKnode", 
[17:26:47.050]                             "SOCK0node"))) {
[17:26:47.050]                             sendCondition <<- function(cond) {
[17:26:47.050]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.050]                                 success = TRUE)
[17:26:47.050]                               parallel_sendData(master, data)
[17:26:47.050]                             }
[17:26:47.050]                             return(sendCondition)
[17:26:47.050]                           }
[17:26:47.050]                         }
[17:26:47.050]                         frame <- frame + 1L
[17:26:47.050]                         envir <- sys.frame(frame)
[17:26:47.050]                       }
[17:26:47.050]                     }
[17:26:47.050]                     sendCondition <<- function(cond) NULL
[17:26:47.050]                   }
[17:26:47.050]                 })
[17:26:47.050]                 withCallingHandlers({
[17:26:47.050]                   NULL
[17:26:47.050]                 }, immediateCondition = function(cond) {
[17:26:47.050]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.050]                   sendCondition(cond)
[17:26:47.050]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.050]                   {
[17:26:47.050]                     inherits <- base::inherits
[17:26:47.050]                     invokeRestart <- base::invokeRestart
[17:26:47.050]                     is.null <- base::is.null
[17:26:47.050]                     muffled <- FALSE
[17:26:47.050]                     if (inherits(cond, "message")) {
[17:26:47.050]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.050]                       if (muffled) 
[17:26:47.050]                         invokeRestart("muffleMessage")
[17:26:47.050]                     }
[17:26:47.050]                     else if (inherits(cond, "warning")) {
[17:26:47.050]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.050]                       if (muffled) 
[17:26:47.050]                         invokeRestart("muffleWarning")
[17:26:47.050]                     }
[17:26:47.050]                     else if (inherits(cond, "condition")) {
[17:26:47.050]                       if (!is.null(pattern)) {
[17:26:47.050]                         computeRestarts <- base::computeRestarts
[17:26:47.050]                         grepl <- base::grepl
[17:26:47.050]                         restarts <- computeRestarts(cond)
[17:26:47.050]                         for (restart in restarts) {
[17:26:47.050]                           name <- restart$name
[17:26:47.050]                           if (is.null(name)) 
[17:26:47.050]                             next
[17:26:47.050]                           if (!grepl(pattern, name)) 
[17:26:47.050]                             next
[17:26:47.050]                           invokeRestart(restart)
[17:26:47.050]                           muffled <- TRUE
[17:26:47.050]                           break
[17:26:47.050]                         }
[17:26:47.050]                       }
[17:26:47.050]                     }
[17:26:47.050]                     invisible(muffled)
[17:26:47.050]                   }
[17:26:47.050]                   muffleCondition(cond)
[17:26:47.050]                 })
[17:26:47.050]             }))
[17:26:47.050]             future::FutureResult(value = ...future.value$value, 
[17:26:47.050]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.050]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.050]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.050]                     ...future.globalenv.names))
[17:26:47.050]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.050]         }, condition = base::local({
[17:26:47.050]             c <- base::c
[17:26:47.050]             inherits <- base::inherits
[17:26:47.050]             invokeRestart <- base::invokeRestart
[17:26:47.050]             length <- base::length
[17:26:47.050]             list <- base::list
[17:26:47.050]             seq.int <- base::seq.int
[17:26:47.050]             signalCondition <- base::signalCondition
[17:26:47.050]             sys.calls <- base::sys.calls
[17:26:47.050]             `[[` <- base::`[[`
[17:26:47.050]             `+` <- base::`+`
[17:26:47.050]             `<<-` <- base::`<<-`
[17:26:47.050]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.050]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.050]                   3L)]
[17:26:47.050]             }
[17:26:47.050]             function(cond) {
[17:26:47.050]                 is_error <- inherits(cond, "error")
[17:26:47.050]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.050]                   NULL)
[17:26:47.050]                 if (is_error) {
[17:26:47.050]                   sessionInformation <- function() {
[17:26:47.050]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.050]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.050]                       search = base::search(), system = base::Sys.info())
[17:26:47.050]                   }
[17:26:47.050]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.050]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.050]                     cond$call), session = sessionInformation(), 
[17:26:47.050]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.050]                   signalCondition(cond)
[17:26:47.050]                 }
[17:26:47.050]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.050]                 "immediateCondition"))) {
[17:26:47.050]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.050]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.050]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.050]                   if (TRUE && !signal) {
[17:26:47.050]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.050]                     {
[17:26:47.050]                       inherits <- base::inherits
[17:26:47.050]                       invokeRestart <- base::invokeRestart
[17:26:47.050]                       is.null <- base::is.null
[17:26:47.050]                       muffled <- FALSE
[17:26:47.050]                       if (inherits(cond, "message")) {
[17:26:47.050]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.050]                         if (muffled) 
[17:26:47.050]                           invokeRestart("muffleMessage")
[17:26:47.050]                       }
[17:26:47.050]                       else if (inherits(cond, "warning")) {
[17:26:47.050]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.050]                         if (muffled) 
[17:26:47.050]                           invokeRestart("muffleWarning")
[17:26:47.050]                       }
[17:26:47.050]                       else if (inherits(cond, "condition")) {
[17:26:47.050]                         if (!is.null(pattern)) {
[17:26:47.050]                           computeRestarts <- base::computeRestarts
[17:26:47.050]                           grepl <- base::grepl
[17:26:47.050]                           restarts <- computeRestarts(cond)
[17:26:47.050]                           for (restart in restarts) {
[17:26:47.050]                             name <- restart$name
[17:26:47.050]                             if (is.null(name)) 
[17:26:47.050]                               next
[17:26:47.050]                             if (!grepl(pattern, name)) 
[17:26:47.050]                               next
[17:26:47.050]                             invokeRestart(restart)
[17:26:47.050]                             muffled <- TRUE
[17:26:47.050]                             break
[17:26:47.050]                           }
[17:26:47.050]                         }
[17:26:47.050]                       }
[17:26:47.050]                       invisible(muffled)
[17:26:47.050]                     }
[17:26:47.050]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.050]                   }
[17:26:47.050]                 }
[17:26:47.050]                 else {
[17:26:47.050]                   if (TRUE) {
[17:26:47.050]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.050]                     {
[17:26:47.050]                       inherits <- base::inherits
[17:26:47.050]                       invokeRestart <- base::invokeRestart
[17:26:47.050]                       is.null <- base::is.null
[17:26:47.050]                       muffled <- FALSE
[17:26:47.050]                       if (inherits(cond, "message")) {
[17:26:47.050]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.050]                         if (muffled) 
[17:26:47.050]                           invokeRestart("muffleMessage")
[17:26:47.050]                       }
[17:26:47.050]                       else if (inherits(cond, "warning")) {
[17:26:47.050]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.050]                         if (muffled) 
[17:26:47.050]                           invokeRestart("muffleWarning")
[17:26:47.050]                       }
[17:26:47.050]                       else if (inherits(cond, "condition")) {
[17:26:47.050]                         if (!is.null(pattern)) {
[17:26:47.050]                           computeRestarts <- base::computeRestarts
[17:26:47.050]                           grepl <- base::grepl
[17:26:47.050]                           restarts <- computeRestarts(cond)
[17:26:47.050]                           for (restart in restarts) {
[17:26:47.050]                             name <- restart$name
[17:26:47.050]                             if (is.null(name)) 
[17:26:47.050]                               next
[17:26:47.050]                             if (!grepl(pattern, name)) 
[17:26:47.050]                               next
[17:26:47.050]                             invokeRestart(restart)
[17:26:47.050]                             muffled <- TRUE
[17:26:47.050]                             break
[17:26:47.050]                           }
[17:26:47.050]                         }
[17:26:47.050]                       }
[17:26:47.050]                       invisible(muffled)
[17:26:47.050]                     }
[17:26:47.050]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.050]                   }
[17:26:47.050]                 }
[17:26:47.050]             }
[17:26:47.050]         }))
[17:26:47.050]     }, error = function(ex) {
[17:26:47.050]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.050]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.050]                 ...future.rng), started = ...future.startTime, 
[17:26:47.050]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.050]             version = "1.8"), class = "FutureResult")
[17:26:47.050]     }, finally = {
[17:26:47.050]         if (!identical(...future.workdir, getwd())) 
[17:26:47.050]             setwd(...future.workdir)
[17:26:47.050]         {
[17:26:47.050]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.050]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.050]             }
[17:26:47.050]             base::options(...future.oldOptions)
[17:26:47.050]             if (.Platform$OS.type == "windows") {
[17:26:47.050]                 old_names <- names(...future.oldEnvVars)
[17:26:47.050]                 envs <- base::Sys.getenv()
[17:26:47.050]                 names <- names(envs)
[17:26:47.050]                 common <- intersect(names, old_names)
[17:26:47.050]                 added <- setdiff(names, old_names)
[17:26:47.050]                 removed <- setdiff(old_names, names)
[17:26:47.050]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.050]                   envs[common]]
[17:26:47.050]                 NAMES <- toupper(changed)
[17:26:47.050]                 args <- list()
[17:26:47.050]                 for (kk in seq_along(NAMES)) {
[17:26:47.050]                   name <- changed[[kk]]
[17:26:47.050]                   NAME <- NAMES[[kk]]
[17:26:47.050]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.050]                     next
[17:26:47.050]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.050]                 }
[17:26:47.050]                 NAMES <- toupper(added)
[17:26:47.050]                 for (kk in seq_along(NAMES)) {
[17:26:47.050]                   name <- added[[kk]]
[17:26:47.050]                   NAME <- NAMES[[kk]]
[17:26:47.050]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.050]                     next
[17:26:47.050]                   args[[name]] <- ""
[17:26:47.050]                 }
[17:26:47.050]                 NAMES <- toupper(removed)
[17:26:47.050]                 for (kk in seq_along(NAMES)) {
[17:26:47.050]                   name <- removed[[kk]]
[17:26:47.050]                   NAME <- NAMES[[kk]]
[17:26:47.050]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.050]                     next
[17:26:47.050]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.050]                 }
[17:26:47.050]                 if (length(args) > 0) 
[17:26:47.050]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.050]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.050]             }
[17:26:47.050]             else {
[17:26:47.050]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.050]             }
[17:26:47.050]             {
[17:26:47.050]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.050]                   0L) {
[17:26:47.050]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.050]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.050]                   base::options(opts)
[17:26:47.050]                 }
[17:26:47.050]                 {
[17:26:47.050]                   {
[17:26:47.050]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.050]                     NULL
[17:26:47.050]                   }
[17:26:47.050]                   options(future.plan = NULL)
[17:26:47.050]                   if (is.na(NA_character_)) 
[17:26:47.050]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.050]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.050]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.050]                     .init = FALSE)
[17:26:47.050]                 }
[17:26:47.050]             }
[17:26:47.050]         }
[17:26:47.050]     })
[17:26:47.050]     if (TRUE) {
[17:26:47.050]         base::sink(type = "output", split = FALSE)
[17:26:47.050]         if (TRUE) {
[17:26:47.050]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.050]         }
[17:26:47.050]         else {
[17:26:47.050]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.050]         }
[17:26:47.050]         base::close(...future.stdout)
[17:26:47.050]         ...future.stdout <- NULL
[17:26:47.050]     }
[17:26:47.050]     ...future.result$conditions <- ...future.conditions
[17:26:47.050]     ...future.result$finished <- base::Sys.time()
[17:26:47.050]     ...future.result
[17:26:47.050] }
[17:26:47.056] MultisessionFuture started
[17:26:47.056] - Launch lazy future ... done
[17:26:47.056] run() for 'MultisessionFuture' ... done
[17:26:47.057] getGlobalsAndPackages() ...
[17:26:47.057] Searching for globals...
[17:26:47.058] - globals found: [1] '{'
[17:26:47.058] Searching for globals ... DONE
[17:26:47.058] Resolving globals: FALSE
[17:26:47.059] 
[17:26:47.059] 
[17:26:47.059] getGlobalsAndPackages() ... DONE
[17:26:47.059] run() for 'Future' ...
[17:26:47.059] - state: 'created'
[17:26:47.060] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.073] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.074] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.074]   - Field: 'node'
[17:26:47.074]   - Field: 'label'
[17:26:47.074]   - Field: 'local'
[17:26:47.074]   - Field: 'owner'
[17:26:47.074]   - Field: 'envir'
[17:26:47.075]   - Field: 'workers'
[17:26:47.075]   - Field: 'packages'
[17:26:47.075]   - Field: 'gc'
[17:26:47.075]   - Field: 'conditions'
[17:26:47.075]   - Field: 'persistent'
[17:26:47.076]   - Field: 'expr'
[17:26:47.076]   - Field: 'uuid'
[17:26:47.076]   - Field: 'seed'
[17:26:47.076]   - Field: 'version'
[17:26:47.076]   - Field: 'result'
[17:26:47.076]   - Field: 'asynchronous'
[17:26:47.077]   - Field: 'calls'
[17:26:47.077]   - Field: 'globals'
[17:26:47.077]   - Field: 'stdout'
[17:26:47.077]   - Field: 'earlySignal'
[17:26:47.077]   - Field: 'lazy'
[17:26:47.078]   - Field: 'state'
[17:26:47.078] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.078] - Launch lazy future ...
[17:26:47.078] Packages needed by the future expression (n = 0): <none>
[17:26:47.078] Packages needed by future strategies (n = 0): <none>
[17:26:47.079] {
[17:26:47.079]     {
[17:26:47.079]         {
[17:26:47.079]             ...future.startTime <- base::Sys.time()
[17:26:47.079]             {
[17:26:47.079]                 {
[17:26:47.079]                   {
[17:26:47.079]                     {
[17:26:47.079]                       base::local({
[17:26:47.079]                         has_future <- base::requireNamespace("future", 
[17:26:47.079]                           quietly = TRUE)
[17:26:47.079]                         if (has_future) {
[17:26:47.079]                           ns <- base::getNamespace("future")
[17:26:47.079]                           version <- ns[[".package"]][["version"]]
[17:26:47.079]                           if (is.null(version)) 
[17:26:47.079]                             version <- utils::packageVersion("future")
[17:26:47.079]                         }
[17:26:47.079]                         else {
[17:26:47.079]                           version <- NULL
[17:26:47.079]                         }
[17:26:47.079]                         if (!has_future || version < "1.8.0") {
[17:26:47.079]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.079]                             "", base::R.version$version.string), 
[17:26:47.079]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.079]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.079]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.079]                               "release", "version")], collapse = " "), 
[17:26:47.079]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.079]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.079]                             info)
[17:26:47.079]                           info <- base::paste(info, collapse = "; ")
[17:26:47.079]                           if (!has_future) {
[17:26:47.079]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.079]                               info)
[17:26:47.079]                           }
[17:26:47.079]                           else {
[17:26:47.079]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.079]                               info, version)
[17:26:47.079]                           }
[17:26:47.079]                           base::stop(msg)
[17:26:47.079]                         }
[17:26:47.079]                       })
[17:26:47.079]                     }
[17:26:47.079]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.079]                     base::options(mc.cores = 1L)
[17:26:47.079]                   }
[17:26:47.079]                   ...future.strategy.old <- future::plan("list")
[17:26:47.079]                   options(future.plan = NULL)
[17:26:47.079]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.079]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.079]                 }
[17:26:47.079]                 ...future.workdir <- getwd()
[17:26:47.079]             }
[17:26:47.079]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.079]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.079]         }
[17:26:47.079]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.079]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.079]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.079]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.079]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.079]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.079]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.079]             base::names(...future.oldOptions))
[17:26:47.079]     }
[17:26:47.079]     if (FALSE) {
[17:26:47.079]     }
[17:26:47.079]     else {
[17:26:47.079]         if (TRUE) {
[17:26:47.079]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.079]                 open = "w")
[17:26:47.079]         }
[17:26:47.079]         else {
[17:26:47.079]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.079]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.079]         }
[17:26:47.079]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.079]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.079]             base::sink(type = "output", split = FALSE)
[17:26:47.079]             base::close(...future.stdout)
[17:26:47.079]         }, add = TRUE)
[17:26:47.079]     }
[17:26:47.079]     ...future.frame <- base::sys.nframe()
[17:26:47.079]     ...future.conditions <- base::list()
[17:26:47.079]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.079]     if (FALSE) {
[17:26:47.079]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.079]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.079]     }
[17:26:47.079]     ...future.result <- base::tryCatch({
[17:26:47.079]         base::withCallingHandlers({
[17:26:47.079]             ...future.value <- base::withVisible(base::local({
[17:26:47.079]                 ...future.makeSendCondition <- base::local({
[17:26:47.079]                   sendCondition <- NULL
[17:26:47.079]                   function(frame = 1L) {
[17:26:47.079]                     if (is.function(sendCondition)) 
[17:26:47.079]                       return(sendCondition)
[17:26:47.079]                     ns <- getNamespace("parallel")
[17:26:47.079]                     if (exists("sendData", mode = "function", 
[17:26:47.079]                       envir = ns)) {
[17:26:47.079]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.079]                         envir = ns)
[17:26:47.079]                       envir <- sys.frame(frame)
[17:26:47.079]                       master <- NULL
[17:26:47.079]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.079]                         !identical(envir, emptyenv())) {
[17:26:47.079]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.079]                           inherits = FALSE)) {
[17:26:47.079]                           master <- get("master", mode = "list", 
[17:26:47.079]                             envir = envir, inherits = FALSE)
[17:26:47.079]                           if (inherits(master, c("SOCKnode", 
[17:26:47.079]                             "SOCK0node"))) {
[17:26:47.079]                             sendCondition <<- function(cond) {
[17:26:47.079]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.079]                                 success = TRUE)
[17:26:47.079]                               parallel_sendData(master, data)
[17:26:47.079]                             }
[17:26:47.079]                             return(sendCondition)
[17:26:47.079]                           }
[17:26:47.079]                         }
[17:26:47.079]                         frame <- frame + 1L
[17:26:47.079]                         envir <- sys.frame(frame)
[17:26:47.079]                       }
[17:26:47.079]                     }
[17:26:47.079]                     sendCondition <<- function(cond) NULL
[17:26:47.079]                   }
[17:26:47.079]                 })
[17:26:47.079]                 withCallingHandlers({
[17:26:47.079]                   {
[17:26:47.079]                     4
[17:26:47.079]                   }
[17:26:47.079]                 }, immediateCondition = function(cond) {
[17:26:47.079]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.079]                   sendCondition(cond)
[17:26:47.079]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.079]                   {
[17:26:47.079]                     inherits <- base::inherits
[17:26:47.079]                     invokeRestart <- base::invokeRestart
[17:26:47.079]                     is.null <- base::is.null
[17:26:47.079]                     muffled <- FALSE
[17:26:47.079]                     if (inherits(cond, "message")) {
[17:26:47.079]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.079]                       if (muffled) 
[17:26:47.079]                         invokeRestart("muffleMessage")
[17:26:47.079]                     }
[17:26:47.079]                     else if (inherits(cond, "warning")) {
[17:26:47.079]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.079]                       if (muffled) 
[17:26:47.079]                         invokeRestart("muffleWarning")
[17:26:47.079]                     }
[17:26:47.079]                     else if (inherits(cond, "condition")) {
[17:26:47.079]                       if (!is.null(pattern)) {
[17:26:47.079]                         computeRestarts <- base::computeRestarts
[17:26:47.079]                         grepl <- base::grepl
[17:26:47.079]                         restarts <- computeRestarts(cond)
[17:26:47.079]                         for (restart in restarts) {
[17:26:47.079]                           name <- restart$name
[17:26:47.079]                           if (is.null(name)) 
[17:26:47.079]                             next
[17:26:47.079]                           if (!grepl(pattern, name)) 
[17:26:47.079]                             next
[17:26:47.079]                           invokeRestart(restart)
[17:26:47.079]                           muffled <- TRUE
[17:26:47.079]                           break
[17:26:47.079]                         }
[17:26:47.079]                       }
[17:26:47.079]                     }
[17:26:47.079]                     invisible(muffled)
[17:26:47.079]                   }
[17:26:47.079]                   muffleCondition(cond)
[17:26:47.079]                 })
[17:26:47.079]             }))
[17:26:47.079]             future::FutureResult(value = ...future.value$value, 
[17:26:47.079]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.079]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.079]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.079]                     ...future.globalenv.names))
[17:26:47.079]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.079]         }, condition = base::local({
[17:26:47.079]             c <- base::c
[17:26:47.079]             inherits <- base::inherits
[17:26:47.079]             invokeRestart <- base::invokeRestart
[17:26:47.079]             length <- base::length
[17:26:47.079]             list <- base::list
[17:26:47.079]             seq.int <- base::seq.int
[17:26:47.079]             signalCondition <- base::signalCondition
[17:26:47.079]             sys.calls <- base::sys.calls
[17:26:47.079]             `[[` <- base::`[[`
[17:26:47.079]             `+` <- base::`+`
[17:26:47.079]             `<<-` <- base::`<<-`
[17:26:47.079]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.079]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.079]                   3L)]
[17:26:47.079]             }
[17:26:47.079]             function(cond) {
[17:26:47.079]                 is_error <- inherits(cond, "error")
[17:26:47.079]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.079]                   NULL)
[17:26:47.079]                 if (is_error) {
[17:26:47.079]                   sessionInformation <- function() {
[17:26:47.079]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.079]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.079]                       search = base::search(), system = base::Sys.info())
[17:26:47.079]                   }
[17:26:47.079]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.079]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.079]                     cond$call), session = sessionInformation(), 
[17:26:47.079]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.079]                   signalCondition(cond)
[17:26:47.079]                 }
[17:26:47.079]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.079]                 "immediateCondition"))) {
[17:26:47.079]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.079]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.079]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.079]                   if (TRUE && !signal) {
[17:26:47.079]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.079]                     {
[17:26:47.079]                       inherits <- base::inherits
[17:26:47.079]                       invokeRestart <- base::invokeRestart
[17:26:47.079]                       is.null <- base::is.null
[17:26:47.079]                       muffled <- FALSE
[17:26:47.079]                       if (inherits(cond, "message")) {
[17:26:47.079]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.079]                         if (muffled) 
[17:26:47.079]                           invokeRestart("muffleMessage")
[17:26:47.079]                       }
[17:26:47.079]                       else if (inherits(cond, "warning")) {
[17:26:47.079]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.079]                         if (muffled) 
[17:26:47.079]                           invokeRestart("muffleWarning")
[17:26:47.079]                       }
[17:26:47.079]                       else if (inherits(cond, "condition")) {
[17:26:47.079]                         if (!is.null(pattern)) {
[17:26:47.079]                           computeRestarts <- base::computeRestarts
[17:26:47.079]                           grepl <- base::grepl
[17:26:47.079]                           restarts <- computeRestarts(cond)
[17:26:47.079]                           for (restart in restarts) {
[17:26:47.079]                             name <- restart$name
[17:26:47.079]                             if (is.null(name)) 
[17:26:47.079]                               next
[17:26:47.079]                             if (!grepl(pattern, name)) 
[17:26:47.079]                               next
[17:26:47.079]                             invokeRestart(restart)
[17:26:47.079]                             muffled <- TRUE
[17:26:47.079]                             break
[17:26:47.079]                           }
[17:26:47.079]                         }
[17:26:47.079]                       }
[17:26:47.079]                       invisible(muffled)
[17:26:47.079]                     }
[17:26:47.079]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.079]                   }
[17:26:47.079]                 }
[17:26:47.079]                 else {
[17:26:47.079]                   if (TRUE) {
[17:26:47.079]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.079]                     {
[17:26:47.079]                       inherits <- base::inherits
[17:26:47.079]                       invokeRestart <- base::invokeRestart
[17:26:47.079]                       is.null <- base::is.null
[17:26:47.079]                       muffled <- FALSE
[17:26:47.079]                       if (inherits(cond, "message")) {
[17:26:47.079]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.079]                         if (muffled) 
[17:26:47.079]                           invokeRestart("muffleMessage")
[17:26:47.079]                       }
[17:26:47.079]                       else if (inherits(cond, "warning")) {
[17:26:47.079]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.079]                         if (muffled) 
[17:26:47.079]                           invokeRestart("muffleWarning")
[17:26:47.079]                       }
[17:26:47.079]                       else if (inherits(cond, "condition")) {
[17:26:47.079]                         if (!is.null(pattern)) {
[17:26:47.079]                           computeRestarts <- base::computeRestarts
[17:26:47.079]                           grepl <- base::grepl
[17:26:47.079]                           restarts <- computeRestarts(cond)
[17:26:47.079]                           for (restart in restarts) {
[17:26:47.079]                             name <- restart$name
[17:26:47.079]                             if (is.null(name)) 
[17:26:47.079]                               next
[17:26:47.079]                             if (!grepl(pattern, name)) 
[17:26:47.079]                               next
[17:26:47.079]                             invokeRestart(restart)
[17:26:47.079]                             muffled <- TRUE
[17:26:47.079]                             break
[17:26:47.079]                           }
[17:26:47.079]                         }
[17:26:47.079]                       }
[17:26:47.079]                       invisible(muffled)
[17:26:47.079]                     }
[17:26:47.079]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.079]                   }
[17:26:47.079]                 }
[17:26:47.079]             }
[17:26:47.079]         }))
[17:26:47.079]     }, error = function(ex) {
[17:26:47.079]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.079]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.079]                 ...future.rng), started = ...future.startTime, 
[17:26:47.079]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.079]             version = "1.8"), class = "FutureResult")
[17:26:47.079]     }, finally = {
[17:26:47.079]         if (!identical(...future.workdir, getwd())) 
[17:26:47.079]             setwd(...future.workdir)
[17:26:47.079]         {
[17:26:47.079]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.079]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.079]             }
[17:26:47.079]             base::options(...future.oldOptions)
[17:26:47.079]             if (.Platform$OS.type == "windows") {
[17:26:47.079]                 old_names <- names(...future.oldEnvVars)
[17:26:47.079]                 envs <- base::Sys.getenv()
[17:26:47.079]                 names <- names(envs)
[17:26:47.079]                 common <- intersect(names, old_names)
[17:26:47.079]                 added <- setdiff(names, old_names)
[17:26:47.079]                 removed <- setdiff(old_names, names)
[17:26:47.079]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.079]                   envs[common]]
[17:26:47.079]                 NAMES <- toupper(changed)
[17:26:47.079]                 args <- list()
[17:26:47.079]                 for (kk in seq_along(NAMES)) {
[17:26:47.079]                   name <- changed[[kk]]
[17:26:47.079]                   NAME <- NAMES[[kk]]
[17:26:47.079]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.079]                     next
[17:26:47.079]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.079]                 }
[17:26:47.079]                 NAMES <- toupper(added)
[17:26:47.079]                 for (kk in seq_along(NAMES)) {
[17:26:47.079]                   name <- added[[kk]]
[17:26:47.079]                   NAME <- NAMES[[kk]]
[17:26:47.079]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.079]                     next
[17:26:47.079]                   args[[name]] <- ""
[17:26:47.079]                 }
[17:26:47.079]                 NAMES <- toupper(removed)
[17:26:47.079]                 for (kk in seq_along(NAMES)) {
[17:26:47.079]                   name <- removed[[kk]]
[17:26:47.079]                   NAME <- NAMES[[kk]]
[17:26:47.079]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.079]                     next
[17:26:47.079]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.079]                 }
[17:26:47.079]                 if (length(args) > 0) 
[17:26:47.079]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.079]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.079]             }
[17:26:47.079]             else {
[17:26:47.079]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.079]             }
[17:26:47.079]             {
[17:26:47.079]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.079]                   0L) {
[17:26:47.079]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.079]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.079]                   base::options(opts)
[17:26:47.079]                 }
[17:26:47.079]                 {
[17:26:47.079]                   {
[17:26:47.079]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.079]                     NULL
[17:26:47.079]                   }
[17:26:47.079]                   options(future.plan = NULL)
[17:26:47.079]                   if (is.na(NA_character_)) 
[17:26:47.079]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.079]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.079]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.079]                     .init = FALSE)
[17:26:47.079]                 }
[17:26:47.079]             }
[17:26:47.079]         }
[17:26:47.079]     })
[17:26:47.079]     if (TRUE) {
[17:26:47.079]         base::sink(type = "output", split = FALSE)
[17:26:47.079]         if (TRUE) {
[17:26:47.079]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.079]         }
[17:26:47.079]         else {
[17:26:47.079]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.079]         }
[17:26:47.079]         base::close(...future.stdout)
[17:26:47.079]         ...future.stdout <- NULL
[17:26:47.079]     }
[17:26:47.079]     ...future.result$conditions <- ...future.conditions
[17:26:47.079]     ...future.result$finished <- base::Sys.time()
[17:26:47.079]     ...future.result
[17:26:47.079] }
[17:26:47.084] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:47.095] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.095] - Validating connection of MultisessionFuture
[17:26:47.095] - received message: FutureResult
[17:26:47.095] - Received FutureResult
[17:26:47.096] - Erased future from FutureRegistry
[17:26:47.096] result() for ClusterFuture ...
[17:26:47.096] - result already collected: FutureResult
[17:26:47.096] result() for ClusterFuture ... done
[17:26:47.096] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:47.096] result() for ClusterFuture ...
[17:26:47.097] - result already collected: FutureResult
[17:26:47.097] result() for ClusterFuture ... done
[17:26:47.097] result() for ClusterFuture ...
[17:26:47.097] - result already collected: FutureResult
[17:26:47.097] result() for ClusterFuture ... done
[17:26:47.098] MultisessionFuture started
[17:26:47.099] - Launch lazy future ... done
[17:26:47.099] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230ffbcb18> 
Classes 'listenv', 'environment' <environment: 0x0000022310ba9ae0> 
 - attr(*, "dim.")= int [1:2] 2 3
 - attr(*, "dimnames.")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
[17:26:47.108] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.108] - Validating connection of MultisessionFuture
[17:26:47.108] - received message: FutureResult
[17:26:47.108] - Received FutureResult
[17:26:47.108] - Erased future from FutureRegistry
[17:26:47.109] result() for ClusterFuture ...
[17:26:47.109] - result already collected: FutureResult
[17:26:47.109] result() for ClusterFuture ... done
[17:26:47.109] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:47.115] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.115] - Validating connection of MultisessionFuture
[17:26:47.115] - received message: FutureResult
[17:26:47.115] - Received FutureResult
[17:26:47.116] - Erased future from FutureRegistry
[17:26:47.116] result() for ClusterFuture ...
[17:26:47.116] - result already collected: FutureResult
[17:26:47.116] result() for ClusterFuture ... done
[17:26:47.116] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:47.119] resolve() on list environment ...
[17:26:47.119]  recursive: 0
[17:26:47.120]  length: 6
[17:26:47.121]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:47.121] signalConditionsASAP(numeric, pos=1) ...
[17:26:47.121] - nx: 6
[17:26:47.121] - relay: TRUE
[17:26:47.121] - stdout: TRUE
[17:26:47.122] - signal: TRUE
[17:26:47.122] - resignal: FALSE
[17:26:47.122] - force: TRUE
[17:26:47.122] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.122] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.122]  - until=2
[17:26:47.123]  - relaying element #2
[17:26:47.123] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.123] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.123] signalConditionsASAP(NULL, pos=1) ... done
[17:26:47.123]  length: 5 (resolved future 1)
[17:26:47.123] Future #2
[17:26:47.124] result() for ClusterFuture ...
[17:26:47.124] - result already collected: FutureResult
[17:26:47.124] result() for ClusterFuture ... done
[17:26:47.124] result() for ClusterFuture ...
[17:26:47.124] - result already collected: FutureResult
[17:26:47.124] result() for ClusterFuture ... done
[17:26:47.125] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:47.125] - nx: 6
[17:26:47.125] - relay: TRUE
[17:26:47.125] - stdout: TRUE
[17:26:47.125] - signal: TRUE
[17:26:47.125] - resignal: FALSE
[17:26:47.125] - force: TRUE
[17:26:47.126] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.126] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.126]  - until=2
[17:26:47.126]  - relaying element #2
[17:26:47.126] result() for ClusterFuture ...
[17:26:47.126] - result already collected: FutureResult
[17:26:47.127] result() for ClusterFuture ... done
[17:26:47.127] result() for ClusterFuture ...
[17:26:47.127] - result already collected: FutureResult
[17:26:47.127] result() for ClusterFuture ... done
[17:26:47.127] result() for ClusterFuture ...
[17:26:47.127] - result already collected: FutureResult
[17:26:47.128] result() for ClusterFuture ... done
[17:26:47.128] result() for ClusterFuture ...
[17:26:47.128] - result already collected: FutureResult
[17:26:47.128] result() for ClusterFuture ... done
[17:26:47.128] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.128] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.129] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:47.129]  length: 4 (resolved future 2)
[17:26:47.129] Future #3
[17:26:47.129] result() for ClusterFuture ...
[17:26:47.129] - result already collected: FutureResult
[17:26:47.130] result() for ClusterFuture ... done
[17:26:47.130] result() for ClusterFuture ...
[17:26:47.130] - result already collected: FutureResult
[17:26:47.130] result() for ClusterFuture ... done
[17:26:47.130] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:47.130] - nx: 6
[17:26:47.131] - relay: TRUE
[17:26:47.131] - stdout: TRUE
[17:26:47.131] - signal: TRUE
[17:26:47.131] - resignal: FALSE
[17:26:47.131] - force: TRUE
[17:26:47.131] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.131] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.132]  - until=3
[17:26:47.132]  - relaying element #3
[17:26:47.132] result() for ClusterFuture ...
[17:26:47.132] - result already collected: FutureResult
[17:26:47.132] result() for ClusterFuture ... done
[17:26:47.133] result() for ClusterFuture ...
[17:26:47.133] - result already collected: FutureResult
[17:26:47.133] result() for ClusterFuture ... done
[17:26:47.133] result() for ClusterFuture ...
[17:26:47.133] - result already collected: FutureResult
[17:26:47.133] result() for ClusterFuture ... done
[17:26:47.134] result() for ClusterFuture ...
[17:26:47.134] - result already collected: FutureResult
[17:26:47.134] result() for ClusterFuture ... done
[17:26:47.134] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.134] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.134] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:47.135]  length: 3 (resolved future 3)
[17:26:47.135] Future #4
[17:26:47.135] result() for ClusterFuture ...
[17:26:47.135] - result already collected: FutureResult
[17:26:47.135] result() for ClusterFuture ... done
[17:26:47.136] result() for ClusterFuture ...
[17:26:47.136] - result already collected: FutureResult
[17:26:47.136] result() for ClusterFuture ... done
[17:26:47.136] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:47.136] - nx: 6
[17:26:47.136] - relay: TRUE
[17:26:47.137] - stdout: TRUE
[17:26:47.137] - signal: TRUE
[17:26:47.137] - resignal: FALSE
[17:26:47.137] - force: TRUE
[17:26:47.137] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.137] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.138]  - until=4
[17:26:47.138]  - relaying element #4
[17:26:47.138] result() for ClusterFuture ...
[17:26:47.138] - result already collected: FutureResult
[17:26:47.138] result() for ClusterFuture ... done
[17:26:47.138] result() for ClusterFuture ...
[17:26:47.139] - result already collected: FutureResult
[17:26:47.139] result() for ClusterFuture ... done
[17:26:47.139] result() for ClusterFuture ...
[17:26:47.139] - result already collected: FutureResult
[17:26:47.139] result() for ClusterFuture ... done
[17:26:47.139] result() for ClusterFuture ...
[17:26:47.140] - result already collected: FutureResult
[17:26:47.140] result() for ClusterFuture ... done
[17:26:47.140] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.140] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.140] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:47.140]  length: 2 (resolved future 4)
[17:26:47.141] signalConditionsASAP(NULL, pos=5) ...
[17:26:47.141] - nx: 6
[17:26:47.141] - relay: TRUE
[17:26:47.141] - stdout: TRUE
[17:26:47.141] - signal: TRUE
[17:26:47.142] - resignal: FALSE
[17:26:47.142] - force: TRUE
[17:26:47.142] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.142] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.142]  - until=6
[17:26:47.142]  - relaying element #6
[17:26:47.143] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:47.143] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.143] signalConditionsASAP(NULL, pos=5) ... done
[17:26:47.143]  length: 1 (resolved future 5)
[17:26:47.143] signalConditionsASAP(numeric, pos=6) ...
[17:26:47.144] - nx: 6
[17:26:47.144] - relay: TRUE
[17:26:47.144] - stdout: TRUE
[17:26:47.144] - signal: TRUE
[17:26:47.144] - resignal: FALSE
[17:26:47.144] - force: TRUE
[17:26:47.145] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:47.145] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.145]  - until=6
[17:26:47.145] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.145] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.146] signalConditionsASAP(numeric, pos=6) ... done
[17:26:47.146]  length: 0 (resolved future 6)
[17:26:47.146] Relaying remaining futures
[17:26:47.146] signalConditionsASAP(NULL, pos=0) ...
[17:26:47.146] - nx: 6
[17:26:47.146] - relay: TRUE
[17:26:47.147] - stdout: TRUE
[17:26:47.147] - signal: TRUE
[17:26:47.147] - resignal: FALSE
[17:26:47.147] - force: TRUE
[17:26:47.147] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.147] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:47.148] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.148] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.148] signalConditionsASAP(NULL, pos=0) ... done
[17:26:47.148] resolve() on list environment ... DONE
[17:26:47.148] result() for ClusterFuture ...
[17:26:47.149] - result already collected: FutureResult
[17:26:47.149] result() for ClusterFuture ... done
[17:26:47.149] result() for ClusterFuture ...
[17:26:47.149] - result already collected: FutureResult
[17:26:47.149] result() for ClusterFuture ... done
[17:26:47.149] result() for ClusterFuture ...
[17:26:47.150] - result already collected: FutureResult
[17:26:47.150] result() for ClusterFuture ... done
[17:26:47.150] result() for ClusterFuture ...
[17:26:47.150] - result already collected: FutureResult
[17:26:47.150] result() for ClusterFuture ... done
[17:26:47.151] result() for ClusterFuture ...
[17:26:47.151] - result already collected: FutureResult
[17:26:47.151] result() for ClusterFuture ... done
[17:26:47.151] result() for ClusterFuture ...
[17:26:47.151] - result already collected: FutureResult
[17:26:47.151] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x000002230d722ed8> 
 - attr(*, "dim.")= int [1:2] 2 3
 - attr(*, "dimnames.")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
Dimensions: c(2, 3, 1)
[17:26:47.154] getGlobalsAndPackages() ...
[17:26:47.154] Searching for globals...
[17:26:47.154] 
[17:26:47.154] Searching for globals ... DONE
[17:26:47.154] - globals: [0] <none>
[17:26:47.155] getGlobalsAndPackages() ... DONE
[17:26:47.155] run() for 'Future' ...
[17:26:47.155] - state: 'created'
[17:26:47.155] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.169] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.169] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.169]   - Field: 'node'
[17:26:47.170]   - Field: 'label'
[17:26:47.170]   - Field: 'local'
[17:26:47.170]   - Field: 'owner'
[17:26:47.170]   - Field: 'envir'
[17:26:47.170]   - Field: 'workers'
[17:26:47.171]   - Field: 'packages'
[17:26:47.171]   - Field: 'gc'
[17:26:47.171]   - Field: 'conditions'
[17:26:47.171]   - Field: 'persistent'
[17:26:47.171]   - Field: 'expr'
[17:26:47.172]   - Field: 'uuid'
[17:26:47.172]   - Field: 'seed'
[17:26:47.172]   - Field: 'version'
[17:26:47.172]   - Field: 'result'
[17:26:47.172]   - Field: 'asynchronous'
[17:26:47.172]   - Field: 'calls'
[17:26:47.173]   - Field: 'globals'
[17:26:47.173]   - Field: 'stdout'
[17:26:47.173]   - Field: 'earlySignal'
[17:26:47.173]   - Field: 'lazy'
[17:26:47.173]   - Field: 'state'
[17:26:47.173] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.174] - Launch lazy future ...
[17:26:47.174] Packages needed by the future expression (n = 0): <none>
[17:26:47.174] Packages needed by future strategies (n = 0): <none>
[17:26:47.175] {
[17:26:47.175]     {
[17:26:47.175]         {
[17:26:47.175]             ...future.startTime <- base::Sys.time()
[17:26:47.175]             {
[17:26:47.175]                 {
[17:26:47.175]                   {
[17:26:47.175]                     {
[17:26:47.175]                       base::local({
[17:26:47.175]                         has_future <- base::requireNamespace("future", 
[17:26:47.175]                           quietly = TRUE)
[17:26:47.175]                         if (has_future) {
[17:26:47.175]                           ns <- base::getNamespace("future")
[17:26:47.175]                           version <- ns[[".package"]][["version"]]
[17:26:47.175]                           if (is.null(version)) 
[17:26:47.175]                             version <- utils::packageVersion("future")
[17:26:47.175]                         }
[17:26:47.175]                         else {
[17:26:47.175]                           version <- NULL
[17:26:47.175]                         }
[17:26:47.175]                         if (!has_future || version < "1.8.0") {
[17:26:47.175]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.175]                             "", base::R.version$version.string), 
[17:26:47.175]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.175]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.175]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.175]                               "release", "version")], collapse = " "), 
[17:26:47.175]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.175]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.175]                             info)
[17:26:47.175]                           info <- base::paste(info, collapse = "; ")
[17:26:47.175]                           if (!has_future) {
[17:26:47.175]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.175]                               info)
[17:26:47.175]                           }
[17:26:47.175]                           else {
[17:26:47.175]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.175]                               info, version)
[17:26:47.175]                           }
[17:26:47.175]                           base::stop(msg)
[17:26:47.175]                         }
[17:26:47.175]                       })
[17:26:47.175]                     }
[17:26:47.175]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.175]                     base::options(mc.cores = 1L)
[17:26:47.175]                   }
[17:26:47.175]                   ...future.strategy.old <- future::plan("list")
[17:26:47.175]                   options(future.plan = NULL)
[17:26:47.175]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.175]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.175]                 }
[17:26:47.175]                 ...future.workdir <- getwd()
[17:26:47.175]             }
[17:26:47.175]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.175]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.175]         }
[17:26:47.175]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.175]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.175]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.175]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.175]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.175]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.175]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.175]             base::names(...future.oldOptions))
[17:26:47.175]     }
[17:26:47.175]     if (FALSE) {
[17:26:47.175]     }
[17:26:47.175]     else {
[17:26:47.175]         if (TRUE) {
[17:26:47.175]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.175]                 open = "w")
[17:26:47.175]         }
[17:26:47.175]         else {
[17:26:47.175]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.175]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.175]         }
[17:26:47.175]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.175]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.175]             base::sink(type = "output", split = FALSE)
[17:26:47.175]             base::close(...future.stdout)
[17:26:47.175]         }, add = TRUE)
[17:26:47.175]     }
[17:26:47.175]     ...future.frame <- base::sys.nframe()
[17:26:47.175]     ...future.conditions <- base::list()
[17:26:47.175]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.175]     if (FALSE) {
[17:26:47.175]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.175]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.175]     }
[17:26:47.175]     ...future.result <- base::tryCatch({
[17:26:47.175]         base::withCallingHandlers({
[17:26:47.175]             ...future.value <- base::withVisible(base::local({
[17:26:47.175]                 ...future.makeSendCondition <- base::local({
[17:26:47.175]                   sendCondition <- NULL
[17:26:47.175]                   function(frame = 1L) {
[17:26:47.175]                     if (is.function(sendCondition)) 
[17:26:47.175]                       return(sendCondition)
[17:26:47.175]                     ns <- getNamespace("parallel")
[17:26:47.175]                     if (exists("sendData", mode = "function", 
[17:26:47.175]                       envir = ns)) {
[17:26:47.175]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.175]                         envir = ns)
[17:26:47.175]                       envir <- sys.frame(frame)
[17:26:47.175]                       master <- NULL
[17:26:47.175]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.175]                         !identical(envir, emptyenv())) {
[17:26:47.175]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.175]                           inherits = FALSE)) {
[17:26:47.175]                           master <- get("master", mode = "list", 
[17:26:47.175]                             envir = envir, inherits = FALSE)
[17:26:47.175]                           if (inherits(master, c("SOCKnode", 
[17:26:47.175]                             "SOCK0node"))) {
[17:26:47.175]                             sendCondition <<- function(cond) {
[17:26:47.175]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.175]                                 success = TRUE)
[17:26:47.175]                               parallel_sendData(master, data)
[17:26:47.175]                             }
[17:26:47.175]                             return(sendCondition)
[17:26:47.175]                           }
[17:26:47.175]                         }
[17:26:47.175]                         frame <- frame + 1L
[17:26:47.175]                         envir <- sys.frame(frame)
[17:26:47.175]                       }
[17:26:47.175]                     }
[17:26:47.175]                     sendCondition <<- function(cond) NULL
[17:26:47.175]                   }
[17:26:47.175]                 })
[17:26:47.175]                 withCallingHandlers({
[17:26:47.175]                   2
[17:26:47.175]                 }, immediateCondition = function(cond) {
[17:26:47.175]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.175]                   sendCondition(cond)
[17:26:47.175]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.175]                   {
[17:26:47.175]                     inherits <- base::inherits
[17:26:47.175]                     invokeRestart <- base::invokeRestart
[17:26:47.175]                     is.null <- base::is.null
[17:26:47.175]                     muffled <- FALSE
[17:26:47.175]                     if (inherits(cond, "message")) {
[17:26:47.175]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.175]                       if (muffled) 
[17:26:47.175]                         invokeRestart("muffleMessage")
[17:26:47.175]                     }
[17:26:47.175]                     else if (inherits(cond, "warning")) {
[17:26:47.175]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.175]                       if (muffled) 
[17:26:47.175]                         invokeRestart("muffleWarning")
[17:26:47.175]                     }
[17:26:47.175]                     else if (inherits(cond, "condition")) {
[17:26:47.175]                       if (!is.null(pattern)) {
[17:26:47.175]                         computeRestarts <- base::computeRestarts
[17:26:47.175]                         grepl <- base::grepl
[17:26:47.175]                         restarts <- computeRestarts(cond)
[17:26:47.175]                         for (restart in restarts) {
[17:26:47.175]                           name <- restart$name
[17:26:47.175]                           if (is.null(name)) 
[17:26:47.175]                             next
[17:26:47.175]                           if (!grepl(pattern, name)) 
[17:26:47.175]                             next
[17:26:47.175]                           invokeRestart(restart)
[17:26:47.175]                           muffled <- TRUE
[17:26:47.175]                           break
[17:26:47.175]                         }
[17:26:47.175]                       }
[17:26:47.175]                     }
[17:26:47.175]                     invisible(muffled)
[17:26:47.175]                   }
[17:26:47.175]                   muffleCondition(cond)
[17:26:47.175]                 })
[17:26:47.175]             }))
[17:26:47.175]             future::FutureResult(value = ...future.value$value, 
[17:26:47.175]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.175]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.175]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.175]                     ...future.globalenv.names))
[17:26:47.175]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.175]         }, condition = base::local({
[17:26:47.175]             c <- base::c
[17:26:47.175]             inherits <- base::inherits
[17:26:47.175]             invokeRestart <- base::invokeRestart
[17:26:47.175]             length <- base::length
[17:26:47.175]             list <- base::list
[17:26:47.175]             seq.int <- base::seq.int
[17:26:47.175]             signalCondition <- base::signalCondition
[17:26:47.175]             sys.calls <- base::sys.calls
[17:26:47.175]             `[[` <- base::`[[`
[17:26:47.175]             `+` <- base::`+`
[17:26:47.175]             `<<-` <- base::`<<-`
[17:26:47.175]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.175]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.175]                   3L)]
[17:26:47.175]             }
[17:26:47.175]             function(cond) {
[17:26:47.175]                 is_error <- inherits(cond, "error")
[17:26:47.175]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.175]                   NULL)
[17:26:47.175]                 if (is_error) {
[17:26:47.175]                   sessionInformation <- function() {
[17:26:47.175]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.175]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.175]                       search = base::search(), system = base::Sys.info())
[17:26:47.175]                   }
[17:26:47.175]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.175]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.175]                     cond$call), session = sessionInformation(), 
[17:26:47.175]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.175]                   signalCondition(cond)
[17:26:47.175]                 }
[17:26:47.175]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.175]                 "immediateCondition"))) {
[17:26:47.175]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.175]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.175]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.175]                   if (TRUE && !signal) {
[17:26:47.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.175]                     {
[17:26:47.175]                       inherits <- base::inherits
[17:26:47.175]                       invokeRestart <- base::invokeRestart
[17:26:47.175]                       is.null <- base::is.null
[17:26:47.175]                       muffled <- FALSE
[17:26:47.175]                       if (inherits(cond, "message")) {
[17:26:47.175]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.175]                         if (muffled) 
[17:26:47.175]                           invokeRestart("muffleMessage")
[17:26:47.175]                       }
[17:26:47.175]                       else if (inherits(cond, "warning")) {
[17:26:47.175]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.175]                         if (muffled) 
[17:26:47.175]                           invokeRestart("muffleWarning")
[17:26:47.175]                       }
[17:26:47.175]                       else if (inherits(cond, "condition")) {
[17:26:47.175]                         if (!is.null(pattern)) {
[17:26:47.175]                           computeRestarts <- base::computeRestarts
[17:26:47.175]                           grepl <- base::grepl
[17:26:47.175]                           restarts <- computeRestarts(cond)
[17:26:47.175]                           for (restart in restarts) {
[17:26:47.175]                             name <- restart$name
[17:26:47.175]                             if (is.null(name)) 
[17:26:47.175]                               next
[17:26:47.175]                             if (!grepl(pattern, name)) 
[17:26:47.175]                               next
[17:26:47.175]                             invokeRestart(restart)
[17:26:47.175]                             muffled <- TRUE
[17:26:47.175]                             break
[17:26:47.175]                           }
[17:26:47.175]                         }
[17:26:47.175]                       }
[17:26:47.175]                       invisible(muffled)
[17:26:47.175]                     }
[17:26:47.175]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.175]                   }
[17:26:47.175]                 }
[17:26:47.175]                 else {
[17:26:47.175]                   if (TRUE) {
[17:26:47.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.175]                     {
[17:26:47.175]                       inherits <- base::inherits
[17:26:47.175]                       invokeRestart <- base::invokeRestart
[17:26:47.175]                       is.null <- base::is.null
[17:26:47.175]                       muffled <- FALSE
[17:26:47.175]                       if (inherits(cond, "message")) {
[17:26:47.175]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.175]                         if (muffled) 
[17:26:47.175]                           invokeRestart("muffleMessage")
[17:26:47.175]                       }
[17:26:47.175]                       else if (inherits(cond, "warning")) {
[17:26:47.175]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.175]                         if (muffled) 
[17:26:47.175]                           invokeRestart("muffleWarning")
[17:26:47.175]                       }
[17:26:47.175]                       else if (inherits(cond, "condition")) {
[17:26:47.175]                         if (!is.null(pattern)) {
[17:26:47.175]                           computeRestarts <- base::computeRestarts
[17:26:47.175]                           grepl <- base::grepl
[17:26:47.175]                           restarts <- computeRestarts(cond)
[17:26:47.175]                           for (restart in restarts) {
[17:26:47.175]                             name <- restart$name
[17:26:47.175]                             if (is.null(name)) 
[17:26:47.175]                               next
[17:26:47.175]                             if (!grepl(pattern, name)) 
[17:26:47.175]                               next
[17:26:47.175]                             invokeRestart(restart)
[17:26:47.175]                             muffled <- TRUE
[17:26:47.175]                             break
[17:26:47.175]                           }
[17:26:47.175]                         }
[17:26:47.175]                       }
[17:26:47.175]                       invisible(muffled)
[17:26:47.175]                     }
[17:26:47.175]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.175]                   }
[17:26:47.175]                 }
[17:26:47.175]             }
[17:26:47.175]         }))
[17:26:47.175]     }, error = function(ex) {
[17:26:47.175]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.175]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.175]                 ...future.rng), started = ...future.startTime, 
[17:26:47.175]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.175]             version = "1.8"), class = "FutureResult")
[17:26:47.175]     }, finally = {
[17:26:47.175]         if (!identical(...future.workdir, getwd())) 
[17:26:47.175]             setwd(...future.workdir)
[17:26:47.175]         {
[17:26:47.175]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.175]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.175]             }
[17:26:47.175]             base::options(...future.oldOptions)
[17:26:47.175]             if (.Platform$OS.type == "windows") {
[17:26:47.175]                 old_names <- names(...future.oldEnvVars)
[17:26:47.175]                 envs <- base::Sys.getenv()
[17:26:47.175]                 names <- names(envs)
[17:26:47.175]                 common <- intersect(names, old_names)
[17:26:47.175]                 added <- setdiff(names, old_names)
[17:26:47.175]                 removed <- setdiff(old_names, names)
[17:26:47.175]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.175]                   envs[common]]
[17:26:47.175]                 NAMES <- toupper(changed)
[17:26:47.175]                 args <- list()
[17:26:47.175]                 for (kk in seq_along(NAMES)) {
[17:26:47.175]                   name <- changed[[kk]]
[17:26:47.175]                   NAME <- NAMES[[kk]]
[17:26:47.175]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.175]                     next
[17:26:47.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.175]                 }
[17:26:47.175]                 NAMES <- toupper(added)
[17:26:47.175]                 for (kk in seq_along(NAMES)) {
[17:26:47.175]                   name <- added[[kk]]
[17:26:47.175]                   NAME <- NAMES[[kk]]
[17:26:47.175]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.175]                     next
[17:26:47.175]                   args[[name]] <- ""
[17:26:47.175]                 }
[17:26:47.175]                 NAMES <- toupper(removed)
[17:26:47.175]                 for (kk in seq_along(NAMES)) {
[17:26:47.175]                   name <- removed[[kk]]
[17:26:47.175]                   NAME <- NAMES[[kk]]
[17:26:47.175]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.175]                     next
[17:26:47.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.175]                 }
[17:26:47.175]                 if (length(args) > 0) 
[17:26:47.175]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.175]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.175]             }
[17:26:47.175]             else {
[17:26:47.175]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.175]             }
[17:26:47.175]             {
[17:26:47.175]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.175]                   0L) {
[17:26:47.175]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.175]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.175]                   base::options(opts)
[17:26:47.175]                 }
[17:26:47.175]                 {
[17:26:47.175]                   {
[17:26:47.175]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.175]                     NULL
[17:26:47.175]                   }
[17:26:47.175]                   options(future.plan = NULL)
[17:26:47.175]                   if (is.na(NA_character_)) 
[17:26:47.175]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.175]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.175]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.175]                     .init = FALSE)
[17:26:47.175]                 }
[17:26:47.175]             }
[17:26:47.175]         }
[17:26:47.175]     })
[17:26:47.175]     if (TRUE) {
[17:26:47.175]         base::sink(type = "output", split = FALSE)
[17:26:47.175]         if (TRUE) {
[17:26:47.175]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.175]         }
[17:26:47.175]         else {
[17:26:47.175]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.175]         }
[17:26:47.175]         base::close(...future.stdout)
[17:26:47.175]         ...future.stdout <- NULL
[17:26:47.175]     }
[17:26:47.175]     ...future.result$conditions <- ...future.conditions
[17:26:47.175]     ...future.result$finished <- base::Sys.time()
[17:26:47.175]     ...future.result
[17:26:47.175] }
[17:26:47.180] MultisessionFuture started
[17:26:47.181] - Launch lazy future ... done
[17:26:47.181] run() for 'MultisessionFuture' ... done
[17:26:47.181] getGlobalsAndPackages() ...
[17:26:47.181] Searching for globals...
[17:26:47.182] 
[17:26:47.182] Searching for globals ... DONE
[17:26:47.182] - globals: [0] <none>
[17:26:47.182] getGlobalsAndPackages() ... DONE
[17:26:47.183] run() for 'Future' ...
[17:26:47.183] - state: 'created'
[17:26:47.183] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.197] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.197] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.197]   - Field: 'node'
[17:26:47.197]   - Field: 'label'
[17:26:47.198]   - Field: 'local'
[17:26:47.198]   - Field: 'owner'
[17:26:47.198]   - Field: 'envir'
[17:26:47.198]   - Field: 'workers'
[17:26:47.198]   - Field: 'packages'
[17:26:47.199]   - Field: 'gc'
[17:26:47.199]   - Field: 'conditions'
[17:26:47.199]   - Field: 'persistent'
[17:26:47.199]   - Field: 'expr'
[17:26:47.199]   - Field: 'uuid'
[17:26:47.199]   - Field: 'seed'
[17:26:47.200]   - Field: 'version'
[17:26:47.200]   - Field: 'result'
[17:26:47.200]   - Field: 'asynchronous'
[17:26:47.200]   - Field: 'calls'
[17:26:47.200]   - Field: 'globals'
[17:26:47.201]   - Field: 'stdout'
[17:26:47.201]   - Field: 'earlySignal'
[17:26:47.201]   - Field: 'lazy'
[17:26:47.201]   - Field: 'state'
[17:26:47.201] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.202] - Launch lazy future ...
[17:26:47.202] Packages needed by the future expression (n = 0): <none>
[17:26:47.202] Packages needed by future strategies (n = 0): <none>
[17:26:47.203] {
[17:26:47.203]     {
[17:26:47.203]         {
[17:26:47.203]             ...future.startTime <- base::Sys.time()
[17:26:47.203]             {
[17:26:47.203]                 {
[17:26:47.203]                   {
[17:26:47.203]                     {
[17:26:47.203]                       base::local({
[17:26:47.203]                         has_future <- base::requireNamespace("future", 
[17:26:47.203]                           quietly = TRUE)
[17:26:47.203]                         if (has_future) {
[17:26:47.203]                           ns <- base::getNamespace("future")
[17:26:47.203]                           version <- ns[[".package"]][["version"]]
[17:26:47.203]                           if (is.null(version)) 
[17:26:47.203]                             version <- utils::packageVersion("future")
[17:26:47.203]                         }
[17:26:47.203]                         else {
[17:26:47.203]                           version <- NULL
[17:26:47.203]                         }
[17:26:47.203]                         if (!has_future || version < "1.8.0") {
[17:26:47.203]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.203]                             "", base::R.version$version.string), 
[17:26:47.203]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.203]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.203]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.203]                               "release", "version")], collapse = " "), 
[17:26:47.203]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.203]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.203]                             info)
[17:26:47.203]                           info <- base::paste(info, collapse = "; ")
[17:26:47.203]                           if (!has_future) {
[17:26:47.203]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.203]                               info)
[17:26:47.203]                           }
[17:26:47.203]                           else {
[17:26:47.203]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.203]                               info, version)
[17:26:47.203]                           }
[17:26:47.203]                           base::stop(msg)
[17:26:47.203]                         }
[17:26:47.203]                       })
[17:26:47.203]                     }
[17:26:47.203]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.203]                     base::options(mc.cores = 1L)
[17:26:47.203]                   }
[17:26:47.203]                   ...future.strategy.old <- future::plan("list")
[17:26:47.203]                   options(future.plan = NULL)
[17:26:47.203]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.203]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.203]                 }
[17:26:47.203]                 ...future.workdir <- getwd()
[17:26:47.203]             }
[17:26:47.203]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.203]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.203]         }
[17:26:47.203]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.203]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.203]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.203]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.203]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.203]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.203]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.203]             base::names(...future.oldOptions))
[17:26:47.203]     }
[17:26:47.203]     if (FALSE) {
[17:26:47.203]     }
[17:26:47.203]     else {
[17:26:47.203]         if (TRUE) {
[17:26:47.203]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.203]                 open = "w")
[17:26:47.203]         }
[17:26:47.203]         else {
[17:26:47.203]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.203]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.203]         }
[17:26:47.203]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.203]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.203]             base::sink(type = "output", split = FALSE)
[17:26:47.203]             base::close(...future.stdout)
[17:26:47.203]         }, add = TRUE)
[17:26:47.203]     }
[17:26:47.203]     ...future.frame <- base::sys.nframe()
[17:26:47.203]     ...future.conditions <- base::list()
[17:26:47.203]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.203]     if (FALSE) {
[17:26:47.203]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.203]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.203]     }
[17:26:47.203]     ...future.result <- base::tryCatch({
[17:26:47.203]         base::withCallingHandlers({
[17:26:47.203]             ...future.value <- base::withVisible(base::local({
[17:26:47.203]                 ...future.makeSendCondition <- base::local({
[17:26:47.203]                   sendCondition <- NULL
[17:26:47.203]                   function(frame = 1L) {
[17:26:47.203]                     if (is.function(sendCondition)) 
[17:26:47.203]                       return(sendCondition)
[17:26:47.203]                     ns <- getNamespace("parallel")
[17:26:47.203]                     if (exists("sendData", mode = "function", 
[17:26:47.203]                       envir = ns)) {
[17:26:47.203]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.203]                         envir = ns)
[17:26:47.203]                       envir <- sys.frame(frame)
[17:26:47.203]                       master <- NULL
[17:26:47.203]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.203]                         !identical(envir, emptyenv())) {
[17:26:47.203]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.203]                           inherits = FALSE)) {
[17:26:47.203]                           master <- get("master", mode = "list", 
[17:26:47.203]                             envir = envir, inherits = FALSE)
[17:26:47.203]                           if (inherits(master, c("SOCKnode", 
[17:26:47.203]                             "SOCK0node"))) {
[17:26:47.203]                             sendCondition <<- function(cond) {
[17:26:47.203]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.203]                                 success = TRUE)
[17:26:47.203]                               parallel_sendData(master, data)
[17:26:47.203]                             }
[17:26:47.203]                             return(sendCondition)
[17:26:47.203]                           }
[17:26:47.203]                         }
[17:26:47.203]                         frame <- frame + 1L
[17:26:47.203]                         envir <- sys.frame(frame)
[17:26:47.203]                       }
[17:26:47.203]                     }
[17:26:47.203]                     sendCondition <<- function(cond) NULL
[17:26:47.203]                   }
[17:26:47.203]                 })
[17:26:47.203]                 withCallingHandlers({
[17:26:47.203]                   NULL
[17:26:47.203]                 }, immediateCondition = function(cond) {
[17:26:47.203]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.203]                   sendCondition(cond)
[17:26:47.203]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.203]                   {
[17:26:47.203]                     inherits <- base::inherits
[17:26:47.203]                     invokeRestart <- base::invokeRestart
[17:26:47.203]                     is.null <- base::is.null
[17:26:47.203]                     muffled <- FALSE
[17:26:47.203]                     if (inherits(cond, "message")) {
[17:26:47.203]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.203]                       if (muffled) 
[17:26:47.203]                         invokeRestart("muffleMessage")
[17:26:47.203]                     }
[17:26:47.203]                     else if (inherits(cond, "warning")) {
[17:26:47.203]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.203]                       if (muffled) 
[17:26:47.203]                         invokeRestart("muffleWarning")
[17:26:47.203]                     }
[17:26:47.203]                     else if (inherits(cond, "condition")) {
[17:26:47.203]                       if (!is.null(pattern)) {
[17:26:47.203]                         computeRestarts <- base::computeRestarts
[17:26:47.203]                         grepl <- base::grepl
[17:26:47.203]                         restarts <- computeRestarts(cond)
[17:26:47.203]                         for (restart in restarts) {
[17:26:47.203]                           name <- restart$name
[17:26:47.203]                           if (is.null(name)) 
[17:26:47.203]                             next
[17:26:47.203]                           if (!grepl(pattern, name)) 
[17:26:47.203]                             next
[17:26:47.203]                           invokeRestart(restart)
[17:26:47.203]                           muffled <- TRUE
[17:26:47.203]                           break
[17:26:47.203]                         }
[17:26:47.203]                       }
[17:26:47.203]                     }
[17:26:47.203]                     invisible(muffled)
[17:26:47.203]                   }
[17:26:47.203]                   muffleCondition(cond)
[17:26:47.203]                 })
[17:26:47.203]             }))
[17:26:47.203]             future::FutureResult(value = ...future.value$value, 
[17:26:47.203]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.203]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.203]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.203]                     ...future.globalenv.names))
[17:26:47.203]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.203]         }, condition = base::local({
[17:26:47.203]             c <- base::c
[17:26:47.203]             inherits <- base::inherits
[17:26:47.203]             invokeRestart <- base::invokeRestart
[17:26:47.203]             length <- base::length
[17:26:47.203]             list <- base::list
[17:26:47.203]             seq.int <- base::seq.int
[17:26:47.203]             signalCondition <- base::signalCondition
[17:26:47.203]             sys.calls <- base::sys.calls
[17:26:47.203]             `[[` <- base::`[[`
[17:26:47.203]             `+` <- base::`+`
[17:26:47.203]             `<<-` <- base::`<<-`
[17:26:47.203]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.203]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.203]                   3L)]
[17:26:47.203]             }
[17:26:47.203]             function(cond) {
[17:26:47.203]                 is_error <- inherits(cond, "error")
[17:26:47.203]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.203]                   NULL)
[17:26:47.203]                 if (is_error) {
[17:26:47.203]                   sessionInformation <- function() {
[17:26:47.203]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.203]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.203]                       search = base::search(), system = base::Sys.info())
[17:26:47.203]                   }
[17:26:47.203]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.203]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.203]                     cond$call), session = sessionInformation(), 
[17:26:47.203]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.203]                   signalCondition(cond)
[17:26:47.203]                 }
[17:26:47.203]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.203]                 "immediateCondition"))) {
[17:26:47.203]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.203]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.203]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.203]                   if (TRUE && !signal) {
[17:26:47.203]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.203]                     {
[17:26:47.203]                       inherits <- base::inherits
[17:26:47.203]                       invokeRestart <- base::invokeRestart
[17:26:47.203]                       is.null <- base::is.null
[17:26:47.203]                       muffled <- FALSE
[17:26:47.203]                       if (inherits(cond, "message")) {
[17:26:47.203]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.203]                         if (muffled) 
[17:26:47.203]                           invokeRestart("muffleMessage")
[17:26:47.203]                       }
[17:26:47.203]                       else if (inherits(cond, "warning")) {
[17:26:47.203]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.203]                         if (muffled) 
[17:26:47.203]                           invokeRestart("muffleWarning")
[17:26:47.203]                       }
[17:26:47.203]                       else if (inherits(cond, "condition")) {
[17:26:47.203]                         if (!is.null(pattern)) {
[17:26:47.203]                           computeRestarts <- base::computeRestarts
[17:26:47.203]                           grepl <- base::grepl
[17:26:47.203]                           restarts <- computeRestarts(cond)
[17:26:47.203]                           for (restart in restarts) {
[17:26:47.203]                             name <- restart$name
[17:26:47.203]                             if (is.null(name)) 
[17:26:47.203]                               next
[17:26:47.203]                             if (!grepl(pattern, name)) 
[17:26:47.203]                               next
[17:26:47.203]                             invokeRestart(restart)
[17:26:47.203]                             muffled <- TRUE
[17:26:47.203]                             break
[17:26:47.203]                           }
[17:26:47.203]                         }
[17:26:47.203]                       }
[17:26:47.203]                       invisible(muffled)
[17:26:47.203]                     }
[17:26:47.203]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.203]                   }
[17:26:47.203]                 }
[17:26:47.203]                 else {
[17:26:47.203]                   if (TRUE) {
[17:26:47.203]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.203]                     {
[17:26:47.203]                       inherits <- base::inherits
[17:26:47.203]                       invokeRestart <- base::invokeRestart
[17:26:47.203]                       is.null <- base::is.null
[17:26:47.203]                       muffled <- FALSE
[17:26:47.203]                       if (inherits(cond, "message")) {
[17:26:47.203]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.203]                         if (muffled) 
[17:26:47.203]                           invokeRestart("muffleMessage")
[17:26:47.203]                       }
[17:26:47.203]                       else if (inherits(cond, "warning")) {
[17:26:47.203]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.203]                         if (muffled) 
[17:26:47.203]                           invokeRestart("muffleWarning")
[17:26:47.203]                       }
[17:26:47.203]                       else if (inherits(cond, "condition")) {
[17:26:47.203]                         if (!is.null(pattern)) {
[17:26:47.203]                           computeRestarts <- base::computeRestarts
[17:26:47.203]                           grepl <- base::grepl
[17:26:47.203]                           restarts <- computeRestarts(cond)
[17:26:47.203]                           for (restart in restarts) {
[17:26:47.203]                             name <- restart$name
[17:26:47.203]                             if (is.null(name)) 
[17:26:47.203]                               next
[17:26:47.203]                             if (!grepl(pattern, name)) 
[17:26:47.203]                               next
[17:26:47.203]                             invokeRestart(restart)
[17:26:47.203]                             muffled <- TRUE
[17:26:47.203]                             break
[17:26:47.203]                           }
[17:26:47.203]                         }
[17:26:47.203]                       }
[17:26:47.203]                       invisible(muffled)
[17:26:47.203]                     }
[17:26:47.203]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.203]                   }
[17:26:47.203]                 }
[17:26:47.203]             }
[17:26:47.203]         }))
[17:26:47.203]     }, error = function(ex) {
[17:26:47.203]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.203]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.203]                 ...future.rng), started = ...future.startTime, 
[17:26:47.203]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.203]             version = "1.8"), class = "FutureResult")
[17:26:47.203]     }, finally = {
[17:26:47.203]         if (!identical(...future.workdir, getwd())) 
[17:26:47.203]             setwd(...future.workdir)
[17:26:47.203]         {
[17:26:47.203]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.203]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.203]             }
[17:26:47.203]             base::options(...future.oldOptions)
[17:26:47.203]             if (.Platform$OS.type == "windows") {
[17:26:47.203]                 old_names <- names(...future.oldEnvVars)
[17:26:47.203]                 envs <- base::Sys.getenv()
[17:26:47.203]                 names <- names(envs)
[17:26:47.203]                 common <- intersect(names, old_names)
[17:26:47.203]                 added <- setdiff(names, old_names)
[17:26:47.203]                 removed <- setdiff(old_names, names)
[17:26:47.203]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.203]                   envs[common]]
[17:26:47.203]                 NAMES <- toupper(changed)
[17:26:47.203]                 args <- list()
[17:26:47.203]                 for (kk in seq_along(NAMES)) {
[17:26:47.203]                   name <- changed[[kk]]
[17:26:47.203]                   NAME <- NAMES[[kk]]
[17:26:47.203]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.203]                     next
[17:26:47.203]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.203]                 }
[17:26:47.203]                 NAMES <- toupper(added)
[17:26:47.203]                 for (kk in seq_along(NAMES)) {
[17:26:47.203]                   name <- added[[kk]]
[17:26:47.203]                   NAME <- NAMES[[kk]]
[17:26:47.203]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.203]                     next
[17:26:47.203]                   args[[name]] <- ""
[17:26:47.203]                 }
[17:26:47.203]                 NAMES <- toupper(removed)
[17:26:47.203]                 for (kk in seq_along(NAMES)) {
[17:26:47.203]                   name <- removed[[kk]]
[17:26:47.203]                   NAME <- NAMES[[kk]]
[17:26:47.203]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.203]                     next
[17:26:47.203]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.203]                 }
[17:26:47.203]                 if (length(args) > 0) 
[17:26:47.203]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.203]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.203]             }
[17:26:47.203]             else {
[17:26:47.203]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.203]             }
[17:26:47.203]             {
[17:26:47.203]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.203]                   0L) {
[17:26:47.203]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.203]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.203]                   base::options(opts)
[17:26:47.203]                 }
[17:26:47.203]                 {
[17:26:47.203]                   {
[17:26:47.203]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.203]                     NULL
[17:26:47.203]                   }
[17:26:47.203]                   options(future.plan = NULL)
[17:26:47.203]                   if (is.na(NA_character_)) 
[17:26:47.203]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.203]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.203]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.203]                     .init = FALSE)
[17:26:47.203]                 }
[17:26:47.203]             }
[17:26:47.203]         }
[17:26:47.203]     })
[17:26:47.203]     if (TRUE) {
[17:26:47.203]         base::sink(type = "output", split = FALSE)
[17:26:47.203]         if (TRUE) {
[17:26:47.203]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.203]         }
[17:26:47.203]         else {
[17:26:47.203]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.203]         }
[17:26:47.203]         base::close(...future.stdout)
[17:26:47.203]         ...future.stdout <- NULL
[17:26:47.203]     }
[17:26:47.203]     ...future.result$conditions <- ...future.conditions
[17:26:47.203]     ...future.result$finished <- base::Sys.time()
[17:26:47.203]     ...future.result
[17:26:47.203] }
[17:26:47.209] MultisessionFuture started
[17:26:47.210] - Launch lazy future ... done
[17:26:47.210] run() for 'MultisessionFuture' ... done
[17:26:47.210] getGlobalsAndPackages() ...
[17:26:47.211] Searching for globals...
[17:26:47.211] - globals found: [1] '{'
[17:26:47.212] Searching for globals ... DONE
[17:26:47.212] Resolving globals: FALSE
[17:26:47.212] 
[17:26:47.213] 
[17:26:47.213] getGlobalsAndPackages() ... DONE
[17:26:47.213] run() for 'Future' ...
[17:26:47.213] - state: 'created'
[17:26:47.214] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.229] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.229] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.229]   - Field: 'node'
[17:26:47.230]   - Field: 'label'
[17:26:47.230]   - Field: 'local'
[17:26:47.230]   - Field: 'owner'
[17:26:47.230]   - Field: 'envir'
[17:26:47.231]   - Field: 'workers'
[17:26:47.231]   - Field: 'packages'
[17:26:47.231]   - Field: 'gc'
[17:26:47.231]   - Field: 'conditions'
[17:26:47.231]   - Field: 'persistent'
[17:26:47.232]   - Field: 'expr'
[17:26:47.232]   - Field: 'uuid'
[17:26:47.232]   - Field: 'seed'
[17:26:47.232]   - Field: 'version'
[17:26:47.232]   - Field: 'result'
[17:26:47.233]   - Field: 'asynchronous'
[17:26:47.233]   - Field: 'calls'
[17:26:47.233]   - Field: 'globals'
[17:26:47.233]   - Field: 'stdout'
[17:26:47.233]   - Field: 'earlySignal'
[17:26:47.234]   - Field: 'lazy'
[17:26:47.234]   - Field: 'state'
[17:26:47.234] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.234] - Launch lazy future ...
[17:26:47.234] Packages needed by the future expression (n = 0): <none>
[17:26:47.235] Packages needed by future strategies (n = 0): <none>
[17:26:47.235] {
[17:26:47.235]     {
[17:26:47.235]         {
[17:26:47.235]             ...future.startTime <- base::Sys.time()
[17:26:47.235]             {
[17:26:47.235]                 {
[17:26:47.235]                   {
[17:26:47.235]                     {
[17:26:47.235]                       base::local({
[17:26:47.235]                         has_future <- base::requireNamespace("future", 
[17:26:47.235]                           quietly = TRUE)
[17:26:47.235]                         if (has_future) {
[17:26:47.235]                           ns <- base::getNamespace("future")
[17:26:47.235]                           version <- ns[[".package"]][["version"]]
[17:26:47.235]                           if (is.null(version)) 
[17:26:47.235]                             version <- utils::packageVersion("future")
[17:26:47.235]                         }
[17:26:47.235]                         else {
[17:26:47.235]                           version <- NULL
[17:26:47.235]                         }
[17:26:47.235]                         if (!has_future || version < "1.8.0") {
[17:26:47.235]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.235]                             "", base::R.version$version.string), 
[17:26:47.235]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.235]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.235]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.235]                               "release", "version")], collapse = " "), 
[17:26:47.235]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.235]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.235]                             info)
[17:26:47.235]                           info <- base::paste(info, collapse = "; ")
[17:26:47.235]                           if (!has_future) {
[17:26:47.235]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.235]                               info)
[17:26:47.235]                           }
[17:26:47.235]                           else {
[17:26:47.235]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.235]                               info, version)
[17:26:47.235]                           }
[17:26:47.235]                           base::stop(msg)
[17:26:47.235]                         }
[17:26:47.235]                       })
[17:26:47.235]                     }
[17:26:47.235]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.235]                     base::options(mc.cores = 1L)
[17:26:47.235]                   }
[17:26:47.235]                   ...future.strategy.old <- future::plan("list")
[17:26:47.235]                   options(future.plan = NULL)
[17:26:47.235]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.235]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.235]                 }
[17:26:47.235]                 ...future.workdir <- getwd()
[17:26:47.235]             }
[17:26:47.235]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.235]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.235]         }
[17:26:47.235]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.235]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.235]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.235]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.235]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.235]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.235]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.235]             base::names(...future.oldOptions))
[17:26:47.235]     }
[17:26:47.235]     if (FALSE) {
[17:26:47.235]     }
[17:26:47.235]     else {
[17:26:47.235]         if (TRUE) {
[17:26:47.235]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.235]                 open = "w")
[17:26:47.235]         }
[17:26:47.235]         else {
[17:26:47.235]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.235]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.235]         }
[17:26:47.235]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.235]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.235]             base::sink(type = "output", split = FALSE)
[17:26:47.235]             base::close(...future.stdout)
[17:26:47.235]         }, add = TRUE)
[17:26:47.235]     }
[17:26:47.235]     ...future.frame <- base::sys.nframe()
[17:26:47.235]     ...future.conditions <- base::list()
[17:26:47.235]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.235]     if (FALSE) {
[17:26:47.235]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.235]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.235]     }
[17:26:47.235]     ...future.result <- base::tryCatch({
[17:26:47.235]         base::withCallingHandlers({
[17:26:47.235]             ...future.value <- base::withVisible(base::local({
[17:26:47.235]                 ...future.makeSendCondition <- base::local({
[17:26:47.235]                   sendCondition <- NULL
[17:26:47.235]                   function(frame = 1L) {
[17:26:47.235]                     if (is.function(sendCondition)) 
[17:26:47.235]                       return(sendCondition)
[17:26:47.235]                     ns <- getNamespace("parallel")
[17:26:47.235]                     if (exists("sendData", mode = "function", 
[17:26:47.235]                       envir = ns)) {
[17:26:47.235]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.235]                         envir = ns)
[17:26:47.235]                       envir <- sys.frame(frame)
[17:26:47.235]                       master <- NULL
[17:26:47.235]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.235]                         !identical(envir, emptyenv())) {
[17:26:47.235]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.235]                           inherits = FALSE)) {
[17:26:47.235]                           master <- get("master", mode = "list", 
[17:26:47.235]                             envir = envir, inherits = FALSE)
[17:26:47.235]                           if (inherits(master, c("SOCKnode", 
[17:26:47.235]                             "SOCK0node"))) {
[17:26:47.235]                             sendCondition <<- function(cond) {
[17:26:47.235]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.235]                                 success = TRUE)
[17:26:47.235]                               parallel_sendData(master, data)
[17:26:47.235]                             }
[17:26:47.235]                             return(sendCondition)
[17:26:47.235]                           }
[17:26:47.235]                         }
[17:26:47.235]                         frame <- frame + 1L
[17:26:47.235]                         envir <- sys.frame(frame)
[17:26:47.235]                       }
[17:26:47.235]                     }
[17:26:47.235]                     sendCondition <<- function(cond) NULL
[17:26:47.235]                   }
[17:26:47.235]                 })
[17:26:47.235]                 withCallingHandlers({
[17:26:47.235]                   {
[17:26:47.235]                     4
[17:26:47.235]                   }
[17:26:47.235]                 }, immediateCondition = function(cond) {
[17:26:47.235]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.235]                   sendCondition(cond)
[17:26:47.235]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.235]                   {
[17:26:47.235]                     inherits <- base::inherits
[17:26:47.235]                     invokeRestart <- base::invokeRestart
[17:26:47.235]                     is.null <- base::is.null
[17:26:47.235]                     muffled <- FALSE
[17:26:47.235]                     if (inherits(cond, "message")) {
[17:26:47.235]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.235]                       if (muffled) 
[17:26:47.235]                         invokeRestart("muffleMessage")
[17:26:47.235]                     }
[17:26:47.235]                     else if (inherits(cond, "warning")) {
[17:26:47.235]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.235]                       if (muffled) 
[17:26:47.235]                         invokeRestart("muffleWarning")
[17:26:47.235]                     }
[17:26:47.235]                     else if (inherits(cond, "condition")) {
[17:26:47.235]                       if (!is.null(pattern)) {
[17:26:47.235]                         computeRestarts <- base::computeRestarts
[17:26:47.235]                         grepl <- base::grepl
[17:26:47.235]                         restarts <- computeRestarts(cond)
[17:26:47.235]                         for (restart in restarts) {
[17:26:47.235]                           name <- restart$name
[17:26:47.235]                           if (is.null(name)) 
[17:26:47.235]                             next
[17:26:47.235]                           if (!grepl(pattern, name)) 
[17:26:47.235]                             next
[17:26:47.235]                           invokeRestart(restart)
[17:26:47.235]                           muffled <- TRUE
[17:26:47.235]                           break
[17:26:47.235]                         }
[17:26:47.235]                       }
[17:26:47.235]                     }
[17:26:47.235]                     invisible(muffled)
[17:26:47.235]                   }
[17:26:47.235]                   muffleCondition(cond)
[17:26:47.235]                 })
[17:26:47.235]             }))
[17:26:47.235]             future::FutureResult(value = ...future.value$value, 
[17:26:47.235]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.235]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.235]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.235]                     ...future.globalenv.names))
[17:26:47.235]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.235]         }, condition = base::local({
[17:26:47.235]             c <- base::c
[17:26:47.235]             inherits <- base::inherits
[17:26:47.235]             invokeRestart <- base::invokeRestart
[17:26:47.235]             length <- base::length
[17:26:47.235]             list <- base::list
[17:26:47.235]             seq.int <- base::seq.int
[17:26:47.235]             signalCondition <- base::signalCondition
[17:26:47.235]             sys.calls <- base::sys.calls
[17:26:47.235]             `[[` <- base::`[[`
[17:26:47.235]             `+` <- base::`+`
[17:26:47.235]             `<<-` <- base::`<<-`
[17:26:47.235]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.235]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.235]                   3L)]
[17:26:47.235]             }
[17:26:47.235]             function(cond) {
[17:26:47.235]                 is_error <- inherits(cond, "error")
[17:26:47.235]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.235]                   NULL)
[17:26:47.235]                 if (is_error) {
[17:26:47.235]                   sessionInformation <- function() {
[17:26:47.235]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.235]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.235]                       search = base::search(), system = base::Sys.info())
[17:26:47.235]                   }
[17:26:47.235]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.235]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.235]                     cond$call), session = sessionInformation(), 
[17:26:47.235]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.235]                   signalCondition(cond)
[17:26:47.235]                 }
[17:26:47.235]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.235]                 "immediateCondition"))) {
[17:26:47.235]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.235]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.235]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.235]                   if (TRUE && !signal) {
[17:26:47.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.235]                     {
[17:26:47.235]                       inherits <- base::inherits
[17:26:47.235]                       invokeRestart <- base::invokeRestart
[17:26:47.235]                       is.null <- base::is.null
[17:26:47.235]                       muffled <- FALSE
[17:26:47.235]                       if (inherits(cond, "message")) {
[17:26:47.235]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.235]                         if (muffled) 
[17:26:47.235]                           invokeRestart("muffleMessage")
[17:26:47.235]                       }
[17:26:47.235]                       else if (inherits(cond, "warning")) {
[17:26:47.235]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.235]                         if (muffled) 
[17:26:47.235]                           invokeRestart("muffleWarning")
[17:26:47.235]                       }
[17:26:47.235]                       else if (inherits(cond, "condition")) {
[17:26:47.235]                         if (!is.null(pattern)) {
[17:26:47.235]                           computeRestarts <- base::computeRestarts
[17:26:47.235]                           grepl <- base::grepl
[17:26:47.235]                           restarts <- computeRestarts(cond)
[17:26:47.235]                           for (restart in restarts) {
[17:26:47.235]                             name <- restart$name
[17:26:47.235]                             if (is.null(name)) 
[17:26:47.235]                               next
[17:26:47.235]                             if (!grepl(pattern, name)) 
[17:26:47.235]                               next
[17:26:47.235]                             invokeRestart(restart)
[17:26:47.235]                             muffled <- TRUE
[17:26:47.235]                             break
[17:26:47.235]                           }
[17:26:47.235]                         }
[17:26:47.235]                       }
[17:26:47.235]                       invisible(muffled)
[17:26:47.235]                     }
[17:26:47.235]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.235]                   }
[17:26:47.235]                 }
[17:26:47.235]                 else {
[17:26:47.235]                   if (TRUE) {
[17:26:47.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.235]                     {
[17:26:47.235]                       inherits <- base::inherits
[17:26:47.235]                       invokeRestart <- base::invokeRestart
[17:26:47.235]                       is.null <- base::is.null
[17:26:47.235]                       muffled <- FALSE
[17:26:47.235]                       if (inherits(cond, "message")) {
[17:26:47.235]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.235]                         if (muffled) 
[17:26:47.235]                           invokeRestart("muffleMessage")
[17:26:47.235]                       }
[17:26:47.235]                       else if (inherits(cond, "warning")) {
[17:26:47.235]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.235]                         if (muffled) 
[17:26:47.235]                           invokeRestart("muffleWarning")
[17:26:47.235]                       }
[17:26:47.235]                       else if (inherits(cond, "condition")) {
[17:26:47.235]                         if (!is.null(pattern)) {
[17:26:47.235]                           computeRestarts <- base::computeRestarts
[17:26:47.235]                           grepl <- base::grepl
[17:26:47.235]                           restarts <- computeRestarts(cond)
[17:26:47.235]                           for (restart in restarts) {
[17:26:47.235]                             name <- restart$name
[17:26:47.235]                             if (is.null(name)) 
[17:26:47.235]                               next
[17:26:47.235]                             if (!grepl(pattern, name)) 
[17:26:47.235]                               next
[17:26:47.235]                             invokeRestart(restart)
[17:26:47.235]                             muffled <- TRUE
[17:26:47.235]                             break
[17:26:47.235]                           }
[17:26:47.235]                         }
[17:26:47.235]                       }
[17:26:47.235]                       invisible(muffled)
[17:26:47.235]                     }
[17:26:47.235]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.235]                   }
[17:26:47.235]                 }
[17:26:47.235]             }
[17:26:47.235]         }))
[17:26:47.235]     }, error = function(ex) {
[17:26:47.235]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.235]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.235]                 ...future.rng), started = ...future.startTime, 
[17:26:47.235]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.235]             version = "1.8"), class = "FutureResult")
[17:26:47.235]     }, finally = {
[17:26:47.235]         if (!identical(...future.workdir, getwd())) 
[17:26:47.235]             setwd(...future.workdir)
[17:26:47.235]         {
[17:26:47.235]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.235]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.235]             }
[17:26:47.235]             base::options(...future.oldOptions)
[17:26:47.235]             if (.Platform$OS.type == "windows") {
[17:26:47.235]                 old_names <- names(...future.oldEnvVars)
[17:26:47.235]                 envs <- base::Sys.getenv()
[17:26:47.235]                 names <- names(envs)
[17:26:47.235]                 common <- intersect(names, old_names)
[17:26:47.235]                 added <- setdiff(names, old_names)
[17:26:47.235]                 removed <- setdiff(old_names, names)
[17:26:47.235]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.235]                   envs[common]]
[17:26:47.235]                 NAMES <- toupper(changed)
[17:26:47.235]                 args <- list()
[17:26:47.235]                 for (kk in seq_along(NAMES)) {
[17:26:47.235]                   name <- changed[[kk]]
[17:26:47.235]                   NAME <- NAMES[[kk]]
[17:26:47.235]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.235]                     next
[17:26:47.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.235]                 }
[17:26:47.235]                 NAMES <- toupper(added)
[17:26:47.235]                 for (kk in seq_along(NAMES)) {
[17:26:47.235]                   name <- added[[kk]]
[17:26:47.235]                   NAME <- NAMES[[kk]]
[17:26:47.235]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.235]                     next
[17:26:47.235]                   args[[name]] <- ""
[17:26:47.235]                 }
[17:26:47.235]                 NAMES <- toupper(removed)
[17:26:47.235]                 for (kk in seq_along(NAMES)) {
[17:26:47.235]                   name <- removed[[kk]]
[17:26:47.235]                   NAME <- NAMES[[kk]]
[17:26:47.235]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.235]                     next
[17:26:47.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.235]                 }
[17:26:47.235]                 if (length(args) > 0) 
[17:26:47.235]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.235]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.235]             }
[17:26:47.235]             else {
[17:26:47.235]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.235]             }
[17:26:47.235]             {
[17:26:47.235]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.235]                   0L) {
[17:26:47.235]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.235]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.235]                   base::options(opts)
[17:26:47.235]                 }
[17:26:47.235]                 {
[17:26:47.235]                   {
[17:26:47.235]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.235]                     NULL
[17:26:47.235]                   }
[17:26:47.235]                   options(future.plan = NULL)
[17:26:47.235]                   if (is.na(NA_character_)) 
[17:26:47.235]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.235]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.235]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.235]                     .init = FALSE)
[17:26:47.235]                 }
[17:26:47.235]             }
[17:26:47.235]         }
[17:26:47.235]     })
[17:26:47.235]     if (TRUE) {
[17:26:47.235]         base::sink(type = "output", split = FALSE)
[17:26:47.235]         if (TRUE) {
[17:26:47.235]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.235]         }
[17:26:47.235]         else {
[17:26:47.235]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.235]         }
[17:26:47.235]         base::close(...future.stdout)
[17:26:47.235]         ...future.stdout <- NULL
[17:26:47.235]     }
[17:26:47.235]     ...future.result$conditions <- ...future.conditions
[17:26:47.235]     ...future.result$finished <- base::Sys.time()
[17:26:47.235]     ...future.result
[17:26:47.235] }
[17:26:47.241] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:47.267] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.267] - Validating connection of MultisessionFuture
[17:26:47.267] - received message: FutureResult
[17:26:47.267] - Received FutureResult
[17:26:47.267] - Erased future from FutureRegistry
[17:26:47.268] result() for ClusterFuture ...
[17:26:47.268] - result already collected: FutureResult
[17:26:47.268] result() for ClusterFuture ... done
[17:26:47.268] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:47.268] result() for ClusterFuture ...
[17:26:47.268] - result already collected: FutureResult
[17:26:47.269] result() for ClusterFuture ... done
[17:26:47.269] result() for ClusterFuture ...
[17:26:47.269] - result already collected: FutureResult
[17:26:47.269] result() for ClusterFuture ... done
[17:26:47.270] MultisessionFuture started
[17:26:47.271] - Launch lazy future ... done
[17:26:47.271] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230f6b4ed8> 
Classes 'listenv', 'environment' <environment: 0x00000223109a1060> 
 - attr(*, "dim.")= int [1:3] 2 3 1
 - attr(*, "dimnames.")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:47.276] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.276] - Validating connection of MultisessionFuture
[17:26:47.276] - received message: FutureResult
[17:26:47.276] - Received FutureResult
[17:26:47.276] - Erased future from FutureRegistry
[17:26:47.277] result() for ClusterFuture ...
[17:26:47.277] - result already collected: FutureResult
[17:26:47.277] result() for ClusterFuture ... done
[17:26:47.277] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:47.288] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.288] - Validating connection of MultisessionFuture
[17:26:47.288] - received message: FutureResult
[17:26:47.288] - Received FutureResult
[17:26:47.289] - Erased future from FutureRegistry
[17:26:47.289] result() for ClusterFuture ...
[17:26:47.289] - result already collected: FutureResult
[17:26:47.289] result() for ClusterFuture ... done
[17:26:47.289] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1:2, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:47.292] resolve() on list environment ...
[17:26:47.293]  recursive: 0
[17:26:47.294]  length: 6
[17:26:47.294]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:47.294] signalConditionsASAP(numeric, pos=1) ...
[17:26:47.294] - nx: 6
[17:26:47.294] - relay: TRUE
[17:26:47.295] - stdout: TRUE
[17:26:47.295] - signal: TRUE
[17:26:47.295] - resignal: FALSE
[17:26:47.295] - force: TRUE
[17:26:47.295] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.295] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.296]  - until=2
[17:26:47.296]  - relaying element #2
[17:26:47.296] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.296] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.296] signalConditionsASAP(NULL, pos=1) ... done
[17:26:47.296]  length: 5 (resolved future 1)
[17:26:47.297] Future #2
[17:26:47.297] result() for ClusterFuture ...
[17:26:47.297] - result already collected: FutureResult
[17:26:47.297] result() for ClusterFuture ... done
[17:26:47.297] result() for ClusterFuture ...
[17:26:47.297] - result already collected: FutureResult
[17:26:47.301] result() for ClusterFuture ... done
[17:26:47.301] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:47.301] - nx: 6
[17:26:47.301] - relay: TRUE
[17:26:47.302] - stdout: TRUE
[17:26:47.302] - signal: TRUE
[17:26:47.302] - resignal: FALSE
[17:26:47.302] - force: TRUE
[17:26:47.302] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.302] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.303]  - until=2
[17:26:47.303]  - relaying element #2
[17:26:47.303] result() for ClusterFuture ...
[17:26:47.303] - result already collected: FutureResult
[17:26:47.303] result() for ClusterFuture ... done
[17:26:47.303] result() for ClusterFuture ...
[17:26:47.304] - result already collected: FutureResult
[17:26:47.304] result() for ClusterFuture ... done
[17:26:47.304] result() for ClusterFuture ...
[17:26:47.304] - result already collected: FutureResult
[17:26:47.304] result() for ClusterFuture ... done
[17:26:47.304] result() for ClusterFuture ...
[17:26:47.304] - result already collected: FutureResult
[17:26:47.305] result() for ClusterFuture ... done
[17:26:47.305] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.305] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.305] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:47.305]  length: 4 (resolved future 2)
[17:26:47.306] Future #3
[17:26:47.306] result() for ClusterFuture ...
[17:26:47.306] - result already collected: FutureResult
[17:26:47.306] result() for ClusterFuture ... done
[17:26:47.306] result() for ClusterFuture ...
[17:26:47.306] - result already collected: FutureResult
[17:26:47.306] result() for ClusterFuture ... done
[17:26:47.307] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:47.307] - nx: 6
[17:26:47.307] - relay: TRUE
[17:26:47.307] - stdout: TRUE
[17:26:47.307] - signal: TRUE
[17:26:47.307] - resignal: FALSE
[17:26:47.308] - force: TRUE
[17:26:47.308] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.308] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.308]  - until=3
[17:26:47.308]  - relaying element #3
[17:26:47.308] result() for ClusterFuture ...
[17:26:47.309] - result already collected: FutureResult
[17:26:47.309] result() for ClusterFuture ... done
[17:26:47.309] result() for ClusterFuture ...
[17:26:47.309] - result already collected: FutureResult
[17:26:47.309] result() for ClusterFuture ... done
[17:26:47.309] result() for ClusterFuture ...
[17:26:47.309] - result already collected: FutureResult
[17:26:47.310] result() for ClusterFuture ... done
[17:26:47.310] result() for ClusterFuture ...
[17:26:47.310] - result already collected: FutureResult
[17:26:47.310] result() for ClusterFuture ... done
[17:26:47.310] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.310] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.311] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:47.311]  length: 3 (resolved future 3)
[17:26:47.311] Future #4
[17:26:47.311] result() for ClusterFuture ...
[17:26:47.311] - result already collected: FutureResult
[17:26:47.311] result() for ClusterFuture ... done
[17:26:47.312] result() for ClusterFuture ...
[17:26:47.312] - result already collected: FutureResult
[17:26:47.312] result() for ClusterFuture ... done
[17:26:47.312] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:47.312] - nx: 6
[17:26:47.312] - relay: TRUE
[17:26:47.313] - stdout: TRUE
[17:26:47.313] - signal: TRUE
[17:26:47.313] - resignal: FALSE
[17:26:47.313] - force: TRUE
[17:26:47.313] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.313] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.313]  - until=4
[17:26:47.314]  - relaying element #4
[17:26:47.314] result() for ClusterFuture ...
[17:26:47.314] - result already collected: FutureResult
[17:26:47.314] result() for ClusterFuture ... done
[17:26:47.314] result() for ClusterFuture ...
[17:26:47.314] - result already collected: FutureResult
[17:26:47.315] result() for ClusterFuture ... done
[17:26:47.315] result() for ClusterFuture ...
[17:26:47.315] - result already collected: FutureResult
[17:26:47.315] result() for ClusterFuture ... done
[17:26:47.315] result() for ClusterFuture ...
[17:26:47.315] - result already collected: FutureResult
[17:26:47.316] result() for ClusterFuture ... done
[17:26:47.316] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.316] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.316] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:47.316]  length: 2 (resolved future 4)
[17:26:47.316] signalConditionsASAP(NULL, pos=5) ...
[17:26:47.317] - nx: 6
[17:26:47.317] - relay: TRUE
[17:26:47.317] - stdout: TRUE
[17:26:47.317] - signal: TRUE
[17:26:47.317] - resignal: FALSE
[17:26:47.317] - force: TRUE
[17:26:47.317] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.318] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.318]  - until=6
[17:26:47.318]  - relaying element #6
[17:26:47.318] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:47.318] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.318] signalConditionsASAP(NULL, pos=5) ... done
[17:26:47.319]  length: 1 (resolved future 5)
[17:26:47.319] signalConditionsASAP(numeric, pos=6) ...
[17:26:47.319] - nx: 6
[17:26:47.319] - relay: TRUE
[17:26:47.319] - stdout: TRUE
[17:26:47.319] - signal: TRUE
[17:26:47.320] - resignal: FALSE
[17:26:47.320] - force: TRUE
[17:26:47.320] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:47.320] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.320]  - until=6
[17:26:47.320] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.320] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.321] signalConditionsASAP(numeric, pos=6) ... done
[17:26:47.321]  length: 0 (resolved future 6)
[17:26:47.321] Relaying remaining futures
[17:26:47.321] signalConditionsASAP(NULL, pos=0) ...
[17:26:47.321] - nx: 6
[17:26:47.321] - relay: TRUE
[17:26:47.322] - stdout: TRUE
[17:26:47.322] - signal: TRUE
[17:26:47.322] - resignal: FALSE
[17:26:47.322] - force: TRUE
[17:26:47.322] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.322] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:47.323] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.323] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.323] signalConditionsASAP(NULL, pos=0) ... done
[17:26:47.323] resolve() on list environment ... DONE
[17:26:47.323] result() for ClusterFuture ...
[17:26:47.324] - result already collected: FutureResult
[17:26:47.324] result() for ClusterFuture ... done
[17:26:47.324] result() for ClusterFuture ...
[17:26:47.324] - result already collected: FutureResult
[17:26:47.324] result() for ClusterFuture ... done
[17:26:47.324] result() for ClusterFuture ...
[17:26:47.325] - result already collected: FutureResult
[17:26:47.325] result() for ClusterFuture ... done
[17:26:47.325] result() for ClusterFuture ...
[17:26:47.325] - result already collected: FutureResult
[17:26:47.325] result() for ClusterFuture ... done
[17:26:47.326] result() for ClusterFuture ...
[17:26:47.326] - result already collected: FutureResult
[17:26:47.326] result() for ClusterFuture ... done
[17:26:47.326] result() for ClusterFuture ...
[17:26:47.326] - result already collected: FutureResult
[17:26:47.326] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000022310ea8198> 
 - attr(*, "dim.")= int [1:3] 2 3 1
 - attr(*, "dimnames.")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
Dimensions: c(2, 1, 3, 1)
[17:26:47.329] getGlobalsAndPackages() ...
[17:26:47.329] Searching for globals...
[17:26:47.330] 
[17:26:47.330] Searching for globals ... DONE
[17:26:47.330] - globals: [0] <none>
[17:26:47.330] getGlobalsAndPackages() ... DONE
[17:26:47.330] run() for 'Future' ...
[17:26:47.331] - state: 'created'
[17:26:47.331] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.346] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.346] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.346]   - Field: 'node'
[17:26:47.346]   - Field: 'label'
[17:26:47.346]   - Field: 'local'
[17:26:47.347]   - Field: 'owner'
[17:26:47.347]   - Field: 'envir'
[17:26:47.347]   - Field: 'workers'
[17:26:47.347]   - Field: 'packages'
[17:26:47.347]   - Field: 'gc'
[17:26:47.347]   - Field: 'conditions'
[17:26:47.348]   - Field: 'persistent'
[17:26:47.348]   - Field: 'expr'
[17:26:47.348]   - Field: 'uuid'
[17:26:47.348]   - Field: 'seed'
[17:26:47.348]   - Field: 'version'
[17:26:47.348]   - Field: 'result'
[17:26:47.349]   - Field: 'asynchronous'
[17:26:47.349]   - Field: 'calls'
[17:26:47.349]   - Field: 'globals'
[17:26:47.349]   - Field: 'stdout'
[17:26:47.349]   - Field: 'earlySignal'
[17:26:47.350]   - Field: 'lazy'
[17:26:47.350]   - Field: 'state'
[17:26:47.350] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.350] - Launch lazy future ...
[17:26:47.351] Packages needed by the future expression (n = 0): <none>
[17:26:47.351] Packages needed by future strategies (n = 0): <none>
[17:26:47.351] {
[17:26:47.351]     {
[17:26:47.351]         {
[17:26:47.351]             ...future.startTime <- base::Sys.time()
[17:26:47.351]             {
[17:26:47.351]                 {
[17:26:47.351]                   {
[17:26:47.351]                     {
[17:26:47.351]                       base::local({
[17:26:47.351]                         has_future <- base::requireNamespace("future", 
[17:26:47.351]                           quietly = TRUE)
[17:26:47.351]                         if (has_future) {
[17:26:47.351]                           ns <- base::getNamespace("future")
[17:26:47.351]                           version <- ns[[".package"]][["version"]]
[17:26:47.351]                           if (is.null(version)) 
[17:26:47.351]                             version <- utils::packageVersion("future")
[17:26:47.351]                         }
[17:26:47.351]                         else {
[17:26:47.351]                           version <- NULL
[17:26:47.351]                         }
[17:26:47.351]                         if (!has_future || version < "1.8.0") {
[17:26:47.351]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.351]                             "", base::R.version$version.string), 
[17:26:47.351]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.351]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.351]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.351]                               "release", "version")], collapse = " "), 
[17:26:47.351]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.351]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.351]                             info)
[17:26:47.351]                           info <- base::paste(info, collapse = "; ")
[17:26:47.351]                           if (!has_future) {
[17:26:47.351]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.351]                               info)
[17:26:47.351]                           }
[17:26:47.351]                           else {
[17:26:47.351]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.351]                               info, version)
[17:26:47.351]                           }
[17:26:47.351]                           base::stop(msg)
[17:26:47.351]                         }
[17:26:47.351]                       })
[17:26:47.351]                     }
[17:26:47.351]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.351]                     base::options(mc.cores = 1L)
[17:26:47.351]                   }
[17:26:47.351]                   ...future.strategy.old <- future::plan("list")
[17:26:47.351]                   options(future.plan = NULL)
[17:26:47.351]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.351]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.351]                 }
[17:26:47.351]                 ...future.workdir <- getwd()
[17:26:47.351]             }
[17:26:47.351]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.351]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.351]         }
[17:26:47.351]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.351]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.351]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.351]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.351]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.351]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.351]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.351]             base::names(...future.oldOptions))
[17:26:47.351]     }
[17:26:47.351]     if (FALSE) {
[17:26:47.351]     }
[17:26:47.351]     else {
[17:26:47.351]         if (TRUE) {
[17:26:47.351]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.351]                 open = "w")
[17:26:47.351]         }
[17:26:47.351]         else {
[17:26:47.351]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.351]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.351]         }
[17:26:47.351]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.351]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.351]             base::sink(type = "output", split = FALSE)
[17:26:47.351]             base::close(...future.stdout)
[17:26:47.351]         }, add = TRUE)
[17:26:47.351]     }
[17:26:47.351]     ...future.frame <- base::sys.nframe()
[17:26:47.351]     ...future.conditions <- base::list()
[17:26:47.351]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.351]     if (FALSE) {
[17:26:47.351]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.351]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.351]     }
[17:26:47.351]     ...future.result <- base::tryCatch({
[17:26:47.351]         base::withCallingHandlers({
[17:26:47.351]             ...future.value <- base::withVisible(base::local({
[17:26:47.351]                 ...future.makeSendCondition <- base::local({
[17:26:47.351]                   sendCondition <- NULL
[17:26:47.351]                   function(frame = 1L) {
[17:26:47.351]                     if (is.function(sendCondition)) 
[17:26:47.351]                       return(sendCondition)
[17:26:47.351]                     ns <- getNamespace("parallel")
[17:26:47.351]                     if (exists("sendData", mode = "function", 
[17:26:47.351]                       envir = ns)) {
[17:26:47.351]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.351]                         envir = ns)
[17:26:47.351]                       envir <- sys.frame(frame)
[17:26:47.351]                       master <- NULL
[17:26:47.351]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.351]                         !identical(envir, emptyenv())) {
[17:26:47.351]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.351]                           inherits = FALSE)) {
[17:26:47.351]                           master <- get("master", mode = "list", 
[17:26:47.351]                             envir = envir, inherits = FALSE)
[17:26:47.351]                           if (inherits(master, c("SOCKnode", 
[17:26:47.351]                             "SOCK0node"))) {
[17:26:47.351]                             sendCondition <<- function(cond) {
[17:26:47.351]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.351]                                 success = TRUE)
[17:26:47.351]                               parallel_sendData(master, data)
[17:26:47.351]                             }
[17:26:47.351]                             return(sendCondition)
[17:26:47.351]                           }
[17:26:47.351]                         }
[17:26:47.351]                         frame <- frame + 1L
[17:26:47.351]                         envir <- sys.frame(frame)
[17:26:47.351]                       }
[17:26:47.351]                     }
[17:26:47.351]                     sendCondition <<- function(cond) NULL
[17:26:47.351]                   }
[17:26:47.351]                 })
[17:26:47.351]                 withCallingHandlers({
[17:26:47.351]                   2
[17:26:47.351]                 }, immediateCondition = function(cond) {
[17:26:47.351]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.351]                   sendCondition(cond)
[17:26:47.351]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.351]                   {
[17:26:47.351]                     inherits <- base::inherits
[17:26:47.351]                     invokeRestart <- base::invokeRestart
[17:26:47.351]                     is.null <- base::is.null
[17:26:47.351]                     muffled <- FALSE
[17:26:47.351]                     if (inherits(cond, "message")) {
[17:26:47.351]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.351]                       if (muffled) 
[17:26:47.351]                         invokeRestart("muffleMessage")
[17:26:47.351]                     }
[17:26:47.351]                     else if (inherits(cond, "warning")) {
[17:26:47.351]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.351]                       if (muffled) 
[17:26:47.351]                         invokeRestart("muffleWarning")
[17:26:47.351]                     }
[17:26:47.351]                     else if (inherits(cond, "condition")) {
[17:26:47.351]                       if (!is.null(pattern)) {
[17:26:47.351]                         computeRestarts <- base::computeRestarts
[17:26:47.351]                         grepl <- base::grepl
[17:26:47.351]                         restarts <- computeRestarts(cond)
[17:26:47.351]                         for (restart in restarts) {
[17:26:47.351]                           name <- restart$name
[17:26:47.351]                           if (is.null(name)) 
[17:26:47.351]                             next
[17:26:47.351]                           if (!grepl(pattern, name)) 
[17:26:47.351]                             next
[17:26:47.351]                           invokeRestart(restart)
[17:26:47.351]                           muffled <- TRUE
[17:26:47.351]                           break
[17:26:47.351]                         }
[17:26:47.351]                       }
[17:26:47.351]                     }
[17:26:47.351]                     invisible(muffled)
[17:26:47.351]                   }
[17:26:47.351]                   muffleCondition(cond)
[17:26:47.351]                 })
[17:26:47.351]             }))
[17:26:47.351]             future::FutureResult(value = ...future.value$value, 
[17:26:47.351]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.351]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.351]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.351]                     ...future.globalenv.names))
[17:26:47.351]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.351]         }, condition = base::local({
[17:26:47.351]             c <- base::c
[17:26:47.351]             inherits <- base::inherits
[17:26:47.351]             invokeRestart <- base::invokeRestart
[17:26:47.351]             length <- base::length
[17:26:47.351]             list <- base::list
[17:26:47.351]             seq.int <- base::seq.int
[17:26:47.351]             signalCondition <- base::signalCondition
[17:26:47.351]             sys.calls <- base::sys.calls
[17:26:47.351]             `[[` <- base::`[[`
[17:26:47.351]             `+` <- base::`+`
[17:26:47.351]             `<<-` <- base::`<<-`
[17:26:47.351]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.351]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.351]                   3L)]
[17:26:47.351]             }
[17:26:47.351]             function(cond) {
[17:26:47.351]                 is_error <- inherits(cond, "error")
[17:26:47.351]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.351]                   NULL)
[17:26:47.351]                 if (is_error) {
[17:26:47.351]                   sessionInformation <- function() {
[17:26:47.351]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.351]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.351]                       search = base::search(), system = base::Sys.info())
[17:26:47.351]                   }
[17:26:47.351]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.351]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.351]                     cond$call), session = sessionInformation(), 
[17:26:47.351]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.351]                   signalCondition(cond)
[17:26:47.351]                 }
[17:26:47.351]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.351]                 "immediateCondition"))) {
[17:26:47.351]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.351]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.351]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.351]                   if (TRUE && !signal) {
[17:26:47.351]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.351]                     {
[17:26:47.351]                       inherits <- base::inherits
[17:26:47.351]                       invokeRestart <- base::invokeRestart
[17:26:47.351]                       is.null <- base::is.null
[17:26:47.351]                       muffled <- FALSE
[17:26:47.351]                       if (inherits(cond, "message")) {
[17:26:47.351]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.351]                         if (muffled) 
[17:26:47.351]                           invokeRestart("muffleMessage")
[17:26:47.351]                       }
[17:26:47.351]                       else if (inherits(cond, "warning")) {
[17:26:47.351]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.351]                         if (muffled) 
[17:26:47.351]                           invokeRestart("muffleWarning")
[17:26:47.351]                       }
[17:26:47.351]                       else if (inherits(cond, "condition")) {
[17:26:47.351]                         if (!is.null(pattern)) {
[17:26:47.351]                           computeRestarts <- base::computeRestarts
[17:26:47.351]                           grepl <- base::grepl
[17:26:47.351]                           restarts <- computeRestarts(cond)
[17:26:47.351]                           for (restart in restarts) {
[17:26:47.351]                             name <- restart$name
[17:26:47.351]                             if (is.null(name)) 
[17:26:47.351]                               next
[17:26:47.351]                             if (!grepl(pattern, name)) 
[17:26:47.351]                               next
[17:26:47.351]                             invokeRestart(restart)
[17:26:47.351]                             muffled <- TRUE
[17:26:47.351]                             break
[17:26:47.351]                           }
[17:26:47.351]                         }
[17:26:47.351]                       }
[17:26:47.351]                       invisible(muffled)
[17:26:47.351]                     }
[17:26:47.351]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.351]                   }
[17:26:47.351]                 }
[17:26:47.351]                 else {
[17:26:47.351]                   if (TRUE) {
[17:26:47.351]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.351]                     {
[17:26:47.351]                       inherits <- base::inherits
[17:26:47.351]                       invokeRestart <- base::invokeRestart
[17:26:47.351]                       is.null <- base::is.null
[17:26:47.351]                       muffled <- FALSE
[17:26:47.351]                       if (inherits(cond, "message")) {
[17:26:47.351]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.351]                         if (muffled) 
[17:26:47.351]                           invokeRestart("muffleMessage")
[17:26:47.351]                       }
[17:26:47.351]                       else if (inherits(cond, "warning")) {
[17:26:47.351]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.351]                         if (muffled) 
[17:26:47.351]                           invokeRestart("muffleWarning")
[17:26:47.351]                       }
[17:26:47.351]                       else if (inherits(cond, "condition")) {
[17:26:47.351]                         if (!is.null(pattern)) {
[17:26:47.351]                           computeRestarts <- base::computeRestarts
[17:26:47.351]                           grepl <- base::grepl
[17:26:47.351]                           restarts <- computeRestarts(cond)
[17:26:47.351]                           for (restart in restarts) {
[17:26:47.351]                             name <- restart$name
[17:26:47.351]                             if (is.null(name)) 
[17:26:47.351]                               next
[17:26:47.351]                             if (!grepl(pattern, name)) 
[17:26:47.351]                               next
[17:26:47.351]                             invokeRestart(restart)
[17:26:47.351]                             muffled <- TRUE
[17:26:47.351]                             break
[17:26:47.351]                           }
[17:26:47.351]                         }
[17:26:47.351]                       }
[17:26:47.351]                       invisible(muffled)
[17:26:47.351]                     }
[17:26:47.351]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.351]                   }
[17:26:47.351]                 }
[17:26:47.351]             }
[17:26:47.351]         }))
[17:26:47.351]     }, error = function(ex) {
[17:26:47.351]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.351]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.351]                 ...future.rng), started = ...future.startTime, 
[17:26:47.351]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.351]             version = "1.8"), class = "FutureResult")
[17:26:47.351]     }, finally = {
[17:26:47.351]         if (!identical(...future.workdir, getwd())) 
[17:26:47.351]             setwd(...future.workdir)
[17:26:47.351]         {
[17:26:47.351]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.351]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.351]             }
[17:26:47.351]             base::options(...future.oldOptions)
[17:26:47.351]             if (.Platform$OS.type == "windows") {
[17:26:47.351]                 old_names <- names(...future.oldEnvVars)
[17:26:47.351]                 envs <- base::Sys.getenv()
[17:26:47.351]                 names <- names(envs)
[17:26:47.351]                 common <- intersect(names, old_names)
[17:26:47.351]                 added <- setdiff(names, old_names)
[17:26:47.351]                 removed <- setdiff(old_names, names)
[17:26:47.351]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.351]                   envs[common]]
[17:26:47.351]                 NAMES <- toupper(changed)
[17:26:47.351]                 args <- list()
[17:26:47.351]                 for (kk in seq_along(NAMES)) {
[17:26:47.351]                   name <- changed[[kk]]
[17:26:47.351]                   NAME <- NAMES[[kk]]
[17:26:47.351]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.351]                     next
[17:26:47.351]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.351]                 }
[17:26:47.351]                 NAMES <- toupper(added)
[17:26:47.351]                 for (kk in seq_along(NAMES)) {
[17:26:47.351]                   name <- added[[kk]]
[17:26:47.351]                   NAME <- NAMES[[kk]]
[17:26:47.351]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.351]                     next
[17:26:47.351]                   args[[name]] <- ""
[17:26:47.351]                 }
[17:26:47.351]                 NAMES <- toupper(removed)
[17:26:47.351]                 for (kk in seq_along(NAMES)) {
[17:26:47.351]                   name <- removed[[kk]]
[17:26:47.351]                   NAME <- NAMES[[kk]]
[17:26:47.351]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.351]                     next
[17:26:47.351]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.351]                 }
[17:26:47.351]                 if (length(args) > 0) 
[17:26:47.351]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.351]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.351]             }
[17:26:47.351]             else {
[17:26:47.351]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.351]             }
[17:26:47.351]             {
[17:26:47.351]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.351]                   0L) {
[17:26:47.351]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.351]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.351]                   base::options(opts)
[17:26:47.351]                 }
[17:26:47.351]                 {
[17:26:47.351]                   {
[17:26:47.351]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.351]                     NULL
[17:26:47.351]                   }
[17:26:47.351]                   options(future.plan = NULL)
[17:26:47.351]                   if (is.na(NA_character_)) 
[17:26:47.351]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.351]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.351]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.351]                     .init = FALSE)
[17:26:47.351]                 }
[17:26:47.351]             }
[17:26:47.351]         }
[17:26:47.351]     })
[17:26:47.351]     if (TRUE) {
[17:26:47.351]         base::sink(type = "output", split = FALSE)
[17:26:47.351]         if (TRUE) {
[17:26:47.351]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.351]         }
[17:26:47.351]         else {
[17:26:47.351]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.351]         }
[17:26:47.351]         base::close(...future.stdout)
[17:26:47.351]         ...future.stdout <- NULL
[17:26:47.351]     }
[17:26:47.351]     ...future.result$conditions <- ...future.conditions
[17:26:47.351]     ...future.result$finished <- base::Sys.time()
[17:26:47.351]     ...future.result
[17:26:47.351] }
[17:26:47.357] MultisessionFuture started
[17:26:47.357] - Launch lazy future ... done
[17:26:47.358] run() for 'MultisessionFuture' ... done
[17:26:47.358] getGlobalsAndPackages() ...
[17:26:47.358] Searching for globals...
[17:26:47.358] 
[17:26:47.359] Searching for globals ... DONE
[17:26:47.359] - globals: [0] <none>
[17:26:47.359] getGlobalsAndPackages() ... DONE
[17:26:47.359] run() for 'Future' ...
[17:26:47.359] - state: 'created'
[17:26:47.360] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.373] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.374] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.374]   - Field: 'node'
[17:26:47.374]   - Field: 'label'
[17:26:47.374]   - Field: 'local'
[17:26:47.374]   - Field: 'owner'
[17:26:47.374]   - Field: 'envir'
[17:26:47.375]   - Field: 'workers'
[17:26:47.375]   - Field: 'packages'
[17:26:47.375]   - Field: 'gc'
[17:26:47.375]   - Field: 'conditions'
[17:26:47.375]   - Field: 'persistent'
[17:26:47.376]   - Field: 'expr'
[17:26:47.376]   - Field: 'uuid'
[17:26:47.376]   - Field: 'seed'
[17:26:47.376]   - Field: 'version'
[17:26:47.376]   - Field: 'result'
[17:26:47.376]   - Field: 'asynchronous'
[17:26:47.377]   - Field: 'calls'
[17:26:47.377]   - Field: 'globals'
[17:26:47.377]   - Field: 'stdout'
[17:26:47.377]   - Field: 'earlySignal'
[17:26:47.377]   - Field: 'lazy'
[17:26:47.378]   - Field: 'state'
[17:26:47.378] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.378] - Launch lazy future ...
[17:26:47.378] Packages needed by the future expression (n = 0): <none>
[17:26:47.379] Packages needed by future strategies (n = 0): <none>
[17:26:47.379] {
[17:26:47.379]     {
[17:26:47.379]         {
[17:26:47.379]             ...future.startTime <- base::Sys.time()
[17:26:47.379]             {
[17:26:47.379]                 {
[17:26:47.379]                   {
[17:26:47.379]                     {
[17:26:47.379]                       base::local({
[17:26:47.379]                         has_future <- base::requireNamespace("future", 
[17:26:47.379]                           quietly = TRUE)
[17:26:47.379]                         if (has_future) {
[17:26:47.379]                           ns <- base::getNamespace("future")
[17:26:47.379]                           version <- ns[[".package"]][["version"]]
[17:26:47.379]                           if (is.null(version)) 
[17:26:47.379]                             version <- utils::packageVersion("future")
[17:26:47.379]                         }
[17:26:47.379]                         else {
[17:26:47.379]                           version <- NULL
[17:26:47.379]                         }
[17:26:47.379]                         if (!has_future || version < "1.8.0") {
[17:26:47.379]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.379]                             "", base::R.version$version.string), 
[17:26:47.379]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.379]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.379]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.379]                               "release", "version")], collapse = " "), 
[17:26:47.379]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.379]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.379]                             info)
[17:26:47.379]                           info <- base::paste(info, collapse = "; ")
[17:26:47.379]                           if (!has_future) {
[17:26:47.379]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.379]                               info)
[17:26:47.379]                           }
[17:26:47.379]                           else {
[17:26:47.379]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.379]                               info, version)
[17:26:47.379]                           }
[17:26:47.379]                           base::stop(msg)
[17:26:47.379]                         }
[17:26:47.379]                       })
[17:26:47.379]                     }
[17:26:47.379]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.379]                     base::options(mc.cores = 1L)
[17:26:47.379]                   }
[17:26:47.379]                   ...future.strategy.old <- future::plan("list")
[17:26:47.379]                   options(future.plan = NULL)
[17:26:47.379]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.379]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.379]                 }
[17:26:47.379]                 ...future.workdir <- getwd()
[17:26:47.379]             }
[17:26:47.379]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.379]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.379]         }
[17:26:47.379]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.379]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.379]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.379]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.379]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.379]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.379]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.379]             base::names(...future.oldOptions))
[17:26:47.379]     }
[17:26:47.379]     if (FALSE) {
[17:26:47.379]     }
[17:26:47.379]     else {
[17:26:47.379]         if (TRUE) {
[17:26:47.379]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.379]                 open = "w")
[17:26:47.379]         }
[17:26:47.379]         else {
[17:26:47.379]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.379]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.379]         }
[17:26:47.379]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.379]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.379]             base::sink(type = "output", split = FALSE)
[17:26:47.379]             base::close(...future.stdout)
[17:26:47.379]         }, add = TRUE)
[17:26:47.379]     }
[17:26:47.379]     ...future.frame <- base::sys.nframe()
[17:26:47.379]     ...future.conditions <- base::list()
[17:26:47.379]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.379]     if (FALSE) {
[17:26:47.379]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.379]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.379]     }
[17:26:47.379]     ...future.result <- base::tryCatch({
[17:26:47.379]         base::withCallingHandlers({
[17:26:47.379]             ...future.value <- base::withVisible(base::local({
[17:26:47.379]                 ...future.makeSendCondition <- base::local({
[17:26:47.379]                   sendCondition <- NULL
[17:26:47.379]                   function(frame = 1L) {
[17:26:47.379]                     if (is.function(sendCondition)) 
[17:26:47.379]                       return(sendCondition)
[17:26:47.379]                     ns <- getNamespace("parallel")
[17:26:47.379]                     if (exists("sendData", mode = "function", 
[17:26:47.379]                       envir = ns)) {
[17:26:47.379]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.379]                         envir = ns)
[17:26:47.379]                       envir <- sys.frame(frame)
[17:26:47.379]                       master <- NULL
[17:26:47.379]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.379]                         !identical(envir, emptyenv())) {
[17:26:47.379]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.379]                           inherits = FALSE)) {
[17:26:47.379]                           master <- get("master", mode = "list", 
[17:26:47.379]                             envir = envir, inherits = FALSE)
[17:26:47.379]                           if (inherits(master, c("SOCKnode", 
[17:26:47.379]                             "SOCK0node"))) {
[17:26:47.379]                             sendCondition <<- function(cond) {
[17:26:47.379]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.379]                                 success = TRUE)
[17:26:47.379]                               parallel_sendData(master, data)
[17:26:47.379]                             }
[17:26:47.379]                             return(sendCondition)
[17:26:47.379]                           }
[17:26:47.379]                         }
[17:26:47.379]                         frame <- frame + 1L
[17:26:47.379]                         envir <- sys.frame(frame)
[17:26:47.379]                       }
[17:26:47.379]                     }
[17:26:47.379]                     sendCondition <<- function(cond) NULL
[17:26:47.379]                   }
[17:26:47.379]                 })
[17:26:47.379]                 withCallingHandlers({
[17:26:47.379]                   NULL
[17:26:47.379]                 }, immediateCondition = function(cond) {
[17:26:47.379]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.379]                   sendCondition(cond)
[17:26:47.379]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.379]                   {
[17:26:47.379]                     inherits <- base::inherits
[17:26:47.379]                     invokeRestart <- base::invokeRestart
[17:26:47.379]                     is.null <- base::is.null
[17:26:47.379]                     muffled <- FALSE
[17:26:47.379]                     if (inherits(cond, "message")) {
[17:26:47.379]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.379]                       if (muffled) 
[17:26:47.379]                         invokeRestart("muffleMessage")
[17:26:47.379]                     }
[17:26:47.379]                     else if (inherits(cond, "warning")) {
[17:26:47.379]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.379]                       if (muffled) 
[17:26:47.379]                         invokeRestart("muffleWarning")
[17:26:47.379]                     }
[17:26:47.379]                     else if (inherits(cond, "condition")) {
[17:26:47.379]                       if (!is.null(pattern)) {
[17:26:47.379]                         computeRestarts <- base::computeRestarts
[17:26:47.379]                         grepl <- base::grepl
[17:26:47.379]                         restarts <- computeRestarts(cond)
[17:26:47.379]                         for (restart in restarts) {
[17:26:47.379]                           name <- restart$name
[17:26:47.379]                           if (is.null(name)) 
[17:26:47.379]                             next
[17:26:47.379]                           if (!grepl(pattern, name)) 
[17:26:47.379]                             next
[17:26:47.379]                           invokeRestart(restart)
[17:26:47.379]                           muffled <- TRUE
[17:26:47.379]                           break
[17:26:47.379]                         }
[17:26:47.379]                       }
[17:26:47.379]                     }
[17:26:47.379]                     invisible(muffled)
[17:26:47.379]                   }
[17:26:47.379]                   muffleCondition(cond)
[17:26:47.379]                 })
[17:26:47.379]             }))
[17:26:47.379]             future::FutureResult(value = ...future.value$value, 
[17:26:47.379]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.379]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.379]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.379]                     ...future.globalenv.names))
[17:26:47.379]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.379]         }, condition = base::local({
[17:26:47.379]             c <- base::c
[17:26:47.379]             inherits <- base::inherits
[17:26:47.379]             invokeRestart <- base::invokeRestart
[17:26:47.379]             length <- base::length
[17:26:47.379]             list <- base::list
[17:26:47.379]             seq.int <- base::seq.int
[17:26:47.379]             signalCondition <- base::signalCondition
[17:26:47.379]             sys.calls <- base::sys.calls
[17:26:47.379]             `[[` <- base::`[[`
[17:26:47.379]             `+` <- base::`+`
[17:26:47.379]             `<<-` <- base::`<<-`
[17:26:47.379]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.379]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.379]                   3L)]
[17:26:47.379]             }
[17:26:47.379]             function(cond) {
[17:26:47.379]                 is_error <- inherits(cond, "error")
[17:26:47.379]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.379]                   NULL)
[17:26:47.379]                 if (is_error) {
[17:26:47.379]                   sessionInformation <- function() {
[17:26:47.379]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.379]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.379]                       search = base::search(), system = base::Sys.info())
[17:26:47.379]                   }
[17:26:47.379]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.379]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.379]                     cond$call), session = sessionInformation(), 
[17:26:47.379]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.379]                   signalCondition(cond)
[17:26:47.379]                 }
[17:26:47.379]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.379]                 "immediateCondition"))) {
[17:26:47.379]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.379]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.379]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.379]                   if (TRUE && !signal) {
[17:26:47.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.379]                     {
[17:26:47.379]                       inherits <- base::inherits
[17:26:47.379]                       invokeRestart <- base::invokeRestart
[17:26:47.379]                       is.null <- base::is.null
[17:26:47.379]                       muffled <- FALSE
[17:26:47.379]                       if (inherits(cond, "message")) {
[17:26:47.379]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.379]                         if (muffled) 
[17:26:47.379]                           invokeRestart("muffleMessage")
[17:26:47.379]                       }
[17:26:47.379]                       else if (inherits(cond, "warning")) {
[17:26:47.379]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.379]                         if (muffled) 
[17:26:47.379]                           invokeRestart("muffleWarning")
[17:26:47.379]                       }
[17:26:47.379]                       else if (inherits(cond, "condition")) {
[17:26:47.379]                         if (!is.null(pattern)) {
[17:26:47.379]                           computeRestarts <- base::computeRestarts
[17:26:47.379]                           grepl <- base::grepl
[17:26:47.379]                           restarts <- computeRestarts(cond)
[17:26:47.379]                           for (restart in restarts) {
[17:26:47.379]                             name <- restart$name
[17:26:47.379]                             if (is.null(name)) 
[17:26:47.379]                               next
[17:26:47.379]                             if (!grepl(pattern, name)) 
[17:26:47.379]                               next
[17:26:47.379]                             invokeRestart(restart)
[17:26:47.379]                             muffled <- TRUE
[17:26:47.379]                             break
[17:26:47.379]                           }
[17:26:47.379]                         }
[17:26:47.379]                       }
[17:26:47.379]                       invisible(muffled)
[17:26:47.379]                     }
[17:26:47.379]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.379]                   }
[17:26:47.379]                 }
[17:26:47.379]                 else {
[17:26:47.379]                   if (TRUE) {
[17:26:47.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.379]                     {
[17:26:47.379]                       inherits <- base::inherits
[17:26:47.379]                       invokeRestart <- base::invokeRestart
[17:26:47.379]                       is.null <- base::is.null
[17:26:47.379]                       muffled <- FALSE
[17:26:47.379]                       if (inherits(cond, "message")) {
[17:26:47.379]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.379]                         if (muffled) 
[17:26:47.379]                           invokeRestart("muffleMessage")
[17:26:47.379]                       }
[17:26:47.379]                       else if (inherits(cond, "warning")) {
[17:26:47.379]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.379]                         if (muffled) 
[17:26:47.379]                           invokeRestart("muffleWarning")
[17:26:47.379]                       }
[17:26:47.379]                       else if (inherits(cond, "condition")) {
[17:26:47.379]                         if (!is.null(pattern)) {
[17:26:47.379]                           computeRestarts <- base::computeRestarts
[17:26:47.379]                           grepl <- base::grepl
[17:26:47.379]                           restarts <- computeRestarts(cond)
[17:26:47.379]                           for (restart in restarts) {
[17:26:47.379]                             name <- restart$name
[17:26:47.379]                             if (is.null(name)) 
[17:26:47.379]                               next
[17:26:47.379]                             if (!grepl(pattern, name)) 
[17:26:47.379]                               next
[17:26:47.379]                             invokeRestart(restart)
[17:26:47.379]                             muffled <- TRUE
[17:26:47.379]                             break
[17:26:47.379]                           }
[17:26:47.379]                         }
[17:26:47.379]                       }
[17:26:47.379]                       invisible(muffled)
[17:26:47.379]                     }
[17:26:47.379]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.379]                   }
[17:26:47.379]                 }
[17:26:47.379]             }
[17:26:47.379]         }))
[17:26:47.379]     }, error = function(ex) {
[17:26:47.379]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.379]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.379]                 ...future.rng), started = ...future.startTime, 
[17:26:47.379]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.379]             version = "1.8"), class = "FutureResult")
[17:26:47.379]     }, finally = {
[17:26:47.379]         if (!identical(...future.workdir, getwd())) 
[17:26:47.379]             setwd(...future.workdir)
[17:26:47.379]         {
[17:26:47.379]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.379]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.379]             }
[17:26:47.379]             base::options(...future.oldOptions)
[17:26:47.379]             if (.Platform$OS.type == "windows") {
[17:26:47.379]                 old_names <- names(...future.oldEnvVars)
[17:26:47.379]                 envs <- base::Sys.getenv()
[17:26:47.379]                 names <- names(envs)
[17:26:47.379]                 common <- intersect(names, old_names)
[17:26:47.379]                 added <- setdiff(names, old_names)
[17:26:47.379]                 removed <- setdiff(old_names, names)
[17:26:47.379]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.379]                   envs[common]]
[17:26:47.379]                 NAMES <- toupper(changed)
[17:26:47.379]                 args <- list()
[17:26:47.379]                 for (kk in seq_along(NAMES)) {
[17:26:47.379]                   name <- changed[[kk]]
[17:26:47.379]                   NAME <- NAMES[[kk]]
[17:26:47.379]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.379]                     next
[17:26:47.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.379]                 }
[17:26:47.379]                 NAMES <- toupper(added)
[17:26:47.379]                 for (kk in seq_along(NAMES)) {
[17:26:47.379]                   name <- added[[kk]]
[17:26:47.379]                   NAME <- NAMES[[kk]]
[17:26:47.379]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.379]                     next
[17:26:47.379]                   args[[name]] <- ""
[17:26:47.379]                 }
[17:26:47.379]                 NAMES <- toupper(removed)
[17:26:47.379]                 for (kk in seq_along(NAMES)) {
[17:26:47.379]                   name <- removed[[kk]]
[17:26:47.379]                   NAME <- NAMES[[kk]]
[17:26:47.379]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.379]                     next
[17:26:47.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.379]                 }
[17:26:47.379]                 if (length(args) > 0) 
[17:26:47.379]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.379]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.379]             }
[17:26:47.379]             else {
[17:26:47.379]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.379]             }
[17:26:47.379]             {
[17:26:47.379]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.379]                   0L) {
[17:26:47.379]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.379]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.379]                   base::options(opts)
[17:26:47.379]                 }
[17:26:47.379]                 {
[17:26:47.379]                   {
[17:26:47.379]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.379]                     NULL
[17:26:47.379]                   }
[17:26:47.379]                   options(future.plan = NULL)
[17:26:47.379]                   if (is.na(NA_character_)) 
[17:26:47.379]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.379]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.379]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.379]                     .init = FALSE)
[17:26:47.379]                 }
[17:26:47.379]             }
[17:26:47.379]         }
[17:26:47.379]     })
[17:26:47.379]     if (TRUE) {
[17:26:47.379]         base::sink(type = "output", split = FALSE)
[17:26:47.379]         if (TRUE) {
[17:26:47.379]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.379]         }
[17:26:47.379]         else {
[17:26:47.379]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.379]         }
[17:26:47.379]         base::close(...future.stdout)
[17:26:47.379]         ...future.stdout <- NULL
[17:26:47.379]     }
[17:26:47.379]     ...future.result$conditions <- ...future.conditions
[17:26:47.379]     ...future.result$finished <- base::Sys.time()
[17:26:47.379]     ...future.result
[17:26:47.379] }
[17:26:47.385] MultisessionFuture started
[17:26:47.385] - Launch lazy future ... done
[17:26:47.385] run() for 'MultisessionFuture' ... done
[17:26:47.386] getGlobalsAndPackages() ...
[17:26:47.386] Searching for globals...
[17:26:47.387] - globals found: [1] '{'
[17:26:47.387] Searching for globals ... DONE
[17:26:47.387] Resolving globals: FALSE
[17:26:47.388] 
[17:26:47.388] 
[17:26:47.388] getGlobalsAndPackages() ... DONE
[17:26:47.388] run() for 'Future' ...
[17:26:47.389] - state: 'created'
[17:26:47.389] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:47.402] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:47.403] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:47.403]   - Field: 'node'
[17:26:47.403]   - Field: 'label'
[17:26:47.403]   - Field: 'local'
[17:26:47.403]   - Field: 'owner'
[17:26:47.404]   - Field: 'envir'
[17:26:47.404]   - Field: 'workers'
[17:26:47.404]   - Field: 'packages'
[17:26:47.404]   - Field: 'gc'
[17:26:47.404]   - Field: 'conditions'
[17:26:47.404]   - Field: 'persistent'
[17:26:47.405]   - Field: 'expr'
[17:26:47.405]   - Field: 'uuid'
[17:26:47.405]   - Field: 'seed'
[17:26:47.405]   - Field: 'version'
[17:26:47.405]   - Field: 'result'
[17:26:47.406]   - Field: 'asynchronous'
[17:26:47.406]   - Field: 'calls'
[17:26:47.406]   - Field: 'globals'
[17:26:47.406]   - Field: 'stdout'
[17:26:47.406]   - Field: 'earlySignal'
[17:26:47.406]   - Field: 'lazy'
[17:26:47.407]   - Field: 'state'
[17:26:47.407] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:47.407] - Launch lazy future ...
[17:26:47.407] Packages needed by the future expression (n = 0): <none>
[17:26:47.408] Packages needed by future strategies (n = 0): <none>
[17:26:47.408] {
[17:26:47.408]     {
[17:26:47.408]         {
[17:26:47.408]             ...future.startTime <- base::Sys.time()
[17:26:47.408]             {
[17:26:47.408]                 {
[17:26:47.408]                   {
[17:26:47.408]                     {
[17:26:47.408]                       base::local({
[17:26:47.408]                         has_future <- base::requireNamespace("future", 
[17:26:47.408]                           quietly = TRUE)
[17:26:47.408]                         if (has_future) {
[17:26:47.408]                           ns <- base::getNamespace("future")
[17:26:47.408]                           version <- ns[[".package"]][["version"]]
[17:26:47.408]                           if (is.null(version)) 
[17:26:47.408]                             version <- utils::packageVersion("future")
[17:26:47.408]                         }
[17:26:47.408]                         else {
[17:26:47.408]                           version <- NULL
[17:26:47.408]                         }
[17:26:47.408]                         if (!has_future || version < "1.8.0") {
[17:26:47.408]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:47.408]                             "", base::R.version$version.string), 
[17:26:47.408]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:47.408]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:47.408]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:47.408]                               "release", "version")], collapse = " "), 
[17:26:47.408]                             hostname = base::Sys.info()[["nodename"]])
[17:26:47.408]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:47.408]                             info)
[17:26:47.408]                           info <- base::paste(info, collapse = "; ")
[17:26:47.408]                           if (!has_future) {
[17:26:47.408]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:47.408]                               info)
[17:26:47.408]                           }
[17:26:47.408]                           else {
[17:26:47.408]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:47.408]                               info, version)
[17:26:47.408]                           }
[17:26:47.408]                           base::stop(msg)
[17:26:47.408]                         }
[17:26:47.408]                       })
[17:26:47.408]                     }
[17:26:47.408]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:47.408]                     base::options(mc.cores = 1L)
[17:26:47.408]                   }
[17:26:47.408]                   ...future.strategy.old <- future::plan("list")
[17:26:47.408]                   options(future.plan = NULL)
[17:26:47.408]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.408]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:47.408]                 }
[17:26:47.408]                 ...future.workdir <- getwd()
[17:26:47.408]             }
[17:26:47.408]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:47.408]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:47.408]         }
[17:26:47.408]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:47.408]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:47.408]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:47.408]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:47.408]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:47.408]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:47.408]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:47.408]             base::names(...future.oldOptions))
[17:26:47.408]     }
[17:26:47.408]     if (FALSE) {
[17:26:47.408]     }
[17:26:47.408]     else {
[17:26:47.408]         if (TRUE) {
[17:26:47.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:47.408]                 open = "w")
[17:26:47.408]         }
[17:26:47.408]         else {
[17:26:47.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:47.408]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:47.408]         }
[17:26:47.408]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:47.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:47.408]             base::sink(type = "output", split = FALSE)
[17:26:47.408]             base::close(...future.stdout)
[17:26:47.408]         }, add = TRUE)
[17:26:47.408]     }
[17:26:47.408]     ...future.frame <- base::sys.nframe()
[17:26:47.408]     ...future.conditions <- base::list()
[17:26:47.408]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:47.408]     if (FALSE) {
[17:26:47.408]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:47.408]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:47.408]     }
[17:26:47.408]     ...future.result <- base::tryCatch({
[17:26:47.408]         base::withCallingHandlers({
[17:26:47.408]             ...future.value <- base::withVisible(base::local({
[17:26:47.408]                 ...future.makeSendCondition <- base::local({
[17:26:47.408]                   sendCondition <- NULL
[17:26:47.408]                   function(frame = 1L) {
[17:26:47.408]                     if (is.function(sendCondition)) 
[17:26:47.408]                       return(sendCondition)
[17:26:47.408]                     ns <- getNamespace("parallel")
[17:26:47.408]                     if (exists("sendData", mode = "function", 
[17:26:47.408]                       envir = ns)) {
[17:26:47.408]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:47.408]                         envir = ns)
[17:26:47.408]                       envir <- sys.frame(frame)
[17:26:47.408]                       master <- NULL
[17:26:47.408]                       while (!identical(envir, .GlobalEnv) && 
[17:26:47.408]                         !identical(envir, emptyenv())) {
[17:26:47.408]                         if (exists("master", mode = "list", envir = envir, 
[17:26:47.408]                           inherits = FALSE)) {
[17:26:47.408]                           master <- get("master", mode = "list", 
[17:26:47.408]                             envir = envir, inherits = FALSE)
[17:26:47.408]                           if (inherits(master, c("SOCKnode", 
[17:26:47.408]                             "SOCK0node"))) {
[17:26:47.408]                             sendCondition <<- function(cond) {
[17:26:47.408]                               data <- list(type = "VALUE", value = cond, 
[17:26:47.408]                                 success = TRUE)
[17:26:47.408]                               parallel_sendData(master, data)
[17:26:47.408]                             }
[17:26:47.408]                             return(sendCondition)
[17:26:47.408]                           }
[17:26:47.408]                         }
[17:26:47.408]                         frame <- frame + 1L
[17:26:47.408]                         envir <- sys.frame(frame)
[17:26:47.408]                       }
[17:26:47.408]                     }
[17:26:47.408]                     sendCondition <<- function(cond) NULL
[17:26:47.408]                   }
[17:26:47.408]                 })
[17:26:47.408]                 withCallingHandlers({
[17:26:47.408]                   {
[17:26:47.408]                     4
[17:26:47.408]                   }
[17:26:47.408]                 }, immediateCondition = function(cond) {
[17:26:47.408]                   sendCondition <- ...future.makeSendCondition()
[17:26:47.408]                   sendCondition(cond)
[17:26:47.408]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.408]                   {
[17:26:47.408]                     inherits <- base::inherits
[17:26:47.408]                     invokeRestart <- base::invokeRestart
[17:26:47.408]                     is.null <- base::is.null
[17:26:47.408]                     muffled <- FALSE
[17:26:47.408]                     if (inherits(cond, "message")) {
[17:26:47.408]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:47.408]                       if (muffled) 
[17:26:47.408]                         invokeRestart("muffleMessage")
[17:26:47.408]                     }
[17:26:47.408]                     else if (inherits(cond, "warning")) {
[17:26:47.408]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:47.408]                       if (muffled) 
[17:26:47.408]                         invokeRestart("muffleWarning")
[17:26:47.408]                     }
[17:26:47.408]                     else if (inherits(cond, "condition")) {
[17:26:47.408]                       if (!is.null(pattern)) {
[17:26:47.408]                         computeRestarts <- base::computeRestarts
[17:26:47.408]                         grepl <- base::grepl
[17:26:47.408]                         restarts <- computeRestarts(cond)
[17:26:47.408]                         for (restart in restarts) {
[17:26:47.408]                           name <- restart$name
[17:26:47.408]                           if (is.null(name)) 
[17:26:47.408]                             next
[17:26:47.408]                           if (!grepl(pattern, name)) 
[17:26:47.408]                             next
[17:26:47.408]                           invokeRestart(restart)
[17:26:47.408]                           muffled <- TRUE
[17:26:47.408]                           break
[17:26:47.408]                         }
[17:26:47.408]                       }
[17:26:47.408]                     }
[17:26:47.408]                     invisible(muffled)
[17:26:47.408]                   }
[17:26:47.408]                   muffleCondition(cond)
[17:26:47.408]                 })
[17:26:47.408]             }))
[17:26:47.408]             future::FutureResult(value = ...future.value$value, 
[17:26:47.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.408]                   ...future.rng), globalenv = if (FALSE) 
[17:26:47.408]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:47.408]                     ...future.globalenv.names))
[17:26:47.408]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:47.408]         }, condition = base::local({
[17:26:47.408]             c <- base::c
[17:26:47.408]             inherits <- base::inherits
[17:26:47.408]             invokeRestart <- base::invokeRestart
[17:26:47.408]             length <- base::length
[17:26:47.408]             list <- base::list
[17:26:47.408]             seq.int <- base::seq.int
[17:26:47.408]             signalCondition <- base::signalCondition
[17:26:47.408]             sys.calls <- base::sys.calls
[17:26:47.408]             `[[` <- base::`[[`
[17:26:47.408]             `+` <- base::`+`
[17:26:47.408]             `<<-` <- base::`<<-`
[17:26:47.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:47.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:47.408]                   3L)]
[17:26:47.408]             }
[17:26:47.408]             function(cond) {
[17:26:47.408]                 is_error <- inherits(cond, "error")
[17:26:47.408]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:47.408]                   NULL)
[17:26:47.408]                 if (is_error) {
[17:26:47.408]                   sessionInformation <- function() {
[17:26:47.408]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:47.408]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:47.408]                       search = base::search(), system = base::Sys.info())
[17:26:47.408]                   }
[17:26:47.408]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:47.408]                     cond$call), session = sessionInformation(), 
[17:26:47.408]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:47.408]                   signalCondition(cond)
[17:26:47.408]                 }
[17:26:47.408]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:47.408]                 "immediateCondition"))) {
[17:26:47.408]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:47.408]                   ...future.conditions[[length(...future.conditions) + 
[17:26:47.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:47.408]                   if (TRUE && !signal) {
[17:26:47.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.408]                     {
[17:26:47.408]                       inherits <- base::inherits
[17:26:47.408]                       invokeRestart <- base::invokeRestart
[17:26:47.408]                       is.null <- base::is.null
[17:26:47.408]                       muffled <- FALSE
[17:26:47.408]                       if (inherits(cond, "message")) {
[17:26:47.408]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.408]                         if (muffled) 
[17:26:47.408]                           invokeRestart("muffleMessage")
[17:26:47.408]                       }
[17:26:47.408]                       else if (inherits(cond, "warning")) {
[17:26:47.408]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.408]                         if (muffled) 
[17:26:47.408]                           invokeRestart("muffleWarning")
[17:26:47.408]                       }
[17:26:47.408]                       else if (inherits(cond, "condition")) {
[17:26:47.408]                         if (!is.null(pattern)) {
[17:26:47.408]                           computeRestarts <- base::computeRestarts
[17:26:47.408]                           grepl <- base::grepl
[17:26:47.408]                           restarts <- computeRestarts(cond)
[17:26:47.408]                           for (restart in restarts) {
[17:26:47.408]                             name <- restart$name
[17:26:47.408]                             if (is.null(name)) 
[17:26:47.408]                               next
[17:26:47.408]                             if (!grepl(pattern, name)) 
[17:26:47.408]                               next
[17:26:47.408]                             invokeRestart(restart)
[17:26:47.408]                             muffled <- TRUE
[17:26:47.408]                             break
[17:26:47.408]                           }
[17:26:47.408]                         }
[17:26:47.408]                       }
[17:26:47.408]                       invisible(muffled)
[17:26:47.408]                     }
[17:26:47.408]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.408]                   }
[17:26:47.408]                 }
[17:26:47.408]                 else {
[17:26:47.408]                   if (TRUE) {
[17:26:47.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:47.408]                     {
[17:26:47.408]                       inherits <- base::inherits
[17:26:47.408]                       invokeRestart <- base::invokeRestart
[17:26:47.408]                       is.null <- base::is.null
[17:26:47.408]                       muffled <- FALSE
[17:26:47.408]                       if (inherits(cond, "message")) {
[17:26:47.408]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:47.408]                         if (muffled) 
[17:26:47.408]                           invokeRestart("muffleMessage")
[17:26:47.408]                       }
[17:26:47.408]                       else if (inherits(cond, "warning")) {
[17:26:47.408]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:47.408]                         if (muffled) 
[17:26:47.408]                           invokeRestart("muffleWarning")
[17:26:47.408]                       }
[17:26:47.408]                       else if (inherits(cond, "condition")) {
[17:26:47.408]                         if (!is.null(pattern)) {
[17:26:47.408]                           computeRestarts <- base::computeRestarts
[17:26:47.408]                           grepl <- base::grepl
[17:26:47.408]                           restarts <- computeRestarts(cond)
[17:26:47.408]                           for (restart in restarts) {
[17:26:47.408]                             name <- restart$name
[17:26:47.408]                             if (is.null(name)) 
[17:26:47.408]                               next
[17:26:47.408]                             if (!grepl(pattern, name)) 
[17:26:47.408]                               next
[17:26:47.408]                             invokeRestart(restart)
[17:26:47.408]                             muffled <- TRUE
[17:26:47.408]                             break
[17:26:47.408]                           }
[17:26:47.408]                         }
[17:26:47.408]                       }
[17:26:47.408]                       invisible(muffled)
[17:26:47.408]                     }
[17:26:47.408]                     muffleCondition(cond, pattern = "^muffle")
[17:26:47.408]                   }
[17:26:47.408]                 }
[17:26:47.408]             }
[17:26:47.408]         }))
[17:26:47.408]     }, error = function(ex) {
[17:26:47.408]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:47.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:47.408]                 ...future.rng), started = ...future.startTime, 
[17:26:47.408]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:47.408]             version = "1.8"), class = "FutureResult")
[17:26:47.408]     }, finally = {
[17:26:47.408]         if (!identical(...future.workdir, getwd())) 
[17:26:47.408]             setwd(...future.workdir)
[17:26:47.408]         {
[17:26:47.408]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:47.408]                 ...future.oldOptions$nwarnings <- NULL
[17:26:47.408]             }
[17:26:47.408]             base::options(...future.oldOptions)
[17:26:47.408]             if (.Platform$OS.type == "windows") {
[17:26:47.408]                 old_names <- names(...future.oldEnvVars)
[17:26:47.408]                 envs <- base::Sys.getenv()
[17:26:47.408]                 names <- names(envs)
[17:26:47.408]                 common <- intersect(names, old_names)
[17:26:47.408]                 added <- setdiff(names, old_names)
[17:26:47.408]                 removed <- setdiff(old_names, names)
[17:26:47.408]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:47.408]                   envs[common]]
[17:26:47.408]                 NAMES <- toupper(changed)
[17:26:47.408]                 args <- list()
[17:26:47.408]                 for (kk in seq_along(NAMES)) {
[17:26:47.408]                   name <- changed[[kk]]
[17:26:47.408]                   NAME <- NAMES[[kk]]
[17:26:47.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.408]                     next
[17:26:47.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.408]                 }
[17:26:47.408]                 NAMES <- toupper(added)
[17:26:47.408]                 for (kk in seq_along(NAMES)) {
[17:26:47.408]                   name <- added[[kk]]
[17:26:47.408]                   NAME <- NAMES[[kk]]
[17:26:47.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.408]                     next
[17:26:47.408]                   args[[name]] <- ""
[17:26:47.408]                 }
[17:26:47.408]                 NAMES <- toupper(removed)
[17:26:47.408]                 for (kk in seq_along(NAMES)) {
[17:26:47.408]                   name <- removed[[kk]]
[17:26:47.408]                   NAME <- NAMES[[kk]]
[17:26:47.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:47.408]                     next
[17:26:47.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:47.408]                 }
[17:26:47.408]                 if (length(args) > 0) 
[17:26:47.408]                   base::do.call(base::Sys.setenv, args = args)
[17:26:47.408]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:47.408]             }
[17:26:47.408]             else {
[17:26:47.408]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:47.408]             }
[17:26:47.408]             {
[17:26:47.408]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:47.408]                   0L) {
[17:26:47.408]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:47.408]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:47.408]                   base::options(opts)
[17:26:47.408]                 }
[17:26:47.408]                 {
[17:26:47.408]                   {
[17:26:47.408]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:47.408]                     NULL
[17:26:47.408]                   }
[17:26:47.408]                   options(future.plan = NULL)
[17:26:47.408]                   if (is.na(NA_character_)) 
[17:26:47.408]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:47.408]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:47.408]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:47.408]                     .init = FALSE)
[17:26:47.408]                 }
[17:26:47.408]             }
[17:26:47.408]         }
[17:26:47.408]     })
[17:26:47.408]     if (TRUE) {
[17:26:47.408]         base::sink(type = "output", split = FALSE)
[17:26:47.408]         if (TRUE) {
[17:26:47.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:47.408]         }
[17:26:47.408]         else {
[17:26:47.408]             ...future.result["stdout"] <- base::list(NULL)
[17:26:47.408]         }
[17:26:47.408]         base::close(...future.stdout)
[17:26:47.408]         ...future.stdout <- NULL
[17:26:47.408]     }
[17:26:47.408]     ...future.result$conditions <- ...future.conditions
[17:26:47.408]     ...future.result$finished <- base::Sys.time()
[17:26:47.408]     ...future.result
[17:26:47.408] }
[17:26:47.413] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:47.438] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.439] - Validating connection of MultisessionFuture
[17:26:47.439] - received message: FutureResult
[17:26:47.439] - Received FutureResult
[17:26:47.439] - Erased future from FutureRegistry
[17:26:47.440] result() for ClusterFuture ...
[17:26:47.440] - result already collected: FutureResult
[17:26:47.440] result() for ClusterFuture ... done
[17:26:47.440] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:47.440] result() for ClusterFuture ...
[17:26:47.441] - result already collected: FutureResult
[17:26:47.441] result() for ClusterFuture ... done
[17:26:47.441] result() for ClusterFuture ...
[17:26:47.441] - result already collected: FutureResult
[17:26:47.441] result() for ClusterFuture ... done
[17:26:47.442] MultisessionFuture started
[17:26:47.443] - Launch lazy future ... done
[17:26:47.443] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x000002230c444f08> 
Classes 'listenv', 'environment' <environment: 0x0000022310252e60> 
 - attr(*, "dim.")= int [1:4] 2 1 3 1
 - attr(*, "dimnames.")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
[17:26:47.449] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.450] - Validating connection of MultisessionFuture
[17:26:47.450] - received message: FutureResult
[17:26:47.450] - Received FutureResult
[17:26:47.450] - Erased future from FutureRegistry
[17:26:47.451] result() for ClusterFuture ...
[17:26:47.451] - result already collected: FutureResult
[17:26:47.451] result() for ClusterFuture ... done
[17:26:47.451] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:47.458] receiveMessageFromWorker() for ClusterFuture ...
[17:26:47.458] - Validating connection of MultisessionFuture
[17:26:47.458] - received message: FutureResult
[17:26:47.458] - Received FutureResult
[17:26:47.459] - Erased future from FutureRegistry
[17:26:47.459] result() for ClusterFuture ...
[17:26:47.459] - result already collected: FutureResult
[17:26:47.459] result() for ClusterFuture ... done
[17:26:47.459] receiveMessageFromWorker() for ClusterFuture ... done
 logi [1:2, 1, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "dimnames")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[17:26:47.463] resolve() on list environment ...
[17:26:47.463]  recursive: 0
[17:26:47.464]  length: 6
[17:26:47.464]  elements: 'a', 'b', 'c', 'd', '', ''
[17:26:47.464] signalConditionsASAP(numeric, pos=1) ...
[17:26:47.464] - nx: 6
[17:26:47.465] - relay: TRUE
[17:26:47.465] - stdout: TRUE
[17:26:47.465] - signal: TRUE
[17:26:47.465] - resignal: FALSE
[17:26:47.465] - force: TRUE
[17:26:47.465] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.466] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.466]  - until=2
[17:26:47.466]  - relaying element #2
[17:26:47.466] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.466] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.466] signalConditionsASAP(NULL, pos=1) ... done
[17:26:47.467]  length: 5 (resolved future 1)
[17:26:47.467] Future #2
[17:26:47.467] result() for ClusterFuture ...
[17:26:47.467] - result already collected: FutureResult
[17:26:47.467] result() for ClusterFuture ... done
[17:26:47.467] result() for ClusterFuture ...
[17:26:47.468] - result already collected: FutureResult
[17:26:47.468] result() for ClusterFuture ... done
[17:26:47.468] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:47.468] - nx: 6
[17:26:47.468] - relay: TRUE
[17:26:47.468] - stdout: TRUE
[17:26:47.469] - signal: TRUE
[17:26:47.469] - resignal: FALSE
[17:26:47.469] - force: TRUE
[17:26:47.469] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.469] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[17:26:47.469]  - until=2
[17:26:47.470]  - relaying element #2
[17:26:47.470] result() for ClusterFuture ...
[17:26:47.470] - result already collected: FutureResult
[17:26:47.470] result() for ClusterFuture ... done
[17:26:47.470] result() for ClusterFuture ...
[17:26:47.470] - result already collected: FutureResult
[17:26:47.470] result() for ClusterFuture ... done
[17:26:47.471] result() for ClusterFuture ...
[17:26:47.471] - result already collected: FutureResult
[17:26:47.471] result() for ClusterFuture ... done
[17:26:47.471] result() for ClusterFuture ...
[17:26:47.471] - result already collected: FutureResult
[17:26:47.471] result() for ClusterFuture ... done
[17:26:47.472] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.472] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.472] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:47.472]  length: 4 (resolved future 2)
[17:26:47.472] Future #3
[17:26:47.472] result() for ClusterFuture ...
[17:26:47.473] - result already collected: FutureResult
[17:26:47.473] result() for ClusterFuture ... done
[17:26:47.473] result() for ClusterFuture ...
[17:26:47.473] - result already collected: FutureResult
[17:26:47.473] result() for ClusterFuture ... done
[17:26:47.473] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:47.474] - nx: 6
[17:26:47.474] - relay: TRUE
[17:26:47.474] - stdout: TRUE
[17:26:47.474] - signal: TRUE
[17:26:47.474] - resignal: FALSE
[17:26:47.474] - force: TRUE
[17:26:47.475] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.475] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[17:26:47.475]  - until=3
[17:26:47.475]  - relaying element #3
[17:26:47.475] result() for ClusterFuture ...
[17:26:47.475] - result already collected: FutureResult
[17:26:47.475] result() for ClusterFuture ... done
[17:26:47.476] result() for ClusterFuture ...
[17:26:47.476] - result already collected: FutureResult
[17:26:47.476] result() for ClusterFuture ... done
[17:26:47.476] result() for ClusterFuture ...
[17:26:47.476] - result already collected: FutureResult
[17:26:47.476] result() for ClusterFuture ... done
[17:26:47.477] result() for ClusterFuture ...
[17:26:47.477] - result already collected: FutureResult
[17:26:47.477] result() for ClusterFuture ... done
[17:26:47.477] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.477] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.477] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:47.478]  length: 3 (resolved future 3)
[17:26:47.478] Future #4
[17:26:47.478] result() for ClusterFuture ...
[17:26:47.478] - result already collected: FutureResult
[17:26:47.478] result() for ClusterFuture ... done
[17:26:47.478] result() for ClusterFuture ...
[17:26:47.479] - result already collected: FutureResult
[17:26:47.479] result() for ClusterFuture ... done
[17:26:47.479] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:26:47.479] - nx: 6
[17:26:47.479] - relay: TRUE
[17:26:47.479] - stdout: TRUE
[17:26:47.480] - signal: TRUE
[17:26:47.480] - resignal: FALSE
[17:26:47.480] - force: TRUE
[17:26:47.480] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.480] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[17:26:47.480]  - until=4
[17:26:47.481]  - relaying element #4
[17:26:47.481] result() for ClusterFuture ...
[17:26:47.481] - result already collected: FutureResult
[17:26:47.481] result() for ClusterFuture ... done
[17:26:47.481] result() for ClusterFuture ...
[17:26:47.481] - result already collected: FutureResult
[17:26:47.482] result() for ClusterFuture ... done
[17:26:47.482] result() for ClusterFuture ...
[17:26:47.482] - result already collected: FutureResult
[17:26:47.482] result() for ClusterFuture ... done
[17:26:47.482] result() for ClusterFuture ...
[17:26:47.482] - result already collected: FutureResult
[17:26:47.482] result() for ClusterFuture ... done
[17:26:47.483] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.483] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.483] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:26:47.483]  length: 2 (resolved future 4)
[17:26:47.483] signalConditionsASAP(NULL, pos=5) ...
[17:26:47.483] - nx: 6
[17:26:47.484] - relay: TRUE
[17:26:47.484] - stdout: TRUE
[17:26:47.484] - signal: TRUE
[17:26:47.484] - resignal: FALSE
[17:26:47.488] - force: TRUE
[17:26:47.489] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.489] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.489]  - until=6
[17:26:47.489]  - relaying element #6
[17:26:47.489] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:47.490] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.490] signalConditionsASAP(NULL, pos=5) ... done
[17:26:47.490]  length: 1 (resolved future 5)
[17:26:47.490] signalConditionsASAP(numeric, pos=6) ...
[17:26:47.490] - nx: 6
[17:26:47.491] - relay: TRUE
[17:26:47.491] - stdout: TRUE
[17:26:47.491] - signal: TRUE
[17:26:47.491] - resignal: FALSE
[17:26:47.491] - force: TRUE
[17:26:47.491] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[17:26:47.492] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.492]  - until=6
[17:26:47.492] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.492] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.492] signalConditionsASAP(numeric, pos=6) ... done
[17:26:47.492]  length: 0 (resolved future 6)
[17:26:47.493] Relaying remaining futures
[17:26:47.493] signalConditionsASAP(NULL, pos=0) ...
[17:26:47.493] - nx: 6
[17:26:47.493] - relay: TRUE
[17:26:47.493] - stdout: TRUE
[17:26:47.493] - signal: TRUE
[17:26:47.493] - resignal: FALSE
[17:26:47.494] - force: TRUE
[17:26:47.494] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.494] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[17:26:47.494] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[17:26:47.494] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[17:26:47.495] signalConditionsASAP(NULL, pos=0) ... done
[17:26:47.495] resolve() on list environment ... DONE
[17:26:47.495] result() for ClusterFuture ...
[17:26:47.495] - result already collected: FutureResult
[17:26:47.495] result() for ClusterFuture ... done
[17:26:47.495] result() for ClusterFuture ...
[17:26:47.496] - result already collected: FutureResult
[17:26:47.496] result() for ClusterFuture ... done
[17:26:47.496] result() for ClusterFuture ...
[17:26:47.496] - result already collected: FutureResult
[17:26:47.496] result() for ClusterFuture ... done
[17:26:47.496] result() for ClusterFuture ...
[17:26:47.497] - result already collected: FutureResult
[17:26:47.497] result() for ClusterFuture ... done
[17:26:47.497] result() for ClusterFuture ...
[17:26:47.497] - result already collected: FutureResult
[17:26:47.497] result() for ClusterFuture ... done
[17:26:47.497] result() for ClusterFuture ...
[17:26:47.498] - result already collected: FutureResult
[17:26:47.498] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000022310849f80> 
 - attr(*, "dim.")= int [1:4] 2 1 3 1
 - attr(*, "dimnames.")=List of 4
  ..$ : chr [1:2] "a" "b"
  ..$ : chr "a"
  ..$ : chr [1:3] "a" "b" "c"
  ..$ : chr "a"
*** futures() - listenv ... DONE
Testing with 2 cores ... DONE
> 
> message("*** futures() / resolved() / value() ... DONE")
*** futures() / resolved() / value() ... DONE
> 
> source("incl/end.R")
[17:26:47.501] plan(): Setting new future strategy stack:
[17:26:47.502] List of future strategies:
[17:26:47.502] 1. FutureStrategy:
[17:26:47.502]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:47.502]    - tweaked: FALSE
[17:26:47.502]    - call: future::plan(oplan)
[17:26:47.503] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   3.46    0.18    5.39