R Under development (unstable) (2023-12-20 r85713 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 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")
[01:27:45.296] plan(): Setting new future strategy stack:
[01:27:45.298] List of future strategies:
[01:27:45.298] 1. sequential:
[01:27:45.298]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.298]    - tweaked: FALSE
[01:27:45.298]    - call: future::plan("sequential")
[01:27:45.320] 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
[01:27:45.387] plan(): Setting new future strategy stack:
[01:27:45.387] List of future strategies:
[01:27:45.387] 1. sequential:
[01:27:45.387]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.387]    - tweaked: FALSE
[01:27:45.387]    - call: plan(strategy)
[01:27:45.400] plan(): nbrOfWorkers() = 1
Dimensions: NULL
[01:27:45.401] getGlobalsAndPackages() ...
[01:27:45.402] Searching for globals...
[01:27:45.405] 
[01:27:45.405] Searching for globals ... DONE
[01:27:45.405] - globals: [0] <none>
[01:27:45.405] getGlobalsAndPackages() ... DONE
[01:27:45.406] run() for 'Future' ...
[01:27:45.406] - state: 'created'
[01:27:45.407] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.407] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.407] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.407]   - Field: 'label'
[01:27:45.408]   - Field: 'local'
[01:27:45.408]   - Field: 'owner'
[01:27:45.408]   - Field: 'envir'
[01:27:45.408]   - Field: 'packages'
[01:27:45.408]   - Field: 'gc'
[01:27:45.409]   - Field: 'conditions'
[01:27:45.409]   - Field: 'expr'
[01:27:45.409]   - Field: 'uuid'
[01:27:45.409]   - Field: 'seed'
[01:27:45.409]   - Field: 'version'
[01:27:45.409]   - Field: 'result'
[01:27:45.410]   - Field: 'asynchronous'
[01:27:45.410]   - Field: 'calls'
[01:27:45.410]   - Field: 'globals'
[01:27:45.410]   - Field: 'stdout'
[01:27:45.410]   - Field: 'earlySignal'
[01:27:45.411]   - Field: 'lazy'
[01:27:45.411]   - Field: 'state'
[01:27:45.411] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.411] - Launch lazy future ...
[01:27:45.413] Packages needed by the future expression (n = 0): <none>
[01:27:45.414] Packages needed by future strategies (n = 0): <none>
[01:27:45.415] {
[01:27:45.415]     {
[01:27:45.415]         {
[01:27:45.415]             ...future.startTime <- base::Sys.time()
[01:27:45.415]             {
[01:27:45.415]                 {
[01:27:45.415]                   {
[01:27:45.415]                     base::local({
[01:27:45.415]                       has_future <- base::requireNamespace("future", 
[01:27:45.415]                         quietly = TRUE)
[01:27:45.415]                       if (has_future) {
[01:27:45.415]                         ns <- base::getNamespace("future")
[01:27:45.415]                         version <- ns[[".package"]][["version"]]
[01:27:45.415]                         if (is.null(version)) 
[01:27:45.415]                           version <- utils::packageVersion("future")
[01:27:45.415]                       }
[01:27:45.415]                       else {
[01:27:45.415]                         version <- NULL
[01:27:45.415]                       }
[01:27:45.415]                       if (!has_future || version < "1.8.0") {
[01:27:45.415]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.415]                           "", base::R.version$version.string), 
[01:27:45.415]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.415]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.415]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.415]                             "release", "version")], collapse = " "), 
[01:27:45.415]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.415]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.415]                           info)
[01:27:45.415]                         info <- base::paste(info, collapse = "; ")
[01:27:45.415]                         if (!has_future) {
[01:27:45.415]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.415]                             info)
[01:27:45.415]                         }
[01:27:45.415]                         else {
[01:27:45.415]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.415]                             info, version)
[01:27:45.415]                         }
[01:27:45.415]                         base::stop(msg)
[01:27:45.415]                       }
[01:27:45.415]                     })
[01:27:45.415]                   }
[01:27:45.415]                   options(future.plan = NULL)
[01:27:45.415]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.415]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.415]                 }
[01:27:45.415]                 ...future.workdir <- getwd()
[01:27:45.415]             }
[01:27:45.415]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.415]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.415]         }
[01:27:45.415]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.415]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.415]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.415]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.415]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.415]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.415]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.415]             base::names(...future.oldOptions))
[01:27:45.415]     }
[01:27:45.415]     if (FALSE) {
[01:27:45.415]     }
[01:27:45.415]     else {
[01:27:45.415]         if (TRUE) {
[01:27:45.415]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.415]                 open = "w")
[01:27:45.415]         }
[01:27:45.415]         else {
[01:27:45.415]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.415]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.415]         }
[01:27:45.415]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.415]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.415]             base::sink(type = "output", split = FALSE)
[01:27:45.415]             base::close(...future.stdout)
[01:27:45.415]         }, add = TRUE)
[01:27:45.415]     }
[01:27:45.415]     ...future.frame <- base::sys.nframe()
[01:27:45.415]     ...future.conditions <- base::list()
[01:27:45.415]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.415]     if (FALSE) {
[01:27:45.415]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.415]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.415]     }
[01:27:45.415]     ...future.result <- base::tryCatch({
[01:27:45.415]         base::withCallingHandlers({
[01:27:45.415]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.415]             future::FutureResult(value = ...future.value$value, 
[01:27:45.415]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.415]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.415]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.415]                     ...future.globalenv.names))
[01:27:45.415]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.415]         }, condition = base::local({
[01:27:45.415]             c <- base::c
[01:27:45.415]             inherits <- base::inherits
[01:27:45.415]             invokeRestart <- base::invokeRestart
[01:27:45.415]             length <- base::length
[01:27:45.415]             list <- base::list
[01:27:45.415]             seq.int <- base::seq.int
[01:27:45.415]             signalCondition <- base::signalCondition
[01:27:45.415]             sys.calls <- base::sys.calls
[01:27:45.415]             `[[` <- base::`[[`
[01:27:45.415]             `+` <- base::`+`
[01:27:45.415]             `<<-` <- base::`<<-`
[01:27:45.415]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.415]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.415]                   3L)]
[01:27:45.415]             }
[01:27:45.415]             function(cond) {
[01:27:45.415]                 is_error <- inherits(cond, "error")
[01:27:45.415]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.415]                   NULL)
[01:27:45.415]                 if (is_error) {
[01:27:45.415]                   sessionInformation <- function() {
[01:27:45.415]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.415]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.415]                       search = base::search(), system = base::Sys.info())
[01:27:45.415]                   }
[01:27:45.415]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.415]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.415]                     cond$call), session = sessionInformation(), 
[01:27:45.415]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.415]                   signalCondition(cond)
[01:27:45.415]                 }
[01:27:45.415]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.415]                 "immediateCondition"))) {
[01:27:45.415]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.415]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.415]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.415]                   if (TRUE && !signal) {
[01:27:45.415]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.415]                     {
[01:27:45.415]                       inherits <- base::inherits
[01:27:45.415]                       invokeRestart <- base::invokeRestart
[01:27:45.415]                       is.null <- base::is.null
[01:27:45.415]                       muffled <- FALSE
[01:27:45.415]                       if (inherits(cond, "message")) {
[01:27:45.415]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.415]                         if (muffled) 
[01:27:45.415]                           invokeRestart("muffleMessage")
[01:27:45.415]                       }
[01:27:45.415]                       else if (inherits(cond, "warning")) {
[01:27:45.415]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.415]                         if (muffled) 
[01:27:45.415]                           invokeRestart("muffleWarning")
[01:27:45.415]                       }
[01:27:45.415]                       else if (inherits(cond, "condition")) {
[01:27:45.415]                         if (!is.null(pattern)) {
[01:27:45.415]                           computeRestarts <- base::computeRestarts
[01:27:45.415]                           grepl <- base::grepl
[01:27:45.415]                           restarts <- computeRestarts(cond)
[01:27:45.415]                           for (restart in restarts) {
[01:27:45.415]                             name <- restart$name
[01:27:45.415]                             if (is.null(name)) 
[01:27:45.415]                               next
[01:27:45.415]                             if (!grepl(pattern, name)) 
[01:27:45.415]                               next
[01:27:45.415]                             invokeRestart(restart)
[01:27:45.415]                             muffled <- TRUE
[01:27:45.415]                             break
[01:27:45.415]                           }
[01:27:45.415]                         }
[01:27:45.415]                       }
[01:27:45.415]                       invisible(muffled)
[01:27:45.415]                     }
[01:27:45.415]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.415]                   }
[01:27:45.415]                 }
[01:27:45.415]                 else {
[01:27:45.415]                   if (TRUE) {
[01:27:45.415]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.415]                     {
[01:27:45.415]                       inherits <- base::inherits
[01:27:45.415]                       invokeRestart <- base::invokeRestart
[01:27:45.415]                       is.null <- base::is.null
[01:27:45.415]                       muffled <- FALSE
[01:27:45.415]                       if (inherits(cond, "message")) {
[01:27:45.415]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.415]                         if (muffled) 
[01:27:45.415]                           invokeRestart("muffleMessage")
[01:27:45.415]                       }
[01:27:45.415]                       else if (inherits(cond, "warning")) {
[01:27:45.415]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.415]                         if (muffled) 
[01:27:45.415]                           invokeRestart("muffleWarning")
[01:27:45.415]                       }
[01:27:45.415]                       else if (inherits(cond, "condition")) {
[01:27:45.415]                         if (!is.null(pattern)) {
[01:27:45.415]                           computeRestarts <- base::computeRestarts
[01:27:45.415]                           grepl <- base::grepl
[01:27:45.415]                           restarts <- computeRestarts(cond)
[01:27:45.415]                           for (restart in restarts) {
[01:27:45.415]                             name <- restart$name
[01:27:45.415]                             if (is.null(name)) 
[01:27:45.415]                               next
[01:27:45.415]                             if (!grepl(pattern, name)) 
[01:27:45.415]                               next
[01:27:45.415]                             invokeRestart(restart)
[01:27:45.415]                             muffled <- TRUE
[01:27:45.415]                             break
[01:27:45.415]                           }
[01:27:45.415]                         }
[01:27:45.415]                       }
[01:27:45.415]                       invisible(muffled)
[01:27:45.415]                     }
[01:27:45.415]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.415]                   }
[01:27:45.415]                 }
[01:27:45.415]             }
[01:27:45.415]         }))
[01:27:45.415]     }, error = function(ex) {
[01:27:45.415]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.415]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.415]                 ...future.rng), started = ...future.startTime, 
[01:27:45.415]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.415]             version = "1.8"), class = "FutureResult")
[01:27:45.415]     }, finally = {
[01:27:45.415]         if (!identical(...future.workdir, getwd())) 
[01:27:45.415]             setwd(...future.workdir)
[01:27:45.415]         {
[01:27:45.415]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.415]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.415]             }
[01:27:45.415]             base::options(...future.oldOptions)
[01:27:45.415]             if (.Platform$OS.type == "windows") {
[01:27:45.415]                 old_names <- names(...future.oldEnvVars)
[01:27:45.415]                 envs <- base::Sys.getenv()
[01:27:45.415]                 names <- names(envs)
[01:27:45.415]                 common <- intersect(names, old_names)
[01:27:45.415]                 added <- setdiff(names, old_names)
[01:27:45.415]                 removed <- setdiff(old_names, names)
[01:27:45.415]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.415]                   envs[common]]
[01:27:45.415]                 NAMES <- toupper(changed)
[01:27:45.415]                 args <- list()
[01:27:45.415]                 for (kk in seq_along(NAMES)) {
[01:27:45.415]                   name <- changed[[kk]]
[01:27:45.415]                   NAME <- NAMES[[kk]]
[01:27:45.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.415]                     next
[01:27:45.415]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.415]                 }
[01:27:45.415]                 NAMES <- toupper(added)
[01:27:45.415]                 for (kk in seq_along(NAMES)) {
[01:27:45.415]                   name <- added[[kk]]
[01:27:45.415]                   NAME <- NAMES[[kk]]
[01:27:45.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.415]                     next
[01:27:45.415]                   args[[name]] <- ""
[01:27:45.415]                 }
[01:27:45.415]                 NAMES <- toupper(removed)
[01:27:45.415]                 for (kk in seq_along(NAMES)) {
[01:27:45.415]                   name <- removed[[kk]]
[01:27:45.415]                   NAME <- NAMES[[kk]]
[01:27:45.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.415]                     next
[01:27:45.415]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.415]                 }
[01:27:45.415]                 if (length(args) > 0) 
[01:27:45.415]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.415]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.415]             }
[01:27:45.415]             else {
[01:27:45.415]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.415]             }
[01:27:45.415]             {
[01:27:45.415]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.415]                   0L) {
[01:27:45.415]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.415]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.415]                   base::options(opts)
[01:27:45.415]                 }
[01:27:45.415]                 {
[01:27:45.415]                   {
[01:27:45.415]                     NULL
[01:27:45.415]                     RNGkind("Mersenne-Twister")
[01:27:45.415]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.415]                       inherits = FALSE)
[01:27:45.415]                   }
[01:27:45.415]                   options(future.plan = NULL)
[01:27:45.415]                   if (is.na(NA_character_)) 
[01:27:45.415]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.415]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.415]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.415]                   {
[01:27:45.415]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.415]                     if (!future$lazy) 
[01:27:45.415]                       future <- run(future)
[01:27:45.415]                     invisible(future)
[01:27:45.415]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.415]                 }
[01:27:45.415]             }
[01:27:45.415]         }
[01:27:45.415]     })
[01:27:45.415]     if (TRUE) {
[01:27:45.415]         base::sink(type = "output", split = FALSE)
[01:27:45.415]         if (TRUE) {
[01:27:45.415]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.415]         }
[01:27:45.415]         else {
[01:27:45.415]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.415]         }
[01:27:45.415]         base::close(...future.stdout)
[01:27:45.415]         ...future.stdout <- NULL
[01:27:45.415]     }
[01:27:45.415]     ...future.result$conditions <- ...future.conditions
[01:27:45.415]     ...future.result$finished <- base::Sys.time()
[01:27:45.415]     ...future.result
[01:27:45.415] }
[01:27:45.419] plan(): Setting new future strategy stack:
[01:27:45.419] List of future strategies:
[01:27:45.419] 1. sequential:
[01:27:45.419]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.419]    - tweaked: FALSE
[01:27:45.419]    - call: NULL
[01:27:45.420] plan(): nbrOfWorkers() = 1
[01:27:45.422] plan(): Setting new future strategy stack:
[01:27:45.422] List of future strategies:
[01:27:45.422] 1. sequential:
[01:27:45.422]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.422]    - tweaked: FALSE
[01:27:45.422]    - call: plan(strategy)
[01:27:45.423] plan(): nbrOfWorkers() = 1
[01:27:45.423] SequentialFuture started (and completed)
[01:27:45.424] - Launch lazy future ... done
[01:27:45.424] run() for 'SequentialFuture' ... done
[01:27:45.425] getGlobalsAndPackages() ...
[01:27:45.425] Searching for globals...
[01:27:45.425] 
[01:27:45.425] Searching for globals ... DONE
[01:27:45.426] - globals: [0] <none>
[01:27:45.426] getGlobalsAndPackages() ... DONE
[01:27:45.426] run() for 'Future' ...
[01:27:45.426] - state: 'created'
[01:27:45.426] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.427] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.427] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.427]   - Field: 'label'
[01:27:45.427]   - Field: 'local'
[01:27:45.428]   - Field: 'owner'
[01:27:45.428]   - Field: 'envir'
[01:27:45.428]   - Field: 'packages'
[01:27:45.428]   - Field: 'gc'
[01:27:45.428]   - Field: 'conditions'
[01:27:45.429]   - Field: 'expr'
[01:27:45.429]   - Field: 'uuid'
[01:27:45.429]   - Field: 'seed'
[01:27:45.429]   - Field: 'version'
[01:27:45.429]   - Field: 'result'
[01:27:45.429]   - Field: 'asynchronous'
[01:27:45.430]   - Field: 'calls'
[01:27:45.430]   - Field: 'globals'
[01:27:45.430]   - Field: 'stdout'
[01:27:45.430]   - Field: 'earlySignal'
[01:27:45.430]   - Field: 'lazy'
[01:27:45.431]   - Field: 'state'
[01:27:45.431] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.431] - Launch lazy future ...
[01:27:45.431] Packages needed by the future expression (n = 0): <none>
[01:27:45.431] Packages needed by future strategies (n = 0): <none>
[01:27:45.432] {
[01:27:45.432]     {
[01:27:45.432]         {
[01:27:45.432]             ...future.startTime <- base::Sys.time()
[01:27:45.432]             {
[01:27:45.432]                 {
[01:27:45.432]                   {
[01:27:45.432]                     base::local({
[01:27:45.432]                       has_future <- base::requireNamespace("future", 
[01:27:45.432]                         quietly = TRUE)
[01:27:45.432]                       if (has_future) {
[01:27:45.432]                         ns <- base::getNamespace("future")
[01:27:45.432]                         version <- ns[[".package"]][["version"]]
[01:27:45.432]                         if (is.null(version)) 
[01:27:45.432]                           version <- utils::packageVersion("future")
[01:27:45.432]                       }
[01:27:45.432]                       else {
[01:27:45.432]                         version <- NULL
[01:27:45.432]                       }
[01:27:45.432]                       if (!has_future || version < "1.8.0") {
[01:27:45.432]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.432]                           "", base::R.version$version.string), 
[01:27:45.432]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.432]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.432]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.432]                             "release", "version")], collapse = " "), 
[01:27:45.432]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.432]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.432]                           info)
[01:27:45.432]                         info <- base::paste(info, collapse = "; ")
[01:27:45.432]                         if (!has_future) {
[01:27:45.432]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.432]                             info)
[01:27:45.432]                         }
[01:27:45.432]                         else {
[01:27:45.432]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.432]                             info, version)
[01:27:45.432]                         }
[01:27:45.432]                         base::stop(msg)
[01:27:45.432]                       }
[01:27:45.432]                     })
[01:27:45.432]                   }
[01:27:45.432]                   options(future.plan = NULL)
[01:27:45.432]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.432]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.432]                 }
[01:27:45.432]                 ...future.workdir <- getwd()
[01:27:45.432]             }
[01:27:45.432]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.432]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.432]         }
[01:27:45.432]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.432]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.432]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.432]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.432]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.432]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.432]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.432]             base::names(...future.oldOptions))
[01:27:45.432]     }
[01:27:45.432]     if (FALSE) {
[01:27:45.432]     }
[01:27:45.432]     else {
[01:27:45.432]         if (TRUE) {
[01:27:45.432]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.432]                 open = "w")
[01:27:45.432]         }
[01:27:45.432]         else {
[01:27:45.432]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.432]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.432]         }
[01:27:45.432]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.432]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.432]             base::sink(type = "output", split = FALSE)
[01:27:45.432]             base::close(...future.stdout)
[01:27:45.432]         }, add = TRUE)
[01:27:45.432]     }
[01:27:45.432]     ...future.frame <- base::sys.nframe()
[01:27:45.432]     ...future.conditions <- base::list()
[01:27:45.432]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.432]     if (FALSE) {
[01:27:45.432]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.432]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.432]     }
[01:27:45.432]     ...future.result <- base::tryCatch({
[01:27:45.432]         base::withCallingHandlers({
[01:27:45.432]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.432]             future::FutureResult(value = ...future.value$value, 
[01:27:45.432]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.432]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.432]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.432]                     ...future.globalenv.names))
[01:27:45.432]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.432]         }, condition = base::local({
[01:27:45.432]             c <- base::c
[01:27:45.432]             inherits <- base::inherits
[01:27:45.432]             invokeRestart <- base::invokeRestart
[01:27:45.432]             length <- base::length
[01:27:45.432]             list <- base::list
[01:27:45.432]             seq.int <- base::seq.int
[01:27:45.432]             signalCondition <- base::signalCondition
[01:27:45.432]             sys.calls <- base::sys.calls
[01:27:45.432]             `[[` <- base::`[[`
[01:27:45.432]             `+` <- base::`+`
[01:27:45.432]             `<<-` <- base::`<<-`
[01:27:45.432]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.432]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.432]                   3L)]
[01:27:45.432]             }
[01:27:45.432]             function(cond) {
[01:27:45.432]                 is_error <- inherits(cond, "error")
[01:27:45.432]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.432]                   NULL)
[01:27:45.432]                 if (is_error) {
[01:27:45.432]                   sessionInformation <- function() {
[01:27:45.432]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.432]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.432]                       search = base::search(), system = base::Sys.info())
[01:27:45.432]                   }
[01:27:45.432]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.432]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.432]                     cond$call), session = sessionInformation(), 
[01:27:45.432]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.432]                   signalCondition(cond)
[01:27:45.432]                 }
[01:27:45.432]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.432]                 "immediateCondition"))) {
[01:27:45.432]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.432]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.432]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.432]                   if (TRUE && !signal) {
[01:27:45.432]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.432]                     {
[01:27:45.432]                       inherits <- base::inherits
[01:27:45.432]                       invokeRestart <- base::invokeRestart
[01:27:45.432]                       is.null <- base::is.null
[01:27:45.432]                       muffled <- FALSE
[01:27:45.432]                       if (inherits(cond, "message")) {
[01:27:45.432]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.432]                         if (muffled) 
[01:27:45.432]                           invokeRestart("muffleMessage")
[01:27:45.432]                       }
[01:27:45.432]                       else if (inherits(cond, "warning")) {
[01:27:45.432]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.432]                         if (muffled) 
[01:27:45.432]                           invokeRestart("muffleWarning")
[01:27:45.432]                       }
[01:27:45.432]                       else if (inherits(cond, "condition")) {
[01:27:45.432]                         if (!is.null(pattern)) {
[01:27:45.432]                           computeRestarts <- base::computeRestarts
[01:27:45.432]                           grepl <- base::grepl
[01:27:45.432]                           restarts <- computeRestarts(cond)
[01:27:45.432]                           for (restart in restarts) {
[01:27:45.432]                             name <- restart$name
[01:27:45.432]                             if (is.null(name)) 
[01:27:45.432]                               next
[01:27:45.432]                             if (!grepl(pattern, name)) 
[01:27:45.432]                               next
[01:27:45.432]                             invokeRestart(restart)
[01:27:45.432]                             muffled <- TRUE
[01:27:45.432]                             break
[01:27:45.432]                           }
[01:27:45.432]                         }
[01:27:45.432]                       }
[01:27:45.432]                       invisible(muffled)
[01:27:45.432]                     }
[01:27:45.432]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.432]                   }
[01:27:45.432]                 }
[01:27:45.432]                 else {
[01:27:45.432]                   if (TRUE) {
[01:27:45.432]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.432]                     {
[01:27:45.432]                       inherits <- base::inherits
[01:27:45.432]                       invokeRestart <- base::invokeRestart
[01:27:45.432]                       is.null <- base::is.null
[01:27:45.432]                       muffled <- FALSE
[01:27:45.432]                       if (inherits(cond, "message")) {
[01:27:45.432]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.432]                         if (muffled) 
[01:27:45.432]                           invokeRestart("muffleMessage")
[01:27:45.432]                       }
[01:27:45.432]                       else if (inherits(cond, "warning")) {
[01:27:45.432]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.432]                         if (muffled) 
[01:27:45.432]                           invokeRestart("muffleWarning")
[01:27:45.432]                       }
[01:27:45.432]                       else if (inherits(cond, "condition")) {
[01:27:45.432]                         if (!is.null(pattern)) {
[01:27:45.432]                           computeRestarts <- base::computeRestarts
[01:27:45.432]                           grepl <- base::grepl
[01:27:45.432]                           restarts <- computeRestarts(cond)
[01:27:45.432]                           for (restart in restarts) {
[01:27:45.432]                             name <- restart$name
[01:27:45.432]                             if (is.null(name)) 
[01:27:45.432]                               next
[01:27:45.432]                             if (!grepl(pattern, name)) 
[01:27:45.432]                               next
[01:27:45.432]                             invokeRestart(restart)
[01:27:45.432]                             muffled <- TRUE
[01:27:45.432]                             break
[01:27:45.432]                           }
[01:27:45.432]                         }
[01:27:45.432]                       }
[01:27:45.432]                       invisible(muffled)
[01:27:45.432]                     }
[01:27:45.432]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.432]                   }
[01:27:45.432]                 }
[01:27:45.432]             }
[01:27:45.432]         }))
[01:27:45.432]     }, error = function(ex) {
[01:27:45.432]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.432]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.432]                 ...future.rng), started = ...future.startTime, 
[01:27:45.432]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.432]             version = "1.8"), class = "FutureResult")
[01:27:45.432]     }, finally = {
[01:27:45.432]         if (!identical(...future.workdir, getwd())) 
[01:27:45.432]             setwd(...future.workdir)
[01:27:45.432]         {
[01:27:45.432]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.432]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.432]             }
[01:27:45.432]             base::options(...future.oldOptions)
[01:27:45.432]             if (.Platform$OS.type == "windows") {
[01:27:45.432]                 old_names <- names(...future.oldEnvVars)
[01:27:45.432]                 envs <- base::Sys.getenv()
[01:27:45.432]                 names <- names(envs)
[01:27:45.432]                 common <- intersect(names, old_names)
[01:27:45.432]                 added <- setdiff(names, old_names)
[01:27:45.432]                 removed <- setdiff(old_names, names)
[01:27:45.432]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.432]                   envs[common]]
[01:27:45.432]                 NAMES <- toupper(changed)
[01:27:45.432]                 args <- list()
[01:27:45.432]                 for (kk in seq_along(NAMES)) {
[01:27:45.432]                   name <- changed[[kk]]
[01:27:45.432]                   NAME <- NAMES[[kk]]
[01:27:45.432]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.432]                     next
[01:27:45.432]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.432]                 }
[01:27:45.432]                 NAMES <- toupper(added)
[01:27:45.432]                 for (kk in seq_along(NAMES)) {
[01:27:45.432]                   name <- added[[kk]]
[01:27:45.432]                   NAME <- NAMES[[kk]]
[01:27:45.432]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.432]                     next
[01:27:45.432]                   args[[name]] <- ""
[01:27:45.432]                 }
[01:27:45.432]                 NAMES <- toupper(removed)
[01:27:45.432]                 for (kk in seq_along(NAMES)) {
[01:27:45.432]                   name <- removed[[kk]]
[01:27:45.432]                   NAME <- NAMES[[kk]]
[01:27:45.432]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.432]                     next
[01:27:45.432]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.432]                 }
[01:27:45.432]                 if (length(args) > 0) 
[01:27:45.432]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.432]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.432]             }
[01:27:45.432]             else {
[01:27:45.432]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.432]             }
[01:27:45.432]             {
[01:27:45.432]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.432]                   0L) {
[01:27:45.432]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.432]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.432]                   base::options(opts)
[01:27:45.432]                 }
[01:27:45.432]                 {
[01:27:45.432]                   {
[01:27:45.432]                     NULL
[01:27:45.432]                     RNGkind("Mersenne-Twister")
[01:27:45.432]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.432]                       inherits = FALSE)
[01:27:45.432]                   }
[01:27:45.432]                   options(future.plan = NULL)
[01:27:45.432]                   if (is.na(NA_character_)) 
[01:27:45.432]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.432]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.432]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.432]                   {
[01:27:45.432]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.432]                     if (!future$lazy) 
[01:27:45.432]                       future <- run(future)
[01:27:45.432]                     invisible(future)
[01:27:45.432]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.432]                 }
[01:27:45.432]             }
[01:27:45.432]         }
[01:27:45.432]     })
[01:27:45.432]     if (TRUE) {
[01:27:45.432]         base::sink(type = "output", split = FALSE)
[01:27:45.432]         if (TRUE) {
[01:27:45.432]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.432]         }
[01:27:45.432]         else {
[01:27:45.432]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.432]         }
[01:27:45.432]         base::close(...future.stdout)
[01:27:45.432]         ...future.stdout <- NULL
[01:27:45.432]     }
[01:27:45.432]     ...future.result$conditions <- ...future.conditions
[01:27:45.432]     ...future.result$finished <- base::Sys.time()
[01:27:45.432]     ...future.result
[01:27:45.432] }
[01:27:45.436] plan(): Setting new future strategy stack:
[01:27:45.436] List of future strategies:
[01:27:45.436] 1. sequential:
[01:27:45.436]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.436]    - tweaked: FALSE
[01:27:45.436]    - call: NULL
[01:27:45.437] plan(): nbrOfWorkers() = 1
[01:27:45.438] plan(): Setting new future strategy stack:
[01:27:45.438] List of future strategies:
[01:27:45.438] 1. sequential:
[01:27:45.438]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.438]    - tweaked: FALSE
[01:27:45.438]    - call: plan(strategy)
[01:27:45.439] plan(): nbrOfWorkers() = 1
[01:27:45.439] SequentialFuture started (and completed)
[01:27:45.439] - Launch lazy future ... done
[01:27:45.439] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b08261378> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b04a8e2d0> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b08261378> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b04a8e2d0> 
 $  : NULL
 $  : NULL
 $  : num 6
[01:27:45.447] resolved() for 'SequentialFuture' ...
[01:27:45.448] - state: 'finished'
[01:27:45.448] - run: TRUE
[01:27:45.448] - result: 'FutureResult'
[01:27:45.448] resolved() for 'SequentialFuture' ... done
[01:27:45.448] resolved() for 'SequentialFuture' ...
[01:27:45.449] - state: 'finished'
[01:27:45.449] - run: TRUE
[01:27:45.449] - result: 'FutureResult'
[01:27:45.449] resolved() for 'SequentialFuture' ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[01:27:45.451] resolve() on list ...
[01:27:45.451]  recursive: 0
[01:27:45.451]  length: 6
[01:27:45.451]  elements: 'a', 'b', 'c', '', '', ''
[01:27:45.452] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.452] - nx: 6
[01:27:45.452] - relay: TRUE
[01:27:45.452] - stdout: TRUE
[01:27:45.452] - signal: TRUE
[01:27:45.452] - resignal: FALSE
[01:27:45.453] - force: TRUE
[01:27:45.453] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.453] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.453]  - until=2
[01:27:45.453]  - relaying element #2
[01:27:45.453] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.454] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.454] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.454]  length: 5 (resolved future 1)
[01:27:45.454] resolved() for 'SequentialFuture' ...
[01:27:45.454] - state: 'finished'
[01:27:45.455] - run: TRUE
[01:27:45.455] - result: 'FutureResult'
[01:27:45.455] resolved() for 'SequentialFuture' ... done
[01:27:45.455] Future #2
[01:27:45.456] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.456] - nx: 6
[01:27:45.456] - relay: TRUE
[01:27:45.456] - stdout: TRUE
[01:27:45.456] - signal: TRUE
[01:27:45.457] - resignal: FALSE
[01:27:45.457] - force: TRUE
[01:27:45.457] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.457] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.457]  - until=2
[01:27:45.458]  - relaying element #2
[01:27:45.458] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.458] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.458] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.459]  length: 4 (resolved future 2)
[01:27:45.459] resolved() for 'SequentialFuture' ...
[01:27:45.459] - state: 'finished'
[01:27:45.459] - run: TRUE
[01:27:45.459] - result: 'FutureResult'
[01:27:45.460] resolved() for 'SequentialFuture' ... done
[01:27:45.460] Future #3
[01:27:45.460] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.460] - nx: 6
[01:27:45.460] - relay: TRUE
[01:27:45.460] - stdout: TRUE
[01:27:45.461] - signal: TRUE
[01:27:45.461] - resignal: FALSE
[01:27:45.461] - force: TRUE
[01:27:45.461] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.461] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.462]  - until=3
[01:27:45.462]  - relaying element #3
[01:27:45.462] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.462] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.462] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.463]  length: 3 (resolved future 3)
[01:27:45.463] signalConditionsASAP(NULL, pos=4) ...
[01:27:45.465] - nx: 6
[01:27:45.465] - relay: TRUE
[01:27:45.465] - stdout: TRUE
[01:27:45.465] - signal: TRUE
[01:27:45.466] - resignal: FALSE
[01:27:45.466] - force: TRUE
[01:27:45.466] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.466] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.466]  - until=5
[01:27:45.466]  - relaying element #5
[01:27:45.467] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.467] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.467] signalConditionsASAP(NULL, pos=4) ... done
[01:27:45.467]  length: 2 (resolved future 4)
[01:27:45.467] signalConditionsASAP(NULL, pos=5) ...
[01:27:45.467] - nx: 6
[01:27:45.468] - relay: TRUE
[01:27:45.468] - stdout: TRUE
[01:27:45.468] - signal: TRUE
[01:27:45.468] - resignal: FALSE
[01:27:45.468] - force: TRUE
[01:27:45.468] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.469] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.469]  - until=6
[01:27:45.469]  - relaying element #6
[01:27:45.469] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.469] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.469] signalConditionsASAP(NULL, pos=5) ... done
[01:27:45.470]  length: 1 (resolved future 5)
[01:27:45.470] signalConditionsASAP(numeric, pos=6) ...
[01:27:45.470] - nx: 6
[01:27:45.470] - relay: TRUE
[01:27:45.470] - stdout: TRUE
[01:27:45.470] - signal: TRUE
[01:27:45.471] - resignal: FALSE
[01:27:45.471] - force: TRUE
[01:27:45.471] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.471] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.471]  - until=6
[01:27:45.471] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.472] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.472] signalConditionsASAP(numeric, pos=6) ... done
[01:27:45.472]  length: 0 (resolved future 6)
[01:27:45.472] Relaying remaining futures
[01:27:45.472] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.472] - nx: 6
[01:27:45.473] - relay: TRUE
[01:27:45.473] - stdout: TRUE
[01:27:45.473] - signal: TRUE
[01:27:45.473] - resignal: FALSE
[01:27:45.473] - force: TRUE
[01:27:45.473] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.474] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:45.474] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.474] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.474] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.474] resolve() on list ... DONE
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
Dimensions: c(1, 6)
[01:27:45.477] getGlobalsAndPackages() ...
[01:27:45.477] Searching for globals...
[01:27:45.478] 
[01:27:45.478] Searching for globals ... DONE
[01:27:45.478] - globals: [0] <none>
[01:27:45.478] getGlobalsAndPackages() ... DONE
[01:27:45.478] run() for 'Future' ...
[01:27:45.479] - state: 'created'
[01:27:45.479] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.479] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.479] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.480]   - Field: 'label'
[01:27:45.480]   - Field: 'local'
[01:27:45.480]   - Field: 'owner'
[01:27:45.480]   - Field: 'envir'
[01:27:45.480]   - Field: 'packages'
[01:27:45.481]   - Field: 'gc'
[01:27:45.481]   - Field: 'conditions'
[01:27:45.481]   - Field: 'expr'
[01:27:45.481]   - Field: 'uuid'
[01:27:45.481]   - Field: 'seed'
[01:27:45.481]   - Field: 'version'
[01:27:45.482]   - Field: 'result'
[01:27:45.482]   - Field: 'asynchronous'
[01:27:45.482]   - Field: 'calls'
[01:27:45.482]   - Field: 'globals'
[01:27:45.482]   - Field: 'stdout'
[01:27:45.482]   - Field: 'earlySignal'
[01:27:45.483]   - Field: 'lazy'
[01:27:45.483]   - Field: 'state'
[01:27:45.483] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.483] - Launch lazy future ...
[01:27:45.483] Packages needed by the future expression (n = 0): <none>
[01:27:45.484] Packages needed by future strategies (n = 0): <none>
[01:27:45.484] {
[01:27:45.484]     {
[01:27:45.484]         {
[01:27:45.484]             ...future.startTime <- base::Sys.time()
[01:27:45.484]             {
[01:27:45.484]                 {
[01:27:45.484]                   {
[01:27:45.484]                     base::local({
[01:27:45.484]                       has_future <- base::requireNamespace("future", 
[01:27:45.484]                         quietly = TRUE)
[01:27:45.484]                       if (has_future) {
[01:27:45.484]                         ns <- base::getNamespace("future")
[01:27:45.484]                         version <- ns[[".package"]][["version"]]
[01:27:45.484]                         if (is.null(version)) 
[01:27:45.484]                           version <- utils::packageVersion("future")
[01:27:45.484]                       }
[01:27:45.484]                       else {
[01:27:45.484]                         version <- NULL
[01:27:45.484]                       }
[01:27:45.484]                       if (!has_future || version < "1.8.0") {
[01:27:45.484]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.484]                           "", base::R.version$version.string), 
[01:27:45.484]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.484]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.484]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.484]                             "release", "version")], collapse = " "), 
[01:27:45.484]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.484]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.484]                           info)
[01:27:45.484]                         info <- base::paste(info, collapse = "; ")
[01:27:45.484]                         if (!has_future) {
[01:27:45.484]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.484]                             info)
[01:27:45.484]                         }
[01:27:45.484]                         else {
[01:27:45.484]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.484]                             info, version)
[01:27:45.484]                         }
[01:27:45.484]                         base::stop(msg)
[01:27:45.484]                       }
[01:27:45.484]                     })
[01:27:45.484]                   }
[01:27:45.484]                   options(future.plan = NULL)
[01:27:45.484]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.484]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.484]                 }
[01:27:45.484]                 ...future.workdir <- getwd()
[01:27:45.484]             }
[01:27:45.484]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.484]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.484]         }
[01:27:45.484]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.484]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.484]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.484]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.484]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.484]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.484]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.484]             base::names(...future.oldOptions))
[01:27:45.484]     }
[01:27:45.484]     if (FALSE) {
[01:27:45.484]     }
[01:27:45.484]     else {
[01:27:45.484]         if (TRUE) {
[01:27:45.484]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.484]                 open = "w")
[01:27:45.484]         }
[01:27:45.484]         else {
[01:27:45.484]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.484]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.484]         }
[01:27:45.484]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.484]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.484]             base::sink(type = "output", split = FALSE)
[01:27:45.484]             base::close(...future.stdout)
[01:27:45.484]         }, add = TRUE)
[01:27:45.484]     }
[01:27:45.484]     ...future.frame <- base::sys.nframe()
[01:27:45.484]     ...future.conditions <- base::list()
[01:27:45.484]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.484]     if (FALSE) {
[01:27:45.484]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.484]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.484]     }
[01:27:45.484]     ...future.result <- base::tryCatch({
[01:27:45.484]         base::withCallingHandlers({
[01:27:45.484]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.484]             future::FutureResult(value = ...future.value$value, 
[01:27:45.484]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.484]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.484]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.484]                     ...future.globalenv.names))
[01:27:45.484]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.484]         }, condition = base::local({
[01:27:45.484]             c <- base::c
[01:27:45.484]             inherits <- base::inherits
[01:27:45.484]             invokeRestart <- base::invokeRestart
[01:27:45.484]             length <- base::length
[01:27:45.484]             list <- base::list
[01:27:45.484]             seq.int <- base::seq.int
[01:27:45.484]             signalCondition <- base::signalCondition
[01:27:45.484]             sys.calls <- base::sys.calls
[01:27:45.484]             `[[` <- base::`[[`
[01:27:45.484]             `+` <- base::`+`
[01:27:45.484]             `<<-` <- base::`<<-`
[01:27:45.484]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.484]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.484]                   3L)]
[01:27:45.484]             }
[01:27:45.484]             function(cond) {
[01:27:45.484]                 is_error <- inherits(cond, "error")
[01:27:45.484]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.484]                   NULL)
[01:27:45.484]                 if (is_error) {
[01:27:45.484]                   sessionInformation <- function() {
[01:27:45.484]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.484]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.484]                       search = base::search(), system = base::Sys.info())
[01:27:45.484]                   }
[01:27:45.484]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.484]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.484]                     cond$call), session = sessionInformation(), 
[01:27:45.484]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.484]                   signalCondition(cond)
[01:27:45.484]                 }
[01:27:45.484]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.484]                 "immediateCondition"))) {
[01:27:45.484]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.484]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.484]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.484]                   if (TRUE && !signal) {
[01:27:45.484]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.484]                     {
[01:27:45.484]                       inherits <- base::inherits
[01:27:45.484]                       invokeRestart <- base::invokeRestart
[01:27:45.484]                       is.null <- base::is.null
[01:27:45.484]                       muffled <- FALSE
[01:27:45.484]                       if (inherits(cond, "message")) {
[01:27:45.484]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.484]                         if (muffled) 
[01:27:45.484]                           invokeRestart("muffleMessage")
[01:27:45.484]                       }
[01:27:45.484]                       else if (inherits(cond, "warning")) {
[01:27:45.484]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.484]                         if (muffled) 
[01:27:45.484]                           invokeRestart("muffleWarning")
[01:27:45.484]                       }
[01:27:45.484]                       else if (inherits(cond, "condition")) {
[01:27:45.484]                         if (!is.null(pattern)) {
[01:27:45.484]                           computeRestarts <- base::computeRestarts
[01:27:45.484]                           grepl <- base::grepl
[01:27:45.484]                           restarts <- computeRestarts(cond)
[01:27:45.484]                           for (restart in restarts) {
[01:27:45.484]                             name <- restart$name
[01:27:45.484]                             if (is.null(name)) 
[01:27:45.484]                               next
[01:27:45.484]                             if (!grepl(pattern, name)) 
[01:27:45.484]                               next
[01:27:45.484]                             invokeRestart(restart)
[01:27:45.484]                             muffled <- TRUE
[01:27:45.484]                             break
[01:27:45.484]                           }
[01:27:45.484]                         }
[01:27:45.484]                       }
[01:27:45.484]                       invisible(muffled)
[01:27:45.484]                     }
[01:27:45.484]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.484]                   }
[01:27:45.484]                 }
[01:27:45.484]                 else {
[01:27:45.484]                   if (TRUE) {
[01:27:45.484]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.484]                     {
[01:27:45.484]                       inherits <- base::inherits
[01:27:45.484]                       invokeRestart <- base::invokeRestart
[01:27:45.484]                       is.null <- base::is.null
[01:27:45.484]                       muffled <- FALSE
[01:27:45.484]                       if (inherits(cond, "message")) {
[01:27:45.484]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.484]                         if (muffled) 
[01:27:45.484]                           invokeRestart("muffleMessage")
[01:27:45.484]                       }
[01:27:45.484]                       else if (inherits(cond, "warning")) {
[01:27:45.484]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.484]                         if (muffled) 
[01:27:45.484]                           invokeRestart("muffleWarning")
[01:27:45.484]                       }
[01:27:45.484]                       else if (inherits(cond, "condition")) {
[01:27:45.484]                         if (!is.null(pattern)) {
[01:27:45.484]                           computeRestarts <- base::computeRestarts
[01:27:45.484]                           grepl <- base::grepl
[01:27:45.484]                           restarts <- computeRestarts(cond)
[01:27:45.484]                           for (restart in restarts) {
[01:27:45.484]                             name <- restart$name
[01:27:45.484]                             if (is.null(name)) 
[01:27:45.484]                               next
[01:27:45.484]                             if (!grepl(pattern, name)) 
[01:27:45.484]                               next
[01:27:45.484]                             invokeRestart(restart)
[01:27:45.484]                             muffled <- TRUE
[01:27:45.484]                             break
[01:27:45.484]                           }
[01:27:45.484]                         }
[01:27:45.484]                       }
[01:27:45.484]                       invisible(muffled)
[01:27:45.484]                     }
[01:27:45.484]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.484]                   }
[01:27:45.484]                 }
[01:27:45.484]             }
[01:27:45.484]         }))
[01:27:45.484]     }, error = function(ex) {
[01:27:45.484]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.484]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.484]                 ...future.rng), started = ...future.startTime, 
[01:27:45.484]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.484]             version = "1.8"), class = "FutureResult")
[01:27:45.484]     }, finally = {
[01:27:45.484]         if (!identical(...future.workdir, getwd())) 
[01:27:45.484]             setwd(...future.workdir)
[01:27:45.484]         {
[01:27:45.484]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.484]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.484]             }
[01:27:45.484]             base::options(...future.oldOptions)
[01:27:45.484]             if (.Platform$OS.type == "windows") {
[01:27:45.484]                 old_names <- names(...future.oldEnvVars)
[01:27:45.484]                 envs <- base::Sys.getenv()
[01:27:45.484]                 names <- names(envs)
[01:27:45.484]                 common <- intersect(names, old_names)
[01:27:45.484]                 added <- setdiff(names, old_names)
[01:27:45.484]                 removed <- setdiff(old_names, names)
[01:27:45.484]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.484]                   envs[common]]
[01:27:45.484]                 NAMES <- toupper(changed)
[01:27:45.484]                 args <- list()
[01:27:45.484]                 for (kk in seq_along(NAMES)) {
[01:27:45.484]                   name <- changed[[kk]]
[01:27:45.484]                   NAME <- NAMES[[kk]]
[01:27:45.484]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.484]                     next
[01:27:45.484]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.484]                 }
[01:27:45.484]                 NAMES <- toupper(added)
[01:27:45.484]                 for (kk in seq_along(NAMES)) {
[01:27:45.484]                   name <- added[[kk]]
[01:27:45.484]                   NAME <- NAMES[[kk]]
[01:27:45.484]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.484]                     next
[01:27:45.484]                   args[[name]] <- ""
[01:27:45.484]                 }
[01:27:45.484]                 NAMES <- toupper(removed)
[01:27:45.484]                 for (kk in seq_along(NAMES)) {
[01:27:45.484]                   name <- removed[[kk]]
[01:27:45.484]                   NAME <- NAMES[[kk]]
[01:27:45.484]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.484]                     next
[01:27:45.484]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.484]                 }
[01:27:45.484]                 if (length(args) > 0) 
[01:27:45.484]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.484]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.484]             }
[01:27:45.484]             else {
[01:27:45.484]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.484]             }
[01:27:45.484]             {
[01:27:45.484]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.484]                   0L) {
[01:27:45.484]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.484]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.484]                   base::options(opts)
[01:27:45.484]                 }
[01:27:45.484]                 {
[01:27:45.484]                   {
[01:27:45.484]                     NULL
[01:27:45.484]                     RNGkind("Mersenne-Twister")
[01:27:45.484]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.484]                       inherits = FALSE)
[01:27:45.484]                   }
[01:27:45.484]                   options(future.plan = NULL)
[01:27:45.484]                   if (is.na(NA_character_)) 
[01:27:45.484]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.484]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.484]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.484]                   {
[01:27:45.484]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.484]                     if (!future$lazy) 
[01:27:45.484]                       future <- run(future)
[01:27:45.484]                     invisible(future)
[01:27:45.484]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.484]                 }
[01:27:45.484]             }
[01:27:45.484]         }
[01:27:45.484]     })
[01:27:45.484]     if (TRUE) {
[01:27:45.484]         base::sink(type = "output", split = FALSE)
[01:27:45.484]         if (TRUE) {
[01:27:45.484]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.484]         }
[01:27:45.484]         else {
[01:27:45.484]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.484]         }
[01:27:45.484]         base::close(...future.stdout)
[01:27:45.484]         ...future.stdout <- NULL
[01:27:45.484]     }
[01:27:45.484]     ...future.result$conditions <- ...future.conditions
[01:27:45.484]     ...future.result$finished <- base::Sys.time()
[01:27:45.484]     ...future.result
[01:27:45.484] }
[01:27:45.488] plan(): Setting new future strategy stack:
[01:27:45.488] List of future strategies:
[01:27:45.488] 1. sequential:
[01:27:45.488]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.488]    - tweaked: FALSE
[01:27:45.488]    - call: NULL
[01:27:45.489] plan(): nbrOfWorkers() = 1
[01:27:45.490] plan(): Setting new future strategy stack:
[01:27:45.490] List of future strategies:
[01:27:45.490] 1. sequential:
[01:27:45.490]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.490]    - tweaked: FALSE
[01:27:45.490]    - call: plan(strategy)
[01:27:45.491] plan(): nbrOfWorkers() = 1
[01:27:45.491] SequentialFuture started (and completed)
[01:27:45.491] - Launch lazy future ... done
[01:27:45.492] run() for 'SequentialFuture' ... done
[01:27:45.492] getGlobalsAndPackages() ...
[01:27:45.492] Searching for globals...
[01:27:45.492] 
[01:27:45.493] Searching for globals ... DONE
[01:27:45.493] - globals: [0] <none>
[01:27:45.493] getGlobalsAndPackages() ... DONE
[01:27:45.493] run() for 'Future' ...
[01:27:45.493] - state: 'created'
[01:27:45.494] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.494] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.494] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.494]   - Field: 'label'
[01:27:45.495]   - Field: 'local'
[01:27:45.495]   - Field: 'owner'
[01:27:45.495]   - Field: 'envir'
[01:27:45.495]   - Field: 'packages'
[01:27:45.495]   - Field: 'gc'
[01:27:45.496]   - Field: 'conditions'
[01:27:45.496]   - Field: 'expr'
[01:27:45.496]   - Field: 'uuid'
[01:27:45.496]   - Field: 'seed'
[01:27:45.496]   - Field: 'version'
[01:27:45.496]   - Field: 'result'
[01:27:45.497]   - Field: 'asynchronous'
[01:27:45.497]   - Field: 'calls'
[01:27:45.497]   - Field: 'globals'
[01:27:45.497]   - Field: 'stdout'
[01:27:45.497]   - Field: 'earlySignal'
[01:27:45.498]   - Field: 'lazy'
[01:27:45.498]   - Field: 'state'
[01:27:45.498] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.498] - Launch lazy future ...
[01:27:45.498] Packages needed by the future expression (n = 0): <none>
[01:27:45.499] Packages needed by future strategies (n = 0): <none>
[01:27:45.499] {
[01:27:45.499]     {
[01:27:45.499]         {
[01:27:45.499]             ...future.startTime <- base::Sys.time()
[01:27:45.499]             {
[01:27:45.499]                 {
[01:27:45.499]                   {
[01:27:45.499]                     base::local({
[01:27:45.499]                       has_future <- base::requireNamespace("future", 
[01:27:45.499]                         quietly = TRUE)
[01:27:45.499]                       if (has_future) {
[01:27:45.499]                         ns <- base::getNamespace("future")
[01:27:45.499]                         version <- ns[[".package"]][["version"]]
[01:27:45.499]                         if (is.null(version)) 
[01:27:45.499]                           version <- utils::packageVersion("future")
[01:27:45.499]                       }
[01:27:45.499]                       else {
[01:27:45.499]                         version <- NULL
[01:27:45.499]                       }
[01:27:45.499]                       if (!has_future || version < "1.8.0") {
[01:27:45.499]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.499]                           "", base::R.version$version.string), 
[01:27:45.499]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.499]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.499]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.499]                             "release", "version")], collapse = " "), 
[01:27:45.499]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.499]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.499]                           info)
[01:27:45.499]                         info <- base::paste(info, collapse = "; ")
[01:27:45.499]                         if (!has_future) {
[01:27:45.499]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.499]                             info)
[01:27:45.499]                         }
[01:27:45.499]                         else {
[01:27:45.499]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.499]                             info, version)
[01:27:45.499]                         }
[01:27:45.499]                         base::stop(msg)
[01:27:45.499]                       }
[01:27:45.499]                     })
[01:27:45.499]                   }
[01:27:45.499]                   options(future.plan = NULL)
[01:27:45.499]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.499]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.499]                 }
[01:27:45.499]                 ...future.workdir <- getwd()
[01:27:45.499]             }
[01:27:45.499]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.499]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.499]         }
[01:27:45.499]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.499]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.499]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.499]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.499]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.499]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.499]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.499]             base::names(...future.oldOptions))
[01:27:45.499]     }
[01:27:45.499]     if (FALSE) {
[01:27:45.499]     }
[01:27:45.499]     else {
[01:27:45.499]         if (TRUE) {
[01:27:45.499]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.499]                 open = "w")
[01:27:45.499]         }
[01:27:45.499]         else {
[01:27:45.499]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.499]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.499]         }
[01:27:45.499]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.499]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.499]             base::sink(type = "output", split = FALSE)
[01:27:45.499]             base::close(...future.stdout)
[01:27:45.499]         }, add = TRUE)
[01:27:45.499]     }
[01:27:45.499]     ...future.frame <- base::sys.nframe()
[01:27:45.499]     ...future.conditions <- base::list()
[01:27:45.499]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.499]     if (FALSE) {
[01:27:45.499]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.499]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.499]     }
[01:27:45.499]     ...future.result <- base::tryCatch({
[01:27:45.499]         base::withCallingHandlers({
[01:27:45.499]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.499]             future::FutureResult(value = ...future.value$value, 
[01:27:45.499]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.499]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.499]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.499]                     ...future.globalenv.names))
[01:27:45.499]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.499]         }, condition = base::local({
[01:27:45.499]             c <- base::c
[01:27:45.499]             inherits <- base::inherits
[01:27:45.499]             invokeRestart <- base::invokeRestart
[01:27:45.499]             length <- base::length
[01:27:45.499]             list <- base::list
[01:27:45.499]             seq.int <- base::seq.int
[01:27:45.499]             signalCondition <- base::signalCondition
[01:27:45.499]             sys.calls <- base::sys.calls
[01:27:45.499]             `[[` <- base::`[[`
[01:27:45.499]             `+` <- base::`+`
[01:27:45.499]             `<<-` <- base::`<<-`
[01:27:45.499]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.499]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.499]                   3L)]
[01:27:45.499]             }
[01:27:45.499]             function(cond) {
[01:27:45.499]                 is_error <- inherits(cond, "error")
[01:27:45.499]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.499]                   NULL)
[01:27:45.499]                 if (is_error) {
[01:27:45.499]                   sessionInformation <- function() {
[01:27:45.499]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.499]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.499]                       search = base::search(), system = base::Sys.info())
[01:27:45.499]                   }
[01:27:45.499]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.499]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.499]                     cond$call), session = sessionInformation(), 
[01:27:45.499]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.499]                   signalCondition(cond)
[01:27:45.499]                 }
[01:27:45.499]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.499]                 "immediateCondition"))) {
[01:27:45.499]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.499]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.499]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.499]                   if (TRUE && !signal) {
[01:27:45.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.499]                     {
[01:27:45.499]                       inherits <- base::inherits
[01:27:45.499]                       invokeRestart <- base::invokeRestart
[01:27:45.499]                       is.null <- base::is.null
[01:27:45.499]                       muffled <- FALSE
[01:27:45.499]                       if (inherits(cond, "message")) {
[01:27:45.499]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.499]                         if (muffled) 
[01:27:45.499]                           invokeRestart("muffleMessage")
[01:27:45.499]                       }
[01:27:45.499]                       else if (inherits(cond, "warning")) {
[01:27:45.499]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.499]                         if (muffled) 
[01:27:45.499]                           invokeRestart("muffleWarning")
[01:27:45.499]                       }
[01:27:45.499]                       else if (inherits(cond, "condition")) {
[01:27:45.499]                         if (!is.null(pattern)) {
[01:27:45.499]                           computeRestarts <- base::computeRestarts
[01:27:45.499]                           grepl <- base::grepl
[01:27:45.499]                           restarts <- computeRestarts(cond)
[01:27:45.499]                           for (restart in restarts) {
[01:27:45.499]                             name <- restart$name
[01:27:45.499]                             if (is.null(name)) 
[01:27:45.499]                               next
[01:27:45.499]                             if (!grepl(pattern, name)) 
[01:27:45.499]                               next
[01:27:45.499]                             invokeRestart(restart)
[01:27:45.499]                             muffled <- TRUE
[01:27:45.499]                             break
[01:27:45.499]                           }
[01:27:45.499]                         }
[01:27:45.499]                       }
[01:27:45.499]                       invisible(muffled)
[01:27:45.499]                     }
[01:27:45.499]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.499]                   }
[01:27:45.499]                 }
[01:27:45.499]                 else {
[01:27:45.499]                   if (TRUE) {
[01:27:45.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.499]                     {
[01:27:45.499]                       inherits <- base::inherits
[01:27:45.499]                       invokeRestart <- base::invokeRestart
[01:27:45.499]                       is.null <- base::is.null
[01:27:45.499]                       muffled <- FALSE
[01:27:45.499]                       if (inherits(cond, "message")) {
[01:27:45.499]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.499]                         if (muffled) 
[01:27:45.499]                           invokeRestart("muffleMessage")
[01:27:45.499]                       }
[01:27:45.499]                       else if (inherits(cond, "warning")) {
[01:27:45.499]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.499]                         if (muffled) 
[01:27:45.499]                           invokeRestart("muffleWarning")
[01:27:45.499]                       }
[01:27:45.499]                       else if (inherits(cond, "condition")) {
[01:27:45.499]                         if (!is.null(pattern)) {
[01:27:45.499]                           computeRestarts <- base::computeRestarts
[01:27:45.499]                           grepl <- base::grepl
[01:27:45.499]                           restarts <- computeRestarts(cond)
[01:27:45.499]                           for (restart in restarts) {
[01:27:45.499]                             name <- restart$name
[01:27:45.499]                             if (is.null(name)) 
[01:27:45.499]                               next
[01:27:45.499]                             if (!grepl(pattern, name)) 
[01:27:45.499]                               next
[01:27:45.499]                             invokeRestart(restart)
[01:27:45.499]                             muffled <- TRUE
[01:27:45.499]                             break
[01:27:45.499]                           }
[01:27:45.499]                         }
[01:27:45.499]                       }
[01:27:45.499]                       invisible(muffled)
[01:27:45.499]                     }
[01:27:45.499]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.499]                   }
[01:27:45.499]                 }
[01:27:45.499]             }
[01:27:45.499]         }))
[01:27:45.499]     }, error = function(ex) {
[01:27:45.499]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.499]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.499]                 ...future.rng), started = ...future.startTime, 
[01:27:45.499]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.499]             version = "1.8"), class = "FutureResult")
[01:27:45.499]     }, finally = {
[01:27:45.499]         if (!identical(...future.workdir, getwd())) 
[01:27:45.499]             setwd(...future.workdir)
[01:27:45.499]         {
[01:27:45.499]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.499]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.499]             }
[01:27:45.499]             base::options(...future.oldOptions)
[01:27:45.499]             if (.Platform$OS.type == "windows") {
[01:27:45.499]                 old_names <- names(...future.oldEnvVars)
[01:27:45.499]                 envs <- base::Sys.getenv()
[01:27:45.499]                 names <- names(envs)
[01:27:45.499]                 common <- intersect(names, old_names)
[01:27:45.499]                 added <- setdiff(names, old_names)
[01:27:45.499]                 removed <- setdiff(old_names, names)
[01:27:45.499]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.499]                   envs[common]]
[01:27:45.499]                 NAMES <- toupper(changed)
[01:27:45.499]                 args <- list()
[01:27:45.499]                 for (kk in seq_along(NAMES)) {
[01:27:45.499]                   name <- changed[[kk]]
[01:27:45.499]                   NAME <- NAMES[[kk]]
[01:27:45.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.499]                     next
[01:27:45.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.499]                 }
[01:27:45.499]                 NAMES <- toupper(added)
[01:27:45.499]                 for (kk in seq_along(NAMES)) {
[01:27:45.499]                   name <- added[[kk]]
[01:27:45.499]                   NAME <- NAMES[[kk]]
[01:27:45.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.499]                     next
[01:27:45.499]                   args[[name]] <- ""
[01:27:45.499]                 }
[01:27:45.499]                 NAMES <- toupper(removed)
[01:27:45.499]                 for (kk in seq_along(NAMES)) {
[01:27:45.499]                   name <- removed[[kk]]
[01:27:45.499]                   NAME <- NAMES[[kk]]
[01:27:45.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.499]                     next
[01:27:45.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.499]                 }
[01:27:45.499]                 if (length(args) > 0) 
[01:27:45.499]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.499]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.499]             }
[01:27:45.499]             else {
[01:27:45.499]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.499]             }
[01:27:45.499]             {
[01:27:45.499]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.499]                   0L) {
[01:27:45.499]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.499]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.499]                   base::options(opts)
[01:27:45.499]                 }
[01:27:45.499]                 {
[01:27:45.499]                   {
[01:27:45.499]                     NULL
[01:27:45.499]                     RNGkind("Mersenne-Twister")
[01:27:45.499]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.499]                       inherits = FALSE)
[01:27:45.499]                   }
[01:27:45.499]                   options(future.plan = NULL)
[01:27:45.499]                   if (is.na(NA_character_)) 
[01:27:45.499]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.499]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.499]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.499]                   {
[01:27:45.499]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.499]                     if (!future$lazy) 
[01:27:45.499]                       future <- run(future)
[01:27:45.499]                     invisible(future)
[01:27:45.499]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.499]                 }
[01:27:45.499]             }
[01:27:45.499]         }
[01:27:45.499]     })
[01:27:45.499]     if (TRUE) {
[01:27:45.499]         base::sink(type = "output", split = FALSE)
[01:27:45.499]         if (TRUE) {
[01:27:45.499]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.499]         }
[01:27:45.499]         else {
[01:27:45.499]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.499]         }
[01:27:45.499]         base::close(...future.stdout)
[01:27:45.499]         ...future.stdout <- NULL
[01:27:45.499]     }
[01:27:45.499]     ...future.result$conditions <- ...future.conditions
[01:27:45.499]     ...future.result$finished <- base::Sys.time()
[01:27:45.499]     ...future.result
[01:27:45.499] }
[01:27:45.503] plan(): Setting new future strategy stack:
[01:27:45.503] List of future strategies:
[01:27:45.503] 1. sequential:
[01:27:45.503]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.503]    - tweaked: FALSE
[01:27:45.503]    - call: NULL
[01:27:45.504] plan(): nbrOfWorkers() = 1
[01:27:45.505] plan(): Setting new future strategy stack:
[01:27:45.505] List of future strategies:
[01:27:45.505] 1. sequential:
[01:27:45.505]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.505]    - tweaked: FALSE
[01:27:45.505]    - call: plan(strategy)
[01:27:45.506] plan(): nbrOfWorkers() = 1
[01:27:45.506] SequentialFuture started (and completed)
[01:27:45.506] - Launch lazy future ... done
[01:27:45.506] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07446ca0> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07e4be68> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07446ca0> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07e4be68> 
 $  : 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" ...
[01:27:45.514] resolved() for 'SequentialFuture' ...
[01:27:45.514] - state: 'finished'
[01:27:45.514] - run: TRUE
[01:27:45.514] - result: 'FutureResult'
[01:27:45.515] resolved() for 'SequentialFuture' ... done
[01:27:45.515] resolved() for 'SequentialFuture' ...
[01:27:45.515] - state: 'finished'
[01:27:45.515] - run: TRUE
[01:27:45.515] - result: 'FutureResult'
[01:27:45.516] 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" "" ...
[01:27:45.518] resolve() on list ...
[01:27:45.518]  recursive: 0
[01:27:45.518]  length: 6
[01:27:45.518]  elements: 'a', 'b', 'c', '', '', ''
[01:27:45.519] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.519] - nx: 6
[01:27:45.519] - relay: TRUE
[01:27:45.519] - stdout: TRUE
[01:27:45.519] - signal: TRUE
[01:27:45.519] - resignal: FALSE
[01:27:45.520] - force: TRUE
[01:27:45.520] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.520] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.520]  - until=2
[01:27:45.520]  - relaying element #2
[01:27:45.520] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.520] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.521] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.521]  length: 5 (resolved future 1)
[01:27:45.521] resolved() for 'SequentialFuture' ...
[01:27:45.521] - state: 'finished'
[01:27:45.521] - run: TRUE
[01:27:45.522] - result: 'FutureResult'
[01:27:45.522] resolved() for 'SequentialFuture' ... done
[01:27:45.522] Future #2
[01:27:45.522] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.522] - nx: 6
[01:27:45.523] - relay: TRUE
[01:27:45.523] - stdout: TRUE
[01:27:45.523] - signal: TRUE
[01:27:45.523] - resignal: FALSE
[01:27:45.523] - force: TRUE
[01:27:45.523] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.524] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.524]  - until=2
[01:27:45.524]  - relaying element #2
[01:27:45.524] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.524] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.525] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.525]  length: 4 (resolved future 2)
[01:27:45.525] resolved() for 'SequentialFuture' ...
[01:27:45.525] - state: 'finished'
[01:27:45.525] - run: TRUE
[01:27:45.526] - result: 'FutureResult'
[01:27:45.526] resolved() for 'SequentialFuture' ... done
[01:27:45.526] Future #3
[01:27:45.526] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.526] - nx: 6
[01:27:45.527] - relay: TRUE
[01:27:45.527] - stdout: TRUE
[01:27:45.527] - signal: TRUE
[01:27:45.527] - resignal: FALSE
[01:27:45.527] - force: TRUE
[01:27:45.527] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.528] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.528]  - until=3
[01:27:45.528]  - relaying element #3
[01:27:45.528] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.528] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.529] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.529]  length: 3 (resolved future 3)
[01:27:45.529] signalConditionsASAP(NULL, pos=4) ...
[01:27:45.529] - nx: 6
[01:27:45.529] - relay: TRUE
[01:27:45.529] - stdout: TRUE
[01:27:45.529] - signal: TRUE
[01:27:45.530] - resignal: FALSE
[01:27:45.530] - force: TRUE
[01:27:45.530] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.530] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.530]  - until=5
[01:27:45.530]  - relaying element #5
[01:27:45.531] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.531] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.531] signalConditionsASAP(NULL, pos=4) ... done
[01:27:45.531]  length: 2 (resolved future 4)
[01:27:45.531] signalConditionsASAP(NULL, pos=5) ...
[01:27:45.531] - nx: 6
[01:27:45.532] - relay: TRUE
[01:27:45.532] - stdout: TRUE
[01:27:45.532] - signal: TRUE
[01:27:45.532] - resignal: FALSE
[01:27:45.532] - force: TRUE
[01:27:45.532] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.533] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.533]  - until=6
[01:27:45.533]  - relaying element #6
[01:27:45.533] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.533] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.533] signalConditionsASAP(NULL, pos=5) ... done
[01:27:45.533]  length: 1 (resolved future 5)
[01:27:45.534] signalConditionsASAP(numeric, pos=6) ...
[01:27:45.534] - nx: 6
[01:27:45.534] - relay: TRUE
[01:27:45.534] - stdout: TRUE
[01:27:45.534] - signal: TRUE
[01:27:45.534] - resignal: FALSE
[01:27:45.535] - force: TRUE
[01:27:45.535] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.535] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.535]  - until=6
[01:27:45.535] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.535] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.536] signalConditionsASAP(numeric, pos=6) ... done
[01:27:45.536]  length: 0 (resolved future 6)
[01:27:45.536] Relaying remaining futures
[01:27:45.536] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.536] - nx: 6
[01:27:45.536] - relay: TRUE
[01:27:45.537] - stdout: TRUE
[01:27:45.537] - signal: TRUE
[01:27:45.537] - resignal: FALSE
[01:27:45.537] - force: TRUE
[01:27:45.537] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.537] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:45.538] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.538] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.538] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.538] 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)
[01:27:45.543] getGlobalsAndPackages() ...
[01:27:45.543] Searching for globals...
[01:27:45.544] 
[01:27:45.544] Searching for globals ... DONE
[01:27:45.544] - globals: [0] <none>
[01:27:45.544] getGlobalsAndPackages() ... DONE
[01:27:45.545] run() for 'Future' ...
[01:27:45.545] - state: 'created'
[01:27:45.545] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.546] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.546] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.546]   - Field: 'label'
[01:27:45.546]   - Field: 'local'
[01:27:45.546]   - Field: 'owner'
[01:27:45.546]   - Field: 'envir'
[01:27:45.547]   - Field: 'packages'
[01:27:45.547]   - Field: 'gc'
[01:27:45.547]   - Field: 'conditions'
[01:27:45.547]   - Field: 'expr'
[01:27:45.547]   - Field: 'uuid'
[01:27:45.548]   - Field: 'seed'
[01:27:45.548]   - Field: 'version'
[01:27:45.548]   - Field: 'result'
[01:27:45.548]   - Field: 'asynchronous'
[01:27:45.548]   - Field: 'calls'
[01:27:45.549]   - Field: 'globals'
[01:27:45.549]   - Field: 'stdout'
[01:27:45.549]   - Field: 'earlySignal'
[01:27:45.549]   - Field: 'lazy'
[01:27:45.549]   - Field: 'state'
[01:27:45.549] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.550] - Launch lazy future ...
[01:27:45.550] Packages needed by the future expression (n = 0): <none>
[01:27:45.550] Packages needed by future strategies (n = 0): <none>
[01:27:45.551] {
[01:27:45.551]     {
[01:27:45.551]         {
[01:27:45.551]             ...future.startTime <- base::Sys.time()
[01:27:45.551]             {
[01:27:45.551]                 {
[01:27:45.551]                   {
[01:27:45.551]                     base::local({
[01:27:45.551]                       has_future <- base::requireNamespace("future", 
[01:27:45.551]                         quietly = TRUE)
[01:27:45.551]                       if (has_future) {
[01:27:45.551]                         ns <- base::getNamespace("future")
[01:27:45.551]                         version <- ns[[".package"]][["version"]]
[01:27:45.551]                         if (is.null(version)) 
[01:27:45.551]                           version <- utils::packageVersion("future")
[01:27:45.551]                       }
[01:27:45.551]                       else {
[01:27:45.551]                         version <- NULL
[01:27:45.551]                       }
[01:27:45.551]                       if (!has_future || version < "1.8.0") {
[01:27:45.551]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.551]                           "", base::R.version$version.string), 
[01:27:45.551]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.551]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.551]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.551]                             "release", "version")], collapse = " "), 
[01:27:45.551]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.551]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.551]                           info)
[01:27:45.551]                         info <- base::paste(info, collapse = "; ")
[01:27:45.551]                         if (!has_future) {
[01:27:45.551]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.551]                             info)
[01:27:45.551]                         }
[01:27:45.551]                         else {
[01:27:45.551]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.551]                             info, version)
[01:27:45.551]                         }
[01:27:45.551]                         base::stop(msg)
[01:27:45.551]                       }
[01:27:45.551]                     })
[01:27:45.551]                   }
[01:27:45.551]                   options(future.plan = NULL)
[01:27:45.551]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.551]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.551]                 }
[01:27:45.551]                 ...future.workdir <- getwd()
[01:27:45.551]             }
[01:27:45.551]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.551]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.551]         }
[01:27:45.551]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.551]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.551]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.551]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.551]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.551]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.551]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.551]             base::names(...future.oldOptions))
[01:27:45.551]     }
[01:27:45.551]     if (FALSE) {
[01:27:45.551]     }
[01:27:45.551]     else {
[01:27:45.551]         if (TRUE) {
[01:27:45.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.551]                 open = "w")
[01:27:45.551]         }
[01:27:45.551]         else {
[01:27:45.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.551]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.551]         }
[01:27:45.551]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.551]             base::sink(type = "output", split = FALSE)
[01:27:45.551]             base::close(...future.stdout)
[01:27:45.551]         }, add = TRUE)
[01:27:45.551]     }
[01:27:45.551]     ...future.frame <- base::sys.nframe()
[01:27:45.551]     ...future.conditions <- base::list()
[01:27:45.551]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.551]     if (FALSE) {
[01:27:45.551]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.551]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.551]     }
[01:27:45.551]     ...future.result <- base::tryCatch({
[01:27:45.551]         base::withCallingHandlers({
[01:27:45.551]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.551]             future::FutureResult(value = ...future.value$value, 
[01:27:45.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.551]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.551]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.551]                     ...future.globalenv.names))
[01:27:45.551]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.551]         }, condition = base::local({
[01:27:45.551]             c <- base::c
[01:27:45.551]             inherits <- base::inherits
[01:27:45.551]             invokeRestart <- base::invokeRestart
[01:27:45.551]             length <- base::length
[01:27:45.551]             list <- base::list
[01:27:45.551]             seq.int <- base::seq.int
[01:27:45.551]             signalCondition <- base::signalCondition
[01:27:45.551]             sys.calls <- base::sys.calls
[01:27:45.551]             `[[` <- base::`[[`
[01:27:45.551]             `+` <- base::`+`
[01:27:45.551]             `<<-` <- base::`<<-`
[01:27:45.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.551]                   3L)]
[01:27:45.551]             }
[01:27:45.551]             function(cond) {
[01:27:45.551]                 is_error <- inherits(cond, "error")
[01:27:45.551]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.551]                   NULL)
[01:27:45.551]                 if (is_error) {
[01:27:45.551]                   sessionInformation <- function() {
[01:27:45.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.551]                       search = base::search(), system = base::Sys.info())
[01:27:45.551]                   }
[01:27:45.551]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.551]                     cond$call), session = sessionInformation(), 
[01:27:45.551]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.551]                   signalCondition(cond)
[01:27:45.551]                 }
[01:27:45.551]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.551]                 "immediateCondition"))) {
[01:27:45.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.551]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.551]                   if (TRUE && !signal) {
[01:27:45.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.551]                     {
[01:27:45.551]                       inherits <- base::inherits
[01:27:45.551]                       invokeRestart <- base::invokeRestart
[01:27:45.551]                       is.null <- base::is.null
[01:27:45.551]                       muffled <- FALSE
[01:27:45.551]                       if (inherits(cond, "message")) {
[01:27:45.551]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.551]                         if (muffled) 
[01:27:45.551]                           invokeRestart("muffleMessage")
[01:27:45.551]                       }
[01:27:45.551]                       else if (inherits(cond, "warning")) {
[01:27:45.551]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.551]                         if (muffled) 
[01:27:45.551]                           invokeRestart("muffleWarning")
[01:27:45.551]                       }
[01:27:45.551]                       else if (inherits(cond, "condition")) {
[01:27:45.551]                         if (!is.null(pattern)) {
[01:27:45.551]                           computeRestarts <- base::computeRestarts
[01:27:45.551]                           grepl <- base::grepl
[01:27:45.551]                           restarts <- computeRestarts(cond)
[01:27:45.551]                           for (restart in restarts) {
[01:27:45.551]                             name <- restart$name
[01:27:45.551]                             if (is.null(name)) 
[01:27:45.551]                               next
[01:27:45.551]                             if (!grepl(pattern, name)) 
[01:27:45.551]                               next
[01:27:45.551]                             invokeRestart(restart)
[01:27:45.551]                             muffled <- TRUE
[01:27:45.551]                             break
[01:27:45.551]                           }
[01:27:45.551]                         }
[01:27:45.551]                       }
[01:27:45.551]                       invisible(muffled)
[01:27:45.551]                     }
[01:27:45.551]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.551]                   }
[01:27:45.551]                 }
[01:27:45.551]                 else {
[01:27:45.551]                   if (TRUE) {
[01:27:45.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.551]                     {
[01:27:45.551]                       inherits <- base::inherits
[01:27:45.551]                       invokeRestart <- base::invokeRestart
[01:27:45.551]                       is.null <- base::is.null
[01:27:45.551]                       muffled <- FALSE
[01:27:45.551]                       if (inherits(cond, "message")) {
[01:27:45.551]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.551]                         if (muffled) 
[01:27:45.551]                           invokeRestart("muffleMessage")
[01:27:45.551]                       }
[01:27:45.551]                       else if (inherits(cond, "warning")) {
[01:27:45.551]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.551]                         if (muffled) 
[01:27:45.551]                           invokeRestart("muffleWarning")
[01:27:45.551]                       }
[01:27:45.551]                       else if (inherits(cond, "condition")) {
[01:27:45.551]                         if (!is.null(pattern)) {
[01:27:45.551]                           computeRestarts <- base::computeRestarts
[01:27:45.551]                           grepl <- base::grepl
[01:27:45.551]                           restarts <- computeRestarts(cond)
[01:27:45.551]                           for (restart in restarts) {
[01:27:45.551]                             name <- restart$name
[01:27:45.551]                             if (is.null(name)) 
[01:27:45.551]                               next
[01:27:45.551]                             if (!grepl(pattern, name)) 
[01:27:45.551]                               next
[01:27:45.551]                             invokeRestart(restart)
[01:27:45.551]                             muffled <- TRUE
[01:27:45.551]                             break
[01:27:45.551]                           }
[01:27:45.551]                         }
[01:27:45.551]                       }
[01:27:45.551]                       invisible(muffled)
[01:27:45.551]                     }
[01:27:45.551]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.551]                   }
[01:27:45.551]                 }
[01:27:45.551]             }
[01:27:45.551]         }))
[01:27:45.551]     }, error = function(ex) {
[01:27:45.551]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.551]                 ...future.rng), started = ...future.startTime, 
[01:27:45.551]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.551]             version = "1.8"), class = "FutureResult")
[01:27:45.551]     }, finally = {
[01:27:45.551]         if (!identical(...future.workdir, getwd())) 
[01:27:45.551]             setwd(...future.workdir)
[01:27:45.551]         {
[01:27:45.551]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.551]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.551]             }
[01:27:45.551]             base::options(...future.oldOptions)
[01:27:45.551]             if (.Platform$OS.type == "windows") {
[01:27:45.551]                 old_names <- names(...future.oldEnvVars)
[01:27:45.551]                 envs <- base::Sys.getenv()
[01:27:45.551]                 names <- names(envs)
[01:27:45.551]                 common <- intersect(names, old_names)
[01:27:45.551]                 added <- setdiff(names, old_names)
[01:27:45.551]                 removed <- setdiff(old_names, names)
[01:27:45.551]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.551]                   envs[common]]
[01:27:45.551]                 NAMES <- toupper(changed)
[01:27:45.551]                 args <- list()
[01:27:45.551]                 for (kk in seq_along(NAMES)) {
[01:27:45.551]                   name <- changed[[kk]]
[01:27:45.551]                   NAME <- NAMES[[kk]]
[01:27:45.551]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.551]                     next
[01:27:45.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.551]                 }
[01:27:45.551]                 NAMES <- toupper(added)
[01:27:45.551]                 for (kk in seq_along(NAMES)) {
[01:27:45.551]                   name <- added[[kk]]
[01:27:45.551]                   NAME <- NAMES[[kk]]
[01:27:45.551]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.551]                     next
[01:27:45.551]                   args[[name]] <- ""
[01:27:45.551]                 }
[01:27:45.551]                 NAMES <- toupper(removed)
[01:27:45.551]                 for (kk in seq_along(NAMES)) {
[01:27:45.551]                   name <- removed[[kk]]
[01:27:45.551]                   NAME <- NAMES[[kk]]
[01:27:45.551]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.551]                     next
[01:27:45.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.551]                 }
[01:27:45.551]                 if (length(args) > 0) 
[01:27:45.551]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.551]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.551]             }
[01:27:45.551]             else {
[01:27:45.551]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.551]             }
[01:27:45.551]             {
[01:27:45.551]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.551]                   0L) {
[01:27:45.551]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.551]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.551]                   base::options(opts)
[01:27:45.551]                 }
[01:27:45.551]                 {
[01:27:45.551]                   {
[01:27:45.551]                     NULL
[01:27:45.551]                     RNGkind("Mersenne-Twister")
[01:27:45.551]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.551]                       inherits = FALSE)
[01:27:45.551]                   }
[01:27:45.551]                   options(future.plan = NULL)
[01:27:45.551]                   if (is.na(NA_character_)) 
[01:27:45.551]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.551]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.551]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.551]                   {
[01:27:45.551]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.551]                     if (!future$lazy) 
[01:27:45.551]                       future <- run(future)
[01:27:45.551]                     invisible(future)
[01:27:45.551]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.551]                 }
[01:27:45.551]             }
[01:27:45.551]         }
[01:27:45.551]     })
[01:27:45.551]     if (TRUE) {
[01:27:45.551]         base::sink(type = "output", split = FALSE)
[01:27:45.551]         if (TRUE) {
[01:27:45.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.551]         }
[01:27:45.551]         else {
[01:27:45.551]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.551]         }
[01:27:45.551]         base::close(...future.stdout)
[01:27:45.551]         ...future.stdout <- NULL
[01:27:45.551]     }
[01:27:45.551]     ...future.result$conditions <- ...future.conditions
[01:27:45.551]     ...future.result$finished <- base::Sys.time()
[01:27:45.551]     ...future.result
[01:27:45.551] }
[01:27:45.555] plan(): Setting new future strategy stack:
[01:27:45.555] List of future strategies:
[01:27:45.555] 1. sequential:
[01:27:45.555]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.555]    - tweaked: FALSE
[01:27:45.555]    - call: NULL
[01:27:45.556] plan(): nbrOfWorkers() = 1
[01:27:45.557] plan(): Setting new future strategy stack:
[01:27:45.557] List of future strategies:
[01:27:45.557] 1. sequential:
[01:27:45.557]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.557]    - tweaked: FALSE
[01:27:45.557]    - call: plan(strategy)
[01:27:45.558] plan(): nbrOfWorkers() = 1
[01:27:45.558] SequentialFuture started (and completed)
[01:27:45.558] - Launch lazy future ... done
[01:27:45.558] run() for 'SequentialFuture' ... done
[01:27:45.558] getGlobalsAndPackages() ...
[01:27:45.559] Searching for globals...
[01:27:45.559] 
[01:27:45.559] Searching for globals ... DONE
[01:27:45.559] - globals: [0] <none>
[01:27:45.559] getGlobalsAndPackages() ... DONE
[01:27:45.560] run() for 'Future' ...
[01:27:45.560] - state: 'created'
[01:27:45.560] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.561] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.561] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.561]   - Field: 'label'
[01:27:45.561]   - Field: 'local'
[01:27:45.561]   - Field: 'owner'
[01:27:45.561]   - Field: 'envir'
[01:27:45.562]   - Field: 'packages'
[01:27:45.562]   - Field: 'gc'
[01:27:45.562]   - Field: 'conditions'
[01:27:45.562]   - Field: 'expr'
[01:27:45.562]   - Field: 'uuid'
[01:27:45.562]   - Field: 'seed'
[01:27:45.563]   - Field: 'version'
[01:27:45.563]   - Field: 'result'
[01:27:45.563]   - Field: 'asynchronous'
[01:27:45.563]   - Field: 'calls'
[01:27:45.563]   - Field: 'globals'
[01:27:45.564]   - Field: 'stdout'
[01:27:45.564]   - Field: 'earlySignal'
[01:27:45.564]   - Field: 'lazy'
[01:27:45.564]   - Field: 'state'
[01:27:45.564] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.564] - Launch lazy future ...
[01:27:45.565] Packages needed by the future expression (n = 0): <none>
[01:27:45.565] Packages needed by future strategies (n = 0): <none>
[01:27:45.565] {
[01:27:45.565]     {
[01:27:45.565]         {
[01:27:45.565]             ...future.startTime <- base::Sys.time()
[01:27:45.565]             {
[01:27:45.565]                 {
[01:27:45.565]                   {
[01:27:45.565]                     base::local({
[01:27:45.565]                       has_future <- base::requireNamespace("future", 
[01:27:45.565]                         quietly = TRUE)
[01:27:45.565]                       if (has_future) {
[01:27:45.565]                         ns <- base::getNamespace("future")
[01:27:45.565]                         version <- ns[[".package"]][["version"]]
[01:27:45.565]                         if (is.null(version)) 
[01:27:45.565]                           version <- utils::packageVersion("future")
[01:27:45.565]                       }
[01:27:45.565]                       else {
[01:27:45.565]                         version <- NULL
[01:27:45.565]                       }
[01:27:45.565]                       if (!has_future || version < "1.8.0") {
[01:27:45.565]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.565]                           "", base::R.version$version.string), 
[01:27:45.565]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.565]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.565]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.565]                             "release", "version")], collapse = " "), 
[01:27:45.565]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.565]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.565]                           info)
[01:27:45.565]                         info <- base::paste(info, collapse = "; ")
[01:27:45.565]                         if (!has_future) {
[01:27:45.565]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.565]                             info)
[01:27:45.565]                         }
[01:27:45.565]                         else {
[01:27:45.565]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.565]                             info, version)
[01:27:45.565]                         }
[01:27:45.565]                         base::stop(msg)
[01:27:45.565]                       }
[01:27:45.565]                     })
[01:27:45.565]                   }
[01:27:45.565]                   options(future.plan = NULL)
[01:27:45.565]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.565]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.565]                 }
[01:27:45.565]                 ...future.workdir <- getwd()
[01:27:45.565]             }
[01:27:45.565]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.565]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.565]         }
[01:27:45.565]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.565]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.565]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.565]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.565]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.565]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.565]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.565]             base::names(...future.oldOptions))
[01:27:45.565]     }
[01:27:45.565]     if (FALSE) {
[01:27:45.565]     }
[01:27:45.565]     else {
[01:27:45.565]         if (TRUE) {
[01:27:45.565]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.565]                 open = "w")
[01:27:45.565]         }
[01:27:45.565]         else {
[01:27:45.565]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.565]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.565]         }
[01:27:45.565]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.565]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.565]             base::sink(type = "output", split = FALSE)
[01:27:45.565]             base::close(...future.stdout)
[01:27:45.565]         }, add = TRUE)
[01:27:45.565]     }
[01:27:45.565]     ...future.frame <- base::sys.nframe()
[01:27:45.565]     ...future.conditions <- base::list()
[01:27:45.565]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.565]     if (FALSE) {
[01:27:45.565]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.565]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.565]     }
[01:27:45.565]     ...future.result <- base::tryCatch({
[01:27:45.565]         base::withCallingHandlers({
[01:27:45.565]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.565]             future::FutureResult(value = ...future.value$value, 
[01:27:45.565]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.565]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.565]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.565]                     ...future.globalenv.names))
[01:27:45.565]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.565]         }, condition = base::local({
[01:27:45.565]             c <- base::c
[01:27:45.565]             inherits <- base::inherits
[01:27:45.565]             invokeRestart <- base::invokeRestart
[01:27:45.565]             length <- base::length
[01:27:45.565]             list <- base::list
[01:27:45.565]             seq.int <- base::seq.int
[01:27:45.565]             signalCondition <- base::signalCondition
[01:27:45.565]             sys.calls <- base::sys.calls
[01:27:45.565]             `[[` <- base::`[[`
[01:27:45.565]             `+` <- base::`+`
[01:27:45.565]             `<<-` <- base::`<<-`
[01:27:45.565]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.565]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.565]                   3L)]
[01:27:45.565]             }
[01:27:45.565]             function(cond) {
[01:27:45.565]                 is_error <- inherits(cond, "error")
[01:27:45.565]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.565]                   NULL)
[01:27:45.565]                 if (is_error) {
[01:27:45.565]                   sessionInformation <- function() {
[01:27:45.565]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.565]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.565]                       search = base::search(), system = base::Sys.info())
[01:27:45.565]                   }
[01:27:45.565]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.565]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.565]                     cond$call), session = sessionInformation(), 
[01:27:45.565]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.565]                   signalCondition(cond)
[01:27:45.565]                 }
[01:27:45.565]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.565]                 "immediateCondition"))) {
[01:27:45.565]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.565]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.565]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.565]                   if (TRUE && !signal) {
[01:27:45.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.565]                     {
[01:27:45.565]                       inherits <- base::inherits
[01:27:45.565]                       invokeRestart <- base::invokeRestart
[01:27:45.565]                       is.null <- base::is.null
[01:27:45.565]                       muffled <- FALSE
[01:27:45.565]                       if (inherits(cond, "message")) {
[01:27:45.565]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.565]                         if (muffled) 
[01:27:45.565]                           invokeRestart("muffleMessage")
[01:27:45.565]                       }
[01:27:45.565]                       else if (inherits(cond, "warning")) {
[01:27:45.565]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.565]                         if (muffled) 
[01:27:45.565]                           invokeRestart("muffleWarning")
[01:27:45.565]                       }
[01:27:45.565]                       else if (inherits(cond, "condition")) {
[01:27:45.565]                         if (!is.null(pattern)) {
[01:27:45.565]                           computeRestarts <- base::computeRestarts
[01:27:45.565]                           grepl <- base::grepl
[01:27:45.565]                           restarts <- computeRestarts(cond)
[01:27:45.565]                           for (restart in restarts) {
[01:27:45.565]                             name <- restart$name
[01:27:45.565]                             if (is.null(name)) 
[01:27:45.565]                               next
[01:27:45.565]                             if (!grepl(pattern, name)) 
[01:27:45.565]                               next
[01:27:45.565]                             invokeRestart(restart)
[01:27:45.565]                             muffled <- TRUE
[01:27:45.565]                             break
[01:27:45.565]                           }
[01:27:45.565]                         }
[01:27:45.565]                       }
[01:27:45.565]                       invisible(muffled)
[01:27:45.565]                     }
[01:27:45.565]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.565]                   }
[01:27:45.565]                 }
[01:27:45.565]                 else {
[01:27:45.565]                   if (TRUE) {
[01:27:45.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.565]                     {
[01:27:45.565]                       inherits <- base::inherits
[01:27:45.565]                       invokeRestart <- base::invokeRestart
[01:27:45.565]                       is.null <- base::is.null
[01:27:45.565]                       muffled <- FALSE
[01:27:45.565]                       if (inherits(cond, "message")) {
[01:27:45.565]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.565]                         if (muffled) 
[01:27:45.565]                           invokeRestart("muffleMessage")
[01:27:45.565]                       }
[01:27:45.565]                       else if (inherits(cond, "warning")) {
[01:27:45.565]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.565]                         if (muffled) 
[01:27:45.565]                           invokeRestart("muffleWarning")
[01:27:45.565]                       }
[01:27:45.565]                       else if (inherits(cond, "condition")) {
[01:27:45.565]                         if (!is.null(pattern)) {
[01:27:45.565]                           computeRestarts <- base::computeRestarts
[01:27:45.565]                           grepl <- base::grepl
[01:27:45.565]                           restarts <- computeRestarts(cond)
[01:27:45.565]                           for (restart in restarts) {
[01:27:45.565]                             name <- restart$name
[01:27:45.565]                             if (is.null(name)) 
[01:27:45.565]                               next
[01:27:45.565]                             if (!grepl(pattern, name)) 
[01:27:45.565]                               next
[01:27:45.565]                             invokeRestart(restart)
[01:27:45.565]                             muffled <- TRUE
[01:27:45.565]                             break
[01:27:45.565]                           }
[01:27:45.565]                         }
[01:27:45.565]                       }
[01:27:45.565]                       invisible(muffled)
[01:27:45.565]                     }
[01:27:45.565]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.565]                   }
[01:27:45.565]                 }
[01:27:45.565]             }
[01:27:45.565]         }))
[01:27:45.565]     }, error = function(ex) {
[01:27:45.565]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.565]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.565]                 ...future.rng), started = ...future.startTime, 
[01:27:45.565]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.565]             version = "1.8"), class = "FutureResult")
[01:27:45.565]     }, finally = {
[01:27:45.565]         if (!identical(...future.workdir, getwd())) 
[01:27:45.565]             setwd(...future.workdir)
[01:27:45.565]         {
[01:27:45.565]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.565]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.565]             }
[01:27:45.565]             base::options(...future.oldOptions)
[01:27:45.565]             if (.Platform$OS.type == "windows") {
[01:27:45.565]                 old_names <- names(...future.oldEnvVars)
[01:27:45.565]                 envs <- base::Sys.getenv()
[01:27:45.565]                 names <- names(envs)
[01:27:45.565]                 common <- intersect(names, old_names)
[01:27:45.565]                 added <- setdiff(names, old_names)
[01:27:45.565]                 removed <- setdiff(old_names, names)
[01:27:45.565]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.565]                   envs[common]]
[01:27:45.565]                 NAMES <- toupper(changed)
[01:27:45.565]                 args <- list()
[01:27:45.565]                 for (kk in seq_along(NAMES)) {
[01:27:45.565]                   name <- changed[[kk]]
[01:27:45.565]                   NAME <- NAMES[[kk]]
[01:27:45.565]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.565]                     next
[01:27:45.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.565]                 }
[01:27:45.565]                 NAMES <- toupper(added)
[01:27:45.565]                 for (kk in seq_along(NAMES)) {
[01:27:45.565]                   name <- added[[kk]]
[01:27:45.565]                   NAME <- NAMES[[kk]]
[01:27:45.565]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.565]                     next
[01:27:45.565]                   args[[name]] <- ""
[01:27:45.565]                 }
[01:27:45.565]                 NAMES <- toupper(removed)
[01:27:45.565]                 for (kk in seq_along(NAMES)) {
[01:27:45.565]                   name <- removed[[kk]]
[01:27:45.565]                   NAME <- NAMES[[kk]]
[01:27:45.565]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.565]                     next
[01:27:45.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.565]                 }
[01:27:45.565]                 if (length(args) > 0) 
[01:27:45.565]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.565]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.565]             }
[01:27:45.565]             else {
[01:27:45.565]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.565]             }
[01:27:45.565]             {
[01:27:45.565]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.565]                   0L) {
[01:27:45.565]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.565]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.565]                   base::options(opts)
[01:27:45.565]                 }
[01:27:45.565]                 {
[01:27:45.565]                   {
[01:27:45.565]                     NULL
[01:27:45.565]                     RNGkind("Mersenne-Twister")
[01:27:45.565]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.565]                       inherits = FALSE)
[01:27:45.565]                   }
[01:27:45.565]                   options(future.plan = NULL)
[01:27:45.565]                   if (is.na(NA_character_)) 
[01:27:45.565]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.565]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.565]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.565]                   {
[01:27:45.565]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.565]                     if (!future$lazy) 
[01:27:45.565]                       future <- run(future)
[01:27:45.565]                     invisible(future)
[01:27:45.565]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.565]                 }
[01:27:45.565]             }
[01:27:45.565]         }
[01:27:45.565]     })
[01:27:45.565]     if (TRUE) {
[01:27:45.565]         base::sink(type = "output", split = FALSE)
[01:27:45.565]         if (TRUE) {
[01:27:45.565]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.565]         }
[01:27:45.565]         else {
[01:27:45.565]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.565]         }
[01:27:45.565]         base::close(...future.stdout)
[01:27:45.565]         ...future.stdout <- NULL
[01:27:45.565]     }
[01:27:45.565]     ...future.result$conditions <- ...future.conditions
[01:27:45.565]     ...future.result$finished <- base::Sys.time()
[01:27:45.565]     ...future.result
[01:27:45.565] }
[01:27:45.569] plan(): Setting new future strategy stack:
[01:27:45.569] List of future strategies:
[01:27:45.569] 1. sequential:
[01:27:45.569]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.569]    - tweaked: FALSE
[01:27:45.569]    - call: NULL
[01:27:45.570] plan(): nbrOfWorkers() = 1
[01:27:45.571] plan(): Setting new future strategy stack:
[01:27:45.571] List of future strategies:
[01:27:45.571] 1. sequential:
[01:27:45.571]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.571]    - tweaked: FALSE
[01:27:45.571]    - call: plan(strategy)
[01:27:45.572] plan(): nbrOfWorkers() = 1
[01:27:45.572] SequentialFuture started (and completed)
[01:27:45.573] - Launch lazy future ... done
[01:27:45.573] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b04ca9aa8> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07439568> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b04ca9aa8> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07439568> 
 $  : 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"
[01:27:45.579] resolved() for 'SequentialFuture' ...
[01:27:45.579] - state: 'finished'
[01:27:45.579] - run: TRUE
[01:27:45.580] - result: 'FutureResult'
[01:27:45.580] resolved() for 'SequentialFuture' ... done
[01:27:45.580] resolved() for 'SequentialFuture' ...
[01:27:45.580] - state: 'finished'
[01:27:45.580] - run: TRUE
[01:27:45.581] - result: 'FutureResult'
[01:27:45.581] 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" "" ...
[01:27:45.584] resolve() on list ...
[01:27:45.584]  recursive: 0
[01:27:45.585]  length: 6
[01:27:45.585]  elements: 'a', 'b', 'c', '', '', ''
[01:27:45.585] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.585] - nx: 6
[01:27:45.585] - relay: TRUE
[01:27:45.586] - stdout: TRUE
[01:27:45.586] - signal: TRUE
[01:27:45.586] - resignal: FALSE
[01:27:45.586] - force: TRUE
[01:27:45.586] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.586] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.587]  - until=2
[01:27:45.587]  - relaying element #2
[01:27:45.587] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.587] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.587] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.588]  length: 5 (resolved future 1)
[01:27:45.588] resolved() for 'SequentialFuture' ...
[01:27:45.588] - state: 'finished'
[01:27:45.588] - run: TRUE
[01:27:45.588] - result: 'FutureResult'
[01:27:45.589] resolved() for 'SequentialFuture' ... done
[01:27:45.589] Future #2
[01:27:45.589] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.589] - nx: 6
[01:27:45.589] - relay: TRUE
[01:27:45.589] - stdout: TRUE
[01:27:45.590] - signal: TRUE
[01:27:45.590] - resignal: FALSE
[01:27:45.590] - force: TRUE
[01:27:45.590] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.590] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.590]  - until=2
[01:27:45.591]  - relaying element #2
[01:27:45.591] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.591] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.591] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.592]  length: 4 (resolved future 2)
[01:27:45.592] resolved() for 'SequentialFuture' ...
[01:27:45.592] - state: 'finished'
[01:27:45.592] - run: TRUE
[01:27:45.592] - result: 'FutureResult'
[01:27:45.592] resolved() for 'SequentialFuture' ... done
[01:27:45.593] Future #3
[01:27:45.593] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.593] - nx: 6
[01:27:45.593] - relay: TRUE
[01:27:45.593] - stdout: TRUE
[01:27:45.594] - signal: TRUE
[01:27:45.594] - resignal: FALSE
[01:27:45.594] - force: TRUE
[01:27:45.594] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.594] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.594]  - until=3
[01:27:45.595]  - relaying element #3
[01:27:45.595] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.595] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.595] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.595]  length: 3 (resolved future 3)
[01:27:45.595] signalConditionsASAP(NULL, pos=4) ...
[01:27:45.596] - nx: 6
[01:27:45.596] - relay: TRUE
[01:27:45.596] - stdout: TRUE
[01:27:45.596] - signal: TRUE
[01:27:45.596] - resignal: FALSE
[01:27:45.596] - force: TRUE
[01:27:45.597] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.597] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.597]  - until=5
[01:27:45.597]  - relaying element #5
[01:27:45.597] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.597] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.598] signalConditionsASAP(NULL, pos=4) ... done
[01:27:45.598]  length: 2 (resolved future 4)
[01:27:45.598] signalConditionsASAP(NULL, pos=5) ...
[01:27:45.598] - nx: 6
[01:27:45.598] - relay: TRUE
[01:27:45.598] - stdout: TRUE
[01:27:45.599] - signal: TRUE
[01:27:45.599] - resignal: FALSE
[01:27:45.599] - force: TRUE
[01:27:45.599] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.599] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.599]  - until=6
[01:27:45.600]  - relaying element #6
[01:27:45.600] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.600] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.600] signalConditionsASAP(NULL, pos=5) ... done
[01:27:45.600]  length: 1 (resolved future 5)
[01:27:45.600] signalConditionsASAP(numeric, pos=6) ...
[01:27:45.600] - nx: 6
[01:27:45.601] - relay: TRUE
[01:27:45.601] - stdout: TRUE
[01:27:45.601] - signal: TRUE
[01:27:45.601] - resignal: FALSE
[01:27:45.601] - force: TRUE
[01:27:45.601] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.602] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.602]  - until=6
[01:27:45.602] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.602] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.602] signalConditionsASAP(numeric, pos=6) ... done
[01:27:45.602]  length: 0 (resolved future 6)
[01:27:45.603] Relaying remaining futures
[01:27:45.603] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.603] - nx: 6
[01:27:45.603] - relay: TRUE
[01:27:45.603] - stdout: TRUE
[01:27:45.603] - signal: TRUE
[01:27:45.604] - resignal: FALSE
[01:27:45.604] - force: TRUE
[01:27:45.604] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.604] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:45.604] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.604] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.605] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.605] 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)
[01:27:45.609] getGlobalsAndPackages() ...
[01:27:45.609] Searching for globals...
[01:27:45.609] 
[01:27:45.609] Searching for globals ... DONE
[01:27:45.610] - globals: [0] <none>
[01:27:45.610] getGlobalsAndPackages() ... DONE
[01:27:45.610] run() for 'Future' ...
[01:27:45.610] - state: 'created'
[01:27:45.610] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.611] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.611] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.611]   - Field: 'label'
[01:27:45.611]   - Field: 'local'
[01:27:45.612]   - Field: 'owner'
[01:27:45.612]   - Field: 'envir'
[01:27:45.612]   - Field: 'packages'
[01:27:45.612]   - Field: 'gc'
[01:27:45.612]   - Field: 'conditions'
[01:27:45.612]   - Field: 'expr'
[01:27:45.613]   - Field: 'uuid'
[01:27:45.613]   - Field: 'seed'
[01:27:45.613]   - Field: 'version'
[01:27:45.613]   - Field: 'result'
[01:27:45.613]   - Field: 'asynchronous'
[01:27:45.613]   - Field: 'calls'
[01:27:45.614]   - Field: 'globals'
[01:27:45.614]   - Field: 'stdout'
[01:27:45.614]   - Field: 'earlySignal'
[01:27:45.614]   - Field: 'lazy'
[01:27:45.614]   - Field: 'state'
[01:27:45.615] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.615] - Launch lazy future ...
[01:27:45.615] Packages needed by the future expression (n = 0): <none>
[01:27:45.615] Packages needed by future strategies (n = 0): <none>
[01:27:45.616] {
[01:27:45.616]     {
[01:27:45.616]         {
[01:27:45.616]             ...future.startTime <- base::Sys.time()
[01:27:45.616]             {
[01:27:45.616]                 {
[01:27:45.616]                   {
[01:27:45.616]                     base::local({
[01:27:45.616]                       has_future <- base::requireNamespace("future", 
[01:27:45.616]                         quietly = TRUE)
[01:27:45.616]                       if (has_future) {
[01:27:45.616]                         ns <- base::getNamespace("future")
[01:27:45.616]                         version <- ns[[".package"]][["version"]]
[01:27:45.616]                         if (is.null(version)) 
[01:27:45.616]                           version <- utils::packageVersion("future")
[01:27:45.616]                       }
[01:27:45.616]                       else {
[01:27:45.616]                         version <- NULL
[01:27:45.616]                       }
[01:27:45.616]                       if (!has_future || version < "1.8.0") {
[01:27:45.616]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.616]                           "", base::R.version$version.string), 
[01:27:45.616]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.616]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.616]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.616]                             "release", "version")], collapse = " "), 
[01:27:45.616]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.616]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.616]                           info)
[01:27:45.616]                         info <- base::paste(info, collapse = "; ")
[01:27:45.616]                         if (!has_future) {
[01:27:45.616]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.616]                             info)
[01:27:45.616]                         }
[01:27:45.616]                         else {
[01:27:45.616]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.616]                             info, version)
[01:27:45.616]                         }
[01:27:45.616]                         base::stop(msg)
[01:27:45.616]                       }
[01:27:45.616]                     })
[01:27:45.616]                   }
[01:27:45.616]                   options(future.plan = NULL)
[01:27:45.616]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.616]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.616]                 }
[01:27:45.616]                 ...future.workdir <- getwd()
[01:27:45.616]             }
[01:27:45.616]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.616]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.616]         }
[01:27:45.616]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.616]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.616]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.616]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.616]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.616]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.616]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.616]             base::names(...future.oldOptions))
[01:27:45.616]     }
[01:27:45.616]     if (FALSE) {
[01:27:45.616]     }
[01:27:45.616]     else {
[01:27:45.616]         if (TRUE) {
[01:27:45.616]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.616]                 open = "w")
[01:27:45.616]         }
[01:27:45.616]         else {
[01:27:45.616]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.616]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.616]         }
[01:27:45.616]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.616]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.616]             base::sink(type = "output", split = FALSE)
[01:27:45.616]             base::close(...future.stdout)
[01:27:45.616]         }, add = TRUE)
[01:27:45.616]     }
[01:27:45.616]     ...future.frame <- base::sys.nframe()
[01:27:45.616]     ...future.conditions <- base::list()
[01:27:45.616]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.616]     if (FALSE) {
[01:27:45.616]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.616]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.616]     }
[01:27:45.616]     ...future.result <- base::tryCatch({
[01:27:45.616]         base::withCallingHandlers({
[01:27:45.616]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.616]             future::FutureResult(value = ...future.value$value, 
[01:27:45.616]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.616]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.616]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.616]                     ...future.globalenv.names))
[01:27:45.616]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.616]         }, condition = base::local({
[01:27:45.616]             c <- base::c
[01:27:45.616]             inherits <- base::inherits
[01:27:45.616]             invokeRestart <- base::invokeRestart
[01:27:45.616]             length <- base::length
[01:27:45.616]             list <- base::list
[01:27:45.616]             seq.int <- base::seq.int
[01:27:45.616]             signalCondition <- base::signalCondition
[01:27:45.616]             sys.calls <- base::sys.calls
[01:27:45.616]             `[[` <- base::`[[`
[01:27:45.616]             `+` <- base::`+`
[01:27:45.616]             `<<-` <- base::`<<-`
[01:27:45.616]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.616]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.616]                   3L)]
[01:27:45.616]             }
[01:27:45.616]             function(cond) {
[01:27:45.616]                 is_error <- inherits(cond, "error")
[01:27:45.616]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.616]                   NULL)
[01:27:45.616]                 if (is_error) {
[01:27:45.616]                   sessionInformation <- function() {
[01:27:45.616]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.616]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.616]                       search = base::search(), system = base::Sys.info())
[01:27:45.616]                   }
[01:27:45.616]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.616]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.616]                     cond$call), session = sessionInformation(), 
[01:27:45.616]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.616]                   signalCondition(cond)
[01:27:45.616]                 }
[01:27:45.616]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.616]                 "immediateCondition"))) {
[01:27:45.616]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.616]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.616]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.616]                   if (TRUE && !signal) {
[01:27:45.616]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.616]                     {
[01:27:45.616]                       inherits <- base::inherits
[01:27:45.616]                       invokeRestart <- base::invokeRestart
[01:27:45.616]                       is.null <- base::is.null
[01:27:45.616]                       muffled <- FALSE
[01:27:45.616]                       if (inherits(cond, "message")) {
[01:27:45.616]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.616]                         if (muffled) 
[01:27:45.616]                           invokeRestart("muffleMessage")
[01:27:45.616]                       }
[01:27:45.616]                       else if (inherits(cond, "warning")) {
[01:27:45.616]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.616]                         if (muffled) 
[01:27:45.616]                           invokeRestart("muffleWarning")
[01:27:45.616]                       }
[01:27:45.616]                       else if (inherits(cond, "condition")) {
[01:27:45.616]                         if (!is.null(pattern)) {
[01:27:45.616]                           computeRestarts <- base::computeRestarts
[01:27:45.616]                           grepl <- base::grepl
[01:27:45.616]                           restarts <- computeRestarts(cond)
[01:27:45.616]                           for (restart in restarts) {
[01:27:45.616]                             name <- restart$name
[01:27:45.616]                             if (is.null(name)) 
[01:27:45.616]                               next
[01:27:45.616]                             if (!grepl(pattern, name)) 
[01:27:45.616]                               next
[01:27:45.616]                             invokeRestart(restart)
[01:27:45.616]                             muffled <- TRUE
[01:27:45.616]                             break
[01:27:45.616]                           }
[01:27:45.616]                         }
[01:27:45.616]                       }
[01:27:45.616]                       invisible(muffled)
[01:27:45.616]                     }
[01:27:45.616]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.616]                   }
[01:27:45.616]                 }
[01:27:45.616]                 else {
[01:27:45.616]                   if (TRUE) {
[01:27:45.616]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.616]                     {
[01:27:45.616]                       inherits <- base::inherits
[01:27:45.616]                       invokeRestart <- base::invokeRestart
[01:27:45.616]                       is.null <- base::is.null
[01:27:45.616]                       muffled <- FALSE
[01:27:45.616]                       if (inherits(cond, "message")) {
[01:27:45.616]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.616]                         if (muffled) 
[01:27:45.616]                           invokeRestart("muffleMessage")
[01:27:45.616]                       }
[01:27:45.616]                       else if (inherits(cond, "warning")) {
[01:27:45.616]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.616]                         if (muffled) 
[01:27:45.616]                           invokeRestart("muffleWarning")
[01:27:45.616]                       }
[01:27:45.616]                       else if (inherits(cond, "condition")) {
[01:27:45.616]                         if (!is.null(pattern)) {
[01:27:45.616]                           computeRestarts <- base::computeRestarts
[01:27:45.616]                           grepl <- base::grepl
[01:27:45.616]                           restarts <- computeRestarts(cond)
[01:27:45.616]                           for (restart in restarts) {
[01:27:45.616]                             name <- restart$name
[01:27:45.616]                             if (is.null(name)) 
[01:27:45.616]                               next
[01:27:45.616]                             if (!grepl(pattern, name)) 
[01:27:45.616]                               next
[01:27:45.616]                             invokeRestart(restart)
[01:27:45.616]                             muffled <- TRUE
[01:27:45.616]                             break
[01:27:45.616]                           }
[01:27:45.616]                         }
[01:27:45.616]                       }
[01:27:45.616]                       invisible(muffled)
[01:27:45.616]                     }
[01:27:45.616]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.616]                   }
[01:27:45.616]                 }
[01:27:45.616]             }
[01:27:45.616]         }))
[01:27:45.616]     }, error = function(ex) {
[01:27:45.616]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.616]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.616]                 ...future.rng), started = ...future.startTime, 
[01:27:45.616]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.616]             version = "1.8"), class = "FutureResult")
[01:27:45.616]     }, finally = {
[01:27:45.616]         if (!identical(...future.workdir, getwd())) 
[01:27:45.616]             setwd(...future.workdir)
[01:27:45.616]         {
[01:27:45.616]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.616]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.616]             }
[01:27:45.616]             base::options(...future.oldOptions)
[01:27:45.616]             if (.Platform$OS.type == "windows") {
[01:27:45.616]                 old_names <- names(...future.oldEnvVars)
[01:27:45.616]                 envs <- base::Sys.getenv()
[01:27:45.616]                 names <- names(envs)
[01:27:45.616]                 common <- intersect(names, old_names)
[01:27:45.616]                 added <- setdiff(names, old_names)
[01:27:45.616]                 removed <- setdiff(old_names, names)
[01:27:45.616]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.616]                   envs[common]]
[01:27:45.616]                 NAMES <- toupper(changed)
[01:27:45.616]                 args <- list()
[01:27:45.616]                 for (kk in seq_along(NAMES)) {
[01:27:45.616]                   name <- changed[[kk]]
[01:27:45.616]                   NAME <- NAMES[[kk]]
[01:27:45.616]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.616]                     next
[01:27:45.616]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.616]                 }
[01:27:45.616]                 NAMES <- toupper(added)
[01:27:45.616]                 for (kk in seq_along(NAMES)) {
[01:27:45.616]                   name <- added[[kk]]
[01:27:45.616]                   NAME <- NAMES[[kk]]
[01:27:45.616]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.616]                     next
[01:27:45.616]                   args[[name]] <- ""
[01:27:45.616]                 }
[01:27:45.616]                 NAMES <- toupper(removed)
[01:27:45.616]                 for (kk in seq_along(NAMES)) {
[01:27:45.616]                   name <- removed[[kk]]
[01:27:45.616]                   NAME <- NAMES[[kk]]
[01:27:45.616]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.616]                     next
[01:27:45.616]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.616]                 }
[01:27:45.616]                 if (length(args) > 0) 
[01:27:45.616]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.616]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.616]             }
[01:27:45.616]             else {
[01:27:45.616]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.616]             }
[01:27:45.616]             {
[01:27:45.616]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.616]                   0L) {
[01:27:45.616]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.616]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.616]                   base::options(opts)
[01:27:45.616]                 }
[01:27:45.616]                 {
[01:27:45.616]                   {
[01:27:45.616]                     NULL
[01:27:45.616]                     RNGkind("Mersenne-Twister")
[01:27:45.616]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.616]                       inherits = FALSE)
[01:27:45.616]                   }
[01:27:45.616]                   options(future.plan = NULL)
[01:27:45.616]                   if (is.na(NA_character_)) 
[01:27:45.616]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.616]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.616]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.616]                   {
[01:27:45.616]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.616]                     if (!future$lazy) 
[01:27:45.616]                       future <- run(future)
[01:27:45.616]                     invisible(future)
[01:27:45.616]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.616]                 }
[01:27:45.616]             }
[01:27:45.616]         }
[01:27:45.616]     })
[01:27:45.616]     if (TRUE) {
[01:27:45.616]         base::sink(type = "output", split = FALSE)
[01:27:45.616]         if (TRUE) {
[01:27:45.616]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.616]         }
[01:27:45.616]         else {
[01:27:45.616]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.616]         }
[01:27:45.616]         base::close(...future.stdout)
[01:27:45.616]         ...future.stdout <- NULL
[01:27:45.616]     }
[01:27:45.616]     ...future.result$conditions <- ...future.conditions
[01:27:45.616]     ...future.result$finished <- base::Sys.time()
[01:27:45.616]     ...future.result
[01:27:45.616] }
[01:27:45.620] plan(): Setting new future strategy stack:
[01:27:45.620] List of future strategies:
[01:27:45.620] 1. sequential:
[01:27:45.620]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.620]    - tweaked: FALSE
[01:27:45.620]    - call: NULL
[01:27:45.621] plan(): nbrOfWorkers() = 1
[01:27:45.623] plan(): Setting new future strategy stack:
[01:27:45.623] List of future strategies:
[01:27:45.623] 1. sequential:
[01:27:45.623]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.623]    - tweaked: FALSE
[01:27:45.623]    - call: plan(strategy)
[01:27:45.624] plan(): nbrOfWorkers() = 1
[01:27:45.624] SequentialFuture started (and completed)
[01:27:45.624] - Launch lazy future ... done
[01:27:45.625] run() for 'SequentialFuture' ... done
[01:27:45.625] getGlobalsAndPackages() ...
[01:27:45.625] Searching for globals...
[01:27:45.625] 
[01:27:45.626] Searching for globals ... DONE
[01:27:45.626] - globals: [0] <none>
[01:27:45.626] getGlobalsAndPackages() ... DONE
[01:27:45.626] run() for 'Future' ...
[01:27:45.626] - state: 'created'
[01:27:45.627] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.627] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.627] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.627]   - Field: 'label'
[01:27:45.628]   - Field: 'local'
[01:27:45.628]   - Field: 'owner'
[01:27:45.628]   - Field: 'envir'
[01:27:45.628]   - Field: 'packages'
[01:27:45.628]   - Field: 'gc'
[01:27:45.628]   - Field: 'conditions'
[01:27:45.629]   - Field: 'expr'
[01:27:45.629]   - Field: 'uuid'
[01:27:45.629]   - Field: 'seed'
[01:27:45.629]   - Field: 'version'
[01:27:45.629]   - Field: 'result'
[01:27:45.630]   - Field: 'asynchronous'
[01:27:45.630]   - Field: 'calls'
[01:27:45.630]   - Field: 'globals'
[01:27:45.630]   - Field: 'stdout'
[01:27:45.630]   - Field: 'earlySignal'
[01:27:45.630]   - Field: 'lazy'
[01:27:45.631]   - Field: 'state'
[01:27:45.631] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.631] - Launch lazy future ...
[01:27:45.631] Packages needed by the future expression (n = 0): <none>
[01:27:45.631] Packages needed by future strategies (n = 0): <none>
[01:27:45.632] {
[01:27:45.632]     {
[01:27:45.632]         {
[01:27:45.632]             ...future.startTime <- base::Sys.time()
[01:27:45.632]             {
[01:27:45.632]                 {
[01:27:45.632]                   {
[01:27:45.632]                     base::local({
[01:27:45.632]                       has_future <- base::requireNamespace("future", 
[01:27:45.632]                         quietly = TRUE)
[01:27:45.632]                       if (has_future) {
[01:27:45.632]                         ns <- base::getNamespace("future")
[01:27:45.632]                         version <- ns[[".package"]][["version"]]
[01:27:45.632]                         if (is.null(version)) 
[01:27:45.632]                           version <- utils::packageVersion("future")
[01:27:45.632]                       }
[01:27:45.632]                       else {
[01:27:45.632]                         version <- NULL
[01:27:45.632]                       }
[01:27:45.632]                       if (!has_future || version < "1.8.0") {
[01:27:45.632]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.632]                           "", base::R.version$version.string), 
[01:27:45.632]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.632]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.632]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.632]                             "release", "version")], collapse = " "), 
[01:27:45.632]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.632]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.632]                           info)
[01:27:45.632]                         info <- base::paste(info, collapse = "; ")
[01:27:45.632]                         if (!has_future) {
[01:27:45.632]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.632]                             info)
[01:27:45.632]                         }
[01:27:45.632]                         else {
[01:27:45.632]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.632]                             info, version)
[01:27:45.632]                         }
[01:27:45.632]                         base::stop(msg)
[01:27:45.632]                       }
[01:27:45.632]                     })
[01:27:45.632]                   }
[01:27:45.632]                   options(future.plan = NULL)
[01:27:45.632]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.632]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.632]                 }
[01:27:45.632]                 ...future.workdir <- getwd()
[01:27:45.632]             }
[01:27:45.632]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.632]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.632]         }
[01:27:45.632]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.632]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.632]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.632]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.632]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.632]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.632]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.632]             base::names(...future.oldOptions))
[01:27:45.632]     }
[01:27:45.632]     if (FALSE) {
[01:27:45.632]     }
[01:27:45.632]     else {
[01:27:45.632]         if (TRUE) {
[01:27:45.632]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.632]                 open = "w")
[01:27:45.632]         }
[01:27:45.632]         else {
[01:27:45.632]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.632]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.632]         }
[01:27:45.632]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.632]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.632]             base::sink(type = "output", split = FALSE)
[01:27:45.632]             base::close(...future.stdout)
[01:27:45.632]         }, add = TRUE)
[01:27:45.632]     }
[01:27:45.632]     ...future.frame <- base::sys.nframe()
[01:27:45.632]     ...future.conditions <- base::list()
[01:27:45.632]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.632]     if (FALSE) {
[01:27:45.632]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.632]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.632]     }
[01:27:45.632]     ...future.result <- base::tryCatch({
[01:27:45.632]         base::withCallingHandlers({
[01:27:45.632]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.632]             future::FutureResult(value = ...future.value$value, 
[01:27:45.632]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.632]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.632]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.632]                     ...future.globalenv.names))
[01:27:45.632]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.632]         }, condition = base::local({
[01:27:45.632]             c <- base::c
[01:27:45.632]             inherits <- base::inherits
[01:27:45.632]             invokeRestart <- base::invokeRestart
[01:27:45.632]             length <- base::length
[01:27:45.632]             list <- base::list
[01:27:45.632]             seq.int <- base::seq.int
[01:27:45.632]             signalCondition <- base::signalCondition
[01:27:45.632]             sys.calls <- base::sys.calls
[01:27:45.632]             `[[` <- base::`[[`
[01:27:45.632]             `+` <- base::`+`
[01:27:45.632]             `<<-` <- base::`<<-`
[01:27:45.632]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.632]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.632]                   3L)]
[01:27:45.632]             }
[01:27:45.632]             function(cond) {
[01:27:45.632]                 is_error <- inherits(cond, "error")
[01:27:45.632]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.632]                   NULL)
[01:27:45.632]                 if (is_error) {
[01:27:45.632]                   sessionInformation <- function() {
[01:27:45.632]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.632]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.632]                       search = base::search(), system = base::Sys.info())
[01:27:45.632]                   }
[01:27:45.632]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.632]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.632]                     cond$call), session = sessionInformation(), 
[01:27:45.632]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.632]                   signalCondition(cond)
[01:27:45.632]                 }
[01:27:45.632]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.632]                 "immediateCondition"))) {
[01:27:45.632]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.632]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.632]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.632]                   if (TRUE && !signal) {
[01:27:45.632]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.632]                     {
[01:27:45.632]                       inherits <- base::inherits
[01:27:45.632]                       invokeRestart <- base::invokeRestart
[01:27:45.632]                       is.null <- base::is.null
[01:27:45.632]                       muffled <- FALSE
[01:27:45.632]                       if (inherits(cond, "message")) {
[01:27:45.632]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.632]                         if (muffled) 
[01:27:45.632]                           invokeRestart("muffleMessage")
[01:27:45.632]                       }
[01:27:45.632]                       else if (inherits(cond, "warning")) {
[01:27:45.632]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.632]                         if (muffled) 
[01:27:45.632]                           invokeRestart("muffleWarning")
[01:27:45.632]                       }
[01:27:45.632]                       else if (inherits(cond, "condition")) {
[01:27:45.632]                         if (!is.null(pattern)) {
[01:27:45.632]                           computeRestarts <- base::computeRestarts
[01:27:45.632]                           grepl <- base::grepl
[01:27:45.632]                           restarts <- computeRestarts(cond)
[01:27:45.632]                           for (restart in restarts) {
[01:27:45.632]                             name <- restart$name
[01:27:45.632]                             if (is.null(name)) 
[01:27:45.632]                               next
[01:27:45.632]                             if (!grepl(pattern, name)) 
[01:27:45.632]                               next
[01:27:45.632]                             invokeRestart(restart)
[01:27:45.632]                             muffled <- TRUE
[01:27:45.632]                             break
[01:27:45.632]                           }
[01:27:45.632]                         }
[01:27:45.632]                       }
[01:27:45.632]                       invisible(muffled)
[01:27:45.632]                     }
[01:27:45.632]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.632]                   }
[01:27:45.632]                 }
[01:27:45.632]                 else {
[01:27:45.632]                   if (TRUE) {
[01:27:45.632]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.632]                     {
[01:27:45.632]                       inherits <- base::inherits
[01:27:45.632]                       invokeRestart <- base::invokeRestart
[01:27:45.632]                       is.null <- base::is.null
[01:27:45.632]                       muffled <- FALSE
[01:27:45.632]                       if (inherits(cond, "message")) {
[01:27:45.632]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.632]                         if (muffled) 
[01:27:45.632]                           invokeRestart("muffleMessage")
[01:27:45.632]                       }
[01:27:45.632]                       else if (inherits(cond, "warning")) {
[01:27:45.632]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.632]                         if (muffled) 
[01:27:45.632]                           invokeRestart("muffleWarning")
[01:27:45.632]                       }
[01:27:45.632]                       else if (inherits(cond, "condition")) {
[01:27:45.632]                         if (!is.null(pattern)) {
[01:27:45.632]                           computeRestarts <- base::computeRestarts
[01:27:45.632]                           grepl <- base::grepl
[01:27:45.632]                           restarts <- computeRestarts(cond)
[01:27:45.632]                           for (restart in restarts) {
[01:27:45.632]                             name <- restart$name
[01:27:45.632]                             if (is.null(name)) 
[01:27:45.632]                               next
[01:27:45.632]                             if (!grepl(pattern, name)) 
[01:27:45.632]                               next
[01:27:45.632]                             invokeRestart(restart)
[01:27:45.632]                             muffled <- TRUE
[01:27:45.632]                             break
[01:27:45.632]                           }
[01:27:45.632]                         }
[01:27:45.632]                       }
[01:27:45.632]                       invisible(muffled)
[01:27:45.632]                     }
[01:27:45.632]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.632]                   }
[01:27:45.632]                 }
[01:27:45.632]             }
[01:27:45.632]         }))
[01:27:45.632]     }, error = function(ex) {
[01:27:45.632]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.632]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.632]                 ...future.rng), started = ...future.startTime, 
[01:27:45.632]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.632]             version = "1.8"), class = "FutureResult")
[01:27:45.632]     }, finally = {
[01:27:45.632]         if (!identical(...future.workdir, getwd())) 
[01:27:45.632]             setwd(...future.workdir)
[01:27:45.632]         {
[01:27:45.632]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.632]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.632]             }
[01:27:45.632]             base::options(...future.oldOptions)
[01:27:45.632]             if (.Platform$OS.type == "windows") {
[01:27:45.632]                 old_names <- names(...future.oldEnvVars)
[01:27:45.632]                 envs <- base::Sys.getenv()
[01:27:45.632]                 names <- names(envs)
[01:27:45.632]                 common <- intersect(names, old_names)
[01:27:45.632]                 added <- setdiff(names, old_names)
[01:27:45.632]                 removed <- setdiff(old_names, names)
[01:27:45.632]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.632]                   envs[common]]
[01:27:45.632]                 NAMES <- toupper(changed)
[01:27:45.632]                 args <- list()
[01:27:45.632]                 for (kk in seq_along(NAMES)) {
[01:27:45.632]                   name <- changed[[kk]]
[01:27:45.632]                   NAME <- NAMES[[kk]]
[01:27:45.632]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.632]                     next
[01:27:45.632]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.632]                 }
[01:27:45.632]                 NAMES <- toupper(added)
[01:27:45.632]                 for (kk in seq_along(NAMES)) {
[01:27:45.632]                   name <- added[[kk]]
[01:27:45.632]                   NAME <- NAMES[[kk]]
[01:27:45.632]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.632]                     next
[01:27:45.632]                   args[[name]] <- ""
[01:27:45.632]                 }
[01:27:45.632]                 NAMES <- toupper(removed)
[01:27:45.632]                 for (kk in seq_along(NAMES)) {
[01:27:45.632]                   name <- removed[[kk]]
[01:27:45.632]                   NAME <- NAMES[[kk]]
[01:27:45.632]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.632]                     next
[01:27:45.632]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.632]                 }
[01:27:45.632]                 if (length(args) > 0) 
[01:27:45.632]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.632]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.632]             }
[01:27:45.632]             else {
[01:27:45.632]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.632]             }
[01:27:45.632]             {
[01:27:45.632]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.632]                   0L) {
[01:27:45.632]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.632]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.632]                   base::options(opts)
[01:27:45.632]                 }
[01:27:45.632]                 {
[01:27:45.632]                   {
[01:27:45.632]                     NULL
[01:27:45.632]                     RNGkind("Mersenne-Twister")
[01:27:45.632]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.632]                       inherits = FALSE)
[01:27:45.632]                   }
[01:27:45.632]                   options(future.plan = NULL)
[01:27:45.632]                   if (is.na(NA_character_)) 
[01:27:45.632]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.632]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.632]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.632]                   {
[01:27:45.632]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.632]                     if (!future$lazy) 
[01:27:45.632]                       future <- run(future)
[01:27:45.632]                     invisible(future)
[01:27:45.632]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.632]                 }
[01:27:45.632]             }
[01:27:45.632]         }
[01:27:45.632]     })
[01:27:45.632]     if (TRUE) {
[01:27:45.632]         base::sink(type = "output", split = FALSE)
[01:27:45.632]         if (TRUE) {
[01:27:45.632]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.632]         }
[01:27:45.632]         else {
[01:27:45.632]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.632]         }
[01:27:45.632]         base::close(...future.stdout)
[01:27:45.632]         ...future.stdout <- NULL
[01:27:45.632]     }
[01:27:45.632]     ...future.result$conditions <- ...future.conditions
[01:27:45.632]     ...future.result$finished <- base::Sys.time()
[01:27:45.632]     ...future.result
[01:27:45.632] }
[01:27:45.636] plan(): Setting new future strategy stack:
[01:27:45.636] List of future strategies:
[01:27:45.636] 1. sequential:
[01:27:45.636]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.636]    - tweaked: FALSE
[01:27:45.636]    - call: NULL
[01:27:45.637] plan(): nbrOfWorkers() = 1
[01:27:45.638] plan(): Setting new future strategy stack:
[01:27:45.638] List of future strategies:
[01:27:45.638] 1. sequential:
[01:27:45.638]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.638]    - tweaked: FALSE
[01:27:45.638]    - call: plan(strategy)
[01:27:45.639] plan(): nbrOfWorkers() = 1
[01:27:45.639] SequentialFuture started (and completed)
[01:27:45.639] - Launch lazy future ... done
[01:27:45.639] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07f61960> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b04c2fb88> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07f61960> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b04c2fb88> 
 $  : 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"
[01:27:45.646] resolved() for 'SequentialFuture' ...
[01:27:45.646] - state: 'finished'
[01:27:45.646] - run: TRUE
[01:27:45.647] - result: 'FutureResult'
[01:27:45.647] resolved() for 'SequentialFuture' ... done
[01:27:45.647] resolved() for 'SequentialFuture' ...
[01:27:45.647] - state: 'finished'
[01:27:45.647] - run: TRUE
[01:27:45.648] - result: 'FutureResult'
[01:27:45.648] 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" "" ...
[01:27:45.650] resolve() on list ...
[01:27:45.650]  recursive: 0
[01:27:45.651]  length: 6
[01:27:45.651]  elements: 'a', 'b', 'c', '', '', ''
[01:27:45.651] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.651] - nx: 6
[01:27:45.651] - relay: TRUE
[01:27:45.651] - stdout: TRUE
[01:27:45.651] - signal: TRUE
[01:27:45.652] - resignal: FALSE
[01:27:45.652] - force: TRUE
[01:27:45.652] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.652] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.652]  - until=2
[01:27:45.652]  - relaying element #2
[01:27:45.653] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.653] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.653] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.653]  length: 5 (resolved future 1)
[01:27:45.653] resolved() for 'SequentialFuture' ...
[01:27:45.653] - state: 'finished'
[01:27:45.654] - run: TRUE
[01:27:45.654] - result: 'FutureResult'
[01:27:45.654] resolved() for 'SequentialFuture' ... done
[01:27:45.654] Future #2
[01:27:45.654] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.655] - nx: 6
[01:27:45.655] - relay: TRUE
[01:27:45.655] - stdout: TRUE
[01:27:45.655] - signal: TRUE
[01:27:45.655] - resignal: FALSE
[01:27:45.655] - force: TRUE
[01:27:45.656] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.656] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.656]  - until=2
[01:27:45.656]  - relaying element #2
[01:27:45.656] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.657] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.657] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.657]  length: 4 (resolved future 2)
[01:27:45.657] resolved() for 'SequentialFuture' ...
[01:27:45.657] - state: 'finished'
[01:27:45.657] - run: TRUE
[01:27:45.658] - result: 'FutureResult'
[01:27:45.658] resolved() for 'SequentialFuture' ... done
[01:27:45.658] Future #3
[01:27:45.658] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.659] - nx: 6
[01:27:45.660] - relay: TRUE
[01:27:45.660] - stdout: TRUE
[01:27:45.660] - signal: TRUE
[01:27:45.660] - resignal: FALSE
[01:27:45.660] - force: TRUE
[01:27:45.660] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.661] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.661]  - until=3
[01:27:45.661]  - relaying element #3
[01:27:45.661] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.661] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.662] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.662]  length: 3 (resolved future 3)
[01:27:45.662] signalConditionsASAP(NULL, pos=4) ...
[01:27:45.662] - nx: 6
[01:27:45.662] - relay: TRUE
[01:27:45.662] - stdout: TRUE
[01:27:45.663] - signal: TRUE
[01:27:45.663] - resignal: FALSE
[01:27:45.663] - force: TRUE
[01:27:45.663] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.663] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.663]  - until=5
[01:27:45.663]  - relaying element #5
[01:27:45.664] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.664] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.664] signalConditionsASAP(NULL, pos=4) ... done
[01:27:45.664]  length: 2 (resolved future 4)
[01:27:45.665] signalConditionsASAP(NULL, pos=5) ...
[01:27:45.665] - nx: 6
[01:27:45.665] - relay: TRUE
[01:27:45.665] - stdout: TRUE
[01:27:45.665] - signal: TRUE
[01:27:45.666] - resignal: FALSE
[01:27:45.666] - force: TRUE
[01:27:45.666] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.666] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.666]  - until=6
[01:27:45.666]  - relaying element #6
[01:27:45.667] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.667] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.667] signalConditionsASAP(NULL, pos=5) ... done
[01:27:45.667]  length: 1 (resolved future 5)
[01:27:45.667] signalConditionsASAP(numeric, pos=6) ...
[01:27:45.667] - nx: 6
[01:27:45.668] - relay: TRUE
[01:27:45.668] - stdout: TRUE
[01:27:45.668] - signal: TRUE
[01:27:45.668] - resignal: FALSE
[01:27:45.668] - force: TRUE
[01:27:45.668] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.668] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.669]  - until=6
[01:27:45.669] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.669] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.669] signalConditionsASAP(numeric, pos=6) ... done
[01:27:45.669]  length: 0 (resolved future 6)
[01:27:45.669] Relaying remaining futures
[01:27:45.670] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.670] - nx: 6
[01:27:45.670] - relay: TRUE
[01:27:45.670] - stdout: TRUE
[01:27:45.670] - signal: TRUE
[01:27:45.670] - resignal: FALSE
[01:27:45.670] - force: TRUE
[01:27:45.671] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.671] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:45.671] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.671] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.671] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.672] 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)
[01:27:45.676] getGlobalsAndPackages() ...
[01:27:45.676] Searching for globals...
[01:27:45.676] 
[01:27:45.676] Searching for globals ... DONE
[01:27:45.677] - globals: [0] <none>
[01:27:45.677] getGlobalsAndPackages() ... DONE
[01:27:45.677] run() for 'Future' ...
[01:27:45.677] - state: 'created'
[01:27:45.678] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.678] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.678] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.678]   - Field: 'label'
[01:27:45.679]   - Field: 'local'
[01:27:45.679]   - Field: 'owner'
[01:27:45.679]   - Field: 'envir'
[01:27:45.679]   - Field: 'packages'
[01:27:45.679]   - Field: 'gc'
[01:27:45.679]   - Field: 'conditions'
[01:27:45.680]   - Field: 'expr'
[01:27:45.680]   - Field: 'uuid'
[01:27:45.680]   - Field: 'seed'
[01:27:45.680]   - Field: 'version'
[01:27:45.680]   - Field: 'result'
[01:27:45.681]   - Field: 'asynchronous'
[01:27:45.681]   - Field: 'calls'
[01:27:45.681]   - Field: 'globals'
[01:27:45.681]   - Field: 'stdout'
[01:27:45.681]   - Field: 'earlySignal'
[01:27:45.681]   - Field: 'lazy'
[01:27:45.682]   - Field: 'state'
[01:27:45.682] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.682] - Launch lazy future ...
[01:27:45.682] Packages needed by the future expression (n = 0): <none>
[01:27:45.682] Packages needed by future strategies (n = 0): <none>
[01:27:45.683] {
[01:27:45.683]     {
[01:27:45.683]         {
[01:27:45.683]             ...future.startTime <- base::Sys.time()
[01:27:45.683]             {
[01:27:45.683]                 {
[01:27:45.683]                   {
[01:27:45.683]                     base::local({
[01:27:45.683]                       has_future <- base::requireNamespace("future", 
[01:27:45.683]                         quietly = TRUE)
[01:27:45.683]                       if (has_future) {
[01:27:45.683]                         ns <- base::getNamespace("future")
[01:27:45.683]                         version <- ns[[".package"]][["version"]]
[01:27:45.683]                         if (is.null(version)) 
[01:27:45.683]                           version <- utils::packageVersion("future")
[01:27:45.683]                       }
[01:27:45.683]                       else {
[01:27:45.683]                         version <- NULL
[01:27:45.683]                       }
[01:27:45.683]                       if (!has_future || version < "1.8.0") {
[01:27:45.683]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.683]                           "", base::R.version$version.string), 
[01:27:45.683]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.683]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.683]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.683]                             "release", "version")], collapse = " "), 
[01:27:45.683]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.683]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.683]                           info)
[01:27:45.683]                         info <- base::paste(info, collapse = "; ")
[01:27:45.683]                         if (!has_future) {
[01:27:45.683]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.683]                             info)
[01:27:45.683]                         }
[01:27:45.683]                         else {
[01:27:45.683]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.683]                             info, version)
[01:27:45.683]                         }
[01:27:45.683]                         base::stop(msg)
[01:27:45.683]                       }
[01:27:45.683]                     })
[01:27:45.683]                   }
[01:27:45.683]                   options(future.plan = NULL)
[01:27:45.683]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.683]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.683]                 }
[01:27:45.683]                 ...future.workdir <- getwd()
[01:27:45.683]             }
[01:27:45.683]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.683]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.683]         }
[01:27:45.683]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.683]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.683]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.683]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.683]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.683]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.683]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.683]             base::names(...future.oldOptions))
[01:27:45.683]     }
[01:27:45.683]     if (FALSE) {
[01:27:45.683]     }
[01:27:45.683]     else {
[01:27:45.683]         if (TRUE) {
[01:27:45.683]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.683]                 open = "w")
[01:27:45.683]         }
[01:27:45.683]         else {
[01:27:45.683]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.683]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.683]         }
[01:27:45.683]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.683]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.683]             base::sink(type = "output", split = FALSE)
[01:27:45.683]             base::close(...future.stdout)
[01:27:45.683]         }, add = TRUE)
[01:27:45.683]     }
[01:27:45.683]     ...future.frame <- base::sys.nframe()
[01:27:45.683]     ...future.conditions <- base::list()
[01:27:45.683]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.683]     if (FALSE) {
[01:27:45.683]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.683]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.683]     }
[01:27:45.683]     ...future.result <- base::tryCatch({
[01:27:45.683]         base::withCallingHandlers({
[01:27:45.683]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.683]             future::FutureResult(value = ...future.value$value, 
[01:27:45.683]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.683]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.683]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.683]                     ...future.globalenv.names))
[01:27:45.683]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.683]         }, condition = base::local({
[01:27:45.683]             c <- base::c
[01:27:45.683]             inherits <- base::inherits
[01:27:45.683]             invokeRestart <- base::invokeRestart
[01:27:45.683]             length <- base::length
[01:27:45.683]             list <- base::list
[01:27:45.683]             seq.int <- base::seq.int
[01:27:45.683]             signalCondition <- base::signalCondition
[01:27:45.683]             sys.calls <- base::sys.calls
[01:27:45.683]             `[[` <- base::`[[`
[01:27:45.683]             `+` <- base::`+`
[01:27:45.683]             `<<-` <- base::`<<-`
[01:27:45.683]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.683]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.683]                   3L)]
[01:27:45.683]             }
[01:27:45.683]             function(cond) {
[01:27:45.683]                 is_error <- inherits(cond, "error")
[01:27:45.683]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.683]                   NULL)
[01:27:45.683]                 if (is_error) {
[01:27:45.683]                   sessionInformation <- function() {
[01:27:45.683]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.683]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.683]                       search = base::search(), system = base::Sys.info())
[01:27:45.683]                   }
[01:27:45.683]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.683]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.683]                     cond$call), session = sessionInformation(), 
[01:27:45.683]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.683]                   signalCondition(cond)
[01:27:45.683]                 }
[01:27:45.683]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.683]                 "immediateCondition"))) {
[01:27:45.683]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.683]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.683]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.683]                   if (TRUE && !signal) {
[01:27:45.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.683]                     {
[01:27:45.683]                       inherits <- base::inherits
[01:27:45.683]                       invokeRestart <- base::invokeRestart
[01:27:45.683]                       is.null <- base::is.null
[01:27:45.683]                       muffled <- FALSE
[01:27:45.683]                       if (inherits(cond, "message")) {
[01:27:45.683]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.683]                         if (muffled) 
[01:27:45.683]                           invokeRestart("muffleMessage")
[01:27:45.683]                       }
[01:27:45.683]                       else if (inherits(cond, "warning")) {
[01:27:45.683]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.683]                         if (muffled) 
[01:27:45.683]                           invokeRestart("muffleWarning")
[01:27:45.683]                       }
[01:27:45.683]                       else if (inherits(cond, "condition")) {
[01:27:45.683]                         if (!is.null(pattern)) {
[01:27:45.683]                           computeRestarts <- base::computeRestarts
[01:27:45.683]                           grepl <- base::grepl
[01:27:45.683]                           restarts <- computeRestarts(cond)
[01:27:45.683]                           for (restart in restarts) {
[01:27:45.683]                             name <- restart$name
[01:27:45.683]                             if (is.null(name)) 
[01:27:45.683]                               next
[01:27:45.683]                             if (!grepl(pattern, name)) 
[01:27:45.683]                               next
[01:27:45.683]                             invokeRestart(restart)
[01:27:45.683]                             muffled <- TRUE
[01:27:45.683]                             break
[01:27:45.683]                           }
[01:27:45.683]                         }
[01:27:45.683]                       }
[01:27:45.683]                       invisible(muffled)
[01:27:45.683]                     }
[01:27:45.683]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.683]                   }
[01:27:45.683]                 }
[01:27:45.683]                 else {
[01:27:45.683]                   if (TRUE) {
[01:27:45.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.683]                     {
[01:27:45.683]                       inherits <- base::inherits
[01:27:45.683]                       invokeRestart <- base::invokeRestart
[01:27:45.683]                       is.null <- base::is.null
[01:27:45.683]                       muffled <- FALSE
[01:27:45.683]                       if (inherits(cond, "message")) {
[01:27:45.683]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.683]                         if (muffled) 
[01:27:45.683]                           invokeRestart("muffleMessage")
[01:27:45.683]                       }
[01:27:45.683]                       else if (inherits(cond, "warning")) {
[01:27:45.683]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.683]                         if (muffled) 
[01:27:45.683]                           invokeRestart("muffleWarning")
[01:27:45.683]                       }
[01:27:45.683]                       else if (inherits(cond, "condition")) {
[01:27:45.683]                         if (!is.null(pattern)) {
[01:27:45.683]                           computeRestarts <- base::computeRestarts
[01:27:45.683]                           grepl <- base::grepl
[01:27:45.683]                           restarts <- computeRestarts(cond)
[01:27:45.683]                           for (restart in restarts) {
[01:27:45.683]                             name <- restart$name
[01:27:45.683]                             if (is.null(name)) 
[01:27:45.683]                               next
[01:27:45.683]                             if (!grepl(pattern, name)) 
[01:27:45.683]                               next
[01:27:45.683]                             invokeRestart(restart)
[01:27:45.683]                             muffled <- TRUE
[01:27:45.683]                             break
[01:27:45.683]                           }
[01:27:45.683]                         }
[01:27:45.683]                       }
[01:27:45.683]                       invisible(muffled)
[01:27:45.683]                     }
[01:27:45.683]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.683]                   }
[01:27:45.683]                 }
[01:27:45.683]             }
[01:27:45.683]         }))
[01:27:45.683]     }, error = function(ex) {
[01:27:45.683]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.683]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.683]                 ...future.rng), started = ...future.startTime, 
[01:27:45.683]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.683]             version = "1.8"), class = "FutureResult")
[01:27:45.683]     }, finally = {
[01:27:45.683]         if (!identical(...future.workdir, getwd())) 
[01:27:45.683]             setwd(...future.workdir)
[01:27:45.683]         {
[01:27:45.683]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.683]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.683]             }
[01:27:45.683]             base::options(...future.oldOptions)
[01:27:45.683]             if (.Platform$OS.type == "windows") {
[01:27:45.683]                 old_names <- names(...future.oldEnvVars)
[01:27:45.683]                 envs <- base::Sys.getenv()
[01:27:45.683]                 names <- names(envs)
[01:27:45.683]                 common <- intersect(names, old_names)
[01:27:45.683]                 added <- setdiff(names, old_names)
[01:27:45.683]                 removed <- setdiff(old_names, names)
[01:27:45.683]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.683]                   envs[common]]
[01:27:45.683]                 NAMES <- toupper(changed)
[01:27:45.683]                 args <- list()
[01:27:45.683]                 for (kk in seq_along(NAMES)) {
[01:27:45.683]                   name <- changed[[kk]]
[01:27:45.683]                   NAME <- NAMES[[kk]]
[01:27:45.683]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.683]                     next
[01:27:45.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.683]                 }
[01:27:45.683]                 NAMES <- toupper(added)
[01:27:45.683]                 for (kk in seq_along(NAMES)) {
[01:27:45.683]                   name <- added[[kk]]
[01:27:45.683]                   NAME <- NAMES[[kk]]
[01:27:45.683]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.683]                     next
[01:27:45.683]                   args[[name]] <- ""
[01:27:45.683]                 }
[01:27:45.683]                 NAMES <- toupper(removed)
[01:27:45.683]                 for (kk in seq_along(NAMES)) {
[01:27:45.683]                   name <- removed[[kk]]
[01:27:45.683]                   NAME <- NAMES[[kk]]
[01:27:45.683]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.683]                     next
[01:27:45.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.683]                 }
[01:27:45.683]                 if (length(args) > 0) 
[01:27:45.683]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.683]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.683]             }
[01:27:45.683]             else {
[01:27:45.683]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.683]             }
[01:27:45.683]             {
[01:27:45.683]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.683]                   0L) {
[01:27:45.683]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.683]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.683]                   base::options(opts)
[01:27:45.683]                 }
[01:27:45.683]                 {
[01:27:45.683]                   {
[01:27:45.683]                     NULL
[01:27:45.683]                     RNGkind("Mersenne-Twister")
[01:27:45.683]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.683]                       inherits = FALSE)
[01:27:45.683]                   }
[01:27:45.683]                   options(future.plan = NULL)
[01:27:45.683]                   if (is.na(NA_character_)) 
[01:27:45.683]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.683]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.683]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.683]                   {
[01:27:45.683]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.683]                     if (!future$lazy) 
[01:27:45.683]                       future <- run(future)
[01:27:45.683]                     invisible(future)
[01:27:45.683]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.683]                 }
[01:27:45.683]             }
[01:27:45.683]         }
[01:27:45.683]     })
[01:27:45.683]     if (TRUE) {
[01:27:45.683]         base::sink(type = "output", split = FALSE)
[01:27:45.683]         if (TRUE) {
[01:27:45.683]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.683]         }
[01:27:45.683]         else {
[01:27:45.683]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.683]         }
[01:27:45.683]         base::close(...future.stdout)
[01:27:45.683]         ...future.stdout <- NULL
[01:27:45.683]     }
[01:27:45.683]     ...future.result$conditions <- ...future.conditions
[01:27:45.683]     ...future.result$finished <- base::Sys.time()
[01:27:45.683]     ...future.result
[01:27:45.683] }
[01:27:45.687] plan(): Setting new future strategy stack:
[01:27:45.687] List of future strategies:
[01:27:45.687] 1. sequential:
[01:27:45.687]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.687]    - tweaked: FALSE
[01:27:45.687]    - call: NULL
[01:27:45.688] plan(): nbrOfWorkers() = 1
[01:27:45.689] plan(): Setting new future strategy stack:
[01:27:45.689] List of future strategies:
[01:27:45.689] 1. sequential:
[01:27:45.689]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.689]    - tweaked: FALSE
[01:27:45.689]    - call: plan(strategy)
[01:27:45.689] plan(): nbrOfWorkers() = 1
[01:27:45.690] SequentialFuture started (and completed)
[01:27:45.690] - Launch lazy future ... done
[01:27:45.690] run() for 'SequentialFuture' ... done
[01:27:45.690] getGlobalsAndPackages() ...
[01:27:45.691] Searching for globals...
[01:27:45.691] 
[01:27:45.691] Searching for globals ... DONE
[01:27:45.691] - globals: [0] <none>
[01:27:45.691] getGlobalsAndPackages() ... DONE
[01:27:45.692] run() for 'Future' ...
[01:27:45.692] - state: 'created'
[01:27:45.692] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.692] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.693] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.693]   - Field: 'label'
[01:27:45.693]   - Field: 'local'
[01:27:45.693]   - Field: 'owner'
[01:27:45.693]   - Field: 'envir'
[01:27:45.694]   - Field: 'packages'
[01:27:45.694]   - Field: 'gc'
[01:27:45.694]   - Field: 'conditions'
[01:27:45.694]   - Field: 'expr'
[01:27:45.694]   - Field: 'uuid'
[01:27:45.694]   - Field: 'seed'
[01:27:45.695]   - Field: 'version'
[01:27:45.695]   - Field: 'result'
[01:27:45.695]   - Field: 'asynchronous'
[01:27:45.695]   - Field: 'calls'
[01:27:45.695]   - Field: 'globals'
[01:27:45.696]   - Field: 'stdout'
[01:27:45.696]   - Field: 'earlySignal'
[01:27:45.696]   - Field: 'lazy'
[01:27:45.697]   - Field: 'state'
[01:27:45.697] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.698] - Launch lazy future ...
[01:27:45.698] Packages needed by the future expression (n = 0): <none>
[01:27:45.698] Packages needed by future strategies (n = 0): <none>
[01:27:45.699] {
[01:27:45.699]     {
[01:27:45.699]         {
[01:27:45.699]             ...future.startTime <- base::Sys.time()
[01:27:45.699]             {
[01:27:45.699]                 {
[01:27:45.699]                   {
[01:27:45.699]                     base::local({
[01:27:45.699]                       has_future <- base::requireNamespace("future", 
[01:27:45.699]                         quietly = TRUE)
[01:27:45.699]                       if (has_future) {
[01:27:45.699]                         ns <- base::getNamespace("future")
[01:27:45.699]                         version <- ns[[".package"]][["version"]]
[01:27:45.699]                         if (is.null(version)) 
[01:27:45.699]                           version <- utils::packageVersion("future")
[01:27:45.699]                       }
[01:27:45.699]                       else {
[01:27:45.699]                         version <- NULL
[01:27:45.699]                       }
[01:27:45.699]                       if (!has_future || version < "1.8.0") {
[01:27:45.699]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.699]                           "", base::R.version$version.string), 
[01:27:45.699]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.699]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.699]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.699]                             "release", "version")], collapse = " "), 
[01:27:45.699]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.699]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.699]                           info)
[01:27:45.699]                         info <- base::paste(info, collapse = "; ")
[01:27:45.699]                         if (!has_future) {
[01:27:45.699]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.699]                             info)
[01:27:45.699]                         }
[01:27:45.699]                         else {
[01:27:45.699]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.699]                             info, version)
[01:27:45.699]                         }
[01:27:45.699]                         base::stop(msg)
[01:27:45.699]                       }
[01:27:45.699]                     })
[01:27:45.699]                   }
[01:27:45.699]                   options(future.plan = NULL)
[01:27:45.699]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.699]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.699]                 }
[01:27:45.699]                 ...future.workdir <- getwd()
[01:27:45.699]             }
[01:27:45.699]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.699]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.699]         }
[01:27:45.699]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.699]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.699]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.699]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.699]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.699]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.699]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.699]             base::names(...future.oldOptions))
[01:27:45.699]     }
[01:27:45.699]     if (FALSE) {
[01:27:45.699]     }
[01:27:45.699]     else {
[01:27:45.699]         if (TRUE) {
[01:27:45.699]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.699]                 open = "w")
[01:27:45.699]         }
[01:27:45.699]         else {
[01:27:45.699]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.699]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.699]         }
[01:27:45.699]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.699]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.699]             base::sink(type = "output", split = FALSE)
[01:27:45.699]             base::close(...future.stdout)
[01:27:45.699]         }, add = TRUE)
[01:27:45.699]     }
[01:27:45.699]     ...future.frame <- base::sys.nframe()
[01:27:45.699]     ...future.conditions <- base::list()
[01:27:45.699]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.699]     if (FALSE) {
[01:27:45.699]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.699]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.699]     }
[01:27:45.699]     ...future.result <- base::tryCatch({
[01:27:45.699]         base::withCallingHandlers({
[01:27:45.699]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.699]             future::FutureResult(value = ...future.value$value, 
[01:27:45.699]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.699]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.699]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.699]                     ...future.globalenv.names))
[01:27:45.699]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.699]         }, condition = base::local({
[01:27:45.699]             c <- base::c
[01:27:45.699]             inherits <- base::inherits
[01:27:45.699]             invokeRestart <- base::invokeRestart
[01:27:45.699]             length <- base::length
[01:27:45.699]             list <- base::list
[01:27:45.699]             seq.int <- base::seq.int
[01:27:45.699]             signalCondition <- base::signalCondition
[01:27:45.699]             sys.calls <- base::sys.calls
[01:27:45.699]             `[[` <- base::`[[`
[01:27:45.699]             `+` <- base::`+`
[01:27:45.699]             `<<-` <- base::`<<-`
[01:27:45.699]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.699]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.699]                   3L)]
[01:27:45.699]             }
[01:27:45.699]             function(cond) {
[01:27:45.699]                 is_error <- inherits(cond, "error")
[01:27:45.699]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.699]                   NULL)
[01:27:45.699]                 if (is_error) {
[01:27:45.699]                   sessionInformation <- function() {
[01:27:45.699]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.699]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.699]                       search = base::search(), system = base::Sys.info())
[01:27:45.699]                   }
[01:27:45.699]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.699]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.699]                     cond$call), session = sessionInformation(), 
[01:27:45.699]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.699]                   signalCondition(cond)
[01:27:45.699]                 }
[01:27:45.699]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.699]                 "immediateCondition"))) {
[01:27:45.699]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.699]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.699]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.699]                   if (TRUE && !signal) {
[01:27:45.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.699]                     {
[01:27:45.699]                       inherits <- base::inherits
[01:27:45.699]                       invokeRestart <- base::invokeRestart
[01:27:45.699]                       is.null <- base::is.null
[01:27:45.699]                       muffled <- FALSE
[01:27:45.699]                       if (inherits(cond, "message")) {
[01:27:45.699]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.699]                         if (muffled) 
[01:27:45.699]                           invokeRestart("muffleMessage")
[01:27:45.699]                       }
[01:27:45.699]                       else if (inherits(cond, "warning")) {
[01:27:45.699]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.699]                         if (muffled) 
[01:27:45.699]                           invokeRestart("muffleWarning")
[01:27:45.699]                       }
[01:27:45.699]                       else if (inherits(cond, "condition")) {
[01:27:45.699]                         if (!is.null(pattern)) {
[01:27:45.699]                           computeRestarts <- base::computeRestarts
[01:27:45.699]                           grepl <- base::grepl
[01:27:45.699]                           restarts <- computeRestarts(cond)
[01:27:45.699]                           for (restart in restarts) {
[01:27:45.699]                             name <- restart$name
[01:27:45.699]                             if (is.null(name)) 
[01:27:45.699]                               next
[01:27:45.699]                             if (!grepl(pattern, name)) 
[01:27:45.699]                               next
[01:27:45.699]                             invokeRestart(restart)
[01:27:45.699]                             muffled <- TRUE
[01:27:45.699]                             break
[01:27:45.699]                           }
[01:27:45.699]                         }
[01:27:45.699]                       }
[01:27:45.699]                       invisible(muffled)
[01:27:45.699]                     }
[01:27:45.699]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.699]                   }
[01:27:45.699]                 }
[01:27:45.699]                 else {
[01:27:45.699]                   if (TRUE) {
[01:27:45.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.699]                     {
[01:27:45.699]                       inherits <- base::inherits
[01:27:45.699]                       invokeRestart <- base::invokeRestart
[01:27:45.699]                       is.null <- base::is.null
[01:27:45.699]                       muffled <- FALSE
[01:27:45.699]                       if (inherits(cond, "message")) {
[01:27:45.699]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.699]                         if (muffled) 
[01:27:45.699]                           invokeRestart("muffleMessage")
[01:27:45.699]                       }
[01:27:45.699]                       else if (inherits(cond, "warning")) {
[01:27:45.699]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.699]                         if (muffled) 
[01:27:45.699]                           invokeRestart("muffleWarning")
[01:27:45.699]                       }
[01:27:45.699]                       else if (inherits(cond, "condition")) {
[01:27:45.699]                         if (!is.null(pattern)) {
[01:27:45.699]                           computeRestarts <- base::computeRestarts
[01:27:45.699]                           grepl <- base::grepl
[01:27:45.699]                           restarts <- computeRestarts(cond)
[01:27:45.699]                           for (restart in restarts) {
[01:27:45.699]                             name <- restart$name
[01:27:45.699]                             if (is.null(name)) 
[01:27:45.699]                               next
[01:27:45.699]                             if (!grepl(pattern, name)) 
[01:27:45.699]                               next
[01:27:45.699]                             invokeRestart(restart)
[01:27:45.699]                             muffled <- TRUE
[01:27:45.699]                             break
[01:27:45.699]                           }
[01:27:45.699]                         }
[01:27:45.699]                       }
[01:27:45.699]                       invisible(muffled)
[01:27:45.699]                     }
[01:27:45.699]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.699]                   }
[01:27:45.699]                 }
[01:27:45.699]             }
[01:27:45.699]         }))
[01:27:45.699]     }, error = function(ex) {
[01:27:45.699]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.699]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.699]                 ...future.rng), started = ...future.startTime, 
[01:27:45.699]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.699]             version = "1.8"), class = "FutureResult")
[01:27:45.699]     }, finally = {
[01:27:45.699]         if (!identical(...future.workdir, getwd())) 
[01:27:45.699]             setwd(...future.workdir)
[01:27:45.699]         {
[01:27:45.699]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.699]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.699]             }
[01:27:45.699]             base::options(...future.oldOptions)
[01:27:45.699]             if (.Platform$OS.type == "windows") {
[01:27:45.699]                 old_names <- names(...future.oldEnvVars)
[01:27:45.699]                 envs <- base::Sys.getenv()
[01:27:45.699]                 names <- names(envs)
[01:27:45.699]                 common <- intersect(names, old_names)
[01:27:45.699]                 added <- setdiff(names, old_names)
[01:27:45.699]                 removed <- setdiff(old_names, names)
[01:27:45.699]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.699]                   envs[common]]
[01:27:45.699]                 NAMES <- toupper(changed)
[01:27:45.699]                 args <- list()
[01:27:45.699]                 for (kk in seq_along(NAMES)) {
[01:27:45.699]                   name <- changed[[kk]]
[01:27:45.699]                   NAME <- NAMES[[kk]]
[01:27:45.699]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.699]                     next
[01:27:45.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.699]                 }
[01:27:45.699]                 NAMES <- toupper(added)
[01:27:45.699]                 for (kk in seq_along(NAMES)) {
[01:27:45.699]                   name <- added[[kk]]
[01:27:45.699]                   NAME <- NAMES[[kk]]
[01:27:45.699]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.699]                     next
[01:27:45.699]                   args[[name]] <- ""
[01:27:45.699]                 }
[01:27:45.699]                 NAMES <- toupper(removed)
[01:27:45.699]                 for (kk in seq_along(NAMES)) {
[01:27:45.699]                   name <- removed[[kk]]
[01:27:45.699]                   NAME <- NAMES[[kk]]
[01:27:45.699]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.699]                     next
[01:27:45.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.699]                 }
[01:27:45.699]                 if (length(args) > 0) 
[01:27:45.699]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.699]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.699]             }
[01:27:45.699]             else {
[01:27:45.699]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.699]             }
[01:27:45.699]             {
[01:27:45.699]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.699]                   0L) {
[01:27:45.699]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.699]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.699]                   base::options(opts)
[01:27:45.699]                 }
[01:27:45.699]                 {
[01:27:45.699]                   {
[01:27:45.699]                     NULL
[01:27:45.699]                     RNGkind("Mersenne-Twister")
[01:27:45.699]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.699]                       inherits = FALSE)
[01:27:45.699]                   }
[01:27:45.699]                   options(future.plan = NULL)
[01:27:45.699]                   if (is.na(NA_character_)) 
[01:27:45.699]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.699]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.699]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.699]                   {
[01:27:45.699]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.699]                     if (!future$lazy) 
[01:27:45.699]                       future <- run(future)
[01:27:45.699]                     invisible(future)
[01:27:45.699]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.699]                 }
[01:27:45.699]             }
[01:27:45.699]         }
[01:27:45.699]     })
[01:27:45.699]     if (TRUE) {
[01:27:45.699]         base::sink(type = "output", split = FALSE)
[01:27:45.699]         if (TRUE) {
[01:27:45.699]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.699]         }
[01:27:45.699]         else {
[01:27:45.699]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.699]         }
[01:27:45.699]         base::close(...future.stdout)
[01:27:45.699]         ...future.stdout <- NULL
[01:27:45.699]     }
[01:27:45.699]     ...future.result$conditions <- ...future.conditions
[01:27:45.699]     ...future.result$finished <- base::Sys.time()
[01:27:45.699]     ...future.result
[01:27:45.699] }
[01:27:45.703] plan(): Setting new future strategy stack:
[01:27:45.703] List of future strategies:
[01:27:45.703] 1. sequential:
[01:27:45.703]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.703]    - tweaked: FALSE
[01:27:45.703]    - call: NULL
[01:27:45.703] plan(): nbrOfWorkers() = 1
[01:27:45.705] plan(): Setting new future strategy stack:
[01:27:45.705] List of future strategies:
[01:27:45.705] 1. sequential:
[01:27:45.705]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.705]    - tweaked: FALSE
[01:27:45.705]    - call: plan(strategy)
[01:27:45.705] plan(): nbrOfWorkers() = 1
[01:27:45.706] SequentialFuture started (and completed)
[01:27:45.706] - Launch lazy future ... done
[01:27:45.706] run() for 'SequentialFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07b7be30> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b08084ff0> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b07b7be30> 
 $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x0000025b08084ff0> 
 $  : 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"
[01:27:45.713] resolved() for 'SequentialFuture' ...
[01:27:45.713] - state: 'finished'
[01:27:45.713] - run: TRUE
[01:27:45.713] - result: 'FutureResult'
[01:27:45.713] resolved() for 'SequentialFuture' ... done
[01:27:45.714] resolved() for 'SequentialFuture' ...
[01:27:45.714] - state: 'finished'
[01:27:45.714] - run: TRUE
[01:27:45.714] - result: 'FutureResult'
[01:27:45.714] 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" "" ...
[01:27:45.717] resolve() on list ...
[01:27:45.717]  recursive: 0
[01:27:45.717]  length: 6
[01:27:45.717]  elements: 'a', 'b', 'c', '', '', ''
[01:27:45.718] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.718] - nx: 6
[01:27:45.718] - relay: TRUE
[01:27:45.718] - stdout: TRUE
[01:27:45.718] - signal: TRUE
[01:27:45.718] - resignal: FALSE
[01:27:45.719] - force: TRUE
[01:27:45.719] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.719] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.719]  - until=2
[01:27:45.719]  - relaying element #2
[01:27:45.719] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.719] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.720] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.720]  length: 5 (resolved future 1)
[01:27:45.720] resolved() for 'SequentialFuture' ...
[01:27:45.720] - state: 'finished'
[01:27:45.720] - run: TRUE
[01:27:45.721] - result: 'FutureResult'
[01:27:45.721] resolved() for 'SequentialFuture' ... done
[01:27:45.721] Future #2
[01:27:45.721] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.721] - nx: 6
[01:27:45.721] - relay: TRUE
[01:27:45.722] - stdout: TRUE
[01:27:45.722] - signal: TRUE
[01:27:45.722] - resignal: FALSE
[01:27:45.722] - force: TRUE
[01:27:45.722] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.722] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:45.723]  - until=2
[01:27:45.723]  - relaying element #2
[01:27:45.723] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.723] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.723] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.724]  length: 4 (resolved future 2)
[01:27:45.724] resolved() for 'SequentialFuture' ...
[01:27:45.724] - state: 'finished'
[01:27:45.724] - run: TRUE
[01:27:45.724] - result: 'FutureResult'
[01:27:45.724] resolved() for 'SequentialFuture' ... done
[01:27:45.725] Future #3
[01:27:45.725] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.725] - nx: 6
[01:27:45.725] - relay: TRUE
[01:27:45.725] - stdout: TRUE
[01:27:45.725] - signal: TRUE
[01:27:45.726] - resignal: FALSE
[01:27:45.726] - force: TRUE
[01:27:45.726] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.726] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:45.726]  - until=3
[01:27:45.726]  - relaying element #3
[01:27:45.727] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.727] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.727] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.727]  length: 3 (resolved future 3)
[01:27:45.727] signalConditionsASAP(NULL, pos=4) ...
[01:27:45.728] - nx: 6
[01:27:45.728] - relay: TRUE
[01:27:45.728] - stdout: TRUE
[01:27:45.728] - signal: TRUE
[01:27:45.728] - resignal: FALSE
[01:27:45.728] - force: TRUE
[01:27:45.729] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.729] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.729]  - until=5
[01:27:45.729]  - relaying element #5
[01:27:45.729] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.729] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.730] signalConditionsASAP(NULL, pos=4) ... done
[01:27:45.730]  length: 2 (resolved future 4)
[01:27:45.730] signalConditionsASAP(NULL, pos=5) ...
[01:27:45.730] - nx: 6
[01:27:45.730] - relay: TRUE
[01:27:45.730] - stdout: TRUE
[01:27:45.730] - signal: TRUE
[01:27:45.731] - resignal: FALSE
[01:27:45.731] - force: TRUE
[01:27:45.731] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:45.731] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.731]  - until=6
[01:27:45.731]  - relaying element #6
[01:27:45.732] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.733] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.733] signalConditionsASAP(NULL, pos=5) ... done
[01:27:45.733]  length: 1 (resolved future 5)
[01:27:45.733] signalConditionsASAP(numeric, pos=6) ...
[01:27:45.733] - nx: 6
[01:27:45.733] - relay: TRUE
[01:27:45.734] - stdout: TRUE
[01:27:45.734] - signal: TRUE
[01:27:45.734] - resignal: FALSE
[01:27:45.734] - force: TRUE
[01:27:45.734] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:45.734] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.735]  - until=6
[01:27:45.735] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.735] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.735] signalConditionsASAP(numeric, pos=6) ... done
[01:27:45.735]  length: 0 (resolved future 6)
[01:27:45.735] Relaying remaining futures
[01:27:45.735] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.736] - nx: 6
[01:27:45.736] - relay: TRUE
[01:27:45.736] - stdout: TRUE
[01:27:45.736] - signal: TRUE
[01:27:45.736] - resignal: FALSE
[01:27:45.736] - force: TRUE
[01:27:45.737] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.737] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:45.737] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:45.737] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:45.737] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.737] 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
[01:27:45.748] plan(): Setting new future strategy stack:
[01:27:45.748] List of future strategies:
[01:27:45.748] 1. sequential:
[01:27:45.748]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.748]    - tweaked: FALSE
[01:27:45.748]    - call: plan(strategy)
[01:27:45.749] plan(): nbrOfWorkers() = 1
Dimensions: NULL
[01:27:45.749] getGlobalsAndPackages() ...
[01:27:45.749] Searching for globals...
[01:27:45.750] 
[01:27:45.750] Searching for globals ... DONE
[01:27:45.750] - globals: [0] <none>
[01:27:45.750] getGlobalsAndPackages() ... DONE
[01:27:45.750] run() for 'Future' ...
[01:27:45.751] - state: 'created'
[01:27:45.751] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.751] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.751] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.752]   - Field: 'label'
[01:27:45.752]   - Field: 'local'
[01:27:45.752]   - Field: 'owner'
[01:27:45.752]   - Field: 'envir'
[01:27:45.752]   - Field: 'packages'
[01:27:45.752]   - Field: 'gc'
[01:27:45.753]   - Field: 'conditions'
[01:27:45.753]   - Field: 'expr'
[01:27:45.753]   - Field: 'uuid'
[01:27:45.753]   - Field: 'seed'
[01:27:45.753]   - Field: 'version'
[01:27:45.754]   - Field: 'result'
[01:27:45.754]   - Field: 'asynchronous'
[01:27:45.754]   - Field: 'calls'
[01:27:45.754]   - Field: 'globals'
[01:27:45.754]   - Field: 'stdout'
[01:27:45.754]   - Field: 'earlySignal'
[01:27:45.755]   - Field: 'lazy'
[01:27:45.755]   - Field: 'state'
[01:27:45.755] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.755] - Launch lazy future ...
[01:27:45.755] Packages needed by the future expression (n = 0): <none>
[01:27:45.756] Packages needed by future strategies (n = 0): <none>
[01:27:45.756] {
[01:27:45.756]     {
[01:27:45.756]         {
[01:27:45.756]             ...future.startTime <- base::Sys.time()
[01:27:45.756]             {
[01:27:45.756]                 {
[01:27:45.756]                   {
[01:27:45.756]                     base::local({
[01:27:45.756]                       has_future <- base::requireNamespace("future", 
[01:27:45.756]                         quietly = TRUE)
[01:27:45.756]                       if (has_future) {
[01:27:45.756]                         ns <- base::getNamespace("future")
[01:27:45.756]                         version <- ns[[".package"]][["version"]]
[01:27:45.756]                         if (is.null(version)) 
[01:27:45.756]                           version <- utils::packageVersion("future")
[01:27:45.756]                       }
[01:27:45.756]                       else {
[01:27:45.756]                         version <- NULL
[01:27:45.756]                       }
[01:27:45.756]                       if (!has_future || version < "1.8.0") {
[01:27:45.756]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.756]                           "", base::R.version$version.string), 
[01:27:45.756]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.756]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.756]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.756]                             "release", "version")], collapse = " "), 
[01:27:45.756]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.756]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.756]                           info)
[01:27:45.756]                         info <- base::paste(info, collapse = "; ")
[01:27:45.756]                         if (!has_future) {
[01:27:45.756]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.756]                             info)
[01:27:45.756]                         }
[01:27:45.756]                         else {
[01:27:45.756]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.756]                             info, version)
[01:27:45.756]                         }
[01:27:45.756]                         base::stop(msg)
[01:27:45.756]                       }
[01:27:45.756]                     })
[01:27:45.756]                   }
[01:27:45.756]                   options(future.plan = NULL)
[01:27:45.756]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.756]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.756]                 }
[01:27:45.756]                 ...future.workdir <- getwd()
[01:27:45.756]             }
[01:27:45.756]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.756]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.756]         }
[01:27:45.756]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.756]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.756]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.756]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.756]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.756]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.756]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.756]             base::names(...future.oldOptions))
[01:27:45.756]     }
[01:27:45.756]     if (FALSE) {
[01:27:45.756]     }
[01:27:45.756]     else {
[01:27:45.756]         if (TRUE) {
[01:27:45.756]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.756]                 open = "w")
[01:27:45.756]         }
[01:27:45.756]         else {
[01:27:45.756]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.756]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.756]         }
[01:27:45.756]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.756]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.756]             base::sink(type = "output", split = FALSE)
[01:27:45.756]             base::close(...future.stdout)
[01:27:45.756]         }, add = TRUE)
[01:27:45.756]     }
[01:27:45.756]     ...future.frame <- base::sys.nframe()
[01:27:45.756]     ...future.conditions <- base::list()
[01:27:45.756]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.756]     if (FALSE) {
[01:27:45.756]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.756]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.756]     }
[01:27:45.756]     ...future.result <- base::tryCatch({
[01:27:45.756]         base::withCallingHandlers({
[01:27:45.756]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.756]             future::FutureResult(value = ...future.value$value, 
[01:27:45.756]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.756]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.756]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.756]                     ...future.globalenv.names))
[01:27:45.756]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.756]         }, condition = base::local({
[01:27:45.756]             c <- base::c
[01:27:45.756]             inherits <- base::inherits
[01:27:45.756]             invokeRestart <- base::invokeRestart
[01:27:45.756]             length <- base::length
[01:27:45.756]             list <- base::list
[01:27:45.756]             seq.int <- base::seq.int
[01:27:45.756]             signalCondition <- base::signalCondition
[01:27:45.756]             sys.calls <- base::sys.calls
[01:27:45.756]             `[[` <- base::`[[`
[01:27:45.756]             `+` <- base::`+`
[01:27:45.756]             `<<-` <- base::`<<-`
[01:27:45.756]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.756]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.756]                   3L)]
[01:27:45.756]             }
[01:27:45.756]             function(cond) {
[01:27:45.756]                 is_error <- inherits(cond, "error")
[01:27:45.756]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.756]                   NULL)
[01:27:45.756]                 if (is_error) {
[01:27:45.756]                   sessionInformation <- function() {
[01:27:45.756]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.756]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.756]                       search = base::search(), system = base::Sys.info())
[01:27:45.756]                   }
[01:27:45.756]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.756]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.756]                     cond$call), session = sessionInformation(), 
[01:27:45.756]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.756]                   signalCondition(cond)
[01:27:45.756]                 }
[01:27:45.756]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.756]                 "immediateCondition"))) {
[01:27:45.756]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.756]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.756]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.756]                   if (TRUE && !signal) {
[01:27:45.756]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.756]                     {
[01:27:45.756]                       inherits <- base::inherits
[01:27:45.756]                       invokeRestart <- base::invokeRestart
[01:27:45.756]                       is.null <- base::is.null
[01:27:45.756]                       muffled <- FALSE
[01:27:45.756]                       if (inherits(cond, "message")) {
[01:27:45.756]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.756]                         if (muffled) 
[01:27:45.756]                           invokeRestart("muffleMessage")
[01:27:45.756]                       }
[01:27:45.756]                       else if (inherits(cond, "warning")) {
[01:27:45.756]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.756]                         if (muffled) 
[01:27:45.756]                           invokeRestart("muffleWarning")
[01:27:45.756]                       }
[01:27:45.756]                       else if (inherits(cond, "condition")) {
[01:27:45.756]                         if (!is.null(pattern)) {
[01:27:45.756]                           computeRestarts <- base::computeRestarts
[01:27:45.756]                           grepl <- base::grepl
[01:27:45.756]                           restarts <- computeRestarts(cond)
[01:27:45.756]                           for (restart in restarts) {
[01:27:45.756]                             name <- restart$name
[01:27:45.756]                             if (is.null(name)) 
[01:27:45.756]                               next
[01:27:45.756]                             if (!grepl(pattern, name)) 
[01:27:45.756]                               next
[01:27:45.756]                             invokeRestart(restart)
[01:27:45.756]                             muffled <- TRUE
[01:27:45.756]                             break
[01:27:45.756]                           }
[01:27:45.756]                         }
[01:27:45.756]                       }
[01:27:45.756]                       invisible(muffled)
[01:27:45.756]                     }
[01:27:45.756]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.756]                   }
[01:27:45.756]                 }
[01:27:45.756]                 else {
[01:27:45.756]                   if (TRUE) {
[01:27:45.756]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.756]                     {
[01:27:45.756]                       inherits <- base::inherits
[01:27:45.756]                       invokeRestart <- base::invokeRestart
[01:27:45.756]                       is.null <- base::is.null
[01:27:45.756]                       muffled <- FALSE
[01:27:45.756]                       if (inherits(cond, "message")) {
[01:27:45.756]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.756]                         if (muffled) 
[01:27:45.756]                           invokeRestart("muffleMessage")
[01:27:45.756]                       }
[01:27:45.756]                       else if (inherits(cond, "warning")) {
[01:27:45.756]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.756]                         if (muffled) 
[01:27:45.756]                           invokeRestart("muffleWarning")
[01:27:45.756]                       }
[01:27:45.756]                       else if (inherits(cond, "condition")) {
[01:27:45.756]                         if (!is.null(pattern)) {
[01:27:45.756]                           computeRestarts <- base::computeRestarts
[01:27:45.756]                           grepl <- base::grepl
[01:27:45.756]                           restarts <- computeRestarts(cond)
[01:27:45.756]                           for (restart in restarts) {
[01:27:45.756]                             name <- restart$name
[01:27:45.756]                             if (is.null(name)) 
[01:27:45.756]                               next
[01:27:45.756]                             if (!grepl(pattern, name)) 
[01:27:45.756]                               next
[01:27:45.756]                             invokeRestart(restart)
[01:27:45.756]                             muffled <- TRUE
[01:27:45.756]                             break
[01:27:45.756]                           }
[01:27:45.756]                         }
[01:27:45.756]                       }
[01:27:45.756]                       invisible(muffled)
[01:27:45.756]                     }
[01:27:45.756]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.756]                   }
[01:27:45.756]                 }
[01:27:45.756]             }
[01:27:45.756]         }))
[01:27:45.756]     }, error = function(ex) {
[01:27:45.756]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.756]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.756]                 ...future.rng), started = ...future.startTime, 
[01:27:45.756]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.756]             version = "1.8"), class = "FutureResult")
[01:27:45.756]     }, finally = {
[01:27:45.756]         if (!identical(...future.workdir, getwd())) 
[01:27:45.756]             setwd(...future.workdir)
[01:27:45.756]         {
[01:27:45.756]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.756]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.756]             }
[01:27:45.756]             base::options(...future.oldOptions)
[01:27:45.756]             if (.Platform$OS.type == "windows") {
[01:27:45.756]                 old_names <- names(...future.oldEnvVars)
[01:27:45.756]                 envs <- base::Sys.getenv()
[01:27:45.756]                 names <- names(envs)
[01:27:45.756]                 common <- intersect(names, old_names)
[01:27:45.756]                 added <- setdiff(names, old_names)
[01:27:45.756]                 removed <- setdiff(old_names, names)
[01:27:45.756]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.756]                   envs[common]]
[01:27:45.756]                 NAMES <- toupper(changed)
[01:27:45.756]                 args <- list()
[01:27:45.756]                 for (kk in seq_along(NAMES)) {
[01:27:45.756]                   name <- changed[[kk]]
[01:27:45.756]                   NAME <- NAMES[[kk]]
[01:27:45.756]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.756]                     next
[01:27:45.756]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.756]                 }
[01:27:45.756]                 NAMES <- toupper(added)
[01:27:45.756]                 for (kk in seq_along(NAMES)) {
[01:27:45.756]                   name <- added[[kk]]
[01:27:45.756]                   NAME <- NAMES[[kk]]
[01:27:45.756]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.756]                     next
[01:27:45.756]                   args[[name]] <- ""
[01:27:45.756]                 }
[01:27:45.756]                 NAMES <- toupper(removed)
[01:27:45.756]                 for (kk in seq_along(NAMES)) {
[01:27:45.756]                   name <- removed[[kk]]
[01:27:45.756]                   NAME <- NAMES[[kk]]
[01:27:45.756]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.756]                     next
[01:27:45.756]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.756]                 }
[01:27:45.756]                 if (length(args) > 0) 
[01:27:45.756]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.756]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.756]             }
[01:27:45.756]             else {
[01:27:45.756]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.756]             }
[01:27:45.756]             {
[01:27:45.756]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.756]                   0L) {
[01:27:45.756]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.756]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.756]                   base::options(opts)
[01:27:45.756]                 }
[01:27:45.756]                 {
[01:27:45.756]                   {
[01:27:45.756]                     NULL
[01:27:45.756]                     RNGkind("Mersenne-Twister")
[01:27:45.756]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.756]                       inherits = FALSE)
[01:27:45.756]                   }
[01:27:45.756]                   options(future.plan = NULL)
[01:27:45.756]                   if (is.na(NA_character_)) 
[01:27:45.756]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.756]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.756]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.756]                   {
[01:27:45.756]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.756]                     if (!future$lazy) 
[01:27:45.756]                       future <- run(future)
[01:27:45.756]                     invisible(future)
[01:27:45.756]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.756]                 }
[01:27:45.756]             }
[01:27:45.756]         }
[01:27:45.756]     })
[01:27:45.756]     if (TRUE) {
[01:27:45.756]         base::sink(type = "output", split = FALSE)
[01:27:45.756]         if (TRUE) {
[01:27:45.756]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.756]         }
[01:27:45.756]         else {
[01:27:45.756]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.756]         }
[01:27:45.756]         base::close(...future.stdout)
[01:27:45.756]         ...future.stdout <- NULL
[01:27:45.756]     }
[01:27:45.756]     ...future.result$conditions <- ...future.conditions
[01:27:45.756]     ...future.result$finished <- base::Sys.time()
[01:27:45.756]     ...future.result
[01:27:45.756] }
[01:27:45.760] plan(): Setting new future strategy stack:
[01:27:45.760] List of future strategies:
[01:27:45.760] 1. sequential:
[01:27:45.760]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.760]    - tweaked: FALSE
[01:27:45.760]    - call: NULL
[01:27:45.761] plan(): nbrOfWorkers() = 1
[01:27:45.762] plan(): Setting new future strategy stack:
[01:27:45.762] List of future strategies:
[01:27:45.762] 1. sequential:
[01:27:45.762]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.762]    - tweaked: FALSE
[01:27:45.762]    - call: plan(strategy)
[01:27:45.764] plan(): nbrOfWorkers() = 1
[01:27:45.764] SequentialFuture started (and completed)
[01:27:45.764] - Launch lazy future ... done
[01:27:45.765] run() for 'SequentialFuture' ... done
[01:27:45.765] getGlobalsAndPackages() ...
[01:27:45.765] Searching for globals...
[01:27:45.765] 
[01:27:45.766] Searching for globals ... DONE
[01:27:45.766] - globals: [0] <none>
[01:27:45.766] getGlobalsAndPackages() ... DONE
[01:27:45.766] run() for 'Future' ...
[01:27:45.766] - state: 'created'
[01:27:45.767] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.767] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.767] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.767]   - Field: 'label'
[01:27:45.767]   - Field: 'local'
[01:27:45.768]   - Field: 'owner'
[01:27:45.768]   - Field: 'envir'
[01:27:45.768]   - Field: 'packages'
[01:27:45.768]   - Field: 'gc'
[01:27:45.768]   - Field: 'conditions'
[01:27:45.769]   - Field: 'expr'
[01:27:45.769]   - Field: 'uuid'
[01:27:45.769]   - Field: 'seed'
[01:27:45.769]   - Field: 'version'
[01:27:45.769]   - Field: 'result'
[01:27:45.769]   - Field: 'asynchronous'
[01:27:45.770]   - Field: 'calls'
[01:27:45.770]   - Field: 'globals'
[01:27:45.770]   - Field: 'stdout'
[01:27:45.770]   - Field: 'earlySignal'
[01:27:45.770]   - Field: 'lazy'
[01:27:45.770]   - Field: 'state'
[01:27:45.771] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.771] - Launch lazy future ...
[01:27:45.771] Packages needed by the future expression (n = 0): <none>
[01:27:45.771] Packages needed by future strategies (n = 0): <none>
[01:27:45.772] {
[01:27:45.772]     {
[01:27:45.772]         {
[01:27:45.772]             ...future.startTime <- base::Sys.time()
[01:27:45.772]             {
[01:27:45.772]                 {
[01:27:45.772]                   {
[01:27:45.772]                     base::local({
[01:27:45.772]                       has_future <- base::requireNamespace("future", 
[01:27:45.772]                         quietly = TRUE)
[01:27:45.772]                       if (has_future) {
[01:27:45.772]                         ns <- base::getNamespace("future")
[01:27:45.772]                         version <- ns[[".package"]][["version"]]
[01:27:45.772]                         if (is.null(version)) 
[01:27:45.772]                           version <- utils::packageVersion("future")
[01:27:45.772]                       }
[01:27:45.772]                       else {
[01:27:45.772]                         version <- NULL
[01:27:45.772]                       }
[01:27:45.772]                       if (!has_future || version < "1.8.0") {
[01:27:45.772]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.772]                           "", base::R.version$version.string), 
[01:27:45.772]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.772]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.772]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.772]                             "release", "version")], collapse = " "), 
[01:27:45.772]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.772]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.772]                           info)
[01:27:45.772]                         info <- base::paste(info, collapse = "; ")
[01:27:45.772]                         if (!has_future) {
[01:27:45.772]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.772]                             info)
[01:27:45.772]                         }
[01:27:45.772]                         else {
[01:27:45.772]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.772]                             info, version)
[01:27:45.772]                         }
[01:27:45.772]                         base::stop(msg)
[01:27:45.772]                       }
[01:27:45.772]                     })
[01:27:45.772]                   }
[01:27:45.772]                   options(future.plan = NULL)
[01:27:45.772]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.772]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.772]                 }
[01:27:45.772]                 ...future.workdir <- getwd()
[01:27:45.772]             }
[01:27:45.772]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.772]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.772]         }
[01:27:45.772]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.772]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.772]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.772]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.772]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.772]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.772]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.772]             base::names(...future.oldOptions))
[01:27:45.772]     }
[01:27:45.772]     if (FALSE) {
[01:27:45.772]     }
[01:27:45.772]     else {
[01:27:45.772]         if (TRUE) {
[01:27:45.772]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.772]                 open = "w")
[01:27:45.772]         }
[01:27:45.772]         else {
[01:27:45.772]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.772]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.772]         }
[01:27:45.772]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.772]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.772]             base::sink(type = "output", split = FALSE)
[01:27:45.772]             base::close(...future.stdout)
[01:27:45.772]         }, add = TRUE)
[01:27:45.772]     }
[01:27:45.772]     ...future.frame <- base::sys.nframe()
[01:27:45.772]     ...future.conditions <- base::list()
[01:27:45.772]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.772]     if (FALSE) {
[01:27:45.772]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.772]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.772]     }
[01:27:45.772]     ...future.result <- base::tryCatch({
[01:27:45.772]         base::withCallingHandlers({
[01:27:45.772]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.772]             future::FutureResult(value = ...future.value$value, 
[01:27:45.772]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.772]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.772]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.772]                     ...future.globalenv.names))
[01:27:45.772]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.772]         }, condition = base::local({
[01:27:45.772]             c <- base::c
[01:27:45.772]             inherits <- base::inherits
[01:27:45.772]             invokeRestart <- base::invokeRestart
[01:27:45.772]             length <- base::length
[01:27:45.772]             list <- base::list
[01:27:45.772]             seq.int <- base::seq.int
[01:27:45.772]             signalCondition <- base::signalCondition
[01:27:45.772]             sys.calls <- base::sys.calls
[01:27:45.772]             `[[` <- base::`[[`
[01:27:45.772]             `+` <- base::`+`
[01:27:45.772]             `<<-` <- base::`<<-`
[01:27:45.772]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.772]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.772]                   3L)]
[01:27:45.772]             }
[01:27:45.772]             function(cond) {
[01:27:45.772]                 is_error <- inherits(cond, "error")
[01:27:45.772]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.772]                   NULL)
[01:27:45.772]                 if (is_error) {
[01:27:45.772]                   sessionInformation <- function() {
[01:27:45.772]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.772]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.772]                       search = base::search(), system = base::Sys.info())
[01:27:45.772]                   }
[01:27:45.772]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.772]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.772]                     cond$call), session = sessionInformation(), 
[01:27:45.772]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.772]                   signalCondition(cond)
[01:27:45.772]                 }
[01:27:45.772]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.772]                 "immediateCondition"))) {
[01:27:45.772]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.772]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.772]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.772]                   if (TRUE && !signal) {
[01:27:45.772]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.772]                     {
[01:27:45.772]                       inherits <- base::inherits
[01:27:45.772]                       invokeRestart <- base::invokeRestart
[01:27:45.772]                       is.null <- base::is.null
[01:27:45.772]                       muffled <- FALSE
[01:27:45.772]                       if (inherits(cond, "message")) {
[01:27:45.772]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.772]                         if (muffled) 
[01:27:45.772]                           invokeRestart("muffleMessage")
[01:27:45.772]                       }
[01:27:45.772]                       else if (inherits(cond, "warning")) {
[01:27:45.772]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.772]                         if (muffled) 
[01:27:45.772]                           invokeRestart("muffleWarning")
[01:27:45.772]                       }
[01:27:45.772]                       else if (inherits(cond, "condition")) {
[01:27:45.772]                         if (!is.null(pattern)) {
[01:27:45.772]                           computeRestarts <- base::computeRestarts
[01:27:45.772]                           grepl <- base::grepl
[01:27:45.772]                           restarts <- computeRestarts(cond)
[01:27:45.772]                           for (restart in restarts) {
[01:27:45.772]                             name <- restart$name
[01:27:45.772]                             if (is.null(name)) 
[01:27:45.772]                               next
[01:27:45.772]                             if (!grepl(pattern, name)) 
[01:27:45.772]                               next
[01:27:45.772]                             invokeRestart(restart)
[01:27:45.772]                             muffled <- TRUE
[01:27:45.772]                             break
[01:27:45.772]                           }
[01:27:45.772]                         }
[01:27:45.772]                       }
[01:27:45.772]                       invisible(muffled)
[01:27:45.772]                     }
[01:27:45.772]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.772]                   }
[01:27:45.772]                 }
[01:27:45.772]                 else {
[01:27:45.772]                   if (TRUE) {
[01:27:45.772]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.772]                     {
[01:27:45.772]                       inherits <- base::inherits
[01:27:45.772]                       invokeRestart <- base::invokeRestart
[01:27:45.772]                       is.null <- base::is.null
[01:27:45.772]                       muffled <- FALSE
[01:27:45.772]                       if (inherits(cond, "message")) {
[01:27:45.772]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.772]                         if (muffled) 
[01:27:45.772]                           invokeRestart("muffleMessage")
[01:27:45.772]                       }
[01:27:45.772]                       else if (inherits(cond, "warning")) {
[01:27:45.772]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.772]                         if (muffled) 
[01:27:45.772]                           invokeRestart("muffleWarning")
[01:27:45.772]                       }
[01:27:45.772]                       else if (inherits(cond, "condition")) {
[01:27:45.772]                         if (!is.null(pattern)) {
[01:27:45.772]                           computeRestarts <- base::computeRestarts
[01:27:45.772]                           grepl <- base::grepl
[01:27:45.772]                           restarts <- computeRestarts(cond)
[01:27:45.772]                           for (restart in restarts) {
[01:27:45.772]                             name <- restart$name
[01:27:45.772]                             if (is.null(name)) 
[01:27:45.772]                               next
[01:27:45.772]                             if (!grepl(pattern, name)) 
[01:27:45.772]                               next
[01:27:45.772]                             invokeRestart(restart)
[01:27:45.772]                             muffled <- TRUE
[01:27:45.772]                             break
[01:27:45.772]                           }
[01:27:45.772]                         }
[01:27:45.772]                       }
[01:27:45.772]                       invisible(muffled)
[01:27:45.772]                     }
[01:27:45.772]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.772]                   }
[01:27:45.772]                 }
[01:27:45.772]             }
[01:27:45.772]         }))
[01:27:45.772]     }, error = function(ex) {
[01:27:45.772]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.772]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.772]                 ...future.rng), started = ...future.startTime, 
[01:27:45.772]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.772]             version = "1.8"), class = "FutureResult")
[01:27:45.772]     }, finally = {
[01:27:45.772]         if (!identical(...future.workdir, getwd())) 
[01:27:45.772]             setwd(...future.workdir)
[01:27:45.772]         {
[01:27:45.772]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.772]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.772]             }
[01:27:45.772]             base::options(...future.oldOptions)
[01:27:45.772]             if (.Platform$OS.type == "windows") {
[01:27:45.772]                 old_names <- names(...future.oldEnvVars)
[01:27:45.772]                 envs <- base::Sys.getenv()
[01:27:45.772]                 names <- names(envs)
[01:27:45.772]                 common <- intersect(names, old_names)
[01:27:45.772]                 added <- setdiff(names, old_names)
[01:27:45.772]                 removed <- setdiff(old_names, names)
[01:27:45.772]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.772]                   envs[common]]
[01:27:45.772]                 NAMES <- toupper(changed)
[01:27:45.772]                 args <- list()
[01:27:45.772]                 for (kk in seq_along(NAMES)) {
[01:27:45.772]                   name <- changed[[kk]]
[01:27:45.772]                   NAME <- NAMES[[kk]]
[01:27:45.772]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.772]                     next
[01:27:45.772]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.772]                 }
[01:27:45.772]                 NAMES <- toupper(added)
[01:27:45.772]                 for (kk in seq_along(NAMES)) {
[01:27:45.772]                   name <- added[[kk]]
[01:27:45.772]                   NAME <- NAMES[[kk]]
[01:27:45.772]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.772]                     next
[01:27:45.772]                   args[[name]] <- ""
[01:27:45.772]                 }
[01:27:45.772]                 NAMES <- toupper(removed)
[01:27:45.772]                 for (kk in seq_along(NAMES)) {
[01:27:45.772]                   name <- removed[[kk]]
[01:27:45.772]                   NAME <- NAMES[[kk]]
[01:27:45.772]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.772]                     next
[01:27:45.772]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.772]                 }
[01:27:45.772]                 if (length(args) > 0) 
[01:27:45.772]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.772]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.772]             }
[01:27:45.772]             else {
[01:27:45.772]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.772]             }
[01:27:45.772]             {
[01:27:45.772]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.772]                   0L) {
[01:27:45.772]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.772]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.772]                   base::options(opts)
[01:27:45.772]                 }
[01:27:45.772]                 {
[01:27:45.772]                   {
[01:27:45.772]                     NULL
[01:27:45.772]                     RNGkind("Mersenne-Twister")
[01:27:45.772]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.772]                       inherits = FALSE)
[01:27:45.772]                   }
[01:27:45.772]                   options(future.plan = NULL)
[01:27:45.772]                   if (is.na(NA_character_)) 
[01:27:45.772]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.772]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.772]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.772]                   {
[01:27:45.772]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.772]                     if (!future$lazy) 
[01:27:45.772]                       future <- run(future)
[01:27:45.772]                     invisible(future)
[01:27:45.772]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.772]                 }
[01:27:45.772]             }
[01:27:45.772]         }
[01:27:45.772]     })
[01:27:45.772]     if (TRUE) {
[01:27:45.772]         base::sink(type = "output", split = FALSE)
[01:27:45.772]         if (TRUE) {
[01:27:45.772]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.772]         }
[01:27:45.772]         else {
[01:27:45.772]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.772]         }
[01:27:45.772]         base::close(...future.stdout)
[01:27:45.772]         ...future.stdout <- NULL
[01:27:45.772]     }
[01:27:45.772]     ...future.result$conditions <- ...future.conditions
[01:27:45.772]     ...future.result$finished <- base::Sys.time()
[01:27:45.772]     ...future.result
[01:27:45.772] }
[01:27:45.776] plan(): Setting new future strategy stack:
[01:27:45.776] List of future strategies:
[01:27:45.776] 1. sequential:
[01:27:45.776]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.776]    - tweaked: FALSE
[01:27:45.776]    - call: NULL
[01:27:45.776] plan(): nbrOfWorkers() = 1
[01:27:45.778] plan(): Setting new future strategy stack:
[01:27:45.778] List of future strategies:
[01:27:45.778] 1. sequential:
[01:27:45.778]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.778]    - tweaked: FALSE
[01:27:45.778]    - call: plan(strategy)
[01:27:45.778] plan(): nbrOfWorkers() = 1
[01:27:45.779] SequentialFuture started (and completed)
[01:27:45.779] - Launch lazy future ... done
[01:27:45.779] run() for 'SequentialFuture' ... done
[01:27:45.781] getGlobalsAndPackages() ...
[01:27:45.781] Searching for globals...
[01:27:45.782] - globals found: [1] '{'
[01:27:45.782] Searching for globals ... DONE
[01:27:45.783] Resolving globals: FALSE
[01:27:45.783] 
[01:27:45.783] 
[01:27:45.784] getGlobalsAndPackages() ... DONE
[01:27:45.784] run() for 'Future' ...
[01:27:45.784] - state: 'created'
[01:27:45.784] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.785] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.785] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.785]   - Field: 'label'
[01:27:45.785]   - Field: 'local'
[01:27:45.785]   - Field: 'owner'
[01:27:45.786]   - Field: 'envir'
[01:27:45.786]   - Field: 'packages'
[01:27:45.786]   - Field: 'gc'
[01:27:45.786]   - Field: 'conditions'
[01:27:45.786]   - Field: 'expr'
[01:27:45.787]   - Field: 'uuid'
[01:27:45.787]   - Field: 'seed'
[01:27:45.787]   - Field: 'version'
[01:27:45.787]   - Field: 'result'
[01:27:45.787]   - Field: 'asynchronous'
[01:27:45.787]   - Field: 'calls'
[01:27:45.788]   - Field: 'globals'
[01:27:45.788]   - Field: 'stdout'
[01:27:45.788]   - Field: 'earlySignal'
[01:27:45.788]   - Field: 'lazy'
[01:27:45.788]   - Field: 'state'
[01:27:45.788] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.789] - Launch lazy future ...
[01:27:45.789] Packages needed by the future expression (n = 0): <none>
[01:27:45.789] Packages needed by future strategies (n = 0): <none>
[01:27:45.790] {
[01:27:45.790]     {
[01:27:45.790]         {
[01:27:45.790]             ...future.startTime <- base::Sys.time()
[01:27:45.790]             {
[01:27:45.790]                 {
[01:27:45.790]                   {
[01:27:45.790]                     base::local({
[01:27:45.790]                       has_future <- base::requireNamespace("future", 
[01:27:45.790]                         quietly = TRUE)
[01:27:45.790]                       if (has_future) {
[01:27:45.790]                         ns <- base::getNamespace("future")
[01:27:45.790]                         version <- ns[[".package"]][["version"]]
[01:27:45.790]                         if (is.null(version)) 
[01:27:45.790]                           version <- utils::packageVersion("future")
[01:27:45.790]                       }
[01:27:45.790]                       else {
[01:27:45.790]                         version <- NULL
[01:27:45.790]                       }
[01:27:45.790]                       if (!has_future || version < "1.8.0") {
[01:27:45.790]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.790]                           "", base::R.version$version.string), 
[01:27:45.790]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.790]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.790]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.790]                             "release", "version")], collapse = " "), 
[01:27:45.790]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.790]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.790]                           info)
[01:27:45.790]                         info <- base::paste(info, collapse = "; ")
[01:27:45.790]                         if (!has_future) {
[01:27:45.790]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.790]                             info)
[01:27:45.790]                         }
[01:27:45.790]                         else {
[01:27:45.790]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.790]                             info, version)
[01:27:45.790]                         }
[01:27:45.790]                         base::stop(msg)
[01:27:45.790]                       }
[01:27:45.790]                     })
[01:27:45.790]                   }
[01:27:45.790]                   options(future.plan = NULL)
[01:27:45.790]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.790]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.790]                 }
[01:27:45.790]                 ...future.workdir <- getwd()
[01:27:45.790]             }
[01:27:45.790]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.790]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.790]         }
[01:27:45.790]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.790]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.790]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.790]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.790]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.790]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.790]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.790]             base::names(...future.oldOptions))
[01:27:45.790]     }
[01:27:45.790]     if (FALSE) {
[01:27:45.790]     }
[01:27:45.790]     else {
[01:27:45.790]         if (TRUE) {
[01:27:45.790]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.790]                 open = "w")
[01:27:45.790]         }
[01:27:45.790]         else {
[01:27:45.790]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.790]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.790]         }
[01:27:45.790]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.790]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.790]             base::sink(type = "output", split = FALSE)
[01:27:45.790]             base::close(...future.stdout)
[01:27:45.790]         }, add = TRUE)
[01:27:45.790]     }
[01:27:45.790]     ...future.frame <- base::sys.nframe()
[01:27:45.790]     ...future.conditions <- base::list()
[01:27:45.790]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.790]     if (FALSE) {
[01:27:45.790]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.790]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.790]     }
[01:27:45.790]     ...future.result <- base::tryCatch({
[01:27:45.790]         base::withCallingHandlers({
[01:27:45.790]             ...future.value <- base::withVisible(base::local({
[01:27:45.790]                 4
[01:27:45.790]             }))
[01:27:45.790]             future::FutureResult(value = ...future.value$value, 
[01:27:45.790]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.790]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.790]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.790]                     ...future.globalenv.names))
[01:27:45.790]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.790]         }, condition = base::local({
[01:27:45.790]             c <- base::c
[01:27:45.790]             inherits <- base::inherits
[01:27:45.790]             invokeRestart <- base::invokeRestart
[01:27:45.790]             length <- base::length
[01:27:45.790]             list <- base::list
[01:27:45.790]             seq.int <- base::seq.int
[01:27:45.790]             signalCondition <- base::signalCondition
[01:27:45.790]             sys.calls <- base::sys.calls
[01:27:45.790]             `[[` <- base::`[[`
[01:27:45.790]             `+` <- base::`+`
[01:27:45.790]             `<<-` <- base::`<<-`
[01:27:45.790]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.790]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.790]                   3L)]
[01:27:45.790]             }
[01:27:45.790]             function(cond) {
[01:27:45.790]                 is_error <- inherits(cond, "error")
[01:27:45.790]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.790]                   NULL)
[01:27:45.790]                 if (is_error) {
[01:27:45.790]                   sessionInformation <- function() {
[01:27:45.790]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.790]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.790]                       search = base::search(), system = base::Sys.info())
[01:27:45.790]                   }
[01:27:45.790]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.790]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.790]                     cond$call), session = sessionInformation(), 
[01:27:45.790]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.790]                   signalCondition(cond)
[01:27:45.790]                 }
[01:27:45.790]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.790]                 "immediateCondition"))) {
[01:27:45.790]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.790]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.790]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.790]                   if (TRUE && !signal) {
[01:27:45.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.790]                     {
[01:27:45.790]                       inherits <- base::inherits
[01:27:45.790]                       invokeRestart <- base::invokeRestart
[01:27:45.790]                       is.null <- base::is.null
[01:27:45.790]                       muffled <- FALSE
[01:27:45.790]                       if (inherits(cond, "message")) {
[01:27:45.790]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.790]                         if (muffled) 
[01:27:45.790]                           invokeRestart("muffleMessage")
[01:27:45.790]                       }
[01:27:45.790]                       else if (inherits(cond, "warning")) {
[01:27:45.790]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.790]                         if (muffled) 
[01:27:45.790]                           invokeRestart("muffleWarning")
[01:27:45.790]                       }
[01:27:45.790]                       else if (inherits(cond, "condition")) {
[01:27:45.790]                         if (!is.null(pattern)) {
[01:27:45.790]                           computeRestarts <- base::computeRestarts
[01:27:45.790]                           grepl <- base::grepl
[01:27:45.790]                           restarts <- computeRestarts(cond)
[01:27:45.790]                           for (restart in restarts) {
[01:27:45.790]                             name <- restart$name
[01:27:45.790]                             if (is.null(name)) 
[01:27:45.790]                               next
[01:27:45.790]                             if (!grepl(pattern, name)) 
[01:27:45.790]                               next
[01:27:45.790]                             invokeRestart(restart)
[01:27:45.790]                             muffled <- TRUE
[01:27:45.790]                             break
[01:27:45.790]                           }
[01:27:45.790]                         }
[01:27:45.790]                       }
[01:27:45.790]                       invisible(muffled)
[01:27:45.790]                     }
[01:27:45.790]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.790]                   }
[01:27:45.790]                 }
[01:27:45.790]                 else {
[01:27:45.790]                   if (TRUE) {
[01:27:45.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.790]                     {
[01:27:45.790]                       inherits <- base::inherits
[01:27:45.790]                       invokeRestart <- base::invokeRestart
[01:27:45.790]                       is.null <- base::is.null
[01:27:45.790]                       muffled <- FALSE
[01:27:45.790]                       if (inherits(cond, "message")) {
[01:27:45.790]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.790]                         if (muffled) 
[01:27:45.790]                           invokeRestart("muffleMessage")
[01:27:45.790]                       }
[01:27:45.790]                       else if (inherits(cond, "warning")) {
[01:27:45.790]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.790]                         if (muffled) 
[01:27:45.790]                           invokeRestart("muffleWarning")
[01:27:45.790]                       }
[01:27:45.790]                       else if (inherits(cond, "condition")) {
[01:27:45.790]                         if (!is.null(pattern)) {
[01:27:45.790]                           computeRestarts <- base::computeRestarts
[01:27:45.790]                           grepl <- base::grepl
[01:27:45.790]                           restarts <- computeRestarts(cond)
[01:27:45.790]                           for (restart in restarts) {
[01:27:45.790]                             name <- restart$name
[01:27:45.790]                             if (is.null(name)) 
[01:27:45.790]                               next
[01:27:45.790]                             if (!grepl(pattern, name)) 
[01:27:45.790]                               next
[01:27:45.790]                             invokeRestart(restart)
[01:27:45.790]                             muffled <- TRUE
[01:27:45.790]                             break
[01:27:45.790]                           }
[01:27:45.790]                         }
[01:27:45.790]                       }
[01:27:45.790]                       invisible(muffled)
[01:27:45.790]                     }
[01:27:45.790]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.790]                   }
[01:27:45.790]                 }
[01:27:45.790]             }
[01:27:45.790]         }))
[01:27:45.790]     }, error = function(ex) {
[01:27:45.790]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.790]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.790]                 ...future.rng), started = ...future.startTime, 
[01:27:45.790]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.790]             version = "1.8"), class = "FutureResult")
[01:27:45.790]     }, finally = {
[01:27:45.790]         if (!identical(...future.workdir, getwd())) 
[01:27:45.790]             setwd(...future.workdir)
[01:27:45.790]         {
[01:27:45.790]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.790]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.790]             }
[01:27:45.790]             base::options(...future.oldOptions)
[01:27:45.790]             if (.Platform$OS.type == "windows") {
[01:27:45.790]                 old_names <- names(...future.oldEnvVars)
[01:27:45.790]                 envs <- base::Sys.getenv()
[01:27:45.790]                 names <- names(envs)
[01:27:45.790]                 common <- intersect(names, old_names)
[01:27:45.790]                 added <- setdiff(names, old_names)
[01:27:45.790]                 removed <- setdiff(old_names, names)
[01:27:45.790]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.790]                   envs[common]]
[01:27:45.790]                 NAMES <- toupper(changed)
[01:27:45.790]                 args <- list()
[01:27:45.790]                 for (kk in seq_along(NAMES)) {
[01:27:45.790]                   name <- changed[[kk]]
[01:27:45.790]                   NAME <- NAMES[[kk]]
[01:27:45.790]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.790]                     next
[01:27:45.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.790]                 }
[01:27:45.790]                 NAMES <- toupper(added)
[01:27:45.790]                 for (kk in seq_along(NAMES)) {
[01:27:45.790]                   name <- added[[kk]]
[01:27:45.790]                   NAME <- NAMES[[kk]]
[01:27:45.790]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.790]                     next
[01:27:45.790]                   args[[name]] <- ""
[01:27:45.790]                 }
[01:27:45.790]                 NAMES <- toupper(removed)
[01:27:45.790]                 for (kk in seq_along(NAMES)) {
[01:27:45.790]                   name <- removed[[kk]]
[01:27:45.790]                   NAME <- NAMES[[kk]]
[01:27:45.790]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.790]                     next
[01:27:45.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.790]                 }
[01:27:45.790]                 if (length(args) > 0) 
[01:27:45.790]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.790]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.790]             }
[01:27:45.790]             else {
[01:27:45.790]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.790]             }
[01:27:45.790]             {
[01:27:45.790]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.790]                   0L) {
[01:27:45.790]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.790]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.790]                   base::options(opts)
[01:27:45.790]                 }
[01:27:45.790]                 {
[01:27:45.790]                   {
[01:27:45.790]                     NULL
[01:27:45.790]                     RNGkind("Mersenne-Twister")
[01:27:45.790]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.790]                       inherits = FALSE)
[01:27:45.790]                   }
[01:27:45.790]                   options(future.plan = NULL)
[01:27:45.790]                   if (is.na(NA_character_)) 
[01:27:45.790]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.790]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.790]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.790]                   {
[01:27:45.790]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.790]                     if (!future$lazy) 
[01:27:45.790]                       future <- run(future)
[01:27:45.790]                     invisible(future)
[01:27:45.790]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.790]                 }
[01:27:45.790]             }
[01:27:45.790]         }
[01:27:45.790]     })
[01:27:45.790]     if (TRUE) {
[01:27:45.790]         base::sink(type = "output", split = FALSE)
[01:27:45.790]         if (TRUE) {
[01:27:45.790]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.790]         }
[01:27:45.790]         else {
[01:27:45.790]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.790]         }
[01:27:45.790]         base::close(...future.stdout)
[01:27:45.790]         ...future.stdout <- NULL
[01:27:45.790]     }
[01:27:45.790]     ...future.result$conditions <- ...future.conditions
[01:27:45.790]     ...future.result$finished <- base::Sys.time()
[01:27:45.790]     ...future.result
[01:27:45.790] }
[01:27:45.794] plan(): Setting new future strategy stack:
[01:27:45.794] List of future strategies:
[01:27:45.794] 1. sequential:
[01:27:45.794]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.794]    - tweaked: FALSE
[01:27:45.794]    - call: NULL
[01:27:45.795] plan(): nbrOfWorkers() = 1
[01:27:45.796] plan(): Setting new future strategy stack:
[01:27:45.796] List of future strategies:
[01:27:45.796] 1. sequential:
[01:27:45.796]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.796]    - tweaked: FALSE
[01:27:45.796]    - call: plan(strategy)
[01:27:45.797] plan(): nbrOfWorkers() = 1
[01:27:45.797] SequentialFuture started (and completed)
[01:27:45.797] - Launch lazy future ... done
[01:27:45.797] run() for 'SequentialFuture' ... done
<environment: 0x0000025b07e1e6c0> 
<environment: 0x0000025b07f4c418> 
[01:27:45.799] resolved() for 'SequentialFuture' ...
[01:27:45.799] - state: 'finished'
[01:27:45.799] - run: TRUE
[01:27:45.800] - result: 'FutureResult'
[01:27:45.800] resolved() for 'SequentialFuture' ... done
[01:27:45.800] resolved() for 'SequentialFuture' ...
[01:27:45.800] - state: 'finished'
[01:27:45.800] - run: TRUE
[01:27:45.801] - result: 'FutureResult'
[01:27:45.801] resolved() for 'SequentialFuture' ... done
[01:27:45.801] resolved() for 'SequentialFuture' ...
[01:27:45.801] - state: 'finished'
[01:27:45.801] - run: TRUE
[01:27:45.802] - result: 'FutureResult'
[01:27:45.802] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:45.803] resolve() on environment ...
[01:27:45.804]  recursive: 0
[01:27:45.806]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:45.806] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.806] - nx: 4
[01:27:45.806] - relay: TRUE
[01:27:45.806] - stdout: TRUE
[01:27:45.806] - signal: TRUE
[01:27:45.807] - resignal: FALSE
[01:27:45.807] - force: TRUE
[01:27:45.807] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.807] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.807]  - until=2
[01:27:45.807]  - relaying element #2
[01:27:45.808] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:45.808] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.808] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.808]  length: 3 (resolved future 1)
[01:27:45.808] resolved() for 'SequentialFuture' ...
[01:27:45.808] - state: 'finished'
[01:27:45.809] - run: TRUE
[01:27:45.809] - result: 'FutureResult'
[01:27:45.809] resolved() for 'SequentialFuture' ... done
[01:27:45.809] Future #2
[01:27:45.809] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.810] - nx: 4
[01:27:45.810] - relay: TRUE
[01:27:45.810] - stdout: TRUE
[01:27:45.810] - signal: TRUE
[01:27:45.810] - resignal: FALSE
[01:27:45.810] - force: TRUE
[01:27:45.810] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:45.811] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.811]  - until=2
[01:27:45.811]  - relaying element #2
[01:27:45.811] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:45.811] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:45.812] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.812]  length: 2 (resolved future 2)
[01:27:45.812] resolved() for 'SequentialFuture' ...
[01:27:45.812] - state: 'finished'
[01:27:45.812] - run: TRUE
[01:27:45.813] - result: 'FutureResult'
[01:27:45.813] resolved() for 'SequentialFuture' ... done
[01:27:45.813] Future #3
[01:27:45.813] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.813] - nx: 4
[01:27:45.813] - relay: TRUE
[01:27:45.814] - stdout: TRUE
[01:27:45.814] - signal: TRUE
[01:27:45.814] - resignal: FALSE
[01:27:45.814] - force: TRUE
[01:27:45.814] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:45.814] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:45.814]  - until=3
[01:27:45.815]  - relaying element #3
[01:27:45.815] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:45.815] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:45.815] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.815]  length: 1 (resolved future 3)
[01:27:45.816] resolved() for 'SequentialFuture' ...
[01:27:45.816] - state: 'finished'
[01:27:45.816] - run: TRUE
[01:27:45.816] - result: 'FutureResult'
[01:27:45.816] resolved() for 'SequentialFuture' ... done
[01:27:45.817] Future #4
[01:27:45.817] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:45.817] - nx: 4
[01:27:45.817] - relay: TRUE
[01:27:45.817] - stdout: TRUE
[01:27:45.817] - signal: TRUE
[01:27:45.817] - resignal: FALSE
[01:27:45.818] - force: TRUE
[01:27:45.818] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:45.818] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:45.818]  - until=4
[01:27:45.818]  - relaying element #4
[01:27:45.819] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:45.819] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:45.819] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:45.819]  length: 0 (resolved future 4)
[01:27:45.819] Relaying remaining futures
[01:27:45.819] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.820] - nx: 4
[01:27:45.820] - relay: TRUE
[01:27:45.820] - stdout: TRUE
[01:27:45.820] - signal: TRUE
[01:27:45.820] - resignal: FALSE
[01:27:45.821] - force: TRUE
[01:27:45.821] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:45.822] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:45.822] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:45.823] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:45.823] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.823] resolve() on environment ... DONE
<environment: 0x0000025b08298688> 
Dimensions: c(1, 6)
[01:27:45.825] getGlobalsAndPackages() ...
[01:27:45.826] Searching for globals...
[01:27:45.827] 
[01:27:45.827] Searching for globals ... DONE
[01:27:45.828] - globals: [0] <none>
[01:27:45.828] getGlobalsAndPackages() ... DONE
[01:27:45.829] run() for 'Future' ...
[01:27:45.829] - state: 'created'
[01:27:45.829] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.830] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.831] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.831]   - Field: 'label'
[01:27:45.831]   - Field: 'local'
[01:27:45.832]   - Field: 'owner'
[01:27:45.832]   - Field: 'envir'
[01:27:45.832]   - Field: 'packages'
[01:27:45.833]   - Field: 'gc'
[01:27:45.833]   - Field: 'conditions'
[01:27:45.833]   - Field: 'expr'
[01:27:45.834]   - Field: 'uuid'
[01:27:45.834]   - Field: 'seed'
[01:27:45.834]   - Field: 'version'
[01:27:45.835]   - Field: 'result'
[01:27:45.835]   - Field: 'asynchronous'
[01:27:45.835]   - Field: 'calls'
[01:27:45.836]   - Field: 'globals'
[01:27:45.836]   - Field: 'stdout'
[01:27:45.836]   - Field: 'earlySignal'
[01:27:45.837]   - Field: 'lazy'
[01:27:45.837]   - Field: 'state'
[01:27:45.837] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.838] - Launch lazy future ...
[01:27:45.838] Packages needed by the future expression (n = 0): <none>
[01:27:45.838] Packages needed by future strategies (n = 0): <none>
[01:27:45.840] {
[01:27:45.840]     {
[01:27:45.840]         {
[01:27:45.840]             ...future.startTime <- base::Sys.time()
[01:27:45.840]             {
[01:27:45.840]                 {
[01:27:45.840]                   {
[01:27:45.840]                     base::local({
[01:27:45.840]                       has_future <- base::requireNamespace("future", 
[01:27:45.840]                         quietly = TRUE)
[01:27:45.840]                       if (has_future) {
[01:27:45.840]                         ns <- base::getNamespace("future")
[01:27:45.840]                         version <- ns[[".package"]][["version"]]
[01:27:45.840]                         if (is.null(version)) 
[01:27:45.840]                           version <- utils::packageVersion("future")
[01:27:45.840]                       }
[01:27:45.840]                       else {
[01:27:45.840]                         version <- NULL
[01:27:45.840]                       }
[01:27:45.840]                       if (!has_future || version < "1.8.0") {
[01:27:45.840]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.840]                           "", base::R.version$version.string), 
[01:27:45.840]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.840]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.840]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.840]                             "release", "version")], collapse = " "), 
[01:27:45.840]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.840]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.840]                           info)
[01:27:45.840]                         info <- base::paste(info, collapse = "; ")
[01:27:45.840]                         if (!has_future) {
[01:27:45.840]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.840]                             info)
[01:27:45.840]                         }
[01:27:45.840]                         else {
[01:27:45.840]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.840]                             info, version)
[01:27:45.840]                         }
[01:27:45.840]                         base::stop(msg)
[01:27:45.840]                       }
[01:27:45.840]                     })
[01:27:45.840]                   }
[01:27:45.840]                   options(future.plan = NULL)
[01:27:45.840]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.840]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.840]                 }
[01:27:45.840]                 ...future.workdir <- getwd()
[01:27:45.840]             }
[01:27:45.840]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.840]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.840]         }
[01:27:45.840]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.840]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.840]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.840]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.840]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.840]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.840]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.840]             base::names(...future.oldOptions))
[01:27:45.840]     }
[01:27:45.840]     if (FALSE) {
[01:27:45.840]     }
[01:27:45.840]     else {
[01:27:45.840]         if (TRUE) {
[01:27:45.840]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.840]                 open = "w")
[01:27:45.840]         }
[01:27:45.840]         else {
[01:27:45.840]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.840]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.840]         }
[01:27:45.840]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.840]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.840]             base::sink(type = "output", split = FALSE)
[01:27:45.840]             base::close(...future.stdout)
[01:27:45.840]         }, add = TRUE)
[01:27:45.840]     }
[01:27:45.840]     ...future.frame <- base::sys.nframe()
[01:27:45.840]     ...future.conditions <- base::list()
[01:27:45.840]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.840]     if (FALSE) {
[01:27:45.840]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.840]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.840]     }
[01:27:45.840]     ...future.result <- base::tryCatch({
[01:27:45.840]         base::withCallingHandlers({
[01:27:45.840]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.840]             future::FutureResult(value = ...future.value$value, 
[01:27:45.840]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.840]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.840]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.840]                     ...future.globalenv.names))
[01:27:45.840]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.840]         }, condition = base::local({
[01:27:45.840]             c <- base::c
[01:27:45.840]             inherits <- base::inherits
[01:27:45.840]             invokeRestart <- base::invokeRestart
[01:27:45.840]             length <- base::length
[01:27:45.840]             list <- base::list
[01:27:45.840]             seq.int <- base::seq.int
[01:27:45.840]             signalCondition <- base::signalCondition
[01:27:45.840]             sys.calls <- base::sys.calls
[01:27:45.840]             `[[` <- base::`[[`
[01:27:45.840]             `+` <- base::`+`
[01:27:45.840]             `<<-` <- base::`<<-`
[01:27:45.840]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.840]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.840]                   3L)]
[01:27:45.840]             }
[01:27:45.840]             function(cond) {
[01:27:45.840]                 is_error <- inherits(cond, "error")
[01:27:45.840]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.840]                   NULL)
[01:27:45.840]                 if (is_error) {
[01:27:45.840]                   sessionInformation <- function() {
[01:27:45.840]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.840]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.840]                       search = base::search(), system = base::Sys.info())
[01:27:45.840]                   }
[01:27:45.840]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.840]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.840]                     cond$call), session = sessionInformation(), 
[01:27:45.840]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.840]                   signalCondition(cond)
[01:27:45.840]                 }
[01:27:45.840]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.840]                 "immediateCondition"))) {
[01:27:45.840]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.840]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.840]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.840]                   if (TRUE && !signal) {
[01:27:45.840]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.840]                     {
[01:27:45.840]                       inherits <- base::inherits
[01:27:45.840]                       invokeRestart <- base::invokeRestart
[01:27:45.840]                       is.null <- base::is.null
[01:27:45.840]                       muffled <- FALSE
[01:27:45.840]                       if (inherits(cond, "message")) {
[01:27:45.840]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.840]                         if (muffled) 
[01:27:45.840]                           invokeRestart("muffleMessage")
[01:27:45.840]                       }
[01:27:45.840]                       else if (inherits(cond, "warning")) {
[01:27:45.840]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.840]                         if (muffled) 
[01:27:45.840]                           invokeRestart("muffleWarning")
[01:27:45.840]                       }
[01:27:45.840]                       else if (inherits(cond, "condition")) {
[01:27:45.840]                         if (!is.null(pattern)) {
[01:27:45.840]                           computeRestarts <- base::computeRestarts
[01:27:45.840]                           grepl <- base::grepl
[01:27:45.840]                           restarts <- computeRestarts(cond)
[01:27:45.840]                           for (restart in restarts) {
[01:27:45.840]                             name <- restart$name
[01:27:45.840]                             if (is.null(name)) 
[01:27:45.840]                               next
[01:27:45.840]                             if (!grepl(pattern, name)) 
[01:27:45.840]                               next
[01:27:45.840]                             invokeRestart(restart)
[01:27:45.840]                             muffled <- TRUE
[01:27:45.840]                             break
[01:27:45.840]                           }
[01:27:45.840]                         }
[01:27:45.840]                       }
[01:27:45.840]                       invisible(muffled)
[01:27:45.840]                     }
[01:27:45.840]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.840]                   }
[01:27:45.840]                 }
[01:27:45.840]                 else {
[01:27:45.840]                   if (TRUE) {
[01:27:45.840]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.840]                     {
[01:27:45.840]                       inherits <- base::inherits
[01:27:45.840]                       invokeRestart <- base::invokeRestart
[01:27:45.840]                       is.null <- base::is.null
[01:27:45.840]                       muffled <- FALSE
[01:27:45.840]                       if (inherits(cond, "message")) {
[01:27:45.840]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.840]                         if (muffled) 
[01:27:45.840]                           invokeRestart("muffleMessage")
[01:27:45.840]                       }
[01:27:45.840]                       else if (inherits(cond, "warning")) {
[01:27:45.840]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.840]                         if (muffled) 
[01:27:45.840]                           invokeRestart("muffleWarning")
[01:27:45.840]                       }
[01:27:45.840]                       else if (inherits(cond, "condition")) {
[01:27:45.840]                         if (!is.null(pattern)) {
[01:27:45.840]                           computeRestarts <- base::computeRestarts
[01:27:45.840]                           grepl <- base::grepl
[01:27:45.840]                           restarts <- computeRestarts(cond)
[01:27:45.840]                           for (restart in restarts) {
[01:27:45.840]                             name <- restart$name
[01:27:45.840]                             if (is.null(name)) 
[01:27:45.840]                               next
[01:27:45.840]                             if (!grepl(pattern, name)) 
[01:27:45.840]                               next
[01:27:45.840]                             invokeRestart(restart)
[01:27:45.840]                             muffled <- TRUE
[01:27:45.840]                             break
[01:27:45.840]                           }
[01:27:45.840]                         }
[01:27:45.840]                       }
[01:27:45.840]                       invisible(muffled)
[01:27:45.840]                     }
[01:27:45.840]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.840]                   }
[01:27:45.840]                 }
[01:27:45.840]             }
[01:27:45.840]         }))
[01:27:45.840]     }, error = function(ex) {
[01:27:45.840]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.840]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.840]                 ...future.rng), started = ...future.startTime, 
[01:27:45.840]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.840]             version = "1.8"), class = "FutureResult")
[01:27:45.840]     }, finally = {
[01:27:45.840]         if (!identical(...future.workdir, getwd())) 
[01:27:45.840]             setwd(...future.workdir)
[01:27:45.840]         {
[01:27:45.840]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.840]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.840]             }
[01:27:45.840]             base::options(...future.oldOptions)
[01:27:45.840]             if (.Platform$OS.type == "windows") {
[01:27:45.840]                 old_names <- names(...future.oldEnvVars)
[01:27:45.840]                 envs <- base::Sys.getenv()
[01:27:45.840]                 names <- names(envs)
[01:27:45.840]                 common <- intersect(names, old_names)
[01:27:45.840]                 added <- setdiff(names, old_names)
[01:27:45.840]                 removed <- setdiff(old_names, names)
[01:27:45.840]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.840]                   envs[common]]
[01:27:45.840]                 NAMES <- toupper(changed)
[01:27:45.840]                 args <- list()
[01:27:45.840]                 for (kk in seq_along(NAMES)) {
[01:27:45.840]                   name <- changed[[kk]]
[01:27:45.840]                   NAME <- NAMES[[kk]]
[01:27:45.840]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.840]                     next
[01:27:45.840]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.840]                 }
[01:27:45.840]                 NAMES <- toupper(added)
[01:27:45.840]                 for (kk in seq_along(NAMES)) {
[01:27:45.840]                   name <- added[[kk]]
[01:27:45.840]                   NAME <- NAMES[[kk]]
[01:27:45.840]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.840]                     next
[01:27:45.840]                   args[[name]] <- ""
[01:27:45.840]                 }
[01:27:45.840]                 NAMES <- toupper(removed)
[01:27:45.840]                 for (kk in seq_along(NAMES)) {
[01:27:45.840]                   name <- removed[[kk]]
[01:27:45.840]                   NAME <- NAMES[[kk]]
[01:27:45.840]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.840]                     next
[01:27:45.840]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.840]                 }
[01:27:45.840]                 if (length(args) > 0) 
[01:27:45.840]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.840]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.840]             }
[01:27:45.840]             else {
[01:27:45.840]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.840]             }
[01:27:45.840]             {
[01:27:45.840]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.840]                   0L) {
[01:27:45.840]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.840]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.840]                   base::options(opts)
[01:27:45.840]                 }
[01:27:45.840]                 {
[01:27:45.840]                   {
[01:27:45.840]                     NULL
[01:27:45.840]                     RNGkind("Mersenne-Twister")
[01:27:45.840]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.840]                       inherits = FALSE)
[01:27:45.840]                   }
[01:27:45.840]                   options(future.plan = NULL)
[01:27:45.840]                   if (is.na(NA_character_)) 
[01:27:45.840]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.840]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.840]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.840]                   {
[01:27:45.840]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.840]                     if (!future$lazy) 
[01:27:45.840]                       future <- run(future)
[01:27:45.840]                     invisible(future)
[01:27:45.840]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.840]                 }
[01:27:45.840]             }
[01:27:45.840]         }
[01:27:45.840]     })
[01:27:45.840]     if (TRUE) {
[01:27:45.840]         base::sink(type = "output", split = FALSE)
[01:27:45.840]         if (TRUE) {
[01:27:45.840]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.840]         }
[01:27:45.840]         else {
[01:27:45.840]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.840]         }
[01:27:45.840]         base::close(...future.stdout)
[01:27:45.840]         ...future.stdout <- NULL
[01:27:45.840]     }
[01:27:45.840]     ...future.result$conditions <- ...future.conditions
[01:27:45.840]     ...future.result$finished <- base::Sys.time()
[01:27:45.840]     ...future.result
[01:27:45.840] }
[01:27:45.847] plan(): Setting new future strategy stack:
[01:27:45.848] List of future strategies:
[01:27:45.848] 1. sequential:
[01:27:45.848]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.848]    - tweaked: FALSE
[01:27:45.848]    - call: NULL
[01:27:45.849] plan(): nbrOfWorkers() = 1
[01:27:45.851] plan(): Setting new future strategy stack:
[01:27:45.852] List of future strategies:
[01:27:45.852] 1. sequential:
[01:27:45.852]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.852]    - tweaked: FALSE
[01:27:45.852]    - call: plan(strategy)
[01:27:45.853] plan(): nbrOfWorkers() = 1
[01:27:45.853] SequentialFuture started (and completed)
[01:27:45.854] - Launch lazy future ... done
[01:27:45.854] run() for 'SequentialFuture' ... done
[01:27:45.854] getGlobalsAndPackages() ...
[01:27:45.855] Searching for globals...
[01:27:45.856] 
[01:27:45.856] Searching for globals ... DONE
[01:27:45.856] - globals: [0] <none>
[01:27:45.856] getGlobalsAndPackages() ... DONE
[01:27:45.857] run() for 'Future' ...
[01:27:45.857] - state: 'created'
[01:27:45.858] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.858] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.859] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.859]   - Field: 'label'
[01:27:45.859]   - Field: 'local'
[01:27:45.860]   - Field: 'owner'
[01:27:45.860]   - Field: 'envir'
[01:27:45.860]   - Field: 'packages'
[01:27:45.861]   - Field: 'gc'
[01:27:45.867]   - Field: 'conditions'
[01:27:45.867]   - Field: 'expr'
[01:27:45.867]   - Field: 'uuid'
[01:27:45.868]   - Field: 'seed'
[01:27:45.868]   - Field: 'version'
[01:27:45.868]   - Field: 'result'
[01:27:45.869]   - Field: 'asynchronous'
[01:27:45.869]   - Field: 'calls'
[01:27:45.869]   - Field: 'globals'
[01:27:45.869]   - Field: 'stdout'
[01:27:45.870]   - Field: 'earlySignal'
[01:27:45.870]   - Field: 'lazy'
[01:27:45.870]   - Field: 'state'
[01:27:45.871] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.871] - Launch lazy future ...
[01:27:45.871] Packages needed by the future expression (n = 0): <none>
[01:27:45.872] Packages needed by future strategies (n = 0): <none>
[01:27:45.873] {
[01:27:45.873]     {
[01:27:45.873]         {
[01:27:45.873]             ...future.startTime <- base::Sys.time()
[01:27:45.873]             {
[01:27:45.873]                 {
[01:27:45.873]                   {
[01:27:45.873]                     base::local({
[01:27:45.873]                       has_future <- base::requireNamespace("future", 
[01:27:45.873]                         quietly = TRUE)
[01:27:45.873]                       if (has_future) {
[01:27:45.873]                         ns <- base::getNamespace("future")
[01:27:45.873]                         version <- ns[[".package"]][["version"]]
[01:27:45.873]                         if (is.null(version)) 
[01:27:45.873]                           version <- utils::packageVersion("future")
[01:27:45.873]                       }
[01:27:45.873]                       else {
[01:27:45.873]                         version <- NULL
[01:27:45.873]                       }
[01:27:45.873]                       if (!has_future || version < "1.8.0") {
[01:27:45.873]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.873]                           "", base::R.version$version.string), 
[01:27:45.873]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.873]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.873]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.873]                             "release", "version")], collapse = " "), 
[01:27:45.873]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.873]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.873]                           info)
[01:27:45.873]                         info <- base::paste(info, collapse = "; ")
[01:27:45.873]                         if (!has_future) {
[01:27:45.873]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.873]                             info)
[01:27:45.873]                         }
[01:27:45.873]                         else {
[01:27:45.873]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.873]                             info, version)
[01:27:45.873]                         }
[01:27:45.873]                         base::stop(msg)
[01:27:45.873]                       }
[01:27:45.873]                     })
[01:27:45.873]                   }
[01:27:45.873]                   options(future.plan = NULL)
[01:27:45.873]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.873]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.873]                 }
[01:27:45.873]                 ...future.workdir <- getwd()
[01:27:45.873]             }
[01:27:45.873]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.873]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.873]         }
[01:27:45.873]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.873]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.873]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.873]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.873]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.873]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.873]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.873]             base::names(...future.oldOptions))
[01:27:45.873]     }
[01:27:45.873]     if (FALSE) {
[01:27:45.873]     }
[01:27:45.873]     else {
[01:27:45.873]         if (TRUE) {
[01:27:45.873]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.873]                 open = "w")
[01:27:45.873]         }
[01:27:45.873]         else {
[01:27:45.873]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.873]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.873]         }
[01:27:45.873]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.873]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.873]             base::sink(type = "output", split = FALSE)
[01:27:45.873]             base::close(...future.stdout)
[01:27:45.873]         }, add = TRUE)
[01:27:45.873]     }
[01:27:45.873]     ...future.frame <- base::sys.nframe()
[01:27:45.873]     ...future.conditions <- base::list()
[01:27:45.873]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.873]     if (FALSE) {
[01:27:45.873]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.873]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.873]     }
[01:27:45.873]     ...future.result <- base::tryCatch({
[01:27:45.873]         base::withCallingHandlers({
[01:27:45.873]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.873]             future::FutureResult(value = ...future.value$value, 
[01:27:45.873]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.873]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.873]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.873]                     ...future.globalenv.names))
[01:27:45.873]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.873]         }, condition = base::local({
[01:27:45.873]             c <- base::c
[01:27:45.873]             inherits <- base::inherits
[01:27:45.873]             invokeRestart <- base::invokeRestart
[01:27:45.873]             length <- base::length
[01:27:45.873]             list <- base::list
[01:27:45.873]             seq.int <- base::seq.int
[01:27:45.873]             signalCondition <- base::signalCondition
[01:27:45.873]             sys.calls <- base::sys.calls
[01:27:45.873]             `[[` <- base::`[[`
[01:27:45.873]             `+` <- base::`+`
[01:27:45.873]             `<<-` <- base::`<<-`
[01:27:45.873]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.873]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.873]                   3L)]
[01:27:45.873]             }
[01:27:45.873]             function(cond) {
[01:27:45.873]                 is_error <- inherits(cond, "error")
[01:27:45.873]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.873]                   NULL)
[01:27:45.873]                 if (is_error) {
[01:27:45.873]                   sessionInformation <- function() {
[01:27:45.873]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.873]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.873]                       search = base::search(), system = base::Sys.info())
[01:27:45.873]                   }
[01:27:45.873]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.873]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.873]                     cond$call), session = sessionInformation(), 
[01:27:45.873]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.873]                   signalCondition(cond)
[01:27:45.873]                 }
[01:27:45.873]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.873]                 "immediateCondition"))) {
[01:27:45.873]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.873]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.873]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.873]                   if (TRUE && !signal) {
[01:27:45.873]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.873]                     {
[01:27:45.873]                       inherits <- base::inherits
[01:27:45.873]                       invokeRestart <- base::invokeRestart
[01:27:45.873]                       is.null <- base::is.null
[01:27:45.873]                       muffled <- FALSE
[01:27:45.873]                       if (inherits(cond, "message")) {
[01:27:45.873]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.873]                         if (muffled) 
[01:27:45.873]                           invokeRestart("muffleMessage")
[01:27:45.873]                       }
[01:27:45.873]                       else if (inherits(cond, "warning")) {
[01:27:45.873]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.873]                         if (muffled) 
[01:27:45.873]                           invokeRestart("muffleWarning")
[01:27:45.873]                       }
[01:27:45.873]                       else if (inherits(cond, "condition")) {
[01:27:45.873]                         if (!is.null(pattern)) {
[01:27:45.873]                           computeRestarts <- base::computeRestarts
[01:27:45.873]                           grepl <- base::grepl
[01:27:45.873]                           restarts <- computeRestarts(cond)
[01:27:45.873]                           for (restart in restarts) {
[01:27:45.873]                             name <- restart$name
[01:27:45.873]                             if (is.null(name)) 
[01:27:45.873]                               next
[01:27:45.873]                             if (!grepl(pattern, name)) 
[01:27:45.873]                               next
[01:27:45.873]                             invokeRestart(restart)
[01:27:45.873]                             muffled <- TRUE
[01:27:45.873]                             break
[01:27:45.873]                           }
[01:27:45.873]                         }
[01:27:45.873]                       }
[01:27:45.873]                       invisible(muffled)
[01:27:45.873]                     }
[01:27:45.873]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.873]                   }
[01:27:45.873]                 }
[01:27:45.873]                 else {
[01:27:45.873]                   if (TRUE) {
[01:27:45.873]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.873]                     {
[01:27:45.873]                       inherits <- base::inherits
[01:27:45.873]                       invokeRestart <- base::invokeRestart
[01:27:45.873]                       is.null <- base::is.null
[01:27:45.873]                       muffled <- FALSE
[01:27:45.873]                       if (inherits(cond, "message")) {
[01:27:45.873]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.873]                         if (muffled) 
[01:27:45.873]                           invokeRestart("muffleMessage")
[01:27:45.873]                       }
[01:27:45.873]                       else if (inherits(cond, "warning")) {
[01:27:45.873]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.873]                         if (muffled) 
[01:27:45.873]                           invokeRestart("muffleWarning")
[01:27:45.873]                       }
[01:27:45.873]                       else if (inherits(cond, "condition")) {
[01:27:45.873]                         if (!is.null(pattern)) {
[01:27:45.873]                           computeRestarts <- base::computeRestarts
[01:27:45.873]                           grepl <- base::grepl
[01:27:45.873]                           restarts <- computeRestarts(cond)
[01:27:45.873]                           for (restart in restarts) {
[01:27:45.873]                             name <- restart$name
[01:27:45.873]                             if (is.null(name)) 
[01:27:45.873]                               next
[01:27:45.873]                             if (!grepl(pattern, name)) 
[01:27:45.873]                               next
[01:27:45.873]                             invokeRestart(restart)
[01:27:45.873]                             muffled <- TRUE
[01:27:45.873]                             break
[01:27:45.873]                           }
[01:27:45.873]                         }
[01:27:45.873]                       }
[01:27:45.873]                       invisible(muffled)
[01:27:45.873]                     }
[01:27:45.873]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.873]                   }
[01:27:45.873]                 }
[01:27:45.873]             }
[01:27:45.873]         }))
[01:27:45.873]     }, error = function(ex) {
[01:27:45.873]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.873]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.873]                 ...future.rng), started = ...future.startTime, 
[01:27:45.873]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.873]             version = "1.8"), class = "FutureResult")
[01:27:45.873]     }, finally = {
[01:27:45.873]         if (!identical(...future.workdir, getwd())) 
[01:27:45.873]             setwd(...future.workdir)
[01:27:45.873]         {
[01:27:45.873]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.873]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.873]             }
[01:27:45.873]             base::options(...future.oldOptions)
[01:27:45.873]             if (.Platform$OS.type == "windows") {
[01:27:45.873]                 old_names <- names(...future.oldEnvVars)
[01:27:45.873]                 envs <- base::Sys.getenv()
[01:27:45.873]                 names <- names(envs)
[01:27:45.873]                 common <- intersect(names, old_names)
[01:27:45.873]                 added <- setdiff(names, old_names)
[01:27:45.873]                 removed <- setdiff(old_names, names)
[01:27:45.873]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.873]                   envs[common]]
[01:27:45.873]                 NAMES <- toupper(changed)
[01:27:45.873]                 args <- list()
[01:27:45.873]                 for (kk in seq_along(NAMES)) {
[01:27:45.873]                   name <- changed[[kk]]
[01:27:45.873]                   NAME <- NAMES[[kk]]
[01:27:45.873]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.873]                     next
[01:27:45.873]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.873]                 }
[01:27:45.873]                 NAMES <- toupper(added)
[01:27:45.873]                 for (kk in seq_along(NAMES)) {
[01:27:45.873]                   name <- added[[kk]]
[01:27:45.873]                   NAME <- NAMES[[kk]]
[01:27:45.873]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.873]                     next
[01:27:45.873]                   args[[name]] <- ""
[01:27:45.873]                 }
[01:27:45.873]                 NAMES <- toupper(removed)
[01:27:45.873]                 for (kk in seq_along(NAMES)) {
[01:27:45.873]                   name <- removed[[kk]]
[01:27:45.873]                   NAME <- NAMES[[kk]]
[01:27:45.873]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.873]                     next
[01:27:45.873]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.873]                 }
[01:27:45.873]                 if (length(args) > 0) 
[01:27:45.873]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.873]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.873]             }
[01:27:45.873]             else {
[01:27:45.873]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.873]             }
[01:27:45.873]             {
[01:27:45.873]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.873]                   0L) {
[01:27:45.873]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.873]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.873]                   base::options(opts)
[01:27:45.873]                 }
[01:27:45.873]                 {
[01:27:45.873]                   {
[01:27:45.873]                     NULL
[01:27:45.873]                     RNGkind("Mersenne-Twister")
[01:27:45.873]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.873]                       inherits = FALSE)
[01:27:45.873]                   }
[01:27:45.873]                   options(future.plan = NULL)
[01:27:45.873]                   if (is.na(NA_character_)) 
[01:27:45.873]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.873]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.873]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.873]                   {
[01:27:45.873]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.873]                     if (!future$lazy) 
[01:27:45.873]                       future <- run(future)
[01:27:45.873]                     invisible(future)
[01:27:45.873]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.873]                 }
[01:27:45.873]             }
[01:27:45.873]         }
[01:27:45.873]     })
[01:27:45.873]     if (TRUE) {
[01:27:45.873]         base::sink(type = "output", split = FALSE)
[01:27:45.873]         if (TRUE) {
[01:27:45.873]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.873]         }
[01:27:45.873]         else {
[01:27:45.873]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.873]         }
[01:27:45.873]         base::close(...future.stdout)
[01:27:45.873]         ...future.stdout <- NULL
[01:27:45.873]     }
[01:27:45.873]     ...future.result$conditions <- ...future.conditions
[01:27:45.873]     ...future.result$finished <- base::Sys.time()
[01:27:45.873]     ...future.result
[01:27:45.873] }
[01:27:45.879] plan(): Setting new future strategy stack:
[01:27:45.880] List of future strategies:
[01:27:45.880] 1. sequential:
[01:27:45.880]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.880]    - tweaked: FALSE
[01:27:45.880]    - call: NULL
[01:27:45.881] plan(): nbrOfWorkers() = 1
[01:27:45.883] plan(): Setting new future strategy stack:
[01:27:45.883] List of future strategies:
[01:27:45.883] 1. sequential:
[01:27:45.883]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.883]    - tweaked: FALSE
[01:27:45.883]    - call: plan(strategy)
[01:27:45.884] plan(): nbrOfWorkers() = 1
[01:27:45.884] SequentialFuture started (and completed)
[01:27:45.885] - Launch lazy future ... done
[01:27:45.885] run() for 'SequentialFuture' ... done
[01:27:45.886] getGlobalsAndPackages() ...
[01:27:45.886] Searching for globals...
[01:27:45.887] - globals found: [1] '{'
[01:27:45.888] Searching for globals ... DONE
[01:27:45.888] Resolving globals: FALSE
[01:27:45.889] 
[01:27:45.889] 
[01:27:45.889] getGlobalsAndPackages() ... DONE
[01:27:45.890] run() for 'Future' ...
[01:27:45.890] - state: 'created'
[01:27:45.890] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.891] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.891] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.892]   - Field: 'label'
[01:27:45.892]   - Field: 'local'
[01:27:45.892]   - Field: 'owner'
[01:27:45.893]   - Field: 'envir'
[01:27:45.893]   - Field: 'packages'
[01:27:45.893]   - Field: 'gc'
[01:27:45.894]   - Field: 'conditions'
[01:27:45.894]   - Field: 'expr'
[01:27:45.894]   - Field: 'uuid'
[01:27:45.895]   - Field: 'seed'
[01:27:45.895]   - Field: 'version'
[01:27:45.895]   - Field: 'result'
[01:27:45.896]   - Field: 'asynchronous'
[01:27:45.896]   - Field: 'calls'
[01:27:45.896]   - Field: 'globals'
[01:27:45.896]   - Field: 'stdout'
[01:27:45.897]   - Field: 'earlySignal'
[01:27:45.897]   - Field: 'lazy'
[01:27:45.897]   - Field: 'state'
[01:27:45.898] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.898] - Launch lazy future ...
[01:27:45.898] Packages needed by the future expression (n = 0): <none>
[01:27:45.899] Packages needed by future strategies (n = 0): <none>
[01:27:45.900] {
[01:27:45.900]     {
[01:27:45.900]         {
[01:27:45.900]             ...future.startTime <- base::Sys.time()
[01:27:45.900]             {
[01:27:45.900]                 {
[01:27:45.900]                   {
[01:27:45.900]                     base::local({
[01:27:45.900]                       has_future <- base::requireNamespace("future", 
[01:27:45.900]                         quietly = TRUE)
[01:27:45.900]                       if (has_future) {
[01:27:45.900]                         ns <- base::getNamespace("future")
[01:27:45.900]                         version <- ns[[".package"]][["version"]]
[01:27:45.900]                         if (is.null(version)) 
[01:27:45.900]                           version <- utils::packageVersion("future")
[01:27:45.900]                       }
[01:27:45.900]                       else {
[01:27:45.900]                         version <- NULL
[01:27:45.900]                       }
[01:27:45.900]                       if (!has_future || version < "1.8.0") {
[01:27:45.900]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.900]                           "", base::R.version$version.string), 
[01:27:45.900]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.900]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.900]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.900]                             "release", "version")], collapse = " "), 
[01:27:45.900]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.900]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.900]                           info)
[01:27:45.900]                         info <- base::paste(info, collapse = "; ")
[01:27:45.900]                         if (!has_future) {
[01:27:45.900]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.900]                             info)
[01:27:45.900]                         }
[01:27:45.900]                         else {
[01:27:45.900]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.900]                             info, version)
[01:27:45.900]                         }
[01:27:45.900]                         base::stop(msg)
[01:27:45.900]                       }
[01:27:45.900]                     })
[01:27:45.900]                   }
[01:27:45.900]                   options(future.plan = NULL)
[01:27:45.900]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.900]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.900]                 }
[01:27:45.900]                 ...future.workdir <- getwd()
[01:27:45.900]             }
[01:27:45.900]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.900]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.900]         }
[01:27:45.900]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.900]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.900]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.900]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.900]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.900]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.900]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.900]             base::names(...future.oldOptions))
[01:27:45.900]     }
[01:27:45.900]     if (FALSE) {
[01:27:45.900]     }
[01:27:45.900]     else {
[01:27:45.900]         if (TRUE) {
[01:27:45.900]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.900]                 open = "w")
[01:27:45.900]         }
[01:27:45.900]         else {
[01:27:45.900]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.900]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.900]         }
[01:27:45.900]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.900]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.900]             base::sink(type = "output", split = FALSE)
[01:27:45.900]             base::close(...future.stdout)
[01:27:45.900]         }, add = TRUE)
[01:27:45.900]     }
[01:27:45.900]     ...future.frame <- base::sys.nframe()
[01:27:45.900]     ...future.conditions <- base::list()
[01:27:45.900]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.900]     if (FALSE) {
[01:27:45.900]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.900]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.900]     }
[01:27:45.900]     ...future.result <- base::tryCatch({
[01:27:45.900]         base::withCallingHandlers({
[01:27:45.900]             ...future.value <- base::withVisible(base::local({
[01:27:45.900]                 4
[01:27:45.900]             }))
[01:27:45.900]             future::FutureResult(value = ...future.value$value, 
[01:27:45.900]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.900]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.900]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.900]                     ...future.globalenv.names))
[01:27:45.900]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.900]         }, condition = base::local({
[01:27:45.900]             c <- base::c
[01:27:45.900]             inherits <- base::inherits
[01:27:45.900]             invokeRestart <- base::invokeRestart
[01:27:45.900]             length <- base::length
[01:27:45.900]             list <- base::list
[01:27:45.900]             seq.int <- base::seq.int
[01:27:45.900]             signalCondition <- base::signalCondition
[01:27:45.900]             sys.calls <- base::sys.calls
[01:27:45.900]             `[[` <- base::`[[`
[01:27:45.900]             `+` <- base::`+`
[01:27:45.900]             `<<-` <- base::`<<-`
[01:27:45.900]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.900]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.900]                   3L)]
[01:27:45.900]             }
[01:27:45.900]             function(cond) {
[01:27:45.900]                 is_error <- inherits(cond, "error")
[01:27:45.900]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.900]                   NULL)
[01:27:45.900]                 if (is_error) {
[01:27:45.900]                   sessionInformation <- function() {
[01:27:45.900]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.900]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.900]                       search = base::search(), system = base::Sys.info())
[01:27:45.900]                   }
[01:27:45.900]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.900]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.900]                     cond$call), session = sessionInformation(), 
[01:27:45.900]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.900]                   signalCondition(cond)
[01:27:45.900]                 }
[01:27:45.900]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.900]                 "immediateCondition"))) {
[01:27:45.900]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.900]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.900]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.900]                   if (TRUE && !signal) {
[01:27:45.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.900]                     {
[01:27:45.900]                       inherits <- base::inherits
[01:27:45.900]                       invokeRestart <- base::invokeRestart
[01:27:45.900]                       is.null <- base::is.null
[01:27:45.900]                       muffled <- FALSE
[01:27:45.900]                       if (inherits(cond, "message")) {
[01:27:45.900]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.900]                         if (muffled) 
[01:27:45.900]                           invokeRestart("muffleMessage")
[01:27:45.900]                       }
[01:27:45.900]                       else if (inherits(cond, "warning")) {
[01:27:45.900]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.900]                         if (muffled) 
[01:27:45.900]                           invokeRestart("muffleWarning")
[01:27:45.900]                       }
[01:27:45.900]                       else if (inherits(cond, "condition")) {
[01:27:45.900]                         if (!is.null(pattern)) {
[01:27:45.900]                           computeRestarts <- base::computeRestarts
[01:27:45.900]                           grepl <- base::grepl
[01:27:45.900]                           restarts <- computeRestarts(cond)
[01:27:45.900]                           for (restart in restarts) {
[01:27:45.900]                             name <- restart$name
[01:27:45.900]                             if (is.null(name)) 
[01:27:45.900]                               next
[01:27:45.900]                             if (!grepl(pattern, name)) 
[01:27:45.900]                               next
[01:27:45.900]                             invokeRestart(restart)
[01:27:45.900]                             muffled <- TRUE
[01:27:45.900]                             break
[01:27:45.900]                           }
[01:27:45.900]                         }
[01:27:45.900]                       }
[01:27:45.900]                       invisible(muffled)
[01:27:45.900]                     }
[01:27:45.900]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.900]                   }
[01:27:45.900]                 }
[01:27:45.900]                 else {
[01:27:45.900]                   if (TRUE) {
[01:27:45.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.900]                     {
[01:27:45.900]                       inherits <- base::inherits
[01:27:45.900]                       invokeRestart <- base::invokeRestart
[01:27:45.900]                       is.null <- base::is.null
[01:27:45.900]                       muffled <- FALSE
[01:27:45.900]                       if (inherits(cond, "message")) {
[01:27:45.900]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.900]                         if (muffled) 
[01:27:45.900]                           invokeRestart("muffleMessage")
[01:27:45.900]                       }
[01:27:45.900]                       else if (inherits(cond, "warning")) {
[01:27:45.900]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.900]                         if (muffled) 
[01:27:45.900]                           invokeRestart("muffleWarning")
[01:27:45.900]                       }
[01:27:45.900]                       else if (inherits(cond, "condition")) {
[01:27:45.900]                         if (!is.null(pattern)) {
[01:27:45.900]                           computeRestarts <- base::computeRestarts
[01:27:45.900]                           grepl <- base::grepl
[01:27:45.900]                           restarts <- computeRestarts(cond)
[01:27:45.900]                           for (restart in restarts) {
[01:27:45.900]                             name <- restart$name
[01:27:45.900]                             if (is.null(name)) 
[01:27:45.900]                               next
[01:27:45.900]                             if (!grepl(pattern, name)) 
[01:27:45.900]                               next
[01:27:45.900]                             invokeRestart(restart)
[01:27:45.900]                             muffled <- TRUE
[01:27:45.900]                             break
[01:27:45.900]                           }
[01:27:45.900]                         }
[01:27:45.900]                       }
[01:27:45.900]                       invisible(muffled)
[01:27:45.900]                     }
[01:27:45.900]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.900]                   }
[01:27:45.900]                 }
[01:27:45.900]             }
[01:27:45.900]         }))
[01:27:45.900]     }, error = function(ex) {
[01:27:45.900]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.900]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.900]                 ...future.rng), started = ...future.startTime, 
[01:27:45.900]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.900]             version = "1.8"), class = "FutureResult")
[01:27:45.900]     }, finally = {
[01:27:45.900]         if (!identical(...future.workdir, getwd())) 
[01:27:45.900]             setwd(...future.workdir)
[01:27:45.900]         {
[01:27:45.900]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.900]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.900]             }
[01:27:45.900]             base::options(...future.oldOptions)
[01:27:45.900]             if (.Platform$OS.type == "windows") {
[01:27:45.900]                 old_names <- names(...future.oldEnvVars)
[01:27:45.900]                 envs <- base::Sys.getenv()
[01:27:45.900]                 names <- names(envs)
[01:27:45.900]                 common <- intersect(names, old_names)
[01:27:45.900]                 added <- setdiff(names, old_names)
[01:27:45.900]                 removed <- setdiff(old_names, names)
[01:27:45.900]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.900]                   envs[common]]
[01:27:45.900]                 NAMES <- toupper(changed)
[01:27:45.900]                 args <- list()
[01:27:45.900]                 for (kk in seq_along(NAMES)) {
[01:27:45.900]                   name <- changed[[kk]]
[01:27:45.900]                   NAME <- NAMES[[kk]]
[01:27:45.900]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.900]                     next
[01:27:45.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.900]                 }
[01:27:45.900]                 NAMES <- toupper(added)
[01:27:45.900]                 for (kk in seq_along(NAMES)) {
[01:27:45.900]                   name <- added[[kk]]
[01:27:45.900]                   NAME <- NAMES[[kk]]
[01:27:45.900]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.900]                     next
[01:27:45.900]                   args[[name]] <- ""
[01:27:45.900]                 }
[01:27:45.900]                 NAMES <- toupper(removed)
[01:27:45.900]                 for (kk in seq_along(NAMES)) {
[01:27:45.900]                   name <- removed[[kk]]
[01:27:45.900]                   NAME <- NAMES[[kk]]
[01:27:45.900]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.900]                     next
[01:27:45.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.900]                 }
[01:27:45.900]                 if (length(args) > 0) 
[01:27:45.900]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.900]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.900]             }
[01:27:45.900]             else {
[01:27:45.900]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.900]             }
[01:27:45.900]             {
[01:27:45.900]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.900]                   0L) {
[01:27:45.900]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.900]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.900]                   base::options(opts)
[01:27:45.900]                 }
[01:27:45.900]                 {
[01:27:45.900]                   {
[01:27:45.900]                     NULL
[01:27:45.900]                     RNGkind("Mersenne-Twister")
[01:27:45.900]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.900]                       inherits = FALSE)
[01:27:45.900]                   }
[01:27:45.900]                   options(future.plan = NULL)
[01:27:45.900]                   if (is.na(NA_character_)) 
[01:27:45.900]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.900]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.900]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.900]                   {
[01:27:45.900]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.900]                     if (!future$lazy) 
[01:27:45.900]                       future <- run(future)
[01:27:45.900]                     invisible(future)
[01:27:45.900]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.900]                 }
[01:27:45.900]             }
[01:27:45.900]         }
[01:27:45.900]     })
[01:27:45.900]     if (TRUE) {
[01:27:45.900]         base::sink(type = "output", split = FALSE)
[01:27:45.900]         if (TRUE) {
[01:27:45.900]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.900]         }
[01:27:45.900]         else {
[01:27:45.900]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.900]         }
[01:27:45.900]         base::close(...future.stdout)
[01:27:45.900]         ...future.stdout <- NULL
[01:27:45.900]     }
[01:27:45.900]     ...future.result$conditions <- ...future.conditions
[01:27:45.900]     ...future.result$finished <- base::Sys.time()
[01:27:45.900]     ...future.result
[01:27:45.900] }
[01:27:45.906] plan(): Setting new future strategy stack:
[01:27:45.906] List of future strategies:
[01:27:45.906] 1. sequential:
[01:27:45.906]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.906]    - tweaked: FALSE
[01:27:45.906]    - call: NULL
[01:27:45.907] plan(): nbrOfWorkers() = 1
[01:27:45.909] plan(): Setting new future strategy stack:
[01:27:45.909] List of future strategies:
[01:27:45.909] 1. sequential:
[01:27:45.909]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.909]    - tweaked: FALSE
[01:27:45.909]    - call: plan(strategy)
[01:27:45.910] plan(): nbrOfWorkers() = 1
[01:27:45.911] SequentialFuture started (and completed)
[01:27:45.911] - Launch lazy future ... done
[01:27:45.911] run() for 'SequentialFuture' ... done
<environment: 0x0000025b07b2d290> 
<environment: 0x0000025b07d2c3b0> 
[01:27:45.914] resolved() for 'SequentialFuture' ...
[01:27:45.914] - state: 'finished'
[01:27:45.915] - run: TRUE
[01:27:45.915] - result: 'FutureResult'
[01:27:45.915] resolved() for 'SequentialFuture' ... done
[01:27:45.916] resolved() for 'SequentialFuture' ...
[01:27:45.916] - state: 'finished'
[01:27:45.916] - run: TRUE
[01:27:45.916] - result: 'FutureResult'
[01:27:45.917] resolved() for 'SequentialFuture' ... done
[01:27:45.917] resolved() for 'SequentialFuture' ...
[01:27:45.917] - state: 'finished'
[01:27:45.918] - run: TRUE
[01:27:45.918] - result: 'FutureResult'
[01:27:45.918] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:45.921] resolve() on environment ...
[01:27:45.921]  recursive: 0
[01:27:45.922]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:45.922] signalConditionsASAP(numeric, pos=1) ...
[01:27:45.922] - nx: 4
[01:27:45.923] - relay: TRUE
[01:27:45.923] - stdout: TRUE
[01:27:45.923] - signal: TRUE
[01:27:45.923] - resignal: FALSE
[01:27:45.924] - force: TRUE
[01:27:45.924] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.924] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.925]  - until=2
[01:27:45.925]  - relaying element #2
[01:27:45.925] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:45.925] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.926] signalConditionsASAP(NULL, pos=1) ... done
[01:27:45.926]  length: 3 (resolved future 1)
[01:27:45.926] resolved() for 'SequentialFuture' ...
[01:27:45.926] - state: 'finished'
[01:27:45.927] - run: TRUE
[01:27:45.927] - result: 'FutureResult'
[01:27:45.927] resolved() for 'SequentialFuture' ... done
[01:27:45.928] Future #2
[01:27:45.928] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:45.928] - nx: 4
[01:27:45.931] - relay: TRUE
[01:27:45.932] - stdout: TRUE
[01:27:45.932] - signal: TRUE
[01:27:45.932] - resignal: FALSE
[01:27:45.932] - force: TRUE
[01:27:45.933] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:45.933] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:45.933]  - until=2
[01:27:45.933]  - relaying element #2
[01:27:45.934] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:45.934] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:45.934] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:45.935]  length: 2 (resolved future 2)
[01:27:45.935] resolved() for 'SequentialFuture' ...
[01:27:45.935] - state: 'finished'
[01:27:45.936] - run: TRUE
[01:27:45.936] - result: 'FutureResult'
[01:27:45.936] resolved() for 'SequentialFuture' ... done
[01:27:45.936] Future #3
[01:27:45.937] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:45.937] - nx: 4
[01:27:45.937] - relay: TRUE
[01:27:45.938] - stdout: TRUE
[01:27:45.938] - signal: TRUE
[01:27:45.938] - resignal: FALSE
[01:27:45.938] - force: TRUE
[01:27:45.938] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:45.939] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:45.939]  - until=3
[01:27:45.939]  - relaying element #3
[01:27:45.940] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:45.940] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:45.940] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:45.940]  length: 1 (resolved future 3)
[01:27:45.941] resolved() for 'SequentialFuture' ...
[01:27:45.941] - state: 'finished'
[01:27:45.941] - run: TRUE
[01:27:45.942] - result: 'FutureResult'
[01:27:45.942] resolved() for 'SequentialFuture' ... done
[01:27:45.942] Future #4
[01:27:45.943] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:45.943] - nx: 4
[01:27:45.943] - relay: TRUE
[01:27:45.943] - stdout: TRUE
[01:27:45.943] - signal: TRUE
[01:27:45.944] - resignal: FALSE
[01:27:45.944] - force: TRUE
[01:27:45.944] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:45.944] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:45.945]  - until=4
[01:27:45.945]  - relaying element #4
[01:27:45.945] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:45.946] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:45.946] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:45.946]  length: 0 (resolved future 4)
[01:27:45.946] Relaying remaining futures
[01:27:45.947] signalConditionsASAP(NULL, pos=0) ...
[01:27:45.947] - nx: 4
[01:27:45.947] - relay: TRUE
[01:27:45.947] - stdout: TRUE
[01:27:45.948] - signal: TRUE
[01:27:45.948] - resignal: FALSE
[01:27:45.948] - force: TRUE
[01:27:45.948] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:45.949] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:45.949] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:45.949] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:45.950] signalConditionsASAP(NULL, pos=0) ... done
[01:27:45.950] resolve() on environment ... DONE
<environment: 0x0000025b07f73880> 
Dimensions: c(2, 3)
[01:27:45.951] getGlobalsAndPackages() ...
[01:27:45.951] Searching for globals...
[01:27:45.952] 
[01:27:45.952] Searching for globals ... DONE
[01:27:45.952] - globals: [0] <none>
[01:27:45.952] getGlobalsAndPackages() ... DONE
[01:27:45.953] run() for 'Future' ...
[01:27:45.953] - state: 'created'
[01:27:45.953] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.954] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.954] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.955]   - Field: 'label'
[01:27:45.955]   - Field: 'local'
[01:27:45.955]   - Field: 'owner'
[01:27:45.955]   - Field: 'envir'
[01:27:45.956]   - Field: 'packages'
[01:27:45.956]   - Field: 'gc'
[01:27:45.956]   - Field: 'conditions'
[01:27:45.957]   - Field: 'expr'
[01:27:45.957]   - Field: 'uuid'
[01:27:45.957]   - Field: 'seed'
[01:27:45.957]   - Field: 'version'
[01:27:45.958]   - Field: 'result'
[01:27:45.958]   - Field: 'asynchronous'
[01:27:45.958]   - Field: 'calls'
[01:27:45.958]   - Field: 'globals'
[01:27:45.959]   - Field: 'stdout'
[01:27:45.959]   - Field: 'earlySignal'
[01:27:45.959]   - Field: 'lazy'
[01:27:45.960]   - Field: 'state'
[01:27:45.960] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.960] - Launch lazy future ...
[01:27:45.960] Packages needed by the future expression (n = 0): <none>
[01:27:45.961] Packages needed by future strategies (n = 0): <none>
[01:27:45.961] {
[01:27:45.961]     {
[01:27:45.961]         {
[01:27:45.961]             ...future.startTime <- base::Sys.time()
[01:27:45.961]             {
[01:27:45.961]                 {
[01:27:45.961]                   {
[01:27:45.961]                     base::local({
[01:27:45.961]                       has_future <- base::requireNamespace("future", 
[01:27:45.961]                         quietly = TRUE)
[01:27:45.961]                       if (has_future) {
[01:27:45.961]                         ns <- base::getNamespace("future")
[01:27:45.961]                         version <- ns[[".package"]][["version"]]
[01:27:45.961]                         if (is.null(version)) 
[01:27:45.961]                           version <- utils::packageVersion("future")
[01:27:45.961]                       }
[01:27:45.961]                       else {
[01:27:45.961]                         version <- NULL
[01:27:45.961]                       }
[01:27:45.961]                       if (!has_future || version < "1.8.0") {
[01:27:45.961]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.961]                           "", base::R.version$version.string), 
[01:27:45.961]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.961]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.961]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.961]                             "release", "version")], collapse = " "), 
[01:27:45.961]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.961]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.961]                           info)
[01:27:45.961]                         info <- base::paste(info, collapse = "; ")
[01:27:45.961]                         if (!has_future) {
[01:27:45.961]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.961]                             info)
[01:27:45.961]                         }
[01:27:45.961]                         else {
[01:27:45.961]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.961]                             info, version)
[01:27:45.961]                         }
[01:27:45.961]                         base::stop(msg)
[01:27:45.961]                       }
[01:27:45.961]                     })
[01:27:45.961]                   }
[01:27:45.961]                   options(future.plan = NULL)
[01:27:45.961]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.961]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.961]                 }
[01:27:45.961]                 ...future.workdir <- getwd()
[01:27:45.961]             }
[01:27:45.961]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.961]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.961]         }
[01:27:45.961]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.961]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.961]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.961]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.961]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.961]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.961]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.961]             base::names(...future.oldOptions))
[01:27:45.961]     }
[01:27:45.961]     if (FALSE) {
[01:27:45.961]     }
[01:27:45.961]     else {
[01:27:45.961]         if (TRUE) {
[01:27:45.961]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.961]                 open = "w")
[01:27:45.961]         }
[01:27:45.961]         else {
[01:27:45.961]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.961]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.961]         }
[01:27:45.961]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.961]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.961]             base::sink(type = "output", split = FALSE)
[01:27:45.961]             base::close(...future.stdout)
[01:27:45.961]         }, add = TRUE)
[01:27:45.961]     }
[01:27:45.961]     ...future.frame <- base::sys.nframe()
[01:27:45.961]     ...future.conditions <- base::list()
[01:27:45.961]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.961]     if (FALSE) {
[01:27:45.961]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.961]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.961]     }
[01:27:45.961]     ...future.result <- base::tryCatch({
[01:27:45.961]         base::withCallingHandlers({
[01:27:45.961]             ...future.value <- base::withVisible(base::local(2))
[01:27:45.961]             future::FutureResult(value = ...future.value$value, 
[01:27:45.961]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.961]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.961]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.961]                     ...future.globalenv.names))
[01:27:45.961]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.961]         }, condition = base::local({
[01:27:45.961]             c <- base::c
[01:27:45.961]             inherits <- base::inherits
[01:27:45.961]             invokeRestart <- base::invokeRestart
[01:27:45.961]             length <- base::length
[01:27:45.961]             list <- base::list
[01:27:45.961]             seq.int <- base::seq.int
[01:27:45.961]             signalCondition <- base::signalCondition
[01:27:45.961]             sys.calls <- base::sys.calls
[01:27:45.961]             `[[` <- base::`[[`
[01:27:45.961]             `+` <- base::`+`
[01:27:45.961]             `<<-` <- base::`<<-`
[01:27:45.961]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.961]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.961]                   3L)]
[01:27:45.961]             }
[01:27:45.961]             function(cond) {
[01:27:45.961]                 is_error <- inherits(cond, "error")
[01:27:45.961]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.961]                   NULL)
[01:27:45.961]                 if (is_error) {
[01:27:45.961]                   sessionInformation <- function() {
[01:27:45.961]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.961]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.961]                       search = base::search(), system = base::Sys.info())
[01:27:45.961]                   }
[01:27:45.961]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.961]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.961]                     cond$call), session = sessionInformation(), 
[01:27:45.961]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.961]                   signalCondition(cond)
[01:27:45.961]                 }
[01:27:45.961]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.961]                 "immediateCondition"))) {
[01:27:45.961]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.961]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.961]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.961]                   if (TRUE && !signal) {
[01:27:45.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.961]                     {
[01:27:45.961]                       inherits <- base::inherits
[01:27:45.961]                       invokeRestart <- base::invokeRestart
[01:27:45.961]                       is.null <- base::is.null
[01:27:45.961]                       muffled <- FALSE
[01:27:45.961]                       if (inherits(cond, "message")) {
[01:27:45.961]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.961]                         if (muffled) 
[01:27:45.961]                           invokeRestart("muffleMessage")
[01:27:45.961]                       }
[01:27:45.961]                       else if (inherits(cond, "warning")) {
[01:27:45.961]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.961]                         if (muffled) 
[01:27:45.961]                           invokeRestart("muffleWarning")
[01:27:45.961]                       }
[01:27:45.961]                       else if (inherits(cond, "condition")) {
[01:27:45.961]                         if (!is.null(pattern)) {
[01:27:45.961]                           computeRestarts <- base::computeRestarts
[01:27:45.961]                           grepl <- base::grepl
[01:27:45.961]                           restarts <- computeRestarts(cond)
[01:27:45.961]                           for (restart in restarts) {
[01:27:45.961]                             name <- restart$name
[01:27:45.961]                             if (is.null(name)) 
[01:27:45.961]                               next
[01:27:45.961]                             if (!grepl(pattern, name)) 
[01:27:45.961]                               next
[01:27:45.961]                             invokeRestart(restart)
[01:27:45.961]                             muffled <- TRUE
[01:27:45.961]                             break
[01:27:45.961]                           }
[01:27:45.961]                         }
[01:27:45.961]                       }
[01:27:45.961]                       invisible(muffled)
[01:27:45.961]                     }
[01:27:45.961]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.961]                   }
[01:27:45.961]                 }
[01:27:45.961]                 else {
[01:27:45.961]                   if (TRUE) {
[01:27:45.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.961]                     {
[01:27:45.961]                       inherits <- base::inherits
[01:27:45.961]                       invokeRestart <- base::invokeRestart
[01:27:45.961]                       is.null <- base::is.null
[01:27:45.961]                       muffled <- FALSE
[01:27:45.961]                       if (inherits(cond, "message")) {
[01:27:45.961]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.961]                         if (muffled) 
[01:27:45.961]                           invokeRestart("muffleMessage")
[01:27:45.961]                       }
[01:27:45.961]                       else if (inherits(cond, "warning")) {
[01:27:45.961]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.961]                         if (muffled) 
[01:27:45.961]                           invokeRestart("muffleWarning")
[01:27:45.961]                       }
[01:27:45.961]                       else if (inherits(cond, "condition")) {
[01:27:45.961]                         if (!is.null(pattern)) {
[01:27:45.961]                           computeRestarts <- base::computeRestarts
[01:27:45.961]                           grepl <- base::grepl
[01:27:45.961]                           restarts <- computeRestarts(cond)
[01:27:45.961]                           for (restart in restarts) {
[01:27:45.961]                             name <- restart$name
[01:27:45.961]                             if (is.null(name)) 
[01:27:45.961]                               next
[01:27:45.961]                             if (!grepl(pattern, name)) 
[01:27:45.961]                               next
[01:27:45.961]                             invokeRestart(restart)
[01:27:45.961]                             muffled <- TRUE
[01:27:45.961]                             break
[01:27:45.961]                           }
[01:27:45.961]                         }
[01:27:45.961]                       }
[01:27:45.961]                       invisible(muffled)
[01:27:45.961]                     }
[01:27:45.961]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.961]                   }
[01:27:45.961]                 }
[01:27:45.961]             }
[01:27:45.961]         }))
[01:27:45.961]     }, error = function(ex) {
[01:27:45.961]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.961]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.961]                 ...future.rng), started = ...future.startTime, 
[01:27:45.961]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.961]             version = "1.8"), class = "FutureResult")
[01:27:45.961]     }, finally = {
[01:27:45.961]         if (!identical(...future.workdir, getwd())) 
[01:27:45.961]             setwd(...future.workdir)
[01:27:45.961]         {
[01:27:45.961]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.961]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.961]             }
[01:27:45.961]             base::options(...future.oldOptions)
[01:27:45.961]             if (.Platform$OS.type == "windows") {
[01:27:45.961]                 old_names <- names(...future.oldEnvVars)
[01:27:45.961]                 envs <- base::Sys.getenv()
[01:27:45.961]                 names <- names(envs)
[01:27:45.961]                 common <- intersect(names, old_names)
[01:27:45.961]                 added <- setdiff(names, old_names)
[01:27:45.961]                 removed <- setdiff(old_names, names)
[01:27:45.961]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.961]                   envs[common]]
[01:27:45.961]                 NAMES <- toupper(changed)
[01:27:45.961]                 args <- list()
[01:27:45.961]                 for (kk in seq_along(NAMES)) {
[01:27:45.961]                   name <- changed[[kk]]
[01:27:45.961]                   NAME <- NAMES[[kk]]
[01:27:45.961]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.961]                     next
[01:27:45.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.961]                 }
[01:27:45.961]                 NAMES <- toupper(added)
[01:27:45.961]                 for (kk in seq_along(NAMES)) {
[01:27:45.961]                   name <- added[[kk]]
[01:27:45.961]                   NAME <- NAMES[[kk]]
[01:27:45.961]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.961]                     next
[01:27:45.961]                   args[[name]] <- ""
[01:27:45.961]                 }
[01:27:45.961]                 NAMES <- toupper(removed)
[01:27:45.961]                 for (kk in seq_along(NAMES)) {
[01:27:45.961]                   name <- removed[[kk]]
[01:27:45.961]                   NAME <- NAMES[[kk]]
[01:27:45.961]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.961]                     next
[01:27:45.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.961]                 }
[01:27:45.961]                 if (length(args) > 0) 
[01:27:45.961]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.961]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.961]             }
[01:27:45.961]             else {
[01:27:45.961]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.961]             }
[01:27:45.961]             {
[01:27:45.961]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.961]                   0L) {
[01:27:45.961]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.961]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.961]                   base::options(opts)
[01:27:45.961]                 }
[01:27:45.961]                 {
[01:27:45.961]                   {
[01:27:45.961]                     NULL
[01:27:45.961]                     RNGkind("Mersenne-Twister")
[01:27:45.961]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.961]                       inherits = FALSE)
[01:27:45.961]                   }
[01:27:45.961]                   options(future.plan = NULL)
[01:27:45.961]                   if (is.na(NA_character_)) 
[01:27:45.961]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.961]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.961]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.961]                   {
[01:27:45.961]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.961]                     if (!future$lazy) 
[01:27:45.961]                       future <- run(future)
[01:27:45.961]                     invisible(future)
[01:27:45.961]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.961]                 }
[01:27:45.961]             }
[01:27:45.961]         }
[01:27:45.961]     })
[01:27:45.961]     if (TRUE) {
[01:27:45.961]         base::sink(type = "output", split = FALSE)
[01:27:45.961]         if (TRUE) {
[01:27:45.961]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.961]         }
[01:27:45.961]         else {
[01:27:45.961]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.961]         }
[01:27:45.961]         base::close(...future.stdout)
[01:27:45.961]         ...future.stdout <- NULL
[01:27:45.961]     }
[01:27:45.961]     ...future.result$conditions <- ...future.conditions
[01:27:45.961]     ...future.result$finished <- base::Sys.time()
[01:27:45.961]     ...future.result
[01:27:45.961] }
[01:27:45.966] plan(): Setting new future strategy stack:
[01:27:45.966] List of future strategies:
[01:27:45.966] 1. sequential:
[01:27:45.966]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.966]    - tweaked: FALSE
[01:27:45.966]    - call: NULL
[01:27:45.967] plan(): nbrOfWorkers() = 1
[01:27:45.968] plan(): Setting new future strategy stack:
[01:27:45.968] List of future strategies:
[01:27:45.968] 1. sequential:
[01:27:45.968]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.968]    - tweaked: FALSE
[01:27:45.968]    - call: plan(strategy)
[01:27:45.969] plan(): nbrOfWorkers() = 1
[01:27:45.969] SequentialFuture started (and completed)
[01:27:45.969] - Launch lazy future ... done
[01:27:45.969] run() for 'SequentialFuture' ... done
[01:27:45.969] getGlobalsAndPackages() ...
[01:27:45.970] Searching for globals...
[01:27:45.970] 
[01:27:45.970] Searching for globals ... DONE
[01:27:45.970] - globals: [0] <none>
[01:27:45.970] getGlobalsAndPackages() ... DONE
[01:27:45.971] run() for 'Future' ...
[01:27:45.971] - state: 'created'
[01:27:45.971] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.972] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.972] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.972]   - Field: 'label'
[01:27:45.972]   - Field: 'local'
[01:27:45.972]   - Field: 'owner'
[01:27:45.973]   - Field: 'envir'
[01:27:45.973]   - Field: 'packages'
[01:27:45.973]   - Field: 'gc'
[01:27:45.973]   - Field: 'conditions'
[01:27:45.973]   - Field: 'expr'
[01:27:45.973]   - Field: 'uuid'
[01:27:45.974]   - Field: 'seed'
[01:27:45.974]   - Field: 'version'
[01:27:45.974]   - Field: 'result'
[01:27:45.974]   - Field: 'asynchronous'
[01:27:45.974]   - Field: 'calls'
[01:27:45.975]   - Field: 'globals'
[01:27:45.975]   - Field: 'stdout'
[01:27:45.975]   - Field: 'earlySignal'
[01:27:45.975]   - Field: 'lazy'
[01:27:45.975]   - Field: 'state'
[01:27:45.975] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.976] - Launch lazy future ...
[01:27:45.976] Packages needed by the future expression (n = 0): <none>
[01:27:45.976] Packages needed by future strategies (n = 0): <none>
[01:27:45.977] {
[01:27:45.977]     {
[01:27:45.977]         {
[01:27:45.977]             ...future.startTime <- base::Sys.time()
[01:27:45.977]             {
[01:27:45.977]                 {
[01:27:45.977]                   {
[01:27:45.977]                     base::local({
[01:27:45.977]                       has_future <- base::requireNamespace("future", 
[01:27:45.977]                         quietly = TRUE)
[01:27:45.977]                       if (has_future) {
[01:27:45.977]                         ns <- base::getNamespace("future")
[01:27:45.977]                         version <- ns[[".package"]][["version"]]
[01:27:45.977]                         if (is.null(version)) 
[01:27:45.977]                           version <- utils::packageVersion("future")
[01:27:45.977]                       }
[01:27:45.977]                       else {
[01:27:45.977]                         version <- NULL
[01:27:45.977]                       }
[01:27:45.977]                       if (!has_future || version < "1.8.0") {
[01:27:45.977]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.977]                           "", base::R.version$version.string), 
[01:27:45.977]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.977]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.977]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.977]                             "release", "version")], collapse = " "), 
[01:27:45.977]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.977]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.977]                           info)
[01:27:45.977]                         info <- base::paste(info, collapse = "; ")
[01:27:45.977]                         if (!has_future) {
[01:27:45.977]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.977]                             info)
[01:27:45.977]                         }
[01:27:45.977]                         else {
[01:27:45.977]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.977]                             info, version)
[01:27:45.977]                         }
[01:27:45.977]                         base::stop(msg)
[01:27:45.977]                       }
[01:27:45.977]                     })
[01:27:45.977]                   }
[01:27:45.977]                   options(future.plan = NULL)
[01:27:45.977]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.977]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.977]                 }
[01:27:45.977]                 ...future.workdir <- getwd()
[01:27:45.977]             }
[01:27:45.977]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.977]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.977]         }
[01:27:45.977]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.977]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.977]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.977]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.977]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.977]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.977]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.977]             base::names(...future.oldOptions))
[01:27:45.977]     }
[01:27:45.977]     if (FALSE) {
[01:27:45.977]     }
[01:27:45.977]     else {
[01:27:45.977]         if (TRUE) {
[01:27:45.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.977]                 open = "w")
[01:27:45.977]         }
[01:27:45.977]         else {
[01:27:45.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.977]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.977]         }
[01:27:45.977]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.977]             base::sink(type = "output", split = FALSE)
[01:27:45.977]             base::close(...future.stdout)
[01:27:45.977]         }, add = TRUE)
[01:27:45.977]     }
[01:27:45.977]     ...future.frame <- base::sys.nframe()
[01:27:45.977]     ...future.conditions <- base::list()
[01:27:45.977]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.977]     if (FALSE) {
[01:27:45.977]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.977]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.977]     }
[01:27:45.977]     ...future.result <- base::tryCatch({
[01:27:45.977]         base::withCallingHandlers({
[01:27:45.977]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:45.977]             future::FutureResult(value = ...future.value$value, 
[01:27:45.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.977]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.977]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.977]                     ...future.globalenv.names))
[01:27:45.977]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.977]         }, condition = base::local({
[01:27:45.977]             c <- base::c
[01:27:45.977]             inherits <- base::inherits
[01:27:45.977]             invokeRestart <- base::invokeRestart
[01:27:45.977]             length <- base::length
[01:27:45.977]             list <- base::list
[01:27:45.977]             seq.int <- base::seq.int
[01:27:45.977]             signalCondition <- base::signalCondition
[01:27:45.977]             sys.calls <- base::sys.calls
[01:27:45.977]             `[[` <- base::`[[`
[01:27:45.977]             `+` <- base::`+`
[01:27:45.977]             `<<-` <- base::`<<-`
[01:27:45.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.977]                   3L)]
[01:27:45.977]             }
[01:27:45.977]             function(cond) {
[01:27:45.977]                 is_error <- inherits(cond, "error")
[01:27:45.977]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.977]                   NULL)
[01:27:45.977]                 if (is_error) {
[01:27:45.977]                   sessionInformation <- function() {
[01:27:45.977]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.977]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.977]                       search = base::search(), system = base::Sys.info())
[01:27:45.977]                   }
[01:27:45.977]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.977]                     cond$call), session = sessionInformation(), 
[01:27:45.977]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.977]                   signalCondition(cond)
[01:27:45.977]                 }
[01:27:45.977]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.977]                 "immediateCondition"))) {
[01:27:45.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.977]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.977]                   if (TRUE && !signal) {
[01:27:45.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.977]                     {
[01:27:45.977]                       inherits <- base::inherits
[01:27:45.977]                       invokeRestart <- base::invokeRestart
[01:27:45.977]                       is.null <- base::is.null
[01:27:45.977]                       muffled <- FALSE
[01:27:45.977]                       if (inherits(cond, "message")) {
[01:27:45.977]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.977]                         if (muffled) 
[01:27:45.977]                           invokeRestart("muffleMessage")
[01:27:45.977]                       }
[01:27:45.977]                       else if (inherits(cond, "warning")) {
[01:27:45.977]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.977]                         if (muffled) 
[01:27:45.977]                           invokeRestart("muffleWarning")
[01:27:45.977]                       }
[01:27:45.977]                       else if (inherits(cond, "condition")) {
[01:27:45.977]                         if (!is.null(pattern)) {
[01:27:45.977]                           computeRestarts <- base::computeRestarts
[01:27:45.977]                           grepl <- base::grepl
[01:27:45.977]                           restarts <- computeRestarts(cond)
[01:27:45.977]                           for (restart in restarts) {
[01:27:45.977]                             name <- restart$name
[01:27:45.977]                             if (is.null(name)) 
[01:27:45.977]                               next
[01:27:45.977]                             if (!grepl(pattern, name)) 
[01:27:45.977]                               next
[01:27:45.977]                             invokeRestart(restart)
[01:27:45.977]                             muffled <- TRUE
[01:27:45.977]                             break
[01:27:45.977]                           }
[01:27:45.977]                         }
[01:27:45.977]                       }
[01:27:45.977]                       invisible(muffled)
[01:27:45.977]                     }
[01:27:45.977]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.977]                   }
[01:27:45.977]                 }
[01:27:45.977]                 else {
[01:27:45.977]                   if (TRUE) {
[01:27:45.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.977]                     {
[01:27:45.977]                       inherits <- base::inherits
[01:27:45.977]                       invokeRestart <- base::invokeRestart
[01:27:45.977]                       is.null <- base::is.null
[01:27:45.977]                       muffled <- FALSE
[01:27:45.977]                       if (inherits(cond, "message")) {
[01:27:45.977]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.977]                         if (muffled) 
[01:27:45.977]                           invokeRestart("muffleMessage")
[01:27:45.977]                       }
[01:27:45.977]                       else if (inherits(cond, "warning")) {
[01:27:45.977]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.977]                         if (muffled) 
[01:27:45.977]                           invokeRestart("muffleWarning")
[01:27:45.977]                       }
[01:27:45.977]                       else if (inherits(cond, "condition")) {
[01:27:45.977]                         if (!is.null(pattern)) {
[01:27:45.977]                           computeRestarts <- base::computeRestarts
[01:27:45.977]                           grepl <- base::grepl
[01:27:45.977]                           restarts <- computeRestarts(cond)
[01:27:45.977]                           for (restart in restarts) {
[01:27:45.977]                             name <- restart$name
[01:27:45.977]                             if (is.null(name)) 
[01:27:45.977]                               next
[01:27:45.977]                             if (!grepl(pattern, name)) 
[01:27:45.977]                               next
[01:27:45.977]                             invokeRestart(restart)
[01:27:45.977]                             muffled <- TRUE
[01:27:45.977]                             break
[01:27:45.977]                           }
[01:27:45.977]                         }
[01:27:45.977]                       }
[01:27:45.977]                       invisible(muffled)
[01:27:45.977]                     }
[01:27:45.977]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.977]                   }
[01:27:45.977]                 }
[01:27:45.977]             }
[01:27:45.977]         }))
[01:27:45.977]     }, error = function(ex) {
[01:27:45.977]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.977]                 ...future.rng), started = ...future.startTime, 
[01:27:45.977]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.977]             version = "1.8"), class = "FutureResult")
[01:27:45.977]     }, finally = {
[01:27:45.977]         if (!identical(...future.workdir, getwd())) 
[01:27:45.977]             setwd(...future.workdir)
[01:27:45.977]         {
[01:27:45.977]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.977]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.977]             }
[01:27:45.977]             base::options(...future.oldOptions)
[01:27:45.977]             if (.Platform$OS.type == "windows") {
[01:27:45.977]                 old_names <- names(...future.oldEnvVars)
[01:27:45.977]                 envs <- base::Sys.getenv()
[01:27:45.977]                 names <- names(envs)
[01:27:45.977]                 common <- intersect(names, old_names)
[01:27:45.977]                 added <- setdiff(names, old_names)
[01:27:45.977]                 removed <- setdiff(old_names, names)
[01:27:45.977]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.977]                   envs[common]]
[01:27:45.977]                 NAMES <- toupper(changed)
[01:27:45.977]                 args <- list()
[01:27:45.977]                 for (kk in seq_along(NAMES)) {
[01:27:45.977]                   name <- changed[[kk]]
[01:27:45.977]                   NAME <- NAMES[[kk]]
[01:27:45.977]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.977]                     next
[01:27:45.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.977]                 }
[01:27:45.977]                 NAMES <- toupper(added)
[01:27:45.977]                 for (kk in seq_along(NAMES)) {
[01:27:45.977]                   name <- added[[kk]]
[01:27:45.977]                   NAME <- NAMES[[kk]]
[01:27:45.977]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.977]                     next
[01:27:45.977]                   args[[name]] <- ""
[01:27:45.977]                 }
[01:27:45.977]                 NAMES <- toupper(removed)
[01:27:45.977]                 for (kk in seq_along(NAMES)) {
[01:27:45.977]                   name <- removed[[kk]]
[01:27:45.977]                   NAME <- NAMES[[kk]]
[01:27:45.977]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.977]                     next
[01:27:45.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.977]                 }
[01:27:45.977]                 if (length(args) > 0) 
[01:27:45.977]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.977]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.977]             }
[01:27:45.977]             else {
[01:27:45.977]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.977]             }
[01:27:45.977]             {
[01:27:45.977]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.977]                   0L) {
[01:27:45.977]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.977]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.977]                   base::options(opts)
[01:27:45.977]                 }
[01:27:45.977]                 {
[01:27:45.977]                   {
[01:27:45.977]                     NULL
[01:27:45.977]                     RNGkind("Mersenne-Twister")
[01:27:45.977]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.977]                       inherits = FALSE)
[01:27:45.977]                   }
[01:27:45.977]                   options(future.plan = NULL)
[01:27:45.977]                   if (is.na(NA_character_)) 
[01:27:45.977]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.977]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.977]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.977]                   {
[01:27:45.977]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.977]                     if (!future$lazy) 
[01:27:45.977]                       future <- run(future)
[01:27:45.977]                     invisible(future)
[01:27:45.977]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.977]                 }
[01:27:45.977]             }
[01:27:45.977]         }
[01:27:45.977]     })
[01:27:45.977]     if (TRUE) {
[01:27:45.977]         base::sink(type = "output", split = FALSE)
[01:27:45.977]         if (TRUE) {
[01:27:45.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.977]         }
[01:27:45.977]         else {
[01:27:45.977]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.977]         }
[01:27:45.977]         base::close(...future.stdout)
[01:27:45.977]         ...future.stdout <- NULL
[01:27:45.977]     }
[01:27:45.977]     ...future.result$conditions <- ...future.conditions
[01:27:45.977]     ...future.result$finished <- base::Sys.time()
[01:27:45.977]     ...future.result
[01:27:45.977] }
[01:27:45.982] plan(): Setting new future strategy stack:
[01:27:45.983] List of future strategies:
[01:27:45.983] 1. sequential:
[01:27:45.983]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.983]    - tweaked: FALSE
[01:27:45.983]    - call: NULL
[01:27:45.983] plan(): nbrOfWorkers() = 1
[01:27:45.984] plan(): Setting new future strategy stack:
[01:27:45.985] List of future strategies:
[01:27:45.985] 1. sequential:
[01:27:45.985]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.985]    - tweaked: FALSE
[01:27:45.985]    - call: plan(strategy)
[01:27:45.985] plan(): nbrOfWorkers() = 1
[01:27:45.986] SequentialFuture started (and completed)
[01:27:45.986] - Launch lazy future ... done
[01:27:45.986] run() for 'SequentialFuture' ... done
[01:27:45.986] getGlobalsAndPackages() ...
[01:27:45.987] Searching for globals...
[01:27:45.987] - globals found: [1] '{'
[01:27:45.988] Searching for globals ... DONE
[01:27:45.988] Resolving globals: FALSE
[01:27:45.988] 
[01:27:45.988] 
[01:27:45.988] getGlobalsAndPackages() ... DONE
[01:27:45.989] run() for 'Future' ...
[01:27:45.989] - state: 'created'
[01:27:45.989] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:45.990] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:45.990] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:45.990]   - Field: 'label'
[01:27:45.990]   - Field: 'local'
[01:27:45.990]   - Field: 'owner'
[01:27:45.990]   - Field: 'envir'
[01:27:45.991]   - Field: 'packages'
[01:27:45.991]   - Field: 'gc'
[01:27:45.991]   - Field: 'conditions'
[01:27:45.991]   - Field: 'expr'
[01:27:45.991]   - Field: 'uuid'
[01:27:45.992]   - Field: 'seed'
[01:27:45.992]   - Field: 'version'
[01:27:45.992]   - Field: 'result'
[01:27:45.992]   - Field: 'asynchronous'
[01:27:45.992]   - Field: 'calls'
[01:27:45.992]   - Field: 'globals'
[01:27:45.993]   - Field: 'stdout'
[01:27:45.993]   - Field: 'earlySignal'
[01:27:45.993]   - Field: 'lazy'
[01:27:45.993]   - Field: 'state'
[01:27:45.993] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:45.994] - Launch lazy future ...
[01:27:45.994] Packages needed by the future expression (n = 0): <none>
[01:27:45.994] Packages needed by future strategies (n = 0): <none>
[01:27:45.995] {
[01:27:45.995]     {
[01:27:45.995]         {
[01:27:45.995]             ...future.startTime <- base::Sys.time()
[01:27:45.995]             {
[01:27:45.995]                 {
[01:27:45.995]                   {
[01:27:45.995]                     base::local({
[01:27:45.995]                       has_future <- base::requireNamespace("future", 
[01:27:45.995]                         quietly = TRUE)
[01:27:45.995]                       if (has_future) {
[01:27:45.995]                         ns <- base::getNamespace("future")
[01:27:45.995]                         version <- ns[[".package"]][["version"]]
[01:27:45.995]                         if (is.null(version)) 
[01:27:45.995]                           version <- utils::packageVersion("future")
[01:27:45.995]                       }
[01:27:45.995]                       else {
[01:27:45.995]                         version <- NULL
[01:27:45.995]                       }
[01:27:45.995]                       if (!has_future || version < "1.8.0") {
[01:27:45.995]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:45.995]                           "", base::R.version$version.string), 
[01:27:45.995]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:45.995]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:45.995]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:45.995]                             "release", "version")], collapse = " "), 
[01:27:45.995]                           hostname = base::Sys.info()[["nodename"]])
[01:27:45.995]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:45.995]                           info)
[01:27:45.995]                         info <- base::paste(info, collapse = "; ")
[01:27:45.995]                         if (!has_future) {
[01:27:45.995]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:45.995]                             info)
[01:27:45.995]                         }
[01:27:45.995]                         else {
[01:27:45.995]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:45.995]                             info, version)
[01:27:45.995]                         }
[01:27:45.995]                         base::stop(msg)
[01:27:45.995]                       }
[01:27:45.995]                     })
[01:27:45.995]                   }
[01:27:45.995]                   options(future.plan = NULL)
[01:27:45.995]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.995]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:45.995]                 }
[01:27:45.995]                 ...future.workdir <- getwd()
[01:27:45.995]             }
[01:27:45.995]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:45.995]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:45.995]         }
[01:27:45.995]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:45.995]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:45.995]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:45.995]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:45.995]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:45.995]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:45.995]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:45.995]             base::names(...future.oldOptions))
[01:27:45.995]     }
[01:27:45.995]     if (FALSE) {
[01:27:45.995]     }
[01:27:45.995]     else {
[01:27:45.995]         if (TRUE) {
[01:27:45.995]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:45.995]                 open = "w")
[01:27:45.995]         }
[01:27:45.995]         else {
[01:27:45.995]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:45.995]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:45.995]         }
[01:27:45.995]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:45.995]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:45.995]             base::sink(type = "output", split = FALSE)
[01:27:45.995]             base::close(...future.stdout)
[01:27:45.995]         }, add = TRUE)
[01:27:45.995]     }
[01:27:45.995]     ...future.frame <- base::sys.nframe()
[01:27:45.995]     ...future.conditions <- base::list()
[01:27:45.995]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:45.995]     if (FALSE) {
[01:27:45.995]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:45.995]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:45.995]     }
[01:27:45.995]     ...future.result <- base::tryCatch({
[01:27:45.995]         base::withCallingHandlers({
[01:27:45.995]             ...future.value <- base::withVisible(base::local({
[01:27:45.995]                 4
[01:27:45.995]             }))
[01:27:45.995]             future::FutureResult(value = ...future.value$value, 
[01:27:45.995]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.995]                   ...future.rng), globalenv = if (FALSE) 
[01:27:45.995]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:45.995]                     ...future.globalenv.names))
[01:27:45.995]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:45.995]         }, condition = base::local({
[01:27:45.995]             c <- base::c
[01:27:45.995]             inherits <- base::inherits
[01:27:45.995]             invokeRestart <- base::invokeRestart
[01:27:45.995]             length <- base::length
[01:27:45.995]             list <- base::list
[01:27:45.995]             seq.int <- base::seq.int
[01:27:45.995]             signalCondition <- base::signalCondition
[01:27:45.995]             sys.calls <- base::sys.calls
[01:27:45.995]             `[[` <- base::`[[`
[01:27:45.995]             `+` <- base::`+`
[01:27:45.995]             `<<-` <- base::`<<-`
[01:27:45.995]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:45.995]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:45.995]                   3L)]
[01:27:45.995]             }
[01:27:45.995]             function(cond) {
[01:27:45.995]                 is_error <- inherits(cond, "error")
[01:27:45.995]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:45.995]                   NULL)
[01:27:45.995]                 if (is_error) {
[01:27:45.995]                   sessionInformation <- function() {
[01:27:45.995]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:45.995]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:45.995]                       search = base::search(), system = base::Sys.info())
[01:27:45.995]                   }
[01:27:45.995]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.995]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:45.995]                     cond$call), session = sessionInformation(), 
[01:27:45.995]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:45.995]                   signalCondition(cond)
[01:27:45.995]                 }
[01:27:45.995]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:45.995]                 "immediateCondition"))) {
[01:27:45.995]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:45.995]                   ...future.conditions[[length(...future.conditions) + 
[01:27:45.995]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:45.995]                   if (TRUE && !signal) {
[01:27:45.995]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.995]                     {
[01:27:45.995]                       inherits <- base::inherits
[01:27:45.995]                       invokeRestart <- base::invokeRestart
[01:27:45.995]                       is.null <- base::is.null
[01:27:45.995]                       muffled <- FALSE
[01:27:45.995]                       if (inherits(cond, "message")) {
[01:27:45.995]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.995]                         if (muffled) 
[01:27:45.995]                           invokeRestart("muffleMessage")
[01:27:45.995]                       }
[01:27:45.995]                       else if (inherits(cond, "warning")) {
[01:27:45.995]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.995]                         if (muffled) 
[01:27:45.995]                           invokeRestart("muffleWarning")
[01:27:45.995]                       }
[01:27:45.995]                       else if (inherits(cond, "condition")) {
[01:27:45.995]                         if (!is.null(pattern)) {
[01:27:45.995]                           computeRestarts <- base::computeRestarts
[01:27:45.995]                           grepl <- base::grepl
[01:27:45.995]                           restarts <- computeRestarts(cond)
[01:27:45.995]                           for (restart in restarts) {
[01:27:45.995]                             name <- restart$name
[01:27:45.995]                             if (is.null(name)) 
[01:27:45.995]                               next
[01:27:45.995]                             if (!grepl(pattern, name)) 
[01:27:45.995]                               next
[01:27:45.995]                             invokeRestart(restart)
[01:27:45.995]                             muffled <- TRUE
[01:27:45.995]                             break
[01:27:45.995]                           }
[01:27:45.995]                         }
[01:27:45.995]                       }
[01:27:45.995]                       invisible(muffled)
[01:27:45.995]                     }
[01:27:45.995]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.995]                   }
[01:27:45.995]                 }
[01:27:45.995]                 else {
[01:27:45.995]                   if (TRUE) {
[01:27:45.995]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:45.995]                     {
[01:27:45.995]                       inherits <- base::inherits
[01:27:45.995]                       invokeRestart <- base::invokeRestart
[01:27:45.995]                       is.null <- base::is.null
[01:27:45.995]                       muffled <- FALSE
[01:27:45.995]                       if (inherits(cond, "message")) {
[01:27:45.995]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:45.995]                         if (muffled) 
[01:27:45.995]                           invokeRestart("muffleMessage")
[01:27:45.995]                       }
[01:27:45.995]                       else if (inherits(cond, "warning")) {
[01:27:45.995]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:45.995]                         if (muffled) 
[01:27:45.995]                           invokeRestart("muffleWarning")
[01:27:45.995]                       }
[01:27:45.995]                       else if (inherits(cond, "condition")) {
[01:27:45.995]                         if (!is.null(pattern)) {
[01:27:45.995]                           computeRestarts <- base::computeRestarts
[01:27:45.995]                           grepl <- base::grepl
[01:27:45.995]                           restarts <- computeRestarts(cond)
[01:27:45.995]                           for (restart in restarts) {
[01:27:45.995]                             name <- restart$name
[01:27:45.995]                             if (is.null(name)) 
[01:27:45.995]                               next
[01:27:45.995]                             if (!grepl(pattern, name)) 
[01:27:45.995]                               next
[01:27:45.995]                             invokeRestart(restart)
[01:27:45.995]                             muffled <- TRUE
[01:27:45.995]                             break
[01:27:45.995]                           }
[01:27:45.995]                         }
[01:27:45.995]                       }
[01:27:45.995]                       invisible(muffled)
[01:27:45.995]                     }
[01:27:45.995]                     muffleCondition(cond, pattern = "^muffle")
[01:27:45.995]                   }
[01:27:45.995]                 }
[01:27:45.995]             }
[01:27:45.995]         }))
[01:27:45.995]     }, error = function(ex) {
[01:27:45.995]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:45.995]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:45.995]                 ...future.rng), started = ...future.startTime, 
[01:27:45.995]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:45.995]             version = "1.8"), class = "FutureResult")
[01:27:45.995]     }, finally = {
[01:27:45.995]         if (!identical(...future.workdir, getwd())) 
[01:27:45.995]             setwd(...future.workdir)
[01:27:45.995]         {
[01:27:45.995]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:45.995]                 ...future.oldOptions$nwarnings <- NULL
[01:27:45.995]             }
[01:27:45.995]             base::options(...future.oldOptions)
[01:27:45.995]             if (.Platform$OS.type == "windows") {
[01:27:45.995]                 old_names <- names(...future.oldEnvVars)
[01:27:45.995]                 envs <- base::Sys.getenv()
[01:27:45.995]                 names <- names(envs)
[01:27:45.995]                 common <- intersect(names, old_names)
[01:27:45.995]                 added <- setdiff(names, old_names)
[01:27:45.995]                 removed <- setdiff(old_names, names)
[01:27:45.995]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:45.995]                   envs[common]]
[01:27:45.995]                 NAMES <- toupper(changed)
[01:27:45.995]                 args <- list()
[01:27:45.995]                 for (kk in seq_along(NAMES)) {
[01:27:45.995]                   name <- changed[[kk]]
[01:27:45.995]                   NAME <- NAMES[[kk]]
[01:27:45.995]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.995]                     next
[01:27:45.995]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.995]                 }
[01:27:45.995]                 NAMES <- toupper(added)
[01:27:45.995]                 for (kk in seq_along(NAMES)) {
[01:27:45.995]                   name <- added[[kk]]
[01:27:45.995]                   NAME <- NAMES[[kk]]
[01:27:45.995]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.995]                     next
[01:27:45.995]                   args[[name]] <- ""
[01:27:45.995]                 }
[01:27:45.995]                 NAMES <- toupper(removed)
[01:27:45.995]                 for (kk in seq_along(NAMES)) {
[01:27:45.995]                   name <- removed[[kk]]
[01:27:45.995]                   NAME <- NAMES[[kk]]
[01:27:45.995]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:45.995]                     next
[01:27:45.995]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:45.995]                 }
[01:27:45.995]                 if (length(args) > 0) 
[01:27:45.995]                   base::do.call(base::Sys.setenv, args = args)
[01:27:45.995]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:45.995]             }
[01:27:45.995]             else {
[01:27:45.995]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:45.995]             }
[01:27:45.995]             {
[01:27:45.995]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:45.995]                   0L) {
[01:27:45.995]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:45.995]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:45.995]                   base::options(opts)
[01:27:45.995]                 }
[01:27:45.995]                 {
[01:27:45.995]                   {
[01:27:45.995]                     NULL
[01:27:45.995]                     RNGkind("Mersenne-Twister")
[01:27:45.995]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:45.995]                       inherits = FALSE)
[01:27:45.995]                   }
[01:27:45.995]                   options(future.plan = NULL)
[01:27:45.995]                   if (is.na(NA_character_)) 
[01:27:45.995]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:45.995]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:45.995]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:45.995]                   {
[01:27:45.995]                     future <- SequentialFuture(..., envir = envir)
[01:27:45.995]                     if (!future$lazy) 
[01:27:45.995]                       future <- run(future)
[01:27:45.995]                     invisible(future)
[01:27:45.995]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:45.995]                 }
[01:27:45.995]             }
[01:27:45.995]         }
[01:27:45.995]     })
[01:27:45.995]     if (TRUE) {
[01:27:45.995]         base::sink(type = "output", split = FALSE)
[01:27:45.995]         if (TRUE) {
[01:27:45.995]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:45.995]         }
[01:27:45.995]         else {
[01:27:45.995]             ...future.result["stdout"] <- base::list(NULL)
[01:27:45.995]         }
[01:27:45.995]         base::close(...future.stdout)
[01:27:45.995]         ...future.stdout <- NULL
[01:27:45.995]     }
[01:27:45.995]     ...future.result$conditions <- ...future.conditions
[01:27:45.995]     ...future.result$finished <- base::Sys.time()
[01:27:45.995]     ...future.result
[01:27:45.995] }
[01:27:45.999] plan(): Setting new future strategy stack:
[01:27:45.999] List of future strategies:
[01:27:45.999] 1. sequential:
[01:27:45.999]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:45.999]    - tweaked: FALSE
[01:27:45.999]    - call: NULL
[01:27:46.000] plan(): nbrOfWorkers() = 1
[01:27:46.001] plan(): Setting new future strategy stack:
[01:27:46.001] List of future strategies:
[01:27:46.001] 1. sequential:
[01:27:46.001]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.001]    - tweaked: FALSE
[01:27:46.001]    - call: plan(strategy)
[01:27:46.002] plan(): nbrOfWorkers() = 1
[01:27:46.002] SequentialFuture started (and completed)
[01:27:46.002] - Launch lazy future ... done
[01:27:46.002] run() for 'SequentialFuture' ... done
<environment: 0x0000025b063dd8b0> 
<environment: 0x0000025b07b63ea0> 
[01:27:46.004] resolved() for 'SequentialFuture' ...
[01:27:46.004] - state: 'finished'
[01:27:46.004] - run: TRUE
[01:27:46.004] - result: 'FutureResult'
[01:27:46.004] resolved() for 'SequentialFuture' ... done
[01:27:46.005] resolved() for 'SequentialFuture' ...
[01:27:46.005] - state: 'finished'
[01:27:46.005] - run: TRUE
[01:27:46.005] - result: 'FutureResult'
[01:27:46.005] resolved() for 'SequentialFuture' ... done
[01:27:46.006] resolved() for 'SequentialFuture' ...
[01:27:46.006] - state: 'finished'
[01:27:46.006] - run: TRUE
[01:27:46.006] - result: 'FutureResult'
[01:27:46.006] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:46.008] resolve() on environment ...
[01:27:46.008]  recursive: 0
[01:27:46.009]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:46.009] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.009] - nx: 4
[01:27:46.009] - relay: TRUE
[01:27:46.010] - stdout: TRUE
[01:27:46.010] - signal: TRUE
[01:27:46.010] - resignal: FALSE
[01:27:46.010] - force: TRUE
[01:27:46.010] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.010] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.011]  - until=2
[01:27:46.011]  - relaying element #2
[01:27:46.011] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:46.011] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.011] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.011]  length: 3 (resolved future 1)
[01:27:46.012] resolved() for 'SequentialFuture' ...
[01:27:46.012] - state: 'finished'
[01:27:46.012] - run: TRUE
[01:27:46.012] - result: 'FutureResult'
[01:27:46.012] resolved() for 'SequentialFuture' ... done
[01:27:46.013] Future #2
[01:27:46.013] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.013] - nx: 4
[01:27:46.013] - relay: TRUE
[01:27:46.013] - stdout: TRUE
[01:27:46.013] - signal: TRUE
[01:27:46.014] - resignal: FALSE
[01:27:46.014] - force: TRUE
[01:27:46.014] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:46.014] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.014]  - until=2
[01:27:46.014]  - relaying element #2
[01:27:46.015] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:46.015] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:46.015] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.015]  length: 2 (resolved future 2)
[01:27:46.015] resolved() for 'SequentialFuture' ...
[01:27:46.016] - state: 'finished'
[01:27:46.016] - run: TRUE
[01:27:46.016] - result: 'FutureResult'
[01:27:46.016] resolved() for 'SequentialFuture' ... done
[01:27:46.016] Future #3
[01:27:46.018] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.018] - nx: 4
[01:27:46.019] - relay: TRUE
[01:27:46.019] - stdout: TRUE
[01:27:46.019] - signal: TRUE
[01:27:46.019] - resignal: FALSE
[01:27:46.019] - force: TRUE
[01:27:46.019] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:46.019] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:46.020]  - until=3
[01:27:46.020]  - relaying element #3
[01:27:46.020] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:46.020] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:46.020] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.021]  length: 1 (resolved future 3)
[01:27:46.021] resolved() for 'SequentialFuture' ...
[01:27:46.021] - state: 'finished'
[01:27:46.021] - run: TRUE
[01:27:46.021] - result: 'FutureResult'
[01:27:46.021] resolved() for 'SequentialFuture' ... done
[01:27:46.022] Future #4
[01:27:46.022] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.022] - nx: 4
[01:27:46.022] - relay: TRUE
[01:27:46.022] - stdout: TRUE
[01:27:46.023] - signal: TRUE
[01:27:46.023] - resignal: FALSE
[01:27:46.023] - force: TRUE
[01:27:46.023] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:46.023] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:46.023]  - until=4
[01:27:46.024]  - relaying element #4
[01:27:46.024] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.024] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:46.024] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.024]  length: 0 (resolved future 4)
[01:27:46.025] Relaying remaining futures
[01:27:46.025] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.025] - nx: 4
[01:27:46.025] - relay: TRUE
[01:27:46.025] - stdout: TRUE
[01:27:46.025] - signal: TRUE
[01:27:46.026] - resignal: FALSE
[01:27:46.026] - force: TRUE
[01:27:46.026] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.026] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:46.026] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.026] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:46.027] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.027] resolve() on environment ... DONE
<environment: 0x0000025b07dbfc68> 
Dimensions: c(2, 3, 1)
[01:27:46.027] getGlobalsAndPackages() ...
[01:27:46.028] Searching for globals...
[01:27:46.028] 
[01:27:46.028] Searching for globals ... DONE
[01:27:46.028] - globals: [0] <none>
[01:27:46.028] getGlobalsAndPackages() ... DONE
[01:27:46.029] run() for 'Future' ...
[01:27:46.029] - state: 'created'
[01:27:46.029] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.030] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.030] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.030]   - Field: 'label'
[01:27:46.030]   - Field: 'local'
[01:27:46.030]   - Field: 'owner'
[01:27:46.031]   - Field: 'envir'
[01:27:46.031]   - Field: 'packages'
[01:27:46.031]   - Field: 'gc'
[01:27:46.031]   - Field: 'conditions'
[01:27:46.031]   - Field: 'expr'
[01:27:46.031]   - Field: 'uuid'
[01:27:46.032]   - Field: 'seed'
[01:27:46.032]   - Field: 'version'
[01:27:46.032]   - Field: 'result'
[01:27:46.032]   - Field: 'asynchronous'
[01:27:46.032]   - Field: 'calls'
[01:27:46.032]   - Field: 'globals'
[01:27:46.033]   - Field: 'stdout'
[01:27:46.033]   - Field: 'earlySignal'
[01:27:46.033]   - Field: 'lazy'
[01:27:46.033]   - Field: 'state'
[01:27:46.033] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.034] - Launch lazy future ...
[01:27:46.034] Packages needed by the future expression (n = 0): <none>
[01:27:46.034] Packages needed by future strategies (n = 0): <none>
[01:27:46.035] {
[01:27:46.035]     {
[01:27:46.035]         {
[01:27:46.035]             ...future.startTime <- base::Sys.time()
[01:27:46.035]             {
[01:27:46.035]                 {
[01:27:46.035]                   {
[01:27:46.035]                     base::local({
[01:27:46.035]                       has_future <- base::requireNamespace("future", 
[01:27:46.035]                         quietly = TRUE)
[01:27:46.035]                       if (has_future) {
[01:27:46.035]                         ns <- base::getNamespace("future")
[01:27:46.035]                         version <- ns[[".package"]][["version"]]
[01:27:46.035]                         if (is.null(version)) 
[01:27:46.035]                           version <- utils::packageVersion("future")
[01:27:46.035]                       }
[01:27:46.035]                       else {
[01:27:46.035]                         version <- NULL
[01:27:46.035]                       }
[01:27:46.035]                       if (!has_future || version < "1.8.0") {
[01:27:46.035]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.035]                           "", base::R.version$version.string), 
[01:27:46.035]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.035]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.035]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.035]                             "release", "version")], collapse = " "), 
[01:27:46.035]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.035]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.035]                           info)
[01:27:46.035]                         info <- base::paste(info, collapse = "; ")
[01:27:46.035]                         if (!has_future) {
[01:27:46.035]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.035]                             info)
[01:27:46.035]                         }
[01:27:46.035]                         else {
[01:27:46.035]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.035]                             info, version)
[01:27:46.035]                         }
[01:27:46.035]                         base::stop(msg)
[01:27:46.035]                       }
[01:27:46.035]                     })
[01:27:46.035]                   }
[01:27:46.035]                   options(future.plan = NULL)
[01:27:46.035]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.035]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.035]                 }
[01:27:46.035]                 ...future.workdir <- getwd()
[01:27:46.035]             }
[01:27:46.035]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.035]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.035]         }
[01:27:46.035]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.035]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.035]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.035]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.035]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.035]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.035]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.035]             base::names(...future.oldOptions))
[01:27:46.035]     }
[01:27:46.035]     if (FALSE) {
[01:27:46.035]     }
[01:27:46.035]     else {
[01:27:46.035]         if (TRUE) {
[01:27:46.035]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.035]                 open = "w")
[01:27:46.035]         }
[01:27:46.035]         else {
[01:27:46.035]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.035]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.035]         }
[01:27:46.035]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.035]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.035]             base::sink(type = "output", split = FALSE)
[01:27:46.035]             base::close(...future.stdout)
[01:27:46.035]         }, add = TRUE)
[01:27:46.035]     }
[01:27:46.035]     ...future.frame <- base::sys.nframe()
[01:27:46.035]     ...future.conditions <- base::list()
[01:27:46.035]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.035]     if (FALSE) {
[01:27:46.035]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.035]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.035]     }
[01:27:46.035]     ...future.result <- base::tryCatch({
[01:27:46.035]         base::withCallingHandlers({
[01:27:46.035]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.035]             future::FutureResult(value = ...future.value$value, 
[01:27:46.035]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.035]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.035]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.035]                     ...future.globalenv.names))
[01:27:46.035]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.035]         }, condition = base::local({
[01:27:46.035]             c <- base::c
[01:27:46.035]             inherits <- base::inherits
[01:27:46.035]             invokeRestart <- base::invokeRestart
[01:27:46.035]             length <- base::length
[01:27:46.035]             list <- base::list
[01:27:46.035]             seq.int <- base::seq.int
[01:27:46.035]             signalCondition <- base::signalCondition
[01:27:46.035]             sys.calls <- base::sys.calls
[01:27:46.035]             `[[` <- base::`[[`
[01:27:46.035]             `+` <- base::`+`
[01:27:46.035]             `<<-` <- base::`<<-`
[01:27:46.035]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.035]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.035]                   3L)]
[01:27:46.035]             }
[01:27:46.035]             function(cond) {
[01:27:46.035]                 is_error <- inherits(cond, "error")
[01:27:46.035]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.035]                   NULL)
[01:27:46.035]                 if (is_error) {
[01:27:46.035]                   sessionInformation <- function() {
[01:27:46.035]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.035]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.035]                       search = base::search(), system = base::Sys.info())
[01:27:46.035]                   }
[01:27:46.035]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.035]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.035]                     cond$call), session = sessionInformation(), 
[01:27:46.035]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.035]                   signalCondition(cond)
[01:27:46.035]                 }
[01:27:46.035]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.035]                 "immediateCondition"))) {
[01:27:46.035]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.035]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.035]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.035]                   if (TRUE && !signal) {
[01:27:46.035]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.035]                     {
[01:27:46.035]                       inherits <- base::inherits
[01:27:46.035]                       invokeRestart <- base::invokeRestart
[01:27:46.035]                       is.null <- base::is.null
[01:27:46.035]                       muffled <- FALSE
[01:27:46.035]                       if (inherits(cond, "message")) {
[01:27:46.035]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.035]                         if (muffled) 
[01:27:46.035]                           invokeRestart("muffleMessage")
[01:27:46.035]                       }
[01:27:46.035]                       else if (inherits(cond, "warning")) {
[01:27:46.035]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.035]                         if (muffled) 
[01:27:46.035]                           invokeRestart("muffleWarning")
[01:27:46.035]                       }
[01:27:46.035]                       else if (inherits(cond, "condition")) {
[01:27:46.035]                         if (!is.null(pattern)) {
[01:27:46.035]                           computeRestarts <- base::computeRestarts
[01:27:46.035]                           grepl <- base::grepl
[01:27:46.035]                           restarts <- computeRestarts(cond)
[01:27:46.035]                           for (restart in restarts) {
[01:27:46.035]                             name <- restart$name
[01:27:46.035]                             if (is.null(name)) 
[01:27:46.035]                               next
[01:27:46.035]                             if (!grepl(pattern, name)) 
[01:27:46.035]                               next
[01:27:46.035]                             invokeRestart(restart)
[01:27:46.035]                             muffled <- TRUE
[01:27:46.035]                             break
[01:27:46.035]                           }
[01:27:46.035]                         }
[01:27:46.035]                       }
[01:27:46.035]                       invisible(muffled)
[01:27:46.035]                     }
[01:27:46.035]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.035]                   }
[01:27:46.035]                 }
[01:27:46.035]                 else {
[01:27:46.035]                   if (TRUE) {
[01:27:46.035]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.035]                     {
[01:27:46.035]                       inherits <- base::inherits
[01:27:46.035]                       invokeRestart <- base::invokeRestart
[01:27:46.035]                       is.null <- base::is.null
[01:27:46.035]                       muffled <- FALSE
[01:27:46.035]                       if (inherits(cond, "message")) {
[01:27:46.035]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.035]                         if (muffled) 
[01:27:46.035]                           invokeRestart("muffleMessage")
[01:27:46.035]                       }
[01:27:46.035]                       else if (inherits(cond, "warning")) {
[01:27:46.035]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.035]                         if (muffled) 
[01:27:46.035]                           invokeRestart("muffleWarning")
[01:27:46.035]                       }
[01:27:46.035]                       else if (inherits(cond, "condition")) {
[01:27:46.035]                         if (!is.null(pattern)) {
[01:27:46.035]                           computeRestarts <- base::computeRestarts
[01:27:46.035]                           grepl <- base::grepl
[01:27:46.035]                           restarts <- computeRestarts(cond)
[01:27:46.035]                           for (restart in restarts) {
[01:27:46.035]                             name <- restart$name
[01:27:46.035]                             if (is.null(name)) 
[01:27:46.035]                               next
[01:27:46.035]                             if (!grepl(pattern, name)) 
[01:27:46.035]                               next
[01:27:46.035]                             invokeRestart(restart)
[01:27:46.035]                             muffled <- TRUE
[01:27:46.035]                             break
[01:27:46.035]                           }
[01:27:46.035]                         }
[01:27:46.035]                       }
[01:27:46.035]                       invisible(muffled)
[01:27:46.035]                     }
[01:27:46.035]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.035]                   }
[01:27:46.035]                 }
[01:27:46.035]             }
[01:27:46.035]         }))
[01:27:46.035]     }, error = function(ex) {
[01:27:46.035]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.035]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.035]                 ...future.rng), started = ...future.startTime, 
[01:27:46.035]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.035]             version = "1.8"), class = "FutureResult")
[01:27:46.035]     }, finally = {
[01:27:46.035]         if (!identical(...future.workdir, getwd())) 
[01:27:46.035]             setwd(...future.workdir)
[01:27:46.035]         {
[01:27:46.035]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.035]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.035]             }
[01:27:46.035]             base::options(...future.oldOptions)
[01:27:46.035]             if (.Platform$OS.type == "windows") {
[01:27:46.035]                 old_names <- names(...future.oldEnvVars)
[01:27:46.035]                 envs <- base::Sys.getenv()
[01:27:46.035]                 names <- names(envs)
[01:27:46.035]                 common <- intersect(names, old_names)
[01:27:46.035]                 added <- setdiff(names, old_names)
[01:27:46.035]                 removed <- setdiff(old_names, names)
[01:27:46.035]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.035]                   envs[common]]
[01:27:46.035]                 NAMES <- toupper(changed)
[01:27:46.035]                 args <- list()
[01:27:46.035]                 for (kk in seq_along(NAMES)) {
[01:27:46.035]                   name <- changed[[kk]]
[01:27:46.035]                   NAME <- NAMES[[kk]]
[01:27:46.035]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.035]                     next
[01:27:46.035]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.035]                 }
[01:27:46.035]                 NAMES <- toupper(added)
[01:27:46.035]                 for (kk in seq_along(NAMES)) {
[01:27:46.035]                   name <- added[[kk]]
[01:27:46.035]                   NAME <- NAMES[[kk]]
[01:27:46.035]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.035]                     next
[01:27:46.035]                   args[[name]] <- ""
[01:27:46.035]                 }
[01:27:46.035]                 NAMES <- toupper(removed)
[01:27:46.035]                 for (kk in seq_along(NAMES)) {
[01:27:46.035]                   name <- removed[[kk]]
[01:27:46.035]                   NAME <- NAMES[[kk]]
[01:27:46.035]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.035]                     next
[01:27:46.035]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.035]                 }
[01:27:46.035]                 if (length(args) > 0) 
[01:27:46.035]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.035]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.035]             }
[01:27:46.035]             else {
[01:27:46.035]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.035]             }
[01:27:46.035]             {
[01:27:46.035]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.035]                   0L) {
[01:27:46.035]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.035]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.035]                   base::options(opts)
[01:27:46.035]                 }
[01:27:46.035]                 {
[01:27:46.035]                   {
[01:27:46.035]                     NULL
[01:27:46.035]                     RNGkind("Mersenne-Twister")
[01:27:46.035]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.035]                       inherits = FALSE)
[01:27:46.035]                   }
[01:27:46.035]                   options(future.plan = NULL)
[01:27:46.035]                   if (is.na(NA_character_)) 
[01:27:46.035]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.035]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.035]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.035]                   {
[01:27:46.035]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.035]                     if (!future$lazy) 
[01:27:46.035]                       future <- run(future)
[01:27:46.035]                     invisible(future)
[01:27:46.035]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.035]                 }
[01:27:46.035]             }
[01:27:46.035]         }
[01:27:46.035]     })
[01:27:46.035]     if (TRUE) {
[01:27:46.035]         base::sink(type = "output", split = FALSE)
[01:27:46.035]         if (TRUE) {
[01:27:46.035]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.035]         }
[01:27:46.035]         else {
[01:27:46.035]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.035]         }
[01:27:46.035]         base::close(...future.stdout)
[01:27:46.035]         ...future.stdout <- NULL
[01:27:46.035]     }
[01:27:46.035]     ...future.result$conditions <- ...future.conditions
[01:27:46.035]     ...future.result$finished <- base::Sys.time()
[01:27:46.035]     ...future.result
[01:27:46.035] }
[01:27:46.039] plan(): Setting new future strategy stack:
[01:27:46.039] List of future strategies:
[01:27:46.039] 1. sequential:
[01:27:46.039]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.039]    - tweaked: FALSE
[01:27:46.039]    - call: NULL
[01:27:46.039] plan(): nbrOfWorkers() = 1
[01:27:46.041] plan(): Setting new future strategy stack:
[01:27:46.041] List of future strategies:
[01:27:46.041] 1. sequential:
[01:27:46.041]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.041]    - tweaked: FALSE
[01:27:46.041]    - call: plan(strategy)
[01:27:46.041] plan(): nbrOfWorkers() = 1
[01:27:46.042] SequentialFuture started (and completed)
[01:27:46.042] - Launch lazy future ... done
[01:27:46.042] run() for 'SequentialFuture' ... done
[01:27:46.042] getGlobalsAndPackages() ...
[01:27:46.042] Searching for globals...
[01:27:46.043] 
[01:27:46.043] Searching for globals ... DONE
[01:27:46.043] - globals: [0] <none>
[01:27:46.043] getGlobalsAndPackages() ... DONE
[01:27:46.044] run() for 'Future' ...
[01:27:46.044] - state: 'created'
[01:27:46.044] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.044] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.045] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.045]   - Field: 'label'
[01:27:46.045]   - Field: 'local'
[01:27:46.045]   - Field: 'owner'
[01:27:46.045]   - Field: 'envir'
[01:27:46.045]   - Field: 'packages'
[01:27:46.046]   - Field: 'gc'
[01:27:46.046]   - Field: 'conditions'
[01:27:46.046]   - Field: 'expr'
[01:27:46.046]   - Field: 'uuid'
[01:27:46.046]   - Field: 'seed'
[01:27:46.047]   - Field: 'version'
[01:27:46.047]   - Field: 'result'
[01:27:46.047]   - Field: 'asynchronous'
[01:27:46.047]   - Field: 'calls'
[01:27:46.047]   - Field: 'globals'
[01:27:46.047]   - Field: 'stdout'
[01:27:46.048]   - Field: 'earlySignal'
[01:27:46.048]   - Field: 'lazy'
[01:27:46.048]   - Field: 'state'
[01:27:46.048] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.048] - Launch lazy future ...
[01:27:46.049] Packages needed by the future expression (n = 0): <none>
[01:27:46.049] Packages needed by future strategies (n = 0): <none>
[01:27:46.049] {
[01:27:46.049]     {
[01:27:46.049]         {
[01:27:46.049]             ...future.startTime <- base::Sys.time()
[01:27:46.049]             {
[01:27:46.049]                 {
[01:27:46.049]                   {
[01:27:46.049]                     base::local({
[01:27:46.049]                       has_future <- base::requireNamespace("future", 
[01:27:46.049]                         quietly = TRUE)
[01:27:46.049]                       if (has_future) {
[01:27:46.049]                         ns <- base::getNamespace("future")
[01:27:46.049]                         version <- ns[[".package"]][["version"]]
[01:27:46.049]                         if (is.null(version)) 
[01:27:46.049]                           version <- utils::packageVersion("future")
[01:27:46.049]                       }
[01:27:46.049]                       else {
[01:27:46.049]                         version <- NULL
[01:27:46.049]                       }
[01:27:46.049]                       if (!has_future || version < "1.8.0") {
[01:27:46.049]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.049]                           "", base::R.version$version.string), 
[01:27:46.049]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.049]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.049]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.049]                             "release", "version")], collapse = " "), 
[01:27:46.049]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.049]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.049]                           info)
[01:27:46.049]                         info <- base::paste(info, collapse = "; ")
[01:27:46.049]                         if (!has_future) {
[01:27:46.049]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.049]                             info)
[01:27:46.049]                         }
[01:27:46.049]                         else {
[01:27:46.049]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.049]                             info, version)
[01:27:46.049]                         }
[01:27:46.049]                         base::stop(msg)
[01:27:46.049]                       }
[01:27:46.049]                     })
[01:27:46.049]                   }
[01:27:46.049]                   options(future.plan = NULL)
[01:27:46.049]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.049]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.049]                 }
[01:27:46.049]                 ...future.workdir <- getwd()
[01:27:46.049]             }
[01:27:46.049]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.049]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.049]         }
[01:27:46.049]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.049]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.049]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.049]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.049]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.049]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.049]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.049]             base::names(...future.oldOptions))
[01:27:46.049]     }
[01:27:46.049]     if (FALSE) {
[01:27:46.049]     }
[01:27:46.049]     else {
[01:27:46.049]         if (TRUE) {
[01:27:46.049]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.049]                 open = "w")
[01:27:46.049]         }
[01:27:46.049]         else {
[01:27:46.049]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.049]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.049]         }
[01:27:46.049]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.049]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.049]             base::sink(type = "output", split = FALSE)
[01:27:46.049]             base::close(...future.stdout)
[01:27:46.049]         }, add = TRUE)
[01:27:46.049]     }
[01:27:46.049]     ...future.frame <- base::sys.nframe()
[01:27:46.049]     ...future.conditions <- base::list()
[01:27:46.049]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.049]     if (FALSE) {
[01:27:46.049]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.049]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.049]     }
[01:27:46.049]     ...future.result <- base::tryCatch({
[01:27:46.049]         base::withCallingHandlers({
[01:27:46.049]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.049]             future::FutureResult(value = ...future.value$value, 
[01:27:46.049]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.049]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.049]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.049]                     ...future.globalenv.names))
[01:27:46.049]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.049]         }, condition = base::local({
[01:27:46.049]             c <- base::c
[01:27:46.049]             inherits <- base::inherits
[01:27:46.049]             invokeRestart <- base::invokeRestart
[01:27:46.049]             length <- base::length
[01:27:46.049]             list <- base::list
[01:27:46.049]             seq.int <- base::seq.int
[01:27:46.049]             signalCondition <- base::signalCondition
[01:27:46.049]             sys.calls <- base::sys.calls
[01:27:46.049]             `[[` <- base::`[[`
[01:27:46.049]             `+` <- base::`+`
[01:27:46.049]             `<<-` <- base::`<<-`
[01:27:46.049]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.049]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.049]                   3L)]
[01:27:46.049]             }
[01:27:46.049]             function(cond) {
[01:27:46.049]                 is_error <- inherits(cond, "error")
[01:27:46.049]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.049]                   NULL)
[01:27:46.049]                 if (is_error) {
[01:27:46.049]                   sessionInformation <- function() {
[01:27:46.049]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.049]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.049]                       search = base::search(), system = base::Sys.info())
[01:27:46.049]                   }
[01:27:46.049]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.049]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.049]                     cond$call), session = sessionInformation(), 
[01:27:46.049]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.049]                   signalCondition(cond)
[01:27:46.049]                 }
[01:27:46.049]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.049]                 "immediateCondition"))) {
[01:27:46.049]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.049]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.049]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.049]                   if (TRUE && !signal) {
[01:27:46.049]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.049]                     {
[01:27:46.049]                       inherits <- base::inherits
[01:27:46.049]                       invokeRestart <- base::invokeRestart
[01:27:46.049]                       is.null <- base::is.null
[01:27:46.049]                       muffled <- FALSE
[01:27:46.049]                       if (inherits(cond, "message")) {
[01:27:46.049]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.049]                         if (muffled) 
[01:27:46.049]                           invokeRestart("muffleMessage")
[01:27:46.049]                       }
[01:27:46.049]                       else if (inherits(cond, "warning")) {
[01:27:46.049]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.049]                         if (muffled) 
[01:27:46.049]                           invokeRestart("muffleWarning")
[01:27:46.049]                       }
[01:27:46.049]                       else if (inherits(cond, "condition")) {
[01:27:46.049]                         if (!is.null(pattern)) {
[01:27:46.049]                           computeRestarts <- base::computeRestarts
[01:27:46.049]                           grepl <- base::grepl
[01:27:46.049]                           restarts <- computeRestarts(cond)
[01:27:46.049]                           for (restart in restarts) {
[01:27:46.049]                             name <- restart$name
[01:27:46.049]                             if (is.null(name)) 
[01:27:46.049]                               next
[01:27:46.049]                             if (!grepl(pattern, name)) 
[01:27:46.049]                               next
[01:27:46.049]                             invokeRestart(restart)
[01:27:46.049]                             muffled <- TRUE
[01:27:46.049]                             break
[01:27:46.049]                           }
[01:27:46.049]                         }
[01:27:46.049]                       }
[01:27:46.049]                       invisible(muffled)
[01:27:46.049]                     }
[01:27:46.049]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.049]                   }
[01:27:46.049]                 }
[01:27:46.049]                 else {
[01:27:46.049]                   if (TRUE) {
[01:27:46.049]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.049]                     {
[01:27:46.049]                       inherits <- base::inherits
[01:27:46.049]                       invokeRestart <- base::invokeRestart
[01:27:46.049]                       is.null <- base::is.null
[01:27:46.049]                       muffled <- FALSE
[01:27:46.049]                       if (inherits(cond, "message")) {
[01:27:46.049]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.049]                         if (muffled) 
[01:27:46.049]                           invokeRestart("muffleMessage")
[01:27:46.049]                       }
[01:27:46.049]                       else if (inherits(cond, "warning")) {
[01:27:46.049]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.049]                         if (muffled) 
[01:27:46.049]                           invokeRestart("muffleWarning")
[01:27:46.049]                       }
[01:27:46.049]                       else if (inherits(cond, "condition")) {
[01:27:46.049]                         if (!is.null(pattern)) {
[01:27:46.049]                           computeRestarts <- base::computeRestarts
[01:27:46.049]                           grepl <- base::grepl
[01:27:46.049]                           restarts <- computeRestarts(cond)
[01:27:46.049]                           for (restart in restarts) {
[01:27:46.049]                             name <- restart$name
[01:27:46.049]                             if (is.null(name)) 
[01:27:46.049]                               next
[01:27:46.049]                             if (!grepl(pattern, name)) 
[01:27:46.049]                               next
[01:27:46.049]                             invokeRestart(restart)
[01:27:46.049]                             muffled <- TRUE
[01:27:46.049]                             break
[01:27:46.049]                           }
[01:27:46.049]                         }
[01:27:46.049]                       }
[01:27:46.049]                       invisible(muffled)
[01:27:46.049]                     }
[01:27:46.049]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.049]                   }
[01:27:46.049]                 }
[01:27:46.049]             }
[01:27:46.049]         }))
[01:27:46.049]     }, error = function(ex) {
[01:27:46.049]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.049]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.049]                 ...future.rng), started = ...future.startTime, 
[01:27:46.049]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.049]             version = "1.8"), class = "FutureResult")
[01:27:46.049]     }, finally = {
[01:27:46.049]         if (!identical(...future.workdir, getwd())) 
[01:27:46.049]             setwd(...future.workdir)
[01:27:46.049]         {
[01:27:46.049]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.049]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.049]             }
[01:27:46.049]             base::options(...future.oldOptions)
[01:27:46.049]             if (.Platform$OS.type == "windows") {
[01:27:46.049]                 old_names <- names(...future.oldEnvVars)
[01:27:46.049]                 envs <- base::Sys.getenv()
[01:27:46.049]                 names <- names(envs)
[01:27:46.049]                 common <- intersect(names, old_names)
[01:27:46.049]                 added <- setdiff(names, old_names)
[01:27:46.049]                 removed <- setdiff(old_names, names)
[01:27:46.049]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.049]                   envs[common]]
[01:27:46.049]                 NAMES <- toupper(changed)
[01:27:46.049]                 args <- list()
[01:27:46.049]                 for (kk in seq_along(NAMES)) {
[01:27:46.049]                   name <- changed[[kk]]
[01:27:46.049]                   NAME <- NAMES[[kk]]
[01:27:46.049]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.049]                     next
[01:27:46.049]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.049]                 }
[01:27:46.049]                 NAMES <- toupper(added)
[01:27:46.049]                 for (kk in seq_along(NAMES)) {
[01:27:46.049]                   name <- added[[kk]]
[01:27:46.049]                   NAME <- NAMES[[kk]]
[01:27:46.049]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.049]                     next
[01:27:46.049]                   args[[name]] <- ""
[01:27:46.049]                 }
[01:27:46.049]                 NAMES <- toupper(removed)
[01:27:46.049]                 for (kk in seq_along(NAMES)) {
[01:27:46.049]                   name <- removed[[kk]]
[01:27:46.049]                   NAME <- NAMES[[kk]]
[01:27:46.049]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.049]                     next
[01:27:46.049]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.049]                 }
[01:27:46.049]                 if (length(args) > 0) 
[01:27:46.049]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.049]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.049]             }
[01:27:46.049]             else {
[01:27:46.049]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.049]             }
[01:27:46.049]             {
[01:27:46.049]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.049]                   0L) {
[01:27:46.049]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.049]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.049]                   base::options(opts)
[01:27:46.049]                 }
[01:27:46.049]                 {
[01:27:46.049]                   {
[01:27:46.049]                     NULL
[01:27:46.049]                     RNGkind("Mersenne-Twister")
[01:27:46.049]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.049]                       inherits = FALSE)
[01:27:46.049]                   }
[01:27:46.049]                   options(future.plan = NULL)
[01:27:46.049]                   if (is.na(NA_character_)) 
[01:27:46.049]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.049]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.049]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.049]                   {
[01:27:46.049]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.049]                     if (!future$lazy) 
[01:27:46.049]                       future <- run(future)
[01:27:46.049]                     invisible(future)
[01:27:46.049]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.049]                 }
[01:27:46.049]             }
[01:27:46.049]         }
[01:27:46.049]     })
[01:27:46.049]     if (TRUE) {
[01:27:46.049]         base::sink(type = "output", split = FALSE)
[01:27:46.049]         if (TRUE) {
[01:27:46.049]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.049]         }
[01:27:46.049]         else {
[01:27:46.049]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.049]         }
[01:27:46.049]         base::close(...future.stdout)
[01:27:46.049]         ...future.stdout <- NULL
[01:27:46.049]     }
[01:27:46.049]     ...future.result$conditions <- ...future.conditions
[01:27:46.049]     ...future.result$finished <- base::Sys.time()
[01:27:46.049]     ...future.result
[01:27:46.049] }
[01:27:46.053] plan(): Setting new future strategy stack:
[01:27:46.054] List of future strategies:
[01:27:46.054] 1. sequential:
[01:27:46.054]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.054]    - tweaked: FALSE
[01:27:46.054]    - call: NULL
[01:27:46.054] plan(): nbrOfWorkers() = 1
[01:27:46.056] plan(): Setting new future strategy stack:
[01:27:46.056] List of future strategies:
[01:27:46.056] 1. sequential:
[01:27:46.056]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.056]    - tweaked: FALSE
[01:27:46.056]    - call: plan(strategy)
[01:27:46.058] plan(): nbrOfWorkers() = 1
[01:27:46.058] SequentialFuture started (and completed)
[01:27:46.059] - Launch lazy future ... done
[01:27:46.059] run() for 'SequentialFuture' ... done
[01:27:46.059] getGlobalsAndPackages() ...
[01:27:46.059] Searching for globals...
[01:27:46.060] - globals found: [1] '{'
[01:27:46.060] Searching for globals ... DONE
[01:27:46.060] Resolving globals: FALSE
[01:27:46.061] 
[01:27:46.061] 
[01:27:46.061] getGlobalsAndPackages() ... DONE
[01:27:46.061] run() for 'Future' ...
[01:27:46.062] - state: 'created'
[01:27:46.062] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.062] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.063] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.063]   - Field: 'label'
[01:27:46.063]   - Field: 'local'
[01:27:46.063]   - Field: 'owner'
[01:27:46.063]   - Field: 'envir'
[01:27:46.063]   - Field: 'packages'
[01:27:46.064]   - Field: 'gc'
[01:27:46.064]   - Field: 'conditions'
[01:27:46.064]   - Field: 'expr'
[01:27:46.064]   - Field: 'uuid'
[01:27:46.064]   - Field: 'seed'
[01:27:46.064]   - Field: 'version'
[01:27:46.065]   - Field: 'result'
[01:27:46.065]   - Field: 'asynchronous'
[01:27:46.065]   - Field: 'calls'
[01:27:46.065]   - Field: 'globals'
[01:27:46.065]   - Field: 'stdout'
[01:27:46.066]   - Field: 'earlySignal'
[01:27:46.066]   - Field: 'lazy'
[01:27:46.066]   - Field: 'state'
[01:27:46.066] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.066] - Launch lazy future ...
[01:27:46.067] Packages needed by the future expression (n = 0): <none>
[01:27:46.067] Packages needed by future strategies (n = 0): <none>
[01:27:46.067] {
[01:27:46.067]     {
[01:27:46.067]         {
[01:27:46.067]             ...future.startTime <- base::Sys.time()
[01:27:46.067]             {
[01:27:46.067]                 {
[01:27:46.067]                   {
[01:27:46.067]                     base::local({
[01:27:46.067]                       has_future <- base::requireNamespace("future", 
[01:27:46.067]                         quietly = TRUE)
[01:27:46.067]                       if (has_future) {
[01:27:46.067]                         ns <- base::getNamespace("future")
[01:27:46.067]                         version <- ns[[".package"]][["version"]]
[01:27:46.067]                         if (is.null(version)) 
[01:27:46.067]                           version <- utils::packageVersion("future")
[01:27:46.067]                       }
[01:27:46.067]                       else {
[01:27:46.067]                         version <- NULL
[01:27:46.067]                       }
[01:27:46.067]                       if (!has_future || version < "1.8.0") {
[01:27:46.067]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.067]                           "", base::R.version$version.string), 
[01:27:46.067]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.067]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.067]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.067]                             "release", "version")], collapse = " "), 
[01:27:46.067]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.067]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.067]                           info)
[01:27:46.067]                         info <- base::paste(info, collapse = "; ")
[01:27:46.067]                         if (!has_future) {
[01:27:46.067]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.067]                             info)
[01:27:46.067]                         }
[01:27:46.067]                         else {
[01:27:46.067]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.067]                             info, version)
[01:27:46.067]                         }
[01:27:46.067]                         base::stop(msg)
[01:27:46.067]                       }
[01:27:46.067]                     })
[01:27:46.067]                   }
[01:27:46.067]                   options(future.plan = NULL)
[01:27:46.067]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.067]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.067]                 }
[01:27:46.067]                 ...future.workdir <- getwd()
[01:27:46.067]             }
[01:27:46.067]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.067]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.067]         }
[01:27:46.067]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.067]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.067]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.067]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.067]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.067]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.067]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.067]             base::names(...future.oldOptions))
[01:27:46.067]     }
[01:27:46.067]     if (FALSE) {
[01:27:46.067]     }
[01:27:46.067]     else {
[01:27:46.067]         if (TRUE) {
[01:27:46.067]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.067]                 open = "w")
[01:27:46.067]         }
[01:27:46.067]         else {
[01:27:46.067]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.067]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.067]         }
[01:27:46.067]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.067]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.067]             base::sink(type = "output", split = FALSE)
[01:27:46.067]             base::close(...future.stdout)
[01:27:46.067]         }, add = TRUE)
[01:27:46.067]     }
[01:27:46.067]     ...future.frame <- base::sys.nframe()
[01:27:46.067]     ...future.conditions <- base::list()
[01:27:46.067]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.067]     if (FALSE) {
[01:27:46.067]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.067]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.067]     }
[01:27:46.067]     ...future.result <- base::tryCatch({
[01:27:46.067]         base::withCallingHandlers({
[01:27:46.067]             ...future.value <- base::withVisible(base::local({
[01:27:46.067]                 4
[01:27:46.067]             }))
[01:27:46.067]             future::FutureResult(value = ...future.value$value, 
[01:27:46.067]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.067]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.067]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.067]                     ...future.globalenv.names))
[01:27:46.067]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.067]         }, condition = base::local({
[01:27:46.067]             c <- base::c
[01:27:46.067]             inherits <- base::inherits
[01:27:46.067]             invokeRestart <- base::invokeRestart
[01:27:46.067]             length <- base::length
[01:27:46.067]             list <- base::list
[01:27:46.067]             seq.int <- base::seq.int
[01:27:46.067]             signalCondition <- base::signalCondition
[01:27:46.067]             sys.calls <- base::sys.calls
[01:27:46.067]             `[[` <- base::`[[`
[01:27:46.067]             `+` <- base::`+`
[01:27:46.067]             `<<-` <- base::`<<-`
[01:27:46.067]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.067]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.067]                   3L)]
[01:27:46.067]             }
[01:27:46.067]             function(cond) {
[01:27:46.067]                 is_error <- inherits(cond, "error")
[01:27:46.067]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.067]                   NULL)
[01:27:46.067]                 if (is_error) {
[01:27:46.067]                   sessionInformation <- function() {
[01:27:46.067]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.067]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.067]                       search = base::search(), system = base::Sys.info())
[01:27:46.067]                   }
[01:27:46.067]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.067]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.067]                     cond$call), session = sessionInformation(), 
[01:27:46.067]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.067]                   signalCondition(cond)
[01:27:46.067]                 }
[01:27:46.067]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.067]                 "immediateCondition"))) {
[01:27:46.067]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.067]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.067]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.067]                   if (TRUE && !signal) {
[01:27:46.067]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.067]                     {
[01:27:46.067]                       inherits <- base::inherits
[01:27:46.067]                       invokeRestart <- base::invokeRestart
[01:27:46.067]                       is.null <- base::is.null
[01:27:46.067]                       muffled <- FALSE
[01:27:46.067]                       if (inherits(cond, "message")) {
[01:27:46.067]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.067]                         if (muffled) 
[01:27:46.067]                           invokeRestart("muffleMessage")
[01:27:46.067]                       }
[01:27:46.067]                       else if (inherits(cond, "warning")) {
[01:27:46.067]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.067]                         if (muffled) 
[01:27:46.067]                           invokeRestart("muffleWarning")
[01:27:46.067]                       }
[01:27:46.067]                       else if (inherits(cond, "condition")) {
[01:27:46.067]                         if (!is.null(pattern)) {
[01:27:46.067]                           computeRestarts <- base::computeRestarts
[01:27:46.067]                           grepl <- base::grepl
[01:27:46.067]                           restarts <- computeRestarts(cond)
[01:27:46.067]                           for (restart in restarts) {
[01:27:46.067]                             name <- restart$name
[01:27:46.067]                             if (is.null(name)) 
[01:27:46.067]                               next
[01:27:46.067]                             if (!grepl(pattern, name)) 
[01:27:46.067]                               next
[01:27:46.067]                             invokeRestart(restart)
[01:27:46.067]                             muffled <- TRUE
[01:27:46.067]                             break
[01:27:46.067]                           }
[01:27:46.067]                         }
[01:27:46.067]                       }
[01:27:46.067]                       invisible(muffled)
[01:27:46.067]                     }
[01:27:46.067]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.067]                   }
[01:27:46.067]                 }
[01:27:46.067]                 else {
[01:27:46.067]                   if (TRUE) {
[01:27:46.067]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.067]                     {
[01:27:46.067]                       inherits <- base::inherits
[01:27:46.067]                       invokeRestart <- base::invokeRestart
[01:27:46.067]                       is.null <- base::is.null
[01:27:46.067]                       muffled <- FALSE
[01:27:46.067]                       if (inherits(cond, "message")) {
[01:27:46.067]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.067]                         if (muffled) 
[01:27:46.067]                           invokeRestart("muffleMessage")
[01:27:46.067]                       }
[01:27:46.067]                       else if (inherits(cond, "warning")) {
[01:27:46.067]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.067]                         if (muffled) 
[01:27:46.067]                           invokeRestart("muffleWarning")
[01:27:46.067]                       }
[01:27:46.067]                       else if (inherits(cond, "condition")) {
[01:27:46.067]                         if (!is.null(pattern)) {
[01:27:46.067]                           computeRestarts <- base::computeRestarts
[01:27:46.067]                           grepl <- base::grepl
[01:27:46.067]                           restarts <- computeRestarts(cond)
[01:27:46.067]                           for (restart in restarts) {
[01:27:46.067]                             name <- restart$name
[01:27:46.067]                             if (is.null(name)) 
[01:27:46.067]                               next
[01:27:46.067]                             if (!grepl(pattern, name)) 
[01:27:46.067]                               next
[01:27:46.067]                             invokeRestart(restart)
[01:27:46.067]                             muffled <- TRUE
[01:27:46.067]                             break
[01:27:46.067]                           }
[01:27:46.067]                         }
[01:27:46.067]                       }
[01:27:46.067]                       invisible(muffled)
[01:27:46.067]                     }
[01:27:46.067]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.067]                   }
[01:27:46.067]                 }
[01:27:46.067]             }
[01:27:46.067]         }))
[01:27:46.067]     }, error = function(ex) {
[01:27:46.067]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.067]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.067]                 ...future.rng), started = ...future.startTime, 
[01:27:46.067]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.067]             version = "1.8"), class = "FutureResult")
[01:27:46.067]     }, finally = {
[01:27:46.067]         if (!identical(...future.workdir, getwd())) 
[01:27:46.067]             setwd(...future.workdir)
[01:27:46.067]         {
[01:27:46.067]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.067]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.067]             }
[01:27:46.067]             base::options(...future.oldOptions)
[01:27:46.067]             if (.Platform$OS.type == "windows") {
[01:27:46.067]                 old_names <- names(...future.oldEnvVars)
[01:27:46.067]                 envs <- base::Sys.getenv()
[01:27:46.067]                 names <- names(envs)
[01:27:46.067]                 common <- intersect(names, old_names)
[01:27:46.067]                 added <- setdiff(names, old_names)
[01:27:46.067]                 removed <- setdiff(old_names, names)
[01:27:46.067]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.067]                   envs[common]]
[01:27:46.067]                 NAMES <- toupper(changed)
[01:27:46.067]                 args <- list()
[01:27:46.067]                 for (kk in seq_along(NAMES)) {
[01:27:46.067]                   name <- changed[[kk]]
[01:27:46.067]                   NAME <- NAMES[[kk]]
[01:27:46.067]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.067]                     next
[01:27:46.067]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.067]                 }
[01:27:46.067]                 NAMES <- toupper(added)
[01:27:46.067]                 for (kk in seq_along(NAMES)) {
[01:27:46.067]                   name <- added[[kk]]
[01:27:46.067]                   NAME <- NAMES[[kk]]
[01:27:46.067]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.067]                     next
[01:27:46.067]                   args[[name]] <- ""
[01:27:46.067]                 }
[01:27:46.067]                 NAMES <- toupper(removed)
[01:27:46.067]                 for (kk in seq_along(NAMES)) {
[01:27:46.067]                   name <- removed[[kk]]
[01:27:46.067]                   NAME <- NAMES[[kk]]
[01:27:46.067]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.067]                     next
[01:27:46.067]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.067]                 }
[01:27:46.067]                 if (length(args) > 0) 
[01:27:46.067]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.067]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.067]             }
[01:27:46.067]             else {
[01:27:46.067]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.067]             }
[01:27:46.067]             {
[01:27:46.067]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.067]                   0L) {
[01:27:46.067]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.067]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.067]                   base::options(opts)
[01:27:46.067]                 }
[01:27:46.067]                 {
[01:27:46.067]                   {
[01:27:46.067]                     NULL
[01:27:46.067]                     RNGkind("Mersenne-Twister")
[01:27:46.067]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.067]                       inherits = FALSE)
[01:27:46.067]                   }
[01:27:46.067]                   options(future.plan = NULL)
[01:27:46.067]                   if (is.na(NA_character_)) 
[01:27:46.067]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.067]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.067]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.067]                   {
[01:27:46.067]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.067]                     if (!future$lazy) 
[01:27:46.067]                       future <- run(future)
[01:27:46.067]                     invisible(future)
[01:27:46.067]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.067]                 }
[01:27:46.067]             }
[01:27:46.067]         }
[01:27:46.067]     })
[01:27:46.067]     if (TRUE) {
[01:27:46.067]         base::sink(type = "output", split = FALSE)
[01:27:46.067]         if (TRUE) {
[01:27:46.067]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.067]         }
[01:27:46.067]         else {
[01:27:46.067]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.067]         }
[01:27:46.067]         base::close(...future.stdout)
[01:27:46.067]         ...future.stdout <- NULL
[01:27:46.067]     }
[01:27:46.067]     ...future.result$conditions <- ...future.conditions
[01:27:46.067]     ...future.result$finished <- base::Sys.time()
[01:27:46.067]     ...future.result
[01:27:46.067] }
[01:27:46.071] plan(): Setting new future strategy stack:
[01:27:46.072] List of future strategies:
[01:27:46.072] 1. sequential:
[01:27:46.072]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.072]    - tweaked: FALSE
[01:27:46.072]    - call: NULL
[01:27:46.072] plan(): nbrOfWorkers() = 1
[01:27:46.073] plan(): Setting new future strategy stack:
[01:27:46.074] List of future strategies:
[01:27:46.074] 1. sequential:
[01:27:46.074]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.074]    - tweaked: FALSE
[01:27:46.074]    - call: plan(strategy)
[01:27:46.074] plan(): nbrOfWorkers() = 1
[01:27:46.074] SequentialFuture started (and completed)
[01:27:46.075] - Launch lazy future ... done
[01:27:46.075] run() for 'SequentialFuture' ... done
<environment: 0x0000025b0448c190> 
<environment: 0x0000025b0763af80> 
[01:27:46.076] resolved() for 'SequentialFuture' ...
[01:27:46.077] - state: 'finished'
[01:27:46.077] - run: TRUE
[01:27:46.077] - result: 'FutureResult'
[01:27:46.077] resolved() for 'SequentialFuture' ... done
[01:27:46.078] resolved() for 'SequentialFuture' ...
[01:27:46.078] - state: 'finished'
[01:27:46.078] - run: TRUE
[01:27:46.078] - result: 'FutureResult'
[01:27:46.078] resolved() for 'SequentialFuture' ... done
[01:27:46.079] resolved() for 'SequentialFuture' ...
[01:27:46.079] - state: 'finished'
[01:27:46.079] - run: TRUE
[01:27:46.079] - result: 'FutureResult'
[01:27:46.079] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:46.081] resolve() on environment ...
[01:27:46.081]  recursive: 0
[01:27:46.082]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:46.082] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.082] - nx: 4
[01:27:46.082] - relay: TRUE
[01:27:46.082] - stdout: TRUE
[01:27:46.082] - signal: TRUE
[01:27:46.083] - resignal: FALSE
[01:27:46.083] - force: TRUE
[01:27:46.083] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.083] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.083]  - until=2
[01:27:46.083]  - relaying element #2
[01:27:46.084] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:46.084] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.084] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.084]  length: 3 (resolved future 1)
[01:27:46.084] resolved() for 'SequentialFuture' ...
[01:27:46.085] - state: 'finished'
[01:27:46.085] - run: TRUE
[01:27:46.085] - result: 'FutureResult'
[01:27:46.085] resolved() for 'SequentialFuture' ... done
[01:27:46.085] Future #2
[01:27:46.086] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.086] - nx: 4
[01:27:46.086] - relay: TRUE
[01:27:46.086] - stdout: TRUE
[01:27:46.086] - signal: TRUE
[01:27:46.086] - resignal: FALSE
[01:27:46.087] - force: TRUE
[01:27:46.087] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:46.087] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.087]  - until=2
[01:27:46.087]  - relaying element #2
[01:27:46.088] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:46.088] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:46.088] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.088]  length: 2 (resolved future 2)
[01:27:46.088] resolved() for 'SequentialFuture' ...
[01:27:46.088] - state: 'finished'
[01:27:46.089] - run: TRUE
[01:27:46.089] - result: 'FutureResult'
[01:27:46.089] resolved() for 'SequentialFuture' ... done
[01:27:46.089] Future #3
[01:27:46.089] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.090] - nx: 4
[01:27:46.090] - relay: TRUE
[01:27:46.090] - stdout: TRUE
[01:27:46.090] - signal: TRUE
[01:27:46.090] - resignal: FALSE
[01:27:46.090] - force: TRUE
[01:27:46.091] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:46.091] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:46.091]  - until=3
[01:27:46.091]  - relaying element #3
[01:27:46.164] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:46.165] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:46.165] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.165]  length: 1 (resolved future 3)
[01:27:46.166] resolved() for 'SequentialFuture' ...
[01:27:46.166] - state: 'finished'
[01:27:46.166] - run: TRUE
[01:27:46.166] - result: 'FutureResult'
[01:27:46.167] resolved() for 'SequentialFuture' ... done
[01:27:46.167] Future #4
[01:27:46.167] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.168] - nx: 4
[01:27:46.168] - relay: TRUE
[01:27:46.168] - stdout: TRUE
[01:27:46.168] - signal: TRUE
[01:27:46.168] - resignal: FALSE
[01:27:46.169] - force: TRUE
[01:27:46.169] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:46.169] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:46.169]  - until=4
[01:27:46.169]  - relaying element #4
[01:27:46.170] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.170] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:46.170] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.170]  length: 0 (resolved future 4)
[01:27:46.171] Relaying remaining futures
[01:27:46.171] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.171] - nx: 4
[01:27:46.171] - relay: TRUE
[01:27:46.171] - stdout: TRUE
[01:27:46.171] - signal: TRUE
[01:27:46.172] - resignal: FALSE
[01:27:46.172] - force: TRUE
[01:27:46.172] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.172] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:46.172] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.173] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:46.173] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.173] resolve() on environment ... DONE
<environment: 0x0000025b07ca45a8> 
Dimensions: c(2, 1, 3, 1)
[01:27:46.174] getGlobalsAndPackages() ...
[01:27:46.174] Searching for globals...
[01:27:46.175] 
[01:27:46.175] Searching for globals ... DONE
[01:27:46.175] - globals: [0] <none>
[01:27:46.175] getGlobalsAndPackages() ... DONE
[01:27:46.176] run() for 'Future' ...
[01:27:46.176] - state: 'created'
[01:27:46.176] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.177] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.177] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.177]   - Field: 'label'
[01:27:46.177]   - Field: 'local'
[01:27:46.178]   - Field: 'owner'
[01:27:46.178]   - Field: 'envir'
[01:27:46.178]   - Field: 'packages'
[01:27:46.178]   - Field: 'gc'
[01:27:46.178]   - Field: 'conditions'
[01:27:46.179]   - Field: 'expr'
[01:27:46.179]   - Field: 'uuid'
[01:27:46.179]   - Field: 'seed'
[01:27:46.179]   - Field: 'version'
[01:27:46.179]   - Field: 'result'
[01:27:46.180]   - Field: 'asynchronous'
[01:27:46.180]   - Field: 'calls'
[01:27:46.180]   - Field: 'globals'
[01:27:46.180]   - Field: 'stdout'
[01:27:46.181]   - Field: 'earlySignal'
[01:27:46.181]   - Field: 'lazy'
[01:27:46.181]   - Field: 'state'
[01:27:46.181] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.181] - Launch lazy future ...
[01:27:46.182] Packages needed by the future expression (n = 0): <none>
[01:27:46.182] Packages needed by future strategies (n = 0): <none>
[01:27:46.183] {
[01:27:46.183]     {
[01:27:46.183]         {
[01:27:46.183]             ...future.startTime <- base::Sys.time()
[01:27:46.183]             {
[01:27:46.183]                 {
[01:27:46.183]                   {
[01:27:46.183]                     base::local({
[01:27:46.183]                       has_future <- base::requireNamespace("future", 
[01:27:46.183]                         quietly = TRUE)
[01:27:46.183]                       if (has_future) {
[01:27:46.183]                         ns <- base::getNamespace("future")
[01:27:46.183]                         version <- ns[[".package"]][["version"]]
[01:27:46.183]                         if (is.null(version)) 
[01:27:46.183]                           version <- utils::packageVersion("future")
[01:27:46.183]                       }
[01:27:46.183]                       else {
[01:27:46.183]                         version <- NULL
[01:27:46.183]                       }
[01:27:46.183]                       if (!has_future || version < "1.8.0") {
[01:27:46.183]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.183]                           "", base::R.version$version.string), 
[01:27:46.183]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.183]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.183]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.183]                             "release", "version")], collapse = " "), 
[01:27:46.183]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.183]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.183]                           info)
[01:27:46.183]                         info <- base::paste(info, collapse = "; ")
[01:27:46.183]                         if (!has_future) {
[01:27:46.183]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.183]                             info)
[01:27:46.183]                         }
[01:27:46.183]                         else {
[01:27:46.183]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.183]                             info, version)
[01:27:46.183]                         }
[01:27:46.183]                         base::stop(msg)
[01:27:46.183]                       }
[01:27:46.183]                     })
[01:27:46.183]                   }
[01:27:46.183]                   options(future.plan = NULL)
[01:27:46.183]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.183]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.183]                 }
[01:27:46.183]                 ...future.workdir <- getwd()
[01:27:46.183]             }
[01:27:46.183]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.183]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.183]         }
[01:27:46.183]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.183]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.183]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.183]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.183]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.183]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.183]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.183]             base::names(...future.oldOptions))
[01:27:46.183]     }
[01:27:46.183]     if (FALSE) {
[01:27:46.183]     }
[01:27:46.183]     else {
[01:27:46.183]         if (TRUE) {
[01:27:46.183]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.183]                 open = "w")
[01:27:46.183]         }
[01:27:46.183]         else {
[01:27:46.183]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.183]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.183]         }
[01:27:46.183]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.183]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.183]             base::sink(type = "output", split = FALSE)
[01:27:46.183]             base::close(...future.stdout)
[01:27:46.183]         }, add = TRUE)
[01:27:46.183]     }
[01:27:46.183]     ...future.frame <- base::sys.nframe()
[01:27:46.183]     ...future.conditions <- base::list()
[01:27:46.183]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.183]     if (FALSE) {
[01:27:46.183]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.183]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.183]     }
[01:27:46.183]     ...future.result <- base::tryCatch({
[01:27:46.183]         base::withCallingHandlers({
[01:27:46.183]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.183]             future::FutureResult(value = ...future.value$value, 
[01:27:46.183]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.183]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.183]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.183]                     ...future.globalenv.names))
[01:27:46.183]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.183]         }, condition = base::local({
[01:27:46.183]             c <- base::c
[01:27:46.183]             inherits <- base::inherits
[01:27:46.183]             invokeRestart <- base::invokeRestart
[01:27:46.183]             length <- base::length
[01:27:46.183]             list <- base::list
[01:27:46.183]             seq.int <- base::seq.int
[01:27:46.183]             signalCondition <- base::signalCondition
[01:27:46.183]             sys.calls <- base::sys.calls
[01:27:46.183]             `[[` <- base::`[[`
[01:27:46.183]             `+` <- base::`+`
[01:27:46.183]             `<<-` <- base::`<<-`
[01:27:46.183]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.183]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.183]                   3L)]
[01:27:46.183]             }
[01:27:46.183]             function(cond) {
[01:27:46.183]                 is_error <- inherits(cond, "error")
[01:27:46.183]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.183]                   NULL)
[01:27:46.183]                 if (is_error) {
[01:27:46.183]                   sessionInformation <- function() {
[01:27:46.183]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.183]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.183]                       search = base::search(), system = base::Sys.info())
[01:27:46.183]                   }
[01:27:46.183]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.183]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.183]                     cond$call), session = sessionInformation(), 
[01:27:46.183]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.183]                   signalCondition(cond)
[01:27:46.183]                 }
[01:27:46.183]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.183]                 "immediateCondition"))) {
[01:27:46.183]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.183]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.183]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.183]                   if (TRUE && !signal) {
[01:27:46.183]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.183]                     {
[01:27:46.183]                       inherits <- base::inherits
[01:27:46.183]                       invokeRestart <- base::invokeRestart
[01:27:46.183]                       is.null <- base::is.null
[01:27:46.183]                       muffled <- FALSE
[01:27:46.183]                       if (inherits(cond, "message")) {
[01:27:46.183]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.183]                         if (muffled) 
[01:27:46.183]                           invokeRestart("muffleMessage")
[01:27:46.183]                       }
[01:27:46.183]                       else if (inherits(cond, "warning")) {
[01:27:46.183]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.183]                         if (muffled) 
[01:27:46.183]                           invokeRestart("muffleWarning")
[01:27:46.183]                       }
[01:27:46.183]                       else if (inherits(cond, "condition")) {
[01:27:46.183]                         if (!is.null(pattern)) {
[01:27:46.183]                           computeRestarts <- base::computeRestarts
[01:27:46.183]                           grepl <- base::grepl
[01:27:46.183]                           restarts <- computeRestarts(cond)
[01:27:46.183]                           for (restart in restarts) {
[01:27:46.183]                             name <- restart$name
[01:27:46.183]                             if (is.null(name)) 
[01:27:46.183]                               next
[01:27:46.183]                             if (!grepl(pattern, name)) 
[01:27:46.183]                               next
[01:27:46.183]                             invokeRestart(restart)
[01:27:46.183]                             muffled <- TRUE
[01:27:46.183]                             break
[01:27:46.183]                           }
[01:27:46.183]                         }
[01:27:46.183]                       }
[01:27:46.183]                       invisible(muffled)
[01:27:46.183]                     }
[01:27:46.183]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.183]                   }
[01:27:46.183]                 }
[01:27:46.183]                 else {
[01:27:46.183]                   if (TRUE) {
[01:27:46.183]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.183]                     {
[01:27:46.183]                       inherits <- base::inherits
[01:27:46.183]                       invokeRestart <- base::invokeRestart
[01:27:46.183]                       is.null <- base::is.null
[01:27:46.183]                       muffled <- FALSE
[01:27:46.183]                       if (inherits(cond, "message")) {
[01:27:46.183]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.183]                         if (muffled) 
[01:27:46.183]                           invokeRestart("muffleMessage")
[01:27:46.183]                       }
[01:27:46.183]                       else if (inherits(cond, "warning")) {
[01:27:46.183]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.183]                         if (muffled) 
[01:27:46.183]                           invokeRestart("muffleWarning")
[01:27:46.183]                       }
[01:27:46.183]                       else if (inherits(cond, "condition")) {
[01:27:46.183]                         if (!is.null(pattern)) {
[01:27:46.183]                           computeRestarts <- base::computeRestarts
[01:27:46.183]                           grepl <- base::grepl
[01:27:46.183]                           restarts <- computeRestarts(cond)
[01:27:46.183]                           for (restart in restarts) {
[01:27:46.183]                             name <- restart$name
[01:27:46.183]                             if (is.null(name)) 
[01:27:46.183]                               next
[01:27:46.183]                             if (!grepl(pattern, name)) 
[01:27:46.183]                               next
[01:27:46.183]                             invokeRestart(restart)
[01:27:46.183]                             muffled <- TRUE
[01:27:46.183]                             break
[01:27:46.183]                           }
[01:27:46.183]                         }
[01:27:46.183]                       }
[01:27:46.183]                       invisible(muffled)
[01:27:46.183]                     }
[01:27:46.183]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.183]                   }
[01:27:46.183]                 }
[01:27:46.183]             }
[01:27:46.183]         }))
[01:27:46.183]     }, error = function(ex) {
[01:27:46.183]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.183]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.183]                 ...future.rng), started = ...future.startTime, 
[01:27:46.183]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.183]             version = "1.8"), class = "FutureResult")
[01:27:46.183]     }, finally = {
[01:27:46.183]         if (!identical(...future.workdir, getwd())) 
[01:27:46.183]             setwd(...future.workdir)
[01:27:46.183]         {
[01:27:46.183]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.183]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.183]             }
[01:27:46.183]             base::options(...future.oldOptions)
[01:27:46.183]             if (.Platform$OS.type == "windows") {
[01:27:46.183]                 old_names <- names(...future.oldEnvVars)
[01:27:46.183]                 envs <- base::Sys.getenv()
[01:27:46.183]                 names <- names(envs)
[01:27:46.183]                 common <- intersect(names, old_names)
[01:27:46.183]                 added <- setdiff(names, old_names)
[01:27:46.183]                 removed <- setdiff(old_names, names)
[01:27:46.183]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.183]                   envs[common]]
[01:27:46.183]                 NAMES <- toupper(changed)
[01:27:46.183]                 args <- list()
[01:27:46.183]                 for (kk in seq_along(NAMES)) {
[01:27:46.183]                   name <- changed[[kk]]
[01:27:46.183]                   NAME <- NAMES[[kk]]
[01:27:46.183]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.183]                     next
[01:27:46.183]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.183]                 }
[01:27:46.183]                 NAMES <- toupper(added)
[01:27:46.183]                 for (kk in seq_along(NAMES)) {
[01:27:46.183]                   name <- added[[kk]]
[01:27:46.183]                   NAME <- NAMES[[kk]]
[01:27:46.183]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.183]                     next
[01:27:46.183]                   args[[name]] <- ""
[01:27:46.183]                 }
[01:27:46.183]                 NAMES <- toupper(removed)
[01:27:46.183]                 for (kk in seq_along(NAMES)) {
[01:27:46.183]                   name <- removed[[kk]]
[01:27:46.183]                   NAME <- NAMES[[kk]]
[01:27:46.183]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.183]                     next
[01:27:46.183]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.183]                 }
[01:27:46.183]                 if (length(args) > 0) 
[01:27:46.183]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.183]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.183]             }
[01:27:46.183]             else {
[01:27:46.183]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.183]             }
[01:27:46.183]             {
[01:27:46.183]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.183]                   0L) {
[01:27:46.183]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.183]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.183]                   base::options(opts)
[01:27:46.183]                 }
[01:27:46.183]                 {
[01:27:46.183]                   {
[01:27:46.183]                     NULL
[01:27:46.183]                     RNGkind("Mersenne-Twister")
[01:27:46.183]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.183]                       inherits = FALSE)
[01:27:46.183]                   }
[01:27:46.183]                   options(future.plan = NULL)
[01:27:46.183]                   if (is.na(NA_character_)) 
[01:27:46.183]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.183]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.183]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.183]                   {
[01:27:46.183]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.183]                     if (!future$lazy) 
[01:27:46.183]                       future <- run(future)
[01:27:46.183]                     invisible(future)
[01:27:46.183]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.183]                 }
[01:27:46.183]             }
[01:27:46.183]         }
[01:27:46.183]     })
[01:27:46.183]     if (TRUE) {
[01:27:46.183]         base::sink(type = "output", split = FALSE)
[01:27:46.183]         if (TRUE) {
[01:27:46.183]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.183]         }
[01:27:46.183]         else {
[01:27:46.183]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.183]         }
[01:27:46.183]         base::close(...future.stdout)
[01:27:46.183]         ...future.stdout <- NULL
[01:27:46.183]     }
[01:27:46.183]     ...future.result$conditions <- ...future.conditions
[01:27:46.183]     ...future.result$finished <- base::Sys.time()
[01:27:46.183]     ...future.result
[01:27:46.183] }
[01:27:46.188] plan(): Setting new future strategy stack:
[01:27:46.188] List of future strategies:
[01:27:46.188] 1. sequential:
[01:27:46.188]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.188]    - tweaked: FALSE
[01:27:46.188]    - call: NULL
[01:27:46.189] plan(): nbrOfWorkers() = 1
[01:27:46.191] plan(): Setting new future strategy stack:
[01:27:46.191] List of future strategies:
[01:27:46.191] 1. sequential:
[01:27:46.191]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.191]    - tweaked: FALSE
[01:27:46.191]    - call: plan(strategy)
[01:27:46.191] plan(): nbrOfWorkers() = 1
[01:27:46.192] SequentialFuture started (and completed)
[01:27:46.192] - Launch lazy future ... done
[01:27:46.192] run() for 'SequentialFuture' ... done
[01:27:46.193] getGlobalsAndPackages() ...
[01:27:46.193] Searching for globals...
[01:27:46.193] 
[01:27:46.193] Searching for globals ... DONE
[01:27:46.194] - globals: [0] <none>
[01:27:46.194] getGlobalsAndPackages() ... DONE
[01:27:46.194] run() for 'Future' ...
[01:27:46.194] - state: 'created'
[01:27:46.195] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.195] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.195] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.196]   - Field: 'label'
[01:27:46.196]   - Field: 'local'
[01:27:46.196]   - Field: 'owner'
[01:27:46.196]   - Field: 'envir'
[01:27:46.197]   - Field: 'packages'
[01:27:46.197]   - Field: 'gc'
[01:27:46.197]   - Field: 'conditions'
[01:27:46.197]   - Field: 'expr'
[01:27:46.197]   - Field: 'uuid'
[01:27:46.198]   - Field: 'seed'
[01:27:46.198]   - Field: 'version'
[01:27:46.198]   - Field: 'result'
[01:27:46.198]   - Field: 'asynchronous'
[01:27:46.198]   - Field: 'calls'
[01:27:46.199]   - Field: 'globals'
[01:27:46.199]   - Field: 'stdout'
[01:27:46.199]   - Field: 'earlySignal'
[01:27:46.199]   - Field: 'lazy'
[01:27:46.199]   - Field: 'state'
[01:27:46.200] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.200] - Launch lazy future ...
[01:27:46.200] Packages needed by the future expression (n = 0): <none>
[01:27:46.200] Packages needed by future strategies (n = 0): <none>
[01:27:46.201] {
[01:27:46.201]     {
[01:27:46.201]         {
[01:27:46.201]             ...future.startTime <- base::Sys.time()
[01:27:46.201]             {
[01:27:46.201]                 {
[01:27:46.201]                   {
[01:27:46.201]                     base::local({
[01:27:46.201]                       has_future <- base::requireNamespace("future", 
[01:27:46.201]                         quietly = TRUE)
[01:27:46.201]                       if (has_future) {
[01:27:46.201]                         ns <- base::getNamespace("future")
[01:27:46.201]                         version <- ns[[".package"]][["version"]]
[01:27:46.201]                         if (is.null(version)) 
[01:27:46.201]                           version <- utils::packageVersion("future")
[01:27:46.201]                       }
[01:27:46.201]                       else {
[01:27:46.201]                         version <- NULL
[01:27:46.201]                       }
[01:27:46.201]                       if (!has_future || version < "1.8.0") {
[01:27:46.201]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.201]                           "", base::R.version$version.string), 
[01:27:46.201]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.201]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.201]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.201]                             "release", "version")], collapse = " "), 
[01:27:46.201]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.201]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.201]                           info)
[01:27:46.201]                         info <- base::paste(info, collapse = "; ")
[01:27:46.201]                         if (!has_future) {
[01:27:46.201]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.201]                             info)
[01:27:46.201]                         }
[01:27:46.201]                         else {
[01:27:46.201]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.201]                             info, version)
[01:27:46.201]                         }
[01:27:46.201]                         base::stop(msg)
[01:27:46.201]                       }
[01:27:46.201]                     })
[01:27:46.201]                   }
[01:27:46.201]                   options(future.plan = NULL)
[01:27:46.201]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.201]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.201]                 }
[01:27:46.201]                 ...future.workdir <- getwd()
[01:27:46.201]             }
[01:27:46.201]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.201]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.201]         }
[01:27:46.201]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.201]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.201]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.201]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.201]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.201]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.201]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.201]             base::names(...future.oldOptions))
[01:27:46.201]     }
[01:27:46.201]     if (FALSE) {
[01:27:46.201]     }
[01:27:46.201]     else {
[01:27:46.201]         if (TRUE) {
[01:27:46.201]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.201]                 open = "w")
[01:27:46.201]         }
[01:27:46.201]         else {
[01:27:46.201]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.201]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.201]         }
[01:27:46.201]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.201]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.201]             base::sink(type = "output", split = FALSE)
[01:27:46.201]             base::close(...future.stdout)
[01:27:46.201]         }, add = TRUE)
[01:27:46.201]     }
[01:27:46.201]     ...future.frame <- base::sys.nframe()
[01:27:46.201]     ...future.conditions <- base::list()
[01:27:46.201]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.201]     if (FALSE) {
[01:27:46.201]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.201]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.201]     }
[01:27:46.201]     ...future.result <- base::tryCatch({
[01:27:46.201]         base::withCallingHandlers({
[01:27:46.201]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.201]             future::FutureResult(value = ...future.value$value, 
[01:27:46.201]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.201]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.201]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.201]                     ...future.globalenv.names))
[01:27:46.201]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.201]         }, condition = base::local({
[01:27:46.201]             c <- base::c
[01:27:46.201]             inherits <- base::inherits
[01:27:46.201]             invokeRestart <- base::invokeRestart
[01:27:46.201]             length <- base::length
[01:27:46.201]             list <- base::list
[01:27:46.201]             seq.int <- base::seq.int
[01:27:46.201]             signalCondition <- base::signalCondition
[01:27:46.201]             sys.calls <- base::sys.calls
[01:27:46.201]             `[[` <- base::`[[`
[01:27:46.201]             `+` <- base::`+`
[01:27:46.201]             `<<-` <- base::`<<-`
[01:27:46.201]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.201]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.201]                   3L)]
[01:27:46.201]             }
[01:27:46.201]             function(cond) {
[01:27:46.201]                 is_error <- inherits(cond, "error")
[01:27:46.201]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.201]                   NULL)
[01:27:46.201]                 if (is_error) {
[01:27:46.201]                   sessionInformation <- function() {
[01:27:46.201]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.201]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.201]                       search = base::search(), system = base::Sys.info())
[01:27:46.201]                   }
[01:27:46.201]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.201]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.201]                     cond$call), session = sessionInformation(), 
[01:27:46.201]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.201]                   signalCondition(cond)
[01:27:46.201]                 }
[01:27:46.201]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.201]                 "immediateCondition"))) {
[01:27:46.201]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.201]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.201]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.201]                   if (TRUE && !signal) {
[01:27:46.201]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.201]                     {
[01:27:46.201]                       inherits <- base::inherits
[01:27:46.201]                       invokeRestart <- base::invokeRestart
[01:27:46.201]                       is.null <- base::is.null
[01:27:46.201]                       muffled <- FALSE
[01:27:46.201]                       if (inherits(cond, "message")) {
[01:27:46.201]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.201]                         if (muffled) 
[01:27:46.201]                           invokeRestart("muffleMessage")
[01:27:46.201]                       }
[01:27:46.201]                       else if (inherits(cond, "warning")) {
[01:27:46.201]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.201]                         if (muffled) 
[01:27:46.201]                           invokeRestart("muffleWarning")
[01:27:46.201]                       }
[01:27:46.201]                       else if (inherits(cond, "condition")) {
[01:27:46.201]                         if (!is.null(pattern)) {
[01:27:46.201]                           computeRestarts <- base::computeRestarts
[01:27:46.201]                           grepl <- base::grepl
[01:27:46.201]                           restarts <- computeRestarts(cond)
[01:27:46.201]                           for (restart in restarts) {
[01:27:46.201]                             name <- restart$name
[01:27:46.201]                             if (is.null(name)) 
[01:27:46.201]                               next
[01:27:46.201]                             if (!grepl(pattern, name)) 
[01:27:46.201]                               next
[01:27:46.201]                             invokeRestart(restart)
[01:27:46.201]                             muffled <- TRUE
[01:27:46.201]                             break
[01:27:46.201]                           }
[01:27:46.201]                         }
[01:27:46.201]                       }
[01:27:46.201]                       invisible(muffled)
[01:27:46.201]                     }
[01:27:46.201]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.201]                   }
[01:27:46.201]                 }
[01:27:46.201]                 else {
[01:27:46.201]                   if (TRUE) {
[01:27:46.201]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.201]                     {
[01:27:46.201]                       inherits <- base::inherits
[01:27:46.201]                       invokeRestart <- base::invokeRestart
[01:27:46.201]                       is.null <- base::is.null
[01:27:46.201]                       muffled <- FALSE
[01:27:46.201]                       if (inherits(cond, "message")) {
[01:27:46.201]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.201]                         if (muffled) 
[01:27:46.201]                           invokeRestart("muffleMessage")
[01:27:46.201]                       }
[01:27:46.201]                       else if (inherits(cond, "warning")) {
[01:27:46.201]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.201]                         if (muffled) 
[01:27:46.201]                           invokeRestart("muffleWarning")
[01:27:46.201]                       }
[01:27:46.201]                       else if (inherits(cond, "condition")) {
[01:27:46.201]                         if (!is.null(pattern)) {
[01:27:46.201]                           computeRestarts <- base::computeRestarts
[01:27:46.201]                           grepl <- base::grepl
[01:27:46.201]                           restarts <- computeRestarts(cond)
[01:27:46.201]                           for (restart in restarts) {
[01:27:46.201]                             name <- restart$name
[01:27:46.201]                             if (is.null(name)) 
[01:27:46.201]                               next
[01:27:46.201]                             if (!grepl(pattern, name)) 
[01:27:46.201]                               next
[01:27:46.201]                             invokeRestart(restart)
[01:27:46.201]                             muffled <- TRUE
[01:27:46.201]                             break
[01:27:46.201]                           }
[01:27:46.201]                         }
[01:27:46.201]                       }
[01:27:46.201]                       invisible(muffled)
[01:27:46.201]                     }
[01:27:46.201]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.201]                   }
[01:27:46.201]                 }
[01:27:46.201]             }
[01:27:46.201]         }))
[01:27:46.201]     }, error = function(ex) {
[01:27:46.201]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.201]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.201]                 ...future.rng), started = ...future.startTime, 
[01:27:46.201]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.201]             version = "1.8"), class = "FutureResult")
[01:27:46.201]     }, finally = {
[01:27:46.201]         if (!identical(...future.workdir, getwd())) 
[01:27:46.201]             setwd(...future.workdir)
[01:27:46.201]         {
[01:27:46.201]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.201]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.201]             }
[01:27:46.201]             base::options(...future.oldOptions)
[01:27:46.201]             if (.Platform$OS.type == "windows") {
[01:27:46.201]                 old_names <- names(...future.oldEnvVars)
[01:27:46.201]                 envs <- base::Sys.getenv()
[01:27:46.201]                 names <- names(envs)
[01:27:46.201]                 common <- intersect(names, old_names)
[01:27:46.201]                 added <- setdiff(names, old_names)
[01:27:46.201]                 removed <- setdiff(old_names, names)
[01:27:46.201]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.201]                   envs[common]]
[01:27:46.201]                 NAMES <- toupper(changed)
[01:27:46.201]                 args <- list()
[01:27:46.201]                 for (kk in seq_along(NAMES)) {
[01:27:46.201]                   name <- changed[[kk]]
[01:27:46.201]                   NAME <- NAMES[[kk]]
[01:27:46.201]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.201]                     next
[01:27:46.201]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.201]                 }
[01:27:46.201]                 NAMES <- toupper(added)
[01:27:46.201]                 for (kk in seq_along(NAMES)) {
[01:27:46.201]                   name <- added[[kk]]
[01:27:46.201]                   NAME <- NAMES[[kk]]
[01:27:46.201]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.201]                     next
[01:27:46.201]                   args[[name]] <- ""
[01:27:46.201]                 }
[01:27:46.201]                 NAMES <- toupper(removed)
[01:27:46.201]                 for (kk in seq_along(NAMES)) {
[01:27:46.201]                   name <- removed[[kk]]
[01:27:46.201]                   NAME <- NAMES[[kk]]
[01:27:46.201]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.201]                     next
[01:27:46.201]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.201]                 }
[01:27:46.201]                 if (length(args) > 0) 
[01:27:46.201]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.201]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.201]             }
[01:27:46.201]             else {
[01:27:46.201]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.201]             }
[01:27:46.201]             {
[01:27:46.201]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.201]                   0L) {
[01:27:46.201]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.201]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.201]                   base::options(opts)
[01:27:46.201]                 }
[01:27:46.201]                 {
[01:27:46.201]                   {
[01:27:46.201]                     NULL
[01:27:46.201]                     RNGkind("Mersenne-Twister")
[01:27:46.201]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.201]                       inherits = FALSE)
[01:27:46.201]                   }
[01:27:46.201]                   options(future.plan = NULL)
[01:27:46.201]                   if (is.na(NA_character_)) 
[01:27:46.201]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.201]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.201]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.201]                   {
[01:27:46.201]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.201]                     if (!future$lazy) 
[01:27:46.201]                       future <- run(future)
[01:27:46.201]                     invisible(future)
[01:27:46.201]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.201]                 }
[01:27:46.201]             }
[01:27:46.201]         }
[01:27:46.201]     })
[01:27:46.201]     if (TRUE) {
[01:27:46.201]         base::sink(type = "output", split = FALSE)
[01:27:46.201]         if (TRUE) {
[01:27:46.201]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.201]         }
[01:27:46.201]         else {
[01:27:46.201]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.201]         }
[01:27:46.201]         base::close(...future.stdout)
[01:27:46.201]         ...future.stdout <- NULL
[01:27:46.201]     }
[01:27:46.201]     ...future.result$conditions <- ...future.conditions
[01:27:46.201]     ...future.result$finished <- base::Sys.time()
[01:27:46.201]     ...future.result
[01:27:46.201] }
[01:27:46.205] plan(): Setting new future strategy stack:
[01:27:46.206] List of future strategies:
[01:27:46.206] 1. sequential:
[01:27:46.206]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.206]    - tweaked: FALSE
[01:27:46.206]    - call: NULL
[01:27:46.206] plan(): nbrOfWorkers() = 1
[01:27:46.208] plan(): Setting new future strategy stack:
[01:27:46.208] List of future strategies:
[01:27:46.208] 1. sequential:
[01:27:46.208]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.208]    - tweaked: FALSE
[01:27:46.208]    - call: plan(strategy)
[01:27:46.209] plan(): nbrOfWorkers() = 1
[01:27:46.209] SequentialFuture started (and completed)
[01:27:46.209] - Launch lazy future ... done
[01:27:46.209] run() for 'SequentialFuture' ... done
[01:27:46.210] getGlobalsAndPackages() ...
[01:27:46.210] Searching for globals...
[01:27:46.211] - globals found: [1] '{'
[01:27:46.211] Searching for globals ... DONE
[01:27:46.212] Resolving globals: FALSE
[01:27:46.212] 
[01:27:46.212] 
[01:27:46.212] getGlobalsAndPackages() ... DONE
[01:27:46.213] run() for 'Future' ...
[01:27:46.213] - state: 'created'
[01:27:46.213] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.214] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.214] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.214]   - Field: 'label'
[01:27:46.214]   - Field: 'local'
[01:27:46.215]   - Field: 'owner'
[01:27:46.215]   - Field: 'envir'
[01:27:46.215]   - Field: 'packages'
[01:27:46.215]   - Field: 'gc'
[01:27:46.215]   - Field: 'conditions'
[01:27:46.219]   - Field: 'expr'
[01:27:46.219]   - Field: 'uuid'
[01:27:46.219]   - Field: 'seed'
[01:27:46.220]   - Field: 'version'
[01:27:46.220]   - Field: 'result'
[01:27:46.220]   - Field: 'asynchronous'
[01:27:46.220]   - Field: 'calls'
[01:27:46.220]   - Field: 'globals'
[01:27:46.221]   - Field: 'stdout'
[01:27:46.221]   - Field: 'earlySignal'
[01:27:46.221]   - Field: 'lazy'
[01:27:46.221]   - Field: 'state'
[01:27:46.222] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.222] - Launch lazy future ...
[01:27:46.222] Packages needed by the future expression (n = 0): <none>
[01:27:46.222] Packages needed by future strategies (n = 0): <none>
[01:27:46.223] {
[01:27:46.223]     {
[01:27:46.223]         {
[01:27:46.223]             ...future.startTime <- base::Sys.time()
[01:27:46.223]             {
[01:27:46.223]                 {
[01:27:46.223]                   {
[01:27:46.223]                     base::local({
[01:27:46.223]                       has_future <- base::requireNamespace("future", 
[01:27:46.223]                         quietly = TRUE)
[01:27:46.223]                       if (has_future) {
[01:27:46.223]                         ns <- base::getNamespace("future")
[01:27:46.223]                         version <- ns[[".package"]][["version"]]
[01:27:46.223]                         if (is.null(version)) 
[01:27:46.223]                           version <- utils::packageVersion("future")
[01:27:46.223]                       }
[01:27:46.223]                       else {
[01:27:46.223]                         version <- NULL
[01:27:46.223]                       }
[01:27:46.223]                       if (!has_future || version < "1.8.0") {
[01:27:46.223]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.223]                           "", base::R.version$version.string), 
[01:27:46.223]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.223]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.223]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.223]                             "release", "version")], collapse = " "), 
[01:27:46.223]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.223]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.223]                           info)
[01:27:46.223]                         info <- base::paste(info, collapse = "; ")
[01:27:46.223]                         if (!has_future) {
[01:27:46.223]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.223]                             info)
[01:27:46.223]                         }
[01:27:46.223]                         else {
[01:27:46.223]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.223]                             info, version)
[01:27:46.223]                         }
[01:27:46.223]                         base::stop(msg)
[01:27:46.223]                       }
[01:27:46.223]                     })
[01:27:46.223]                   }
[01:27:46.223]                   options(future.plan = NULL)
[01:27:46.223]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.223]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.223]                 }
[01:27:46.223]                 ...future.workdir <- getwd()
[01:27:46.223]             }
[01:27:46.223]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.223]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.223]         }
[01:27:46.223]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.223]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.223]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.223]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.223]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.223]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.223]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.223]             base::names(...future.oldOptions))
[01:27:46.223]     }
[01:27:46.223]     if (FALSE) {
[01:27:46.223]     }
[01:27:46.223]     else {
[01:27:46.223]         if (TRUE) {
[01:27:46.223]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.223]                 open = "w")
[01:27:46.223]         }
[01:27:46.223]         else {
[01:27:46.223]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.223]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.223]         }
[01:27:46.223]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.223]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.223]             base::sink(type = "output", split = FALSE)
[01:27:46.223]             base::close(...future.stdout)
[01:27:46.223]         }, add = TRUE)
[01:27:46.223]     }
[01:27:46.223]     ...future.frame <- base::sys.nframe()
[01:27:46.223]     ...future.conditions <- base::list()
[01:27:46.223]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.223]     if (FALSE) {
[01:27:46.223]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.223]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.223]     }
[01:27:46.223]     ...future.result <- base::tryCatch({
[01:27:46.223]         base::withCallingHandlers({
[01:27:46.223]             ...future.value <- base::withVisible(base::local({
[01:27:46.223]                 4
[01:27:46.223]             }))
[01:27:46.223]             future::FutureResult(value = ...future.value$value, 
[01:27:46.223]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.223]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.223]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.223]                     ...future.globalenv.names))
[01:27:46.223]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.223]         }, condition = base::local({
[01:27:46.223]             c <- base::c
[01:27:46.223]             inherits <- base::inherits
[01:27:46.223]             invokeRestart <- base::invokeRestart
[01:27:46.223]             length <- base::length
[01:27:46.223]             list <- base::list
[01:27:46.223]             seq.int <- base::seq.int
[01:27:46.223]             signalCondition <- base::signalCondition
[01:27:46.223]             sys.calls <- base::sys.calls
[01:27:46.223]             `[[` <- base::`[[`
[01:27:46.223]             `+` <- base::`+`
[01:27:46.223]             `<<-` <- base::`<<-`
[01:27:46.223]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.223]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.223]                   3L)]
[01:27:46.223]             }
[01:27:46.223]             function(cond) {
[01:27:46.223]                 is_error <- inherits(cond, "error")
[01:27:46.223]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.223]                   NULL)
[01:27:46.223]                 if (is_error) {
[01:27:46.223]                   sessionInformation <- function() {
[01:27:46.223]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.223]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.223]                       search = base::search(), system = base::Sys.info())
[01:27:46.223]                   }
[01:27:46.223]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.223]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.223]                     cond$call), session = sessionInformation(), 
[01:27:46.223]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.223]                   signalCondition(cond)
[01:27:46.223]                 }
[01:27:46.223]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.223]                 "immediateCondition"))) {
[01:27:46.223]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.223]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.223]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.223]                   if (TRUE && !signal) {
[01:27:46.223]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.223]                     {
[01:27:46.223]                       inherits <- base::inherits
[01:27:46.223]                       invokeRestart <- base::invokeRestart
[01:27:46.223]                       is.null <- base::is.null
[01:27:46.223]                       muffled <- FALSE
[01:27:46.223]                       if (inherits(cond, "message")) {
[01:27:46.223]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.223]                         if (muffled) 
[01:27:46.223]                           invokeRestart("muffleMessage")
[01:27:46.223]                       }
[01:27:46.223]                       else if (inherits(cond, "warning")) {
[01:27:46.223]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.223]                         if (muffled) 
[01:27:46.223]                           invokeRestart("muffleWarning")
[01:27:46.223]                       }
[01:27:46.223]                       else if (inherits(cond, "condition")) {
[01:27:46.223]                         if (!is.null(pattern)) {
[01:27:46.223]                           computeRestarts <- base::computeRestarts
[01:27:46.223]                           grepl <- base::grepl
[01:27:46.223]                           restarts <- computeRestarts(cond)
[01:27:46.223]                           for (restart in restarts) {
[01:27:46.223]                             name <- restart$name
[01:27:46.223]                             if (is.null(name)) 
[01:27:46.223]                               next
[01:27:46.223]                             if (!grepl(pattern, name)) 
[01:27:46.223]                               next
[01:27:46.223]                             invokeRestart(restart)
[01:27:46.223]                             muffled <- TRUE
[01:27:46.223]                             break
[01:27:46.223]                           }
[01:27:46.223]                         }
[01:27:46.223]                       }
[01:27:46.223]                       invisible(muffled)
[01:27:46.223]                     }
[01:27:46.223]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.223]                   }
[01:27:46.223]                 }
[01:27:46.223]                 else {
[01:27:46.223]                   if (TRUE) {
[01:27:46.223]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.223]                     {
[01:27:46.223]                       inherits <- base::inherits
[01:27:46.223]                       invokeRestart <- base::invokeRestart
[01:27:46.223]                       is.null <- base::is.null
[01:27:46.223]                       muffled <- FALSE
[01:27:46.223]                       if (inherits(cond, "message")) {
[01:27:46.223]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.223]                         if (muffled) 
[01:27:46.223]                           invokeRestart("muffleMessage")
[01:27:46.223]                       }
[01:27:46.223]                       else if (inherits(cond, "warning")) {
[01:27:46.223]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.223]                         if (muffled) 
[01:27:46.223]                           invokeRestart("muffleWarning")
[01:27:46.223]                       }
[01:27:46.223]                       else if (inherits(cond, "condition")) {
[01:27:46.223]                         if (!is.null(pattern)) {
[01:27:46.223]                           computeRestarts <- base::computeRestarts
[01:27:46.223]                           grepl <- base::grepl
[01:27:46.223]                           restarts <- computeRestarts(cond)
[01:27:46.223]                           for (restart in restarts) {
[01:27:46.223]                             name <- restart$name
[01:27:46.223]                             if (is.null(name)) 
[01:27:46.223]                               next
[01:27:46.223]                             if (!grepl(pattern, name)) 
[01:27:46.223]                               next
[01:27:46.223]                             invokeRestart(restart)
[01:27:46.223]                             muffled <- TRUE
[01:27:46.223]                             break
[01:27:46.223]                           }
[01:27:46.223]                         }
[01:27:46.223]                       }
[01:27:46.223]                       invisible(muffled)
[01:27:46.223]                     }
[01:27:46.223]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.223]                   }
[01:27:46.223]                 }
[01:27:46.223]             }
[01:27:46.223]         }))
[01:27:46.223]     }, error = function(ex) {
[01:27:46.223]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.223]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.223]                 ...future.rng), started = ...future.startTime, 
[01:27:46.223]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.223]             version = "1.8"), class = "FutureResult")
[01:27:46.223]     }, finally = {
[01:27:46.223]         if (!identical(...future.workdir, getwd())) 
[01:27:46.223]             setwd(...future.workdir)
[01:27:46.223]         {
[01:27:46.223]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.223]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.223]             }
[01:27:46.223]             base::options(...future.oldOptions)
[01:27:46.223]             if (.Platform$OS.type == "windows") {
[01:27:46.223]                 old_names <- names(...future.oldEnvVars)
[01:27:46.223]                 envs <- base::Sys.getenv()
[01:27:46.223]                 names <- names(envs)
[01:27:46.223]                 common <- intersect(names, old_names)
[01:27:46.223]                 added <- setdiff(names, old_names)
[01:27:46.223]                 removed <- setdiff(old_names, names)
[01:27:46.223]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.223]                   envs[common]]
[01:27:46.223]                 NAMES <- toupper(changed)
[01:27:46.223]                 args <- list()
[01:27:46.223]                 for (kk in seq_along(NAMES)) {
[01:27:46.223]                   name <- changed[[kk]]
[01:27:46.223]                   NAME <- NAMES[[kk]]
[01:27:46.223]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.223]                     next
[01:27:46.223]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.223]                 }
[01:27:46.223]                 NAMES <- toupper(added)
[01:27:46.223]                 for (kk in seq_along(NAMES)) {
[01:27:46.223]                   name <- added[[kk]]
[01:27:46.223]                   NAME <- NAMES[[kk]]
[01:27:46.223]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.223]                     next
[01:27:46.223]                   args[[name]] <- ""
[01:27:46.223]                 }
[01:27:46.223]                 NAMES <- toupper(removed)
[01:27:46.223]                 for (kk in seq_along(NAMES)) {
[01:27:46.223]                   name <- removed[[kk]]
[01:27:46.223]                   NAME <- NAMES[[kk]]
[01:27:46.223]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.223]                     next
[01:27:46.223]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.223]                 }
[01:27:46.223]                 if (length(args) > 0) 
[01:27:46.223]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.223]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.223]             }
[01:27:46.223]             else {
[01:27:46.223]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.223]             }
[01:27:46.223]             {
[01:27:46.223]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.223]                   0L) {
[01:27:46.223]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.223]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.223]                   base::options(opts)
[01:27:46.223]                 }
[01:27:46.223]                 {
[01:27:46.223]                   {
[01:27:46.223]                     NULL
[01:27:46.223]                     RNGkind("Mersenne-Twister")
[01:27:46.223]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.223]                       inherits = FALSE)
[01:27:46.223]                   }
[01:27:46.223]                   options(future.plan = NULL)
[01:27:46.223]                   if (is.na(NA_character_)) 
[01:27:46.223]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.223]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.223]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.223]                   {
[01:27:46.223]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.223]                     if (!future$lazy) 
[01:27:46.223]                       future <- run(future)
[01:27:46.223]                     invisible(future)
[01:27:46.223]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.223]                 }
[01:27:46.223]             }
[01:27:46.223]         }
[01:27:46.223]     })
[01:27:46.223]     if (TRUE) {
[01:27:46.223]         base::sink(type = "output", split = FALSE)
[01:27:46.223]         if (TRUE) {
[01:27:46.223]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.223]         }
[01:27:46.223]         else {
[01:27:46.223]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.223]         }
[01:27:46.223]         base::close(...future.stdout)
[01:27:46.223]         ...future.stdout <- NULL
[01:27:46.223]     }
[01:27:46.223]     ...future.result$conditions <- ...future.conditions
[01:27:46.223]     ...future.result$finished <- base::Sys.time()
[01:27:46.223]     ...future.result
[01:27:46.223] }
[01:27:46.227] plan(): Setting new future strategy stack:
[01:27:46.227] List of future strategies:
[01:27:46.227] 1. sequential:
[01:27:46.227]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.227]    - tweaked: FALSE
[01:27:46.227]    - call: NULL
[01:27:46.228] plan(): nbrOfWorkers() = 1
[01:27:46.229] plan(): Setting new future strategy stack:
[01:27:46.229] List of future strategies:
[01:27:46.229] 1. sequential:
[01:27:46.229]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.229]    - tweaked: FALSE
[01:27:46.229]    - call: plan(strategy)
[01:27:46.230] plan(): nbrOfWorkers() = 1
[01:27:46.230] SequentialFuture started (and completed)
[01:27:46.231] - Launch lazy future ... done
[01:27:46.231] run() for 'SequentialFuture' ... done
<environment: 0x0000025b04b2c148> 
<environment: 0x0000025b04aec810> 
[01:27:46.233] resolved() for 'SequentialFuture' ...
[01:27:46.233] - state: 'finished'
[01:27:46.233] - run: TRUE
[01:27:46.233] - result: 'FutureResult'
[01:27:46.233] resolved() for 'SequentialFuture' ... done
[01:27:46.234] resolved() for 'SequentialFuture' ...
[01:27:46.234] - state: 'finished'
[01:27:46.234] - run: TRUE
[01:27:46.234] - result: 'FutureResult'
[01:27:46.234] resolved() for 'SequentialFuture' ... done
[01:27:46.235] resolved() for 'SequentialFuture' ...
[01:27:46.235] - state: 'finished'
[01:27:46.235] - run: TRUE
[01:27:46.235] - result: 'FutureResult'
[01:27:46.235] resolved() for 'SequentialFuture' ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:46.237] resolve() on environment ...
[01:27:46.237]  recursive: 0
[01:27:46.238]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:46.238] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.238] - nx: 4
[01:27:46.239] - relay: TRUE
[01:27:46.239] - stdout: TRUE
[01:27:46.239] - signal: TRUE
[01:27:46.239] - resignal: FALSE
[01:27:46.239] - force: TRUE
[01:27:46.239] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.240] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.240]  - until=2
[01:27:46.240]  - relaying element #2
[01:27:46.240] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:46.240] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.240] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.241]  length: 3 (resolved future 1)
[01:27:46.241] resolved() for 'SequentialFuture' ...
[01:27:46.241] - state: 'finished'
[01:27:46.241] - run: TRUE
[01:27:46.241] - result: 'FutureResult'
[01:27:46.242] resolved() for 'SequentialFuture' ... done
[01:27:46.242] Future #2
[01:27:46.242] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.242] - nx: 4
[01:27:46.243] - relay: TRUE
[01:27:46.243] - stdout: TRUE
[01:27:46.243] - signal: TRUE
[01:27:46.243] - resignal: FALSE
[01:27:46.243] - force: TRUE
[01:27:46.243] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:46.243] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:46.244]  - until=2
[01:27:46.244]  - relaying element #2
[01:27:46.244] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:46.244] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:46.245] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.245]  length: 2 (resolved future 2)
[01:27:46.245] resolved() for 'SequentialFuture' ...
[01:27:46.245] - state: 'finished'
[01:27:46.245] - run: TRUE
[01:27:46.246] - result: 'FutureResult'
[01:27:46.246] resolved() for 'SequentialFuture' ... done
[01:27:46.246] Future #3
[01:27:46.246] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.246] - nx: 4
[01:27:46.246] - relay: TRUE
[01:27:46.247] - stdout: TRUE
[01:27:46.247] - signal: TRUE
[01:27:46.247] - resignal: FALSE
[01:27:46.247] - force: TRUE
[01:27:46.247] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:46.248] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:46.248]  - until=3
[01:27:46.248]  - relaying element #3
[01:27:46.248] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:46.248] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:46.249] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.249]  length: 1 (resolved future 3)
[01:27:46.249] resolved() for 'SequentialFuture' ...
[01:27:46.249] - state: 'finished'
[01:27:46.249] - run: TRUE
[01:27:46.250] - result: 'FutureResult'
[01:27:46.250] resolved() for 'SequentialFuture' ... done
[01:27:46.250] Future #4
[01:27:46.250] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.250] - nx: 4
[01:27:46.251] - relay: TRUE
[01:27:46.251] - stdout: TRUE
[01:27:46.251] - signal: TRUE
[01:27:46.251] - resignal: FALSE
[01:27:46.251] - force: TRUE
[01:27:46.251] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:46.252] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:46.252]  - until=4
[01:27:46.252]  - relaying element #4
[01:27:46.252] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.252] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:46.253] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.253]  length: 0 (resolved future 4)
[01:27:46.253] Relaying remaining futures
[01:27:46.253] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.253] - nx: 4
[01:27:46.253] - relay: TRUE
[01:27:46.254] - stdout: TRUE
[01:27:46.254] - signal: TRUE
[01:27:46.254] - resignal: FALSE
[01:27:46.254] - force: TRUE
[01:27:46.254] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.254] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:46.255] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:46.255] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:46.255] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.255] resolve() on environment ... DONE
<environment: 0x0000025b06e45990> 
*** futures() - environment ... DONE
Type of object: listenv
Type of future: sequential
[01:27:46.256] plan(): Setting new future strategy stack:
[01:27:46.256] List of future strategies:
[01:27:46.256] 1. sequential:
[01:27:46.256]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.256]    - tweaked: FALSE
[01:27:46.256]    - call: plan(strategy)
[01:27:46.257] plan(): nbrOfWorkers() = 1
Dimensions: NULL
[01:27:46.258] getGlobalsAndPackages() ...
[01:27:46.258] Searching for globals...
[01:27:46.258] 
[01:27:46.259] Searching for globals ... DONE
[01:27:46.259] - globals: [0] <none>
[01:27:46.259] getGlobalsAndPackages() ... DONE
[01:27:46.259] run() for 'Future' ...
[01:27:46.260] - state: 'created'
[01:27:46.260] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.262] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.262] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.263]   - Field: 'label'
[01:27:46.263]   - Field: 'local'
[01:27:46.263]   - Field: 'owner'
[01:27:46.263]   - Field: 'envir'
[01:27:46.263]   - Field: 'packages'
[01:27:46.264]   - Field: 'gc'
[01:27:46.264]   - Field: 'conditions'
[01:27:46.264]   - Field: 'expr'
[01:27:46.264]   - Field: 'uuid'
[01:27:46.264]   - Field: 'seed'
[01:27:46.265]   - Field: 'version'
[01:27:46.265]   - Field: 'result'
[01:27:46.265]   - Field: 'asynchronous'
[01:27:46.265]   - Field: 'calls'
[01:27:46.265]   - Field: 'globals'
[01:27:46.266]   - Field: 'stdout'
[01:27:46.266]   - Field: 'earlySignal'
[01:27:46.266]   - Field: 'lazy'
[01:27:46.266]   - Field: 'state'
[01:27:46.266] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.267] - Launch lazy future ...
[01:27:46.267] Packages needed by the future expression (n = 0): <none>
[01:27:46.267] Packages needed by future strategies (n = 0): <none>
[01:27:46.268] {
[01:27:46.268]     {
[01:27:46.268]         {
[01:27:46.268]             ...future.startTime <- base::Sys.time()
[01:27:46.268]             {
[01:27:46.268]                 {
[01:27:46.268]                   {
[01:27:46.268]                     base::local({
[01:27:46.268]                       has_future <- base::requireNamespace("future", 
[01:27:46.268]                         quietly = TRUE)
[01:27:46.268]                       if (has_future) {
[01:27:46.268]                         ns <- base::getNamespace("future")
[01:27:46.268]                         version <- ns[[".package"]][["version"]]
[01:27:46.268]                         if (is.null(version)) 
[01:27:46.268]                           version <- utils::packageVersion("future")
[01:27:46.268]                       }
[01:27:46.268]                       else {
[01:27:46.268]                         version <- NULL
[01:27:46.268]                       }
[01:27:46.268]                       if (!has_future || version < "1.8.0") {
[01:27:46.268]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.268]                           "", base::R.version$version.string), 
[01:27:46.268]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.268]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.268]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.268]                             "release", "version")], collapse = " "), 
[01:27:46.268]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.268]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.268]                           info)
[01:27:46.268]                         info <- base::paste(info, collapse = "; ")
[01:27:46.268]                         if (!has_future) {
[01:27:46.268]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.268]                             info)
[01:27:46.268]                         }
[01:27:46.268]                         else {
[01:27:46.268]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.268]                             info, version)
[01:27:46.268]                         }
[01:27:46.268]                         base::stop(msg)
[01:27:46.268]                       }
[01:27:46.268]                     })
[01:27:46.268]                   }
[01:27:46.268]                   options(future.plan = NULL)
[01:27:46.268]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.268]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.268]                 }
[01:27:46.268]                 ...future.workdir <- getwd()
[01:27:46.268]             }
[01:27:46.268]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.268]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.268]         }
[01:27:46.268]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.268]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.268]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.268]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.268]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.268]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.268]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.268]             base::names(...future.oldOptions))
[01:27:46.268]     }
[01:27:46.268]     if (FALSE) {
[01:27:46.268]     }
[01:27:46.268]     else {
[01:27:46.268]         if (TRUE) {
[01:27:46.268]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.268]                 open = "w")
[01:27:46.268]         }
[01:27:46.268]         else {
[01:27:46.268]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.268]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.268]         }
[01:27:46.268]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.268]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.268]             base::sink(type = "output", split = FALSE)
[01:27:46.268]             base::close(...future.stdout)
[01:27:46.268]         }, add = TRUE)
[01:27:46.268]     }
[01:27:46.268]     ...future.frame <- base::sys.nframe()
[01:27:46.268]     ...future.conditions <- base::list()
[01:27:46.268]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.268]     if (FALSE) {
[01:27:46.268]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.268]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.268]     }
[01:27:46.268]     ...future.result <- base::tryCatch({
[01:27:46.268]         base::withCallingHandlers({
[01:27:46.268]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.268]             future::FutureResult(value = ...future.value$value, 
[01:27:46.268]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.268]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.268]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.268]                     ...future.globalenv.names))
[01:27:46.268]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.268]         }, condition = base::local({
[01:27:46.268]             c <- base::c
[01:27:46.268]             inherits <- base::inherits
[01:27:46.268]             invokeRestart <- base::invokeRestart
[01:27:46.268]             length <- base::length
[01:27:46.268]             list <- base::list
[01:27:46.268]             seq.int <- base::seq.int
[01:27:46.268]             signalCondition <- base::signalCondition
[01:27:46.268]             sys.calls <- base::sys.calls
[01:27:46.268]             `[[` <- base::`[[`
[01:27:46.268]             `+` <- base::`+`
[01:27:46.268]             `<<-` <- base::`<<-`
[01:27:46.268]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.268]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.268]                   3L)]
[01:27:46.268]             }
[01:27:46.268]             function(cond) {
[01:27:46.268]                 is_error <- inherits(cond, "error")
[01:27:46.268]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.268]                   NULL)
[01:27:46.268]                 if (is_error) {
[01:27:46.268]                   sessionInformation <- function() {
[01:27:46.268]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.268]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.268]                       search = base::search(), system = base::Sys.info())
[01:27:46.268]                   }
[01:27:46.268]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.268]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.268]                     cond$call), session = sessionInformation(), 
[01:27:46.268]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.268]                   signalCondition(cond)
[01:27:46.268]                 }
[01:27:46.268]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.268]                 "immediateCondition"))) {
[01:27:46.268]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.268]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.268]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.268]                   if (TRUE && !signal) {
[01:27:46.268]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.268]                     {
[01:27:46.268]                       inherits <- base::inherits
[01:27:46.268]                       invokeRestart <- base::invokeRestart
[01:27:46.268]                       is.null <- base::is.null
[01:27:46.268]                       muffled <- FALSE
[01:27:46.268]                       if (inherits(cond, "message")) {
[01:27:46.268]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.268]                         if (muffled) 
[01:27:46.268]                           invokeRestart("muffleMessage")
[01:27:46.268]                       }
[01:27:46.268]                       else if (inherits(cond, "warning")) {
[01:27:46.268]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.268]                         if (muffled) 
[01:27:46.268]                           invokeRestart("muffleWarning")
[01:27:46.268]                       }
[01:27:46.268]                       else if (inherits(cond, "condition")) {
[01:27:46.268]                         if (!is.null(pattern)) {
[01:27:46.268]                           computeRestarts <- base::computeRestarts
[01:27:46.268]                           grepl <- base::grepl
[01:27:46.268]                           restarts <- computeRestarts(cond)
[01:27:46.268]                           for (restart in restarts) {
[01:27:46.268]                             name <- restart$name
[01:27:46.268]                             if (is.null(name)) 
[01:27:46.268]                               next
[01:27:46.268]                             if (!grepl(pattern, name)) 
[01:27:46.268]                               next
[01:27:46.268]                             invokeRestart(restart)
[01:27:46.268]                             muffled <- TRUE
[01:27:46.268]                             break
[01:27:46.268]                           }
[01:27:46.268]                         }
[01:27:46.268]                       }
[01:27:46.268]                       invisible(muffled)
[01:27:46.268]                     }
[01:27:46.268]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.268]                   }
[01:27:46.268]                 }
[01:27:46.268]                 else {
[01:27:46.268]                   if (TRUE) {
[01:27:46.268]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.268]                     {
[01:27:46.268]                       inherits <- base::inherits
[01:27:46.268]                       invokeRestart <- base::invokeRestart
[01:27:46.268]                       is.null <- base::is.null
[01:27:46.268]                       muffled <- FALSE
[01:27:46.268]                       if (inherits(cond, "message")) {
[01:27:46.268]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.268]                         if (muffled) 
[01:27:46.268]                           invokeRestart("muffleMessage")
[01:27:46.268]                       }
[01:27:46.268]                       else if (inherits(cond, "warning")) {
[01:27:46.268]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.268]                         if (muffled) 
[01:27:46.268]                           invokeRestart("muffleWarning")
[01:27:46.268]                       }
[01:27:46.268]                       else if (inherits(cond, "condition")) {
[01:27:46.268]                         if (!is.null(pattern)) {
[01:27:46.268]                           computeRestarts <- base::computeRestarts
[01:27:46.268]                           grepl <- base::grepl
[01:27:46.268]                           restarts <- computeRestarts(cond)
[01:27:46.268]                           for (restart in restarts) {
[01:27:46.268]                             name <- restart$name
[01:27:46.268]                             if (is.null(name)) 
[01:27:46.268]                               next
[01:27:46.268]                             if (!grepl(pattern, name)) 
[01:27:46.268]                               next
[01:27:46.268]                             invokeRestart(restart)
[01:27:46.268]                             muffled <- TRUE
[01:27:46.268]                             break
[01:27:46.268]                           }
[01:27:46.268]                         }
[01:27:46.268]                       }
[01:27:46.268]                       invisible(muffled)
[01:27:46.268]                     }
[01:27:46.268]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.268]                   }
[01:27:46.268]                 }
[01:27:46.268]             }
[01:27:46.268]         }))
[01:27:46.268]     }, error = function(ex) {
[01:27:46.268]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.268]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.268]                 ...future.rng), started = ...future.startTime, 
[01:27:46.268]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.268]             version = "1.8"), class = "FutureResult")
[01:27:46.268]     }, finally = {
[01:27:46.268]         if (!identical(...future.workdir, getwd())) 
[01:27:46.268]             setwd(...future.workdir)
[01:27:46.268]         {
[01:27:46.268]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.268]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.268]             }
[01:27:46.268]             base::options(...future.oldOptions)
[01:27:46.268]             if (.Platform$OS.type == "windows") {
[01:27:46.268]                 old_names <- names(...future.oldEnvVars)
[01:27:46.268]                 envs <- base::Sys.getenv()
[01:27:46.268]                 names <- names(envs)
[01:27:46.268]                 common <- intersect(names, old_names)
[01:27:46.268]                 added <- setdiff(names, old_names)
[01:27:46.268]                 removed <- setdiff(old_names, names)
[01:27:46.268]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.268]                   envs[common]]
[01:27:46.268]                 NAMES <- toupper(changed)
[01:27:46.268]                 args <- list()
[01:27:46.268]                 for (kk in seq_along(NAMES)) {
[01:27:46.268]                   name <- changed[[kk]]
[01:27:46.268]                   NAME <- NAMES[[kk]]
[01:27:46.268]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.268]                     next
[01:27:46.268]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.268]                 }
[01:27:46.268]                 NAMES <- toupper(added)
[01:27:46.268]                 for (kk in seq_along(NAMES)) {
[01:27:46.268]                   name <- added[[kk]]
[01:27:46.268]                   NAME <- NAMES[[kk]]
[01:27:46.268]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.268]                     next
[01:27:46.268]                   args[[name]] <- ""
[01:27:46.268]                 }
[01:27:46.268]                 NAMES <- toupper(removed)
[01:27:46.268]                 for (kk in seq_along(NAMES)) {
[01:27:46.268]                   name <- removed[[kk]]
[01:27:46.268]                   NAME <- NAMES[[kk]]
[01:27:46.268]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.268]                     next
[01:27:46.268]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.268]                 }
[01:27:46.268]                 if (length(args) > 0) 
[01:27:46.268]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.268]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.268]             }
[01:27:46.268]             else {
[01:27:46.268]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.268]             }
[01:27:46.268]             {
[01:27:46.268]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.268]                   0L) {
[01:27:46.268]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.268]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.268]                   base::options(opts)
[01:27:46.268]                 }
[01:27:46.268]                 {
[01:27:46.268]                   {
[01:27:46.268]                     NULL
[01:27:46.268]                     RNGkind("Mersenne-Twister")
[01:27:46.268]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.268]                       inherits = FALSE)
[01:27:46.268]                   }
[01:27:46.268]                   options(future.plan = NULL)
[01:27:46.268]                   if (is.na(NA_character_)) 
[01:27:46.268]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.268]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.268]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.268]                   {
[01:27:46.268]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.268]                     if (!future$lazy) 
[01:27:46.268]                       future <- run(future)
[01:27:46.268]                     invisible(future)
[01:27:46.268]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.268]                 }
[01:27:46.268]             }
[01:27:46.268]         }
[01:27:46.268]     })
[01:27:46.268]     if (TRUE) {
[01:27:46.268]         base::sink(type = "output", split = FALSE)
[01:27:46.268]         if (TRUE) {
[01:27:46.268]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.268]         }
[01:27:46.268]         else {
[01:27:46.268]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.268]         }
[01:27:46.268]         base::close(...future.stdout)
[01:27:46.268]         ...future.stdout <- NULL
[01:27:46.268]     }
[01:27:46.268]     ...future.result$conditions <- ...future.conditions
[01:27:46.268]     ...future.result$finished <- base::Sys.time()
[01:27:46.268]     ...future.result
[01:27:46.268] }
[01:27:46.272] plan(): Setting new future strategy stack:
[01:27:46.272] List of future strategies:
[01:27:46.272] 1. sequential:
[01:27:46.272]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.272]    - tweaked: FALSE
[01:27:46.272]    - call: NULL
[01:27:46.273] plan(): nbrOfWorkers() = 1
[01:27:46.274] plan(): Setting new future strategy stack:
[01:27:46.275] List of future strategies:
[01:27:46.275] 1. sequential:
[01:27:46.275]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.275]    - tweaked: FALSE
[01:27:46.275]    - call: plan(strategy)
[01:27:46.276] plan(): nbrOfWorkers() = 1
[01:27:46.276] SequentialFuture started (and completed)
[01:27:46.277] - Launch lazy future ... done
[01:27:46.277] run() for 'SequentialFuture' ... done
[01:27:46.278] getGlobalsAndPackages() ...
[01:27:46.278] Searching for globals...
[01:27:46.279] 
[01:27:46.279] Searching for globals ... DONE
[01:27:46.279] - globals: [0] <none>
[01:27:46.280] getGlobalsAndPackages() ... DONE
[01:27:46.280] run() for 'Future' ...
[01:27:46.281] - state: 'created'
[01:27:46.281] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.282] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.282] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.283]   - Field: 'label'
[01:27:46.283]   - Field: 'local'
[01:27:46.283]   - Field: 'owner'
[01:27:46.284]   - Field: 'envir'
[01:27:46.284]   - Field: 'packages'
[01:27:46.284]   - Field: 'gc'
[01:27:46.285]   - Field: 'conditions'
[01:27:46.285]   - Field: 'expr'
[01:27:46.286]   - Field: 'uuid'
[01:27:46.286]   - Field: 'seed'
[01:27:46.286]   - Field: 'version'
[01:27:46.287]   - Field: 'result'
[01:27:46.287]   - Field: 'asynchronous'
[01:27:46.287]   - Field: 'calls'
[01:27:46.288]   - Field: 'globals'
[01:27:46.288]   - Field: 'stdout'
[01:27:46.288]   - Field: 'earlySignal'
[01:27:46.289]   - Field: 'lazy'
[01:27:46.289]   - Field: 'state'
[01:27:46.289] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.290] - Launch lazy future ...
[01:27:46.290] Packages needed by the future expression (n = 0): <none>
[01:27:46.291] Packages needed by future strategies (n = 0): <none>
[01:27:46.292] {
[01:27:46.292]     {
[01:27:46.292]         {
[01:27:46.292]             ...future.startTime <- base::Sys.time()
[01:27:46.292]             {
[01:27:46.292]                 {
[01:27:46.292]                   {
[01:27:46.292]                     base::local({
[01:27:46.292]                       has_future <- base::requireNamespace("future", 
[01:27:46.292]                         quietly = TRUE)
[01:27:46.292]                       if (has_future) {
[01:27:46.292]                         ns <- base::getNamespace("future")
[01:27:46.292]                         version <- ns[[".package"]][["version"]]
[01:27:46.292]                         if (is.null(version)) 
[01:27:46.292]                           version <- utils::packageVersion("future")
[01:27:46.292]                       }
[01:27:46.292]                       else {
[01:27:46.292]                         version <- NULL
[01:27:46.292]                       }
[01:27:46.292]                       if (!has_future || version < "1.8.0") {
[01:27:46.292]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.292]                           "", base::R.version$version.string), 
[01:27:46.292]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.292]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.292]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.292]                             "release", "version")], collapse = " "), 
[01:27:46.292]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.292]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.292]                           info)
[01:27:46.292]                         info <- base::paste(info, collapse = "; ")
[01:27:46.292]                         if (!has_future) {
[01:27:46.292]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.292]                             info)
[01:27:46.292]                         }
[01:27:46.292]                         else {
[01:27:46.292]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.292]                             info, version)
[01:27:46.292]                         }
[01:27:46.292]                         base::stop(msg)
[01:27:46.292]                       }
[01:27:46.292]                     })
[01:27:46.292]                   }
[01:27:46.292]                   options(future.plan = NULL)
[01:27:46.292]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.292]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.292]                 }
[01:27:46.292]                 ...future.workdir <- getwd()
[01:27:46.292]             }
[01:27:46.292]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.292]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.292]         }
[01:27:46.292]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.292]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.292]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.292]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.292]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.292]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.292]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.292]             base::names(...future.oldOptions))
[01:27:46.292]     }
[01:27:46.292]     if (FALSE) {
[01:27:46.292]     }
[01:27:46.292]     else {
[01:27:46.292]         if (TRUE) {
[01:27:46.292]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.292]                 open = "w")
[01:27:46.292]         }
[01:27:46.292]         else {
[01:27:46.292]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.292]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.292]         }
[01:27:46.292]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.292]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.292]             base::sink(type = "output", split = FALSE)
[01:27:46.292]             base::close(...future.stdout)
[01:27:46.292]         }, add = TRUE)
[01:27:46.292]     }
[01:27:46.292]     ...future.frame <- base::sys.nframe()
[01:27:46.292]     ...future.conditions <- base::list()
[01:27:46.292]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.292]     if (FALSE) {
[01:27:46.292]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.292]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.292]     }
[01:27:46.292]     ...future.result <- base::tryCatch({
[01:27:46.292]         base::withCallingHandlers({
[01:27:46.292]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.292]             future::FutureResult(value = ...future.value$value, 
[01:27:46.292]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.292]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.292]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.292]                     ...future.globalenv.names))
[01:27:46.292]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.292]         }, condition = base::local({
[01:27:46.292]             c <- base::c
[01:27:46.292]             inherits <- base::inherits
[01:27:46.292]             invokeRestart <- base::invokeRestart
[01:27:46.292]             length <- base::length
[01:27:46.292]             list <- base::list
[01:27:46.292]             seq.int <- base::seq.int
[01:27:46.292]             signalCondition <- base::signalCondition
[01:27:46.292]             sys.calls <- base::sys.calls
[01:27:46.292]             `[[` <- base::`[[`
[01:27:46.292]             `+` <- base::`+`
[01:27:46.292]             `<<-` <- base::`<<-`
[01:27:46.292]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.292]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.292]                   3L)]
[01:27:46.292]             }
[01:27:46.292]             function(cond) {
[01:27:46.292]                 is_error <- inherits(cond, "error")
[01:27:46.292]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.292]                   NULL)
[01:27:46.292]                 if (is_error) {
[01:27:46.292]                   sessionInformation <- function() {
[01:27:46.292]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.292]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.292]                       search = base::search(), system = base::Sys.info())
[01:27:46.292]                   }
[01:27:46.292]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.292]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.292]                     cond$call), session = sessionInformation(), 
[01:27:46.292]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.292]                   signalCondition(cond)
[01:27:46.292]                 }
[01:27:46.292]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.292]                 "immediateCondition"))) {
[01:27:46.292]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.292]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.292]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.292]                   if (TRUE && !signal) {
[01:27:46.292]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.292]                     {
[01:27:46.292]                       inherits <- base::inherits
[01:27:46.292]                       invokeRestart <- base::invokeRestart
[01:27:46.292]                       is.null <- base::is.null
[01:27:46.292]                       muffled <- FALSE
[01:27:46.292]                       if (inherits(cond, "message")) {
[01:27:46.292]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.292]                         if (muffled) 
[01:27:46.292]                           invokeRestart("muffleMessage")
[01:27:46.292]                       }
[01:27:46.292]                       else if (inherits(cond, "warning")) {
[01:27:46.292]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.292]                         if (muffled) 
[01:27:46.292]                           invokeRestart("muffleWarning")
[01:27:46.292]                       }
[01:27:46.292]                       else if (inherits(cond, "condition")) {
[01:27:46.292]                         if (!is.null(pattern)) {
[01:27:46.292]                           computeRestarts <- base::computeRestarts
[01:27:46.292]                           grepl <- base::grepl
[01:27:46.292]                           restarts <- computeRestarts(cond)
[01:27:46.292]                           for (restart in restarts) {
[01:27:46.292]                             name <- restart$name
[01:27:46.292]                             if (is.null(name)) 
[01:27:46.292]                               next
[01:27:46.292]                             if (!grepl(pattern, name)) 
[01:27:46.292]                               next
[01:27:46.292]                             invokeRestart(restart)
[01:27:46.292]                             muffled <- TRUE
[01:27:46.292]                             break
[01:27:46.292]                           }
[01:27:46.292]                         }
[01:27:46.292]                       }
[01:27:46.292]                       invisible(muffled)
[01:27:46.292]                     }
[01:27:46.292]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.292]                   }
[01:27:46.292]                 }
[01:27:46.292]                 else {
[01:27:46.292]                   if (TRUE) {
[01:27:46.292]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.292]                     {
[01:27:46.292]                       inherits <- base::inherits
[01:27:46.292]                       invokeRestart <- base::invokeRestart
[01:27:46.292]                       is.null <- base::is.null
[01:27:46.292]                       muffled <- FALSE
[01:27:46.292]                       if (inherits(cond, "message")) {
[01:27:46.292]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.292]                         if (muffled) 
[01:27:46.292]                           invokeRestart("muffleMessage")
[01:27:46.292]                       }
[01:27:46.292]                       else if (inherits(cond, "warning")) {
[01:27:46.292]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.292]                         if (muffled) 
[01:27:46.292]                           invokeRestart("muffleWarning")
[01:27:46.292]                       }
[01:27:46.292]                       else if (inherits(cond, "condition")) {
[01:27:46.292]                         if (!is.null(pattern)) {
[01:27:46.292]                           computeRestarts <- base::computeRestarts
[01:27:46.292]                           grepl <- base::grepl
[01:27:46.292]                           restarts <- computeRestarts(cond)
[01:27:46.292]                           for (restart in restarts) {
[01:27:46.292]                             name <- restart$name
[01:27:46.292]                             if (is.null(name)) 
[01:27:46.292]                               next
[01:27:46.292]                             if (!grepl(pattern, name)) 
[01:27:46.292]                               next
[01:27:46.292]                             invokeRestart(restart)
[01:27:46.292]                             muffled <- TRUE
[01:27:46.292]                             break
[01:27:46.292]                           }
[01:27:46.292]                         }
[01:27:46.292]                       }
[01:27:46.292]                       invisible(muffled)
[01:27:46.292]                     }
[01:27:46.292]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.292]                   }
[01:27:46.292]                 }
[01:27:46.292]             }
[01:27:46.292]         }))
[01:27:46.292]     }, error = function(ex) {
[01:27:46.292]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.292]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.292]                 ...future.rng), started = ...future.startTime, 
[01:27:46.292]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.292]             version = "1.8"), class = "FutureResult")
[01:27:46.292]     }, finally = {
[01:27:46.292]         if (!identical(...future.workdir, getwd())) 
[01:27:46.292]             setwd(...future.workdir)
[01:27:46.292]         {
[01:27:46.292]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.292]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.292]             }
[01:27:46.292]             base::options(...future.oldOptions)
[01:27:46.292]             if (.Platform$OS.type == "windows") {
[01:27:46.292]                 old_names <- names(...future.oldEnvVars)
[01:27:46.292]                 envs <- base::Sys.getenv()
[01:27:46.292]                 names <- names(envs)
[01:27:46.292]                 common <- intersect(names, old_names)
[01:27:46.292]                 added <- setdiff(names, old_names)
[01:27:46.292]                 removed <- setdiff(old_names, names)
[01:27:46.292]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.292]                   envs[common]]
[01:27:46.292]                 NAMES <- toupper(changed)
[01:27:46.292]                 args <- list()
[01:27:46.292]                 for (kk in seq_along(NAMES)) {
[01:27:46.292]                   name <- changed[[kk]]
[01:27:46.292]                   NAME <- NAMES[[kk]]
[01:27:46.292]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.292]                     next
[01:27:46.292]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.292]                 }
[01:27:46.292]                 NAMES <- toupper(added)
[01:27:46.292]                 for (kk in seq_along(NAMES)) {
[01:27:46.292]                   name <- added[[kk]]
[01:27:46.292]                   NAME <- NAMES[[kk]]
[01:27:46.292]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.292]                     next
[01:27:46.292]                   args[[name]] <- ""
[01:27:46.292]                 }
[01:27:46.292]                 NAMES <- toupper(removed)
[01:27:46.292]                 for (kk in seq_along(NAMES)) {
[01:27:46.292]                   name <- removed[[kk]]
[01:27:46.292]                   NAME <- NAMES[[kk]]
[01:27:46.292]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.292]                     next
[01:27:46.292]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.292]                 }
[01:27:46.292]                 if (length(args) > 0) 
[01:27:46.292]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.292]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.292]             }
[01:27:46.292]             else {
[01:27:46.292]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.292]             }
[01:27:46.292]             {
[01:27:46.292]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.292]                   0L) {
[01:27:46.292]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.292]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.292]                   base::options(opts)
[01:27:46.292]                 }
[01:27:46.292]                 {
[01:27:46.292]                   {
[01:27:46.292]                     NULL
[01:27:46.292]                     RNGkind("Mersenne-Twister")
[01:27:46.292]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.292]                       inherits = FALSE)
[01:27:46.292]                   }
[01:27:46.292]                   options(future.plan = NULL)
[01:27:46.292]                   if (is.na(NA_character_)) 
[01:27:46.292]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.292]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.292]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.292]                   {
[01:27:46.292]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.292]                     if (!future$lazy) 
[01:27:46.292]                       future <- run(future)
[01:27:46.292]                     invisible(future)
[01:27:46.292]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.292]                 }
[01:27:46.292]             }
[01:27:46.292]         }
[01:27:46.292]     })
[01:27:46.292]     if (TRUE) {
[01:27:46.292]         base::sink(type = "output", split = FALSE)
[01:27:46.292]         if (TRUE) {
[01:27:46.292]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.292]         }
[01:27:46.292]         else {
[01:27:46.292]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.292]         }
[01:27:46.292]         base::close(...future.stdout)
[01:27:46.292]         ...future.stdout <- NULL
[01:27:46.292]     }
[01:27:46.292]     ...future.result$conditions <- ...future.conditions
[01:27:46.292]     ...future.result$finished <- base::Sys.time()
[01:27:46.292]     ...future.result
[01:27:46.292] }
[01:27:46.299] plan(): Setting new future strategy stack:
[01:27:46.299] List of future strategies:
[01:27:46.299] 1. sequential:
[01:27:46.299]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.299]    - tweaked: FALSE
[01:27:46.299]    - call: NULL
[01:27:46.300] plan(): nbrOfWorkers() = 1
[01:27:46.303] plan(): Setting new future strategy stack:
[01:27:46.303] List of future strategies:
[01:27:46.303] 1. sequential:
[01:27:46.303]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.303]    - tweaked: FALSE
[01:27:46.303]    - call: plan(strategy)
[01:27:46.304] plan(): nbrOfWorkers() = 1
[01:27:46.305] SequentialFuture started (and completed)
[01:27:46.305] - Launch lazy future ... done
[01:27:46.305] run() for 'SequentialFuture' ... done
[01:27:46.306] getGlobalsAndPackages() ...
[01:27:46.306] Searching for globals...
[01:27:46.307] - globals found: [1] '{'
[01:27:46.308] Searching for globals ... DONE
[01:27:46.308] Resolving globals: FALSE
[01:27:46.308] 
[01:27:46.308] 
[01:27:46.309] getGlobalsAndPackages() ... DONE
[01:27:46.309] run() for 'Future' ...
[01:27:46.309] - state: 'created'
[01:27:46.309] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.310] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.310] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.310]   - Field: 'label'
[01:27:46.310]   - Field: 'local'
[01:27:46.311]   - Field: 'owner'
[01:27:46.311]   - Field: 'envir'
[01:27:46.311]   - Field: 'packages'
[01:27:46.311]   - Field: 'gc'
[01:27:46.311]   - Field: 'conditions'
[01:27:46.312]   - Field: 'expr'
[01:27:46.312]   - Field: 'uuid'
[01:27:46.312]   - Field: 'seed'
[01:27:46.312]   - Field: 'version'
[01:27:46.312]   - Field: 'result'
[01:27:46.313]   - Field: 'asynchronous'
[01:27:46.313]   - Field: 'calls'
[01:27:46.313]   - Field: 'globals'
[01:27:46.313]   - Field: 'stdout'
[01:27:46.313]   - Field: 'earlySignal'
[01:27:46.314]   - Field: 'lazy'
[01:27:46.314]   - Field: 'state'
[01:27:46.314] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.314] - Launch lazy future ...
[01:27:46.314] Packages needed by the future expression (n = 0): <none>
[01:27:46.315] Packages needed by future strategies (n = 0): <none>
[01:27:46.315] {
[01:27:46.315]     {
[01:27:46.315]         {
[01:27:46.315]             ...future.startTime <- base::Sys.time()
[01:27:46.315]             {
[01:27:46.315]                 {
[01:27:46.315]                   {
[01:27:46.315]                     base::local({
[01:27:46.315]                       has_future <- base::requireNamespace("future", 
[01:27:46.315]                         quietly = TRUE)
[01:27:46.315]                       if (has_future) {
[01:27:46.315]                         ns <- base::getNamespace("future")
[01:27:46.315]                         version <- ns[[".package"]][["version"]]
[01:27:46.315]                         if (is.null(version)) 
[01:27:46.315]                           version <- utils::packageVersion("future")
[01:27:46.315]                       }
[01:27:46.315]                       else {
[01:27:46.315]                         version <- NULL
[01:27:46.315]                       }
[01:27:46.315]                       if (!has_future || version < "1.8.0") {
[01:27:46.315]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.315]                           "", base::R.version$version.string), 
[01:27:46.315]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.315]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.315]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.315]                             "release", "version")], collapse = " "), 
[01:27:46.315]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.315]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.315]                           info)
[01:27:46.315]                         info <- base::paste(info, collapse = "; ")
[01:27:46.315]                         if (!has_future) {
[01:27:46.315]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.315]                             info)
[01:27:46.315]                         }
[01:27:46.315]                         else {
[01:27:46.315]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.315]                             info, version)
[01:27:46.315]                         }
[01:27:46.315]                         base::stop(msg)
[01:27:46.315]                       }
[01:27:46.315]                     })
[01:27:46.315]                   }
[01:27:46.315]                   options(future.plan = NULL)
[01:27:46.315]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.315]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.315]                 }
[01:27:46.315]                 ...future.workdir <- getwd()
[01:27:46.315]             }
[01:27:46.315]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.315]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.315]         }
[01:27:46.315]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.315]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.315]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.315]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.315]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.315]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.315]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.315]             base::names(...future.oldOptions))
[01:27:46.315]     }
[01:27:46.315]     if (FALSE) {
[01:27:46.315]     }
[01:27:46.315]     else {
[01:27:46.315]         if (TRUE) {
[01:27:46.315]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.315]                 open = "w")
[01:27:46.315]         }
[01:27:46.315]         else {
[01:27:46.315]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.315]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.315]         }
[01:27:46.315]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.315]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.315]             base::sink(type = "output", split = FALSE)
[01:27:46.315]             base::close(...future.stdout)
[01:27:46.315]         }, add = TRUE)
[01:27:46.315]     }
[01:27:46.315]     ...future.frame <- base::sys.nframe()
[01:27:46.315]     ...future.conditions <- base::list()
[01:27:46.315]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.315]     if (FALSE) {
[01:27:46.315]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.315]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.315]     }
[01:27:46.315]     ...future.result <- base::tryCatch({
[01:27:46.315]         base::withCallingHandlers({
[01:27:46.315]             ...future.value <- base::withVisible(base::local({
[01:27:46.315]                 4
[01:27:46.315]             }))
[01:27:46.315]             future::FutureResult(value = ...future.value$value, 
[01:27:46.315]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.315]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.315]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.315]                     ...future.globalenv.names))
[01:27:46.315]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.315]         }, condition = base::local({
[01:27:46.315]             c <- base::c
[01:27:46.315]             inherits <- base::inherits
[01:27:46.315]             invokeRestart <- base::invokeRestart
[01:27:46.315]             length <- base::length
[01:27:46.315]             list <- base::list
[01:27:46.315]             seq.int <- base::seq.int
[01:27:46.315]             signalCondition <- base::signalCondition
[01:27:46.315]             sys.calls <- base::sys.calls
[01:27:46.315]             `[[` <- base::`[[`
[01:27:46.315]             `+` <- base::`+`
[01:27:46.315]             `<<-` <- base::`<<-`
[01:27:46.315]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.315]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.315]                   3L)]
[01:27:46.315]             }
[01:27:46.315]             function(cond) {
[01:27:46.315]                 is_error <- inherits(cond, "error")
[01:27:46.315]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.315]                   NULL)
[01:27:46.315]                 if (is_error) {
[01:27:46.315]                   sessionInformation <- function() {
[01:27:46.315]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.315]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.315]                       search = base::search(), system = base::Sys.info())
[01:27:46.315]                   }
[01:27:46.315]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.315]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.315]                     cond$call), session = sessionInformation(), 
[01:27:46.315]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.315]                   signalCondition(cond)
[01:27:46.315]                 }
[01:27:46.315]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.315]                 "immediateCondition"))) {
[01:27:46.315]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.315]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.315]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.315]                   if (TRUE && !signal) {
[01:27:46.315]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.315]                     {
[01:27:46.315]                       inherits <- base::inherits
[01:27:46.315]                       invokeRestart <- base::invokeRestart
[01:27:46.315]                       is.null <- base::is.null
[01:27:46.315]                       muffled <- FALSE
[01:27:46.315]                       if (inherits(cond, "message")) {
[01:27:46.315]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.315]                         if (muffled) 
[01:27:46.315]                           invokeRestart("muffleMessage")
[01:27:46.315]                       }
[01:27:46.315]                       else if (inherits(cond, "warning")) {
[01:27:46.315]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.315]                         if (muffled) 
[01:27:46.315]                           invokeRestart("muffleWarning")
[01:27:46.315]                       }
[01:27:46.315]                       else if (inherits(cond, "condition")) {
[01:27:46.315]                         if (!is.null(pattern)) {
[01:27:46.315]                           computeRestarts <- base::computeRestarts
[01:27:46.315]                           grepl <- base::grepl
[01:27:46.315]                           restarts <- computeRestarts(cond)
[01:27:46.315]                           for (restart in restarts) {
[01:27:46.315]                             name <- restart$name
[01:27:46.315]                             if (is.null(name)) 
[01:27:46.315]                               next
[01:27:46.315]                             if (!grepl(pattern, name)) 
[01:27:46.315]                               next
[01:27:46.315]                             invokeRestart(restart)
[01:27:46.315]                             muffled <- TRUE
[01:27:46.315]                             break
[01:27:46.315]                           }
[01:27:46.315]                         }
[01:27:46.315]                       }
[01:27:46.315]                       invisible(muffled)
[01:27:46.315]                     }
[01:27:46.315]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.315]                   }
[01:27:46.315]                 }
[01:27:46.315]                 else {
[01:27:46.315]                   if (TRUE) {
[01:27:46.315]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.315]                     {
[01:27:46.315]                       inherits <- base::inherits
[01:27:46.315]                       invokeRestart <- base::invokeRestart
[01:27:46.315]                       is.null <- base::is.null
[01:27:46.315]                       muffled <- FALSE
[01:27:46.315]                       if (inherits(cond, "message")) {
[01:27:46.315]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.315]                         if (muffled) 
[01:27:46.315]                           invokeRestart("muffleMessage")
[01:27:46.315]                       }
[01:27:46.315]                       else if (inherits(cond, "warning")) {
[01:27:46.315]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.315]                         if (muffled) 
[01:27:46.315]                           invokeRestart("muffleWarning")
[01:27:46.315]                       }
[01:27:46.315]                       else if (inherits(cond, "condition")) {
[01:27:46.315]                         if (!is.null(pattern)) {
[01:27:46.315]                           computeRestarts <- base::computeRestarts
[01:27:46.315]                           grepl <- base::grepl
[01:27:46.315]                           restarts <- computeRestarts(cond)
[01:27:46.315]                           for (restart in restarts) {
[01:27:46.315]                             name <- restart$name
[01:27:46.315]                             if (is.null(name)) 
[01:27:46.315]                               next
[01:27:46.315]                             if (!grepl(pattern, name)) 
[01:27:46.315]                               next
[01:27:46.315]                             invokeRestart(restart)
[01:27:46.315]                             muffled <- TRUE
[01:27:46.315]                             break
[01:27:46.315]                           }
[01:27:46.315]                         }
[01:27:46.315]                       }
[01:27:46.315]                       invisible(muffled)
[01:27:46.315]                     }
[01:27:46.315]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.315]                   }
[01:27:46.315]                 }
[01:27:46.315]             }
[01:27:46.315]         }))
[01:27:46.315]     }, error = function(ex) {
[01:27:46.315]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.315]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.315]                 ...future.rng), started = ...future.startTime, 
[01:27:46.315]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.315]             version = "1.8"), class = "FutureResult")
[01:27:46.315]     }, finally = {
[01:27:46.315]         if (!identical(...future.workdir, getwd())) 
[01:27:46.315]             setwd(...future.workdir)
[01:27:46.315]         {
[01:27:46.315]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.315]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.315]             }
[01:27:46.315]             base::options(...future.oldOptions)
[01:27:46.315]             if (.Platform$OS.type == "windows") {
[01:27:46.315]                 old_names <- names(...future.oldEnvVars)
[01:27:46.315]                 envs <- base::Sys.getenv()
[01:27:46.315]                 names <- names(envs)
[01:27:46.315]                 common <- intersect(names, old_names)
[01:27:46.315]                 added <- setdiff(names, old_names)
[01:27:46.315]                 removed <- setdiff(old_names, names)
[01:27:46.315]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.315]                   envs[common]]
[01:27:46.315]                 NAMES <- toupper(changed)
[01:27:46.315]                 args <- list()
[01:27:46.315]                 for (kk in seq_along(NAMES)) {
[01:27:46.315]                   name <- changed[[kk]]
[01:27:46.315]                   NAME <- NAMES[[kk]]
[01:27:46.315]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.315]                     next
[01:27:46.315]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.315]                 }
[01:27:46.315]                 NAMES <- toupper(added)
[01:27:46.315]                 for (kk in seq_along(NAMES)) {
[01:27:46.315]                   name <- added[[kk]]
[01:27:46.315]                   NAME <- NAMES[[kk]]
[01:27:46.315]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.315]                     next
[01:27:46.315]                   args[[name]] <- ""
[01:27:46.315]                 }
[01:27:46.315]                 NAMES <- toupper(removed)
[01:27:46.315]                 for (kk in seq_along(NAMES)) {
[01:27:46.315]                   name <- removed[[kk]]
[01:27:46.315]                   NAME <- NAMES[[kk]]
[01:27:46.315]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.315]                     next
[01:27:46.315]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.315]                 }
[01:27:46.315]                 if (length(args) > 0) 
[01:27:46.315]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.315]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.315]             }
[01:27:46.315]             else {
[01:27:46.315]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.315]             }
[01:27:46.315]             {
[01:27:46.315]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.315]                   0L) {
[01:27:46.315]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.315]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.315]                   base::options(opts)
[01:27:46.315]                 }
[01:27:46.315]                 {
[01:27:46.315]                   {
[01:27:46.315]                     NULL
[01:27:46.315]                     RNGkind("Mersenne-Twister")
[01:27:46.315]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.315]                       inherits = FALSE)
[01:27:46.315]                   }
[01:27:46.315]                   options(future.plan = NULL)
[01:27:46.315]                   if (is.na(NA_character_)) 
[01:27:46.315]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.315]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.315]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.315]                   {
[01:27:46.315]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.315]                     if (!future$lazy) 
[01:27:46.315]                       future <- run(future)
[01:27:46.315]                     invisible(future)
[01:27:46.315]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.315]                 }
[01:27:46.315]             }
[01:27:46.315]         }
[01:27:46.315]     })
[01:27:46.315]     if (TRUE) {
[01:27:46.315]         base::sink(type = "output", split = FALSE)
[01:27:46.315]         if (TRUE) {
[01:27:46.315]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.315]         }
[01:27:46.315]         else {
[01:27:46.315]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.315]         }
[01:27:46.315]         base::close(...future.stdout)
[01:27:46.315]         ...future.stdout <- NULL
[01:27:46.315]     }
[01:27:46.315]     ...future.result$conditions <- ...future.conditions
[01:27:46.315]     ...future.result$finished <- base::Sys.time()
[01:27:46.315]     ...future.result
[01:27:46.315] }
[01:27:46.320] plan(): Setting new future strategy stack:
[01:27:46.320] List of future strategies:
[01:27:46.320] 1. sequential:
[01:27:46.320]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.320]    - tweaked: FALSE
[01:27:46.320]    - call: NULL
[01:27:46.321] plan(): nbrOfWorkers() = 1
[01:27:46.322] plan(): Setting new future strategy stack:
[01:27:46.322] List of future strategies:
[01:27:46.322] 1. sequential:
[01:27:46.322]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.322]    - tweaked: FALSE
[01:27:46.322]    - call: plan(strategy)
[01:27:46.323] plan(): nbrOfWorkers() = 1
[01:27:46.323] SequentialFuture started (and completed)
[01:27:46.324] - Launch lazy future ... done
[01:27:46.324] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b082987d8> 
Classes 'listenv', 'environment' <environment: 0x0000025b08218c70> 
[01:27:46.334] resolved() for 'SequentialFuture' ...
[01:27:46.334] - state: 'finished'
[01:27:46.334] - run: TRUE
[01:27:46.334] - result: 'FutureResult'
[01:27:46.335] resolved() for 'SequentialFuture' ... done
[01:27:46.335] resolved() for 'SequentialFuture' ...
[01:27:46.335] - state: 'finished'
[01:27:46.335] - run: TRUE
[01:27:46.336] - result: 'FutureResult'
[01:27:46.336] resolved() for 'SequentialFuture' ... done
[01:27:46.336] resolved() for 'SequentialFuture' ...
[01:27:46.336] - state: 'finished'
[01:27:46.336] - run: TRUE
[01:27:46.337] - result: 'FutureResult'
[01:27:46.337] resolved() for 'SequentialFuture' ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[01:27:46.340] resolve() on list environment ...
[01:27:46.340]  recursive: 0
[01:27:46.341]  length: 6
[01:27:46.341]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:46.341] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.342] - nx: 6
[01:27:46.342] - relay: TRUE
[01:27:46.342] - stdout: TRUE
[01:27:46.342] - signal: TRUE
[01:27:46.342] - resignal: FALSE
[01:27:46.343] - force: TRUE
[01:27:46.343] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.343] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.343]  - until=2
[01:27:46.343]  - relaying element #2
[01:27:46.343] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.344] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.344] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.344]  length: 5 (resolved future 1)
[01:27:46.344] resolved() for 'SequentialFuture' ...
[01:27:46.344] - state: 'finished'
[01:27:46.345] - run: TRUE
[01:27:46.345] - result: 'FutureResult'
[01:27:46.345] resolved() for 'SequentialFuture' ... done
[01:27:46.345] Future #2
[01:27:46.346] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.346] - nx: 6
[01:27:46.346] - relay: TRUE
[01:27:46.346] - stdout: TRUE
[01:27:46.346] - signal: TRUE
[01:27:46.347] - resignal: FALSE
[01:27:46.347] - force: TRUE
[01:27:46.347] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.347] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.347]  - until=2
[01:27:46.347]  - relaying element #2
[01:27:46.348] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.348] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.348] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.348]  length: 4 (resolved future 2)
[01:27:46.349] resolved() for 'SequentialFuture' ...
[01:27:46.349] - state: 'finished'
[01:27:46.349] - run: TRUE
[01:27:46.349] - result: 'FutureResult'
[01:27:46.350] resolved() for 'SequentialFuture' ... done
[01:27:46.350] Future #3
[01:27:46.350] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.350] - nx: 6
[01:27:46.350] - relay: TRUE
[01:27:46.351] - stdout: TRUE
[01:27:46.351] - signal: TRUE
[01:27:46.351] - resignal: FALSE
[01:27:46.351] - force: TRUE
[01:27:46.351] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.352] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.352]  - until=3
[01:27:46.352]  - relaying element #3
[01:27:46.352] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.353] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.353] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.353]  length: 3 (resolved future 3)
[01:27:46.353] resolved() for 'SequentialFuture' ...
[01:27:46.354] - state: 'finished'
[01:27:46.354] - run: TRUE
[01:27:46.354] - result: 'FutureResult'
[01:27:46.355] resolved() for 'SequentialFuture' ... done
[01:27:46.355] Future #4
[01:27:46.355] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.355] - nx: 6
[01:27:46.356] - relay: TRUE
[01:27:46.356] - stdout: TRUE
[01:27:46.356] - signal: TRUE
[01:27:46.356] - resignal: FALSE
[01:27:46.356] - force: TRUE
[01:27:46.357] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.357] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.357]  - until=4
[01:27:46.357]  - relaying element #4
[01:27:46.358] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.358] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.358] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.358]  length: 2 (resolved future 4)
[01:27:46.359] signalConditionsASAP(NULL, pos=5) ...
[01:27:46.359] - nx: 6
[01:27:46.359] - relay: TRUE
[01:27:46.359] - stdout: TRUE
[01:27:46.360] - signal: TRUE
[01:27:46.360] - resignal: FALSE
[01:27:46.360] - force: TRUE
[01:27:46.361] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.361] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.361]  - until=6
[01:27:46.361]  - relaying element #6
[01:27:46.362] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.362] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.362] signalConditionsASAP(NULL, pos=5) ... done
[01:27:46.363]  length: 1 (resolved future 5)
[01:27:46.363] signalConditionsASAP(numeric, pos=6) ...
[01:27:46.363] - nx: 6
[01:27:46.363] - relay: TRUE
[01:27:46.363] - stdout: TRUE
[01:27:46.364] - signal: TRUE
[01:27:46.364] - resignal: FALSE
[01:27:46.364] - force: TRUE
[01:27:46.364] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.364] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.365]  - until=6
[01:27:46.365] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.365] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.365] signalConditionsASAP(numeric, pos=6) ... done
[01:27:46.365]  length: 0 (resolved future 6)
[01:27:46.366] Relaying remaining futures
[01:27:46.366] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.366] - nx: 6
[01:27:46.366] - relay: TRUE
[01:27:46.366] - stdout: TRUE
[01:27:46.367] - signal: TRUE
[01:27:46.367] - resignal: FALSE
[01:27:46.367] - force: TRUE
[01:27:46.367] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.367] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:46.368] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.368] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.368] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.369] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x0000025b04acd9c8> 
Dimensions: c(1, 6)
[01:27:46.370] getGlobalsAndPackages() ...
[01:27:46.370] Searching for globals...
[01:27:46.373] 
[01:27:46.374] Searching for globals ... DONE
[01:27:46.374] - globals: [0] <none>
[01:27:46.374] getGlobalsAndPackages() ... DONE
[01:27:46.375] run() for 'Future' ...
[01:27:46.375] - state: 'created'
[01:27:46.375] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.376] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.376] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.376]   - Field: 'label'
[01:27:46.376]   - Field: 'local'
[01:27:46.377]   - Field: 'owner'
[01:27:46.377]   - Field: 'envir'
[01:27:46.377]   - Field: 'packages'
[01:27:46.377]   - Field: 'gc'
[01:27:46.377]   - Field: 'conditions'
[01:27:46.378]   - Field: 'expr'
[01:27:46.378]   - Field: 'uuid'
[01:27:46.378]   - Field: 'seed'
[01:27:46.378]   - Field: 'version'
[01:27:46.378]   - Field: 'result'
[01:27:46.378]   - Field: 'asynchronous'
[01:27:46.379]   - Field: 'calls'
[01:27:46.379]   - Field: 'globals'
[01:27:46.379]   - Field: 'stdout'
[01:27:46.379]   - Field: 'earlySignal'
[01:27:46.379]   - Field: 'lazy'
[01:27:46.380]   - Field: 'state'
[01:27:46.380] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.380] - Launch lazy future ...
[01:27:46.380] Packages needed by the future expression (n = 0): <none>
[01:27:46.381] Packages needed by future strategies (n = 0): <none>
[01:27:46.381] {
[01:27:46.381]     {
[01:27:46.381]         {
[01:27:46.381]             ...future.startTime <- base::Sys.time()
[01:27:46.381]             {
[01:27:46.381]                 {
[01:27:46.381]                   {
[01:27:46.381]                     base::local({
[01:27:46.381]                       has_future <- base::requireNamespace("future", 
[01:27:46.381]                         quietly = TRUE)
[01:27:46.381]                       if (has_future) {
[01:27:46.381]                         ns <- base::getNamespace("future")
[01:27:46.381]                         version <- ns[[".package"]][["version"]]
[01:27:46.381]                         if (is.null(version)) 
[01:27:46.381]                           version <- utils::packageVersion("future")
[01:27:46.381]                       }
[01:27:46.381]                       else {
[01:27:46.381]                         version <- NULL
[01:27:46.381]                       }
[01:27:46.381]                       if (!has_future || version < "1.8.0") {
[01:27:46.381]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.381]                           "", base::R.version$version.string), 
[01:27:46.381]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.381]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.381]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.381]                             "release", "version")], collapse = " "), 
[01:27:46.381]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.381]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.381]                           info)
[01:27:46.381]                         info <- base::paste(info, collapse = "; ")
[01:27:46.381]                         if (!has_future) {
[01:27:46.381]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.381]                             info)
[01:27:46.381]                         }
[01:27:46.381]                         else {
[01:27:46.381]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.381]                             info, version)
[01:27:46.381]                         }
[01:27:46.381]                         base::stop(msg)
[01:27:46.381]                       }
[01:27:46.381]                     })
[01:27:46.381]                   }
[01:27:46.381]                   options(future.plan = NULL)
[01:27:46.381]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.381]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.381]                 }
[01:27:46.381]                 ...future.workdir <- getwd()
[01:27:46.381]             }
[01:27:46.381]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.381]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.381]         }
[01:27:46.381]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.381]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.381]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.381]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.381]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.381]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.381]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.381]             base::names(...future.oldOptions))
[01:27:46.381]     }
[01:27:46.381]     if (FALSE) {
[01:27:46.381]     }
[01:27:46.381]     else {
[01:27:46.381]         if (TRUE) {
[01:27:46.381]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.381]                 open = "w")
[01:27:46.381]         }
[01:27:46.381]         else {
[01:27:46.381]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.381]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.381]         }
[01:27:46.381]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.381]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.381]             base::sink(type = "output", split = FALSE)
[01:27:46.381]             base::close(...future.stdout)
[01:27:46.381]         }, add = TRUE)
[01:27:46.381]     }
[01:27:46.381]     ...future.frame <- base::sys.nframe()
[01:27:46.381]     ...future.conditions <- base::list()
[01:27:46.381]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.381]     if (FALSE) {
[01:27:46.381]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.381]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.381]     }
[01:27:46.381]     ...future.result <- base::tryCatch({
[01:27:46.381]         base::withCallingHandlers({
[01:27:46.381]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.381]             future::FutureResult(value = ...future.value$value, 
[01:27:46.381]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.381]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.381]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.381]                     ...future.globalenv.names))
[01:27:46.381]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.381]         }, condition = base::local({
[01:27:46.381]             c <- base::c
[01:27:46.381]             inherits <- base::inherits
[01:27:46.381]             invokeRestart <- base::invokeRestart
[01:27:46.381]             length <- base::length
[01:27:46.381]             list <- base::list
[01:27:46.381]             seq.int <- base::seq.int
[01:27:46.381]             signalCondition <- base::signalCondition
[01:27:46.381]             sys.calls <- base::sys.calls
[01:27:46.381]             `[[` <- base::`[[`
[01:27:46.381]             `+` <- base::`+`
[01:27:46.381]             `<<-` <- base::`<<-`
[01:27:46.381]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.381]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.381]                   3L)]
[01:27:46.381]             }
[01:27:46.381]             function(cond) {
[01:27:46.381]                 is_error <- inherits(cond, "error")
[01:27:46.381]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.381]                   NULL)
[01:27:46.381]                 if (is_error) {
[01:27:46.381]                   sessionInformation <- function() {
[01:27:46.381]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.381]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.381]                       search = base::search(), system = base::Sys.info())
[01:27:46.381]                   }
[01:27:46.381]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.381]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.381]                     cond$call), session = sessionInformation(), 
[01:27:46.381]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.381]                   signalCondition(cond)
[01:27:46.381]                 }
[01:27:46.381]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.381]                 "immediateCondition"))) {
[01:27:46.381]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.381]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.381]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.381]                   if (TRUE && !signal) {
[01:27:46.381]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.381]                     {
[01:27:46.381]                       inherits <- base::inherits
[01:27:46.381]                       invokeRestart <- base::invokeRestart
[01:27:46.381]                       is.null <- base::is.null
[01:27:46.381]                       muffled <- FALSE
[01:27:46.381]                       if (inherits(cond, "message")) {
[01:27:46.381]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.381]                         if (muffled) 
[01:27:46.381]                           invokeRestart("muffleMessage")
[01:27:46.381]                       }
[01:27:46.381]                       else if (inherits(cond, "warning")) {
[01:27:46.381]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.381]                         if (muffled) 
[01:27:46.381]                           invokeRestart("muffleWarning")
[01:27:46.381]                       }
[01:27:46.381]                       else if (inherits(cond, "condition")) {
[01:27:46.381]                         if (!is.null(pattern)) {
[01:27:46.381]                           computeRestarts <- base::computeRestarts
[01:27:46.381]                           grepl <- base::grepl
[01:27:46.381]                           restarts <- computeRestarts(cond)
[01:27:46.381]                           for (restart in restarts) {
[01:27:46.381]                             name <- restart$name
[01:27:46.381]                             if (is.null(name)) 
[01:27:46.381]                               next
[01:27:46.381]                             if (!grepl(pattern, name)) 
[01:27:46.381]                               next
[01:27:46.381]                             invokeRestart(restart)
[01:27:46.381]                             muffled <- TRUE
[01:27:46.381]                             break
[01:27:46.381]                           }
[01:27:46.381]                         }
[01:27:46.381]                       }
[01:27:46.381]                       invisible(muffled)
[01:27:46.381]                     }
[01:27:46.381]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.381]                   }
[01:27:46.381]                 }
[01:27:46.381]                 else {
[01:27:46.381]                   if (TRUE) {
[01:27:46.381]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.381]                     {
[01:27:46.381]                       inherits <- base::inherits
[01:27:46.381]                       invokeRestart <- base::invokeRestart
[01:27:46.381]                       is.null <- base::is.null
[01:27:46.381]                       muffled <- FALSE
[01:27:46.381]                       if (inherits(cond, "message")) {
[01:27:46.381]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.381]                         if (muffled) 
[01:27:46.381]                           invokeRestart("muffleMessage")
[01:27:46.381]                       }
[01:27:46.381]                       else if (inherits(cond, "warning")) {
[01:27:46.381]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.381]                         if (muffled) 
[01:27:46.381]                           invokeRestart("muffleWarning")
[01:27:46.381]                       }
[01:27:46.381]                       else if (inherits(cond, "condition")) {
[01:27:46.381]                         if (!is.null(pattern)) {
[01:27:46.381]                           computeRestarts <- base::computeRestarts
[01:27:46.381]                           grepl <- base::grepl
[01:27:46.381]                           restarts <- computeRestarts(cond)
[01:27:46.381]                           for (restart in restarts) {
[01:27:46.381]                             name <- restart$name
[01:27:46.381]                             if (is.null(name)) 
[01:27:46.381]                               next
[01:27:46.381]                             if (!grepl(pattern, name)) 
[01:27:46.381]                               next
[01:27:46.381]                             invokeRestart(restart)
[01:27:46.381]                             muffled <- TRUE
[01:27:46.381]                             break
[01:27:46.381]                           }
[01:27:46.381]                         }
[01:27:46.381]                       }
[01:27:46.381]                       invisible(muffled)
[01:27:46.381]                     }
[01:27:46.381]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.381]                   }
[01:27:46.381]                 }
[01:27:46.381]             }
[01:27:46.381]         }))
[01:27:46.381]     }, error = function(ex) {
[01:27:46.381]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.381]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.381]                 ...future.rng), started = ...future.startTime, 
[01:27:46.381]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.381]             version = "1.8"), class = "FutureResult")
[01:27:46.381]     }, finally = {
[01:27:46.381]         if (!identical(...future.workdir, getwd())) 
[01:27:46.381]             setwd(...future.workdir)
[01:27:46.381]         {
[01:27:46.381]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.381]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.381]             }
[01:27:46.381]             base::options(...future.oldOptions)
[01:27:46.381]             if (.Platform$OS.type == "windows") {
[01:27:46.381]                 old_names <- names(...future.oldEnvVars)
[01:27:46.381]                 envs <- base::Sys.getenv()
[01:27:46.381]                 names <- names(envs)
[01:27:46.381]                 common <- intersect(names, old_names)
[01:27:46.381]                 added <- setdiff(names, old_names)
[01:27:46.381]                 removed <- setdiff(old_names, names)
[01:27:46.381]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.381]                   envs[common]]
[01:27:46.381]                 NAMES <- toupper(changed)
[01:27:46.381]                 args <- list()
[01:27:46.381]                 for (kk in seq_along(NAMES)) {
[01:27:46.381]                   name <- changed[[kk]]
[01:27:46.381]                   NAME <- NAMES[[kk]]
[01:27:46.381]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.381]                     next
[01:27:46.381]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.381]                 }
[01:27:46.381]                 NAMES <- toupper(added)
[01:27:46.381]                 for (kk in seq_along(NAMES)) {
[01:27:46.381]                   name <- added[[kk]]
[01:27:46.381]                   NAME <- NAMES[[kk]]
[01:27:46.381]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.381]                     next
[01:27:46.381]                   args[[name]] <- ""
[01:27:46.381]                 }
[01:27:46.381]                 NAMES <- toupper(removed)
[01:27:46.381]                 for (kk in seq_along(NAMES)) {
[01:27:46.381]                   name <- removed[[kk]]
[01:27:46.381]                   NAME <- NAMES[[kk]]
[01:27:46.381]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.381]                     next
[01:27:46.381]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.381]                 }
[01:27:46.381]                 if (length(args) > 0) 
[01:27:46.381]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.381]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.381]             }
[01:27:46.381]             else {
[01:27:46.381]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.381]             }
[01:27:46.381]             {
[01:27:46.381]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.381]                   0L) {
[01:27:46.381]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.381]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.381]                   base::options(opts)
[01:27:46.381]                 }
[01:27:46.381]                 {
[01:27:46.381]                   {
[01:27:46.381]                     NULL
[01:27:46.381]                     RNGkind("Mersenne-Twister")
[01:27:46.381]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.381]                       inherits = FALSE)
[01:27:46.381]                   }
[01:27:46.381]                   options(future.plan = NULL)
[01:27:46.381]                   if (is.na(NA_character_)) 
[01:27:46.381]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.381]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.381]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.381]                   {
[01:27:46.381]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.381]                     if (!future$lazy) 
[01:27:46.381]                       future <- run(future)
[01:27:46.381]                     invisible(future)
[01:27:46.381]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.381]                 }
[01:27:46.381]             }
[01:27:46.381]         }
[01:27:46.381]     })
[01:27:46.381]     if (TRUE) {
[01:27:46.381]         base::sink(type = "output", split = FALSE)
[01:27:46.381]         if (TRUE) {
[01:27:46.381]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.381]         }
[01:27:46.381]         else {
[01:27:46.381]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.381]         }
[01:27:46.381]         base::close(...future.stdout)
[01:27:46.381]         ...future.stdout <- NULL
[01:27:46.381]     }
[01:27:46.381]     ...future.result$conditions <- ...future.conditions
[01:27:46.381]     ...future.result$finished <- base::Sys.time()
[01:27:46.381]     ...future.result
[01:27:46.381] }
[01:27:46.386] plan(): Setting new future strategy stack:
[01:27:46.386] List of future strategies:
[01:27:46.386] 1. sequential:
[01:27:46.386]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.386]    - tweaked: FALSE
[01:27:46.386]    - call: NULL
[01:27:46.387] plan(): nbrOfWorkers() = 1
[01:27:46.388] plan(): Setting new future strategy stack:
[01:27:46.388] List of future strategies:
[01:27:46.388] 1. sequential:
[01:27:46.388]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.388]    - tweaked: FALSE
[01:27:46.388]    - call: plan(strategy)
[01:27:46.389] plan(): nbrOfWorkers() = 1
[01:27:46.389] SequentialFuture started (and completed)
[01:27:46.390] - Launch lazy future ... done
[01:27:46.390] run() for 'SequentialFuture' ... done
[01:27:46.390] getGlobalsAndPackages() ...
[01:27:46.390] Searching for globals...
[01:27:46.391] 
[01:27:46.391] Searching for globals ... DONE
[01:27:46.391] - globals: [0] <none>
[01:27:46.391] getGlobalsAndPackages() ... DONE
[01:27:46.392] run() for 'Future' ...
[01:27:46.392] - state: 'created'
[01:27:46.392] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.392] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.393] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.393]   - Field: 'label'
[01:27:46.393]   - Field: 'local'
[01:27:46.393]   - Field: 'owner'
[01:27:46.393]   - Field: 'envir'
[01:27:46.394]   - Field: 'packages'
[01:27:46.394]   - Field: 'gc'
[01:27:46.394]   - Field: 'conditions'
[01:27:46.394]   - Field: 'expr'
[01:27:46.394]   - Field: 'uuid'
[01:27:46.395]   - Field: 'seed'
[01:27:46.395]   - Field: 'version'
[01:27:46.395]   - Field: 'result'
[01:27:46.395]   - Field: 'asynchronous'
[01:27:46.395]   - Field: 'calls'
[01:27:46.396]   - Field: 'globals'
[01:27:46.396]   - Field: 'stdout'
[01:27:46.396]   - Field: 'earlySignal'
[01:27:46.396]   - Field: 'lazy'
[01:27:46.396]   - Field: 'state'
[01:27:46.397] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.397] - Launch lazy future ...
[01:27:46.397] Packages needed by the future expression (n = 0): <none>
[01:27:46.397] Packages needed by future strategies (n = 0): <none>
[01:27:46.398] {
[01:27:46.398]     {
[01:27:46.398]         {
[01:27:46.398]             ...future.startTime <- base::Sys.time()
[01:27:46.398]             {
[01:27:46.398]                 {
[01:27:46.398]                   {
[01:27:46.398]                     base::local({
[01:27:46.398]                       has_future <- base::requireNamespace("future", 
[01:27:46.398]                         quietly = TRUE)
[01:27:46.398]                       if (has_future) {
[01:27:46.398]                         ns <- base::getNamespace("future")
[01:27:46.398]                         version <- ns[[".package"]][["version"]]
[01:27:46.398]                         if (is.null(version)) 
[01:27:46.398]                           version <- utils::packageVersion("future")
[01:27:46.398]                       }
[01:27:46.398]                       else {
[01:27:46.398]                         version <- NULL
[01:27:46.398]                       }
[01:27:46.398]                       if (!has_future || version < "1.8.0") {
[01:27:46.398]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.398]                           "", base::R.version$version.string), 
[01:27:46.398]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.398]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.398]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.398]                             "release", "version")], collapse = " "), 
[01:27:46.398]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.398]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.398]                           info)
[01:27:46.398]                         info <- base::paste(info, collapse = "; ")
[01:27:46.398]                         if (!has_future) {
[01:27:46.398]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.398]                             info)
[01:27:46.398]                         }
[01:27:46.398]                         else {
[01:27:46.398]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.398]                             info, version)
[01:27:46.398]                         }
[01:27:46.398]                         base::stop(msg)
[01:27:46.398]                       }
[01:27:46.398]                     })
[01:27:46.398]                   }
[01:27:46.398]                   options(future.plan = NULL)
[01:27:46.398]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.398]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.398]                 }
[01:27:46.398]                 ...future.workdir <- getwd()
[01:27:46.398]             }
[01:27:46.398]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.398]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.398]         }
[01:27:46.398]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.398]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.398]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.398]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.398]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.398]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.398]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.398]             base::names(...future.oldOptions))
[01:27:46.398]     }
[01:27:46.398]     if (FALSE) {
[01:27:46.398]     }
[01:27:46.398]     else {
[01:27:46.398]         if (TRUE) {
[01:27:46.398]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.398]                 open = "w")
[01:27:46.398]         }
[01:27:46.398]         else {
[01:27:46.398]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.398]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.398]         }
[01:27:46.398]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.398]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.398]             base::sink(type = "output", split = FALSE)
[01:27:46.398]             base::close(...future.stdout)
[01:27:46.398]         }, add = TRUE)
[01:27:46.398]     }
[01:27:46.398]     ...future.frame <- base::sys.nframe()
[01:27:46.398]     ...future.conditions <- base::list()
[01:27:46.398]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.398]     if (FALSE) {
[01:27:46.398]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.398]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.398]     }
[01:27:46.398]     ...future.result <- base::tryCatch({
[01:27:46.398]         base::withCallingHandlers({
[01:27:46.398]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.398]             future::FutureResult(value = ...future.value$value, 
[01:27:46.398]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.398]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.398]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.398]                     ...future.globalenv.names))
[01:27:46.398]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.398]         }, condition = base::local({
[01:27:46.398]             c <- base::c
[01:27:46.398]             inherits <- base::inherits
[01:27:46.398]             invokeRestart <- base::invokeRestart
[01:27:46.398]             length <- base::length
[01:27:46.398]             list <- base::list
[01:27:46.398]             seq.int <- base::seq.int
[01:27:46.398]             signalCondition <- base::signalCondition
[01:27:46.398]             sys.calls <- base::sys.calls
[01:27:46.398]             `[[` <- base::`[[`
[01:27:46.398]             `+` <- base::`+`
[01:27:46.398]             `<<-` <- base::`<<-`
[01:27:46.398]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.398]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.398]                   3L)]
[01:27:46.398]             }
[01:27:46.398]             function(cond) {
[01:27:46.398]                 is_error <- inherits(cond, "error")
[01:27:46.398]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.398]                   NULL)
[01:27:46.398]                 if (is_error) {
[01:27:46.398]                   sessionInformation <- function() {
[01:27:46.398]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.398]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.398]                       search = base::search(), system = base::Sys.info())
[01:27:46.398]                   }
[01:27:46.398]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.398]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.398]                     cond$call), session = sessionInformation(), 
[01:27:46.398]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.398]                   signalCondition(cond)
[01:27:46.398]                 }
[01:27:46.398]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.398]                 "immediateCondition"))) {
[01:27:46.398]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.398]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.398]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.398]                   if (TRUE && !signal) {
[01:27:46.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.398]                     {
[01:27:46.398]                       inherits <- base::inherits
[01:27:46.398]                       invokeRestart <- base::invokeRestart
[01:27:46.398]                       is.null <- base::is.null
[01:27:46.398]                       muffled <- FALSE
[01:27:46.398]                       if (inherits(cond, "message")) {
[01:27:46.398]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.398]                         if (muffled) 
[01:27:46.398]                           invokeRestart("muffleMessage")
[01:27:46.398]                       }
[01:27:46.398]                       else if (inherits(cond, "warning")) {
[01:27:46.398]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.398]                         if (muffled) 
[01:27:46.398]                           invokeRestart("muffleWarning")
[01:27:46.398]                       }
[01:27:46.398]                       else if (inherits(cond, "condition")) {
[01:27:46.398]                         if (!is.null(pattern)) {
[01:27:46.398]                           computeRestarts <- base::computeRestarts
[01:27:46.398]                           grepl <- base::grepl
[01:27:46.398]                           restarts <- computeRestarts(cond)
[01:27:46.398]                           for (restart in restarts) {
[01:27:46.398]                             name <- restart$name
[01:27:46.398]                             if (is.null(name)) 
[01:27:46.398]                               next
[01:27:46.398]                             if (!grepl(pattern, name)) 
[01:27:46.398]                               next
[01:27:46.398]                             invokeRestart(restart)
[01:27:46.398]                             muffled <- TRUE
[01:27:46.398]                             break
[01:27:46.398]                           }
[01:27:46.398]                         }
[01:27:46.398]                       }
[01:27:46.398]                       invisible(muffled)
[01:27:46.398]                     }
[01:27:46.398]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.398]                   }
[01:27:46.398]                 }
[01:27:46.398]                 else {
[01:27:46.398]                   if (TRUE) {
[01:27:46.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.398]                     {
[01:27:46.398]                       inherits <- base::inherits
[01:27:46.398]                       invokeRestart <- base::invokeRestart
[01:27:46.398]                       is.null <- base::is.null
[01:27:46.398]                       muffled <- FALSE
[01:27:46.398]                       if (inherits(cond, "message")) {
[01:27:46.398]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.398]                         if (muffled) 
[01:27:46.398]                           invokeRestart("muffleMessage")
[01:27:46.398]                       }
[01:27:46.398]                       else if (inherits(cond, "warning")) {
[01:27:46.398]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.398]                         if (muffled) 
[01:27:46.398]                           invokeRestart("muffleWarning")
[01:27:46.398]                       }
[01:27:46.398]                       else if (inherits(cond, "condition")) {
[01:27:46.398]                         if (!is.null(pattern)) {
[01:27:46.398]                           computeRestarts <- base::computeRestarts
[01:27:46.398]                           grepl <- base::grepl
[01:27:46.398]                           restarts <- computeRestarts(cond)
[01:27:46.398]                           for (restart in restarts) {
[01:27:46.398]                             name <- restart$name
[01:27:46.398]                             if (is.null(name)) 
[01:27:46.398]                               next
[01:27:46.398]                             if (!grepl(pattern, name)) 
[01:27:46.398]                               next
[01:27:46.398]                             invokeRestart(restart)
[01:27:46.398]                             muffled <- TRUE
[01:27:46.398]                             break
[01:27:46.398]                           }
[01:27:46.398]                         }
[01:27:46.398]                       }
[01:27:46.398]                       invisible(muffled)
[01:27:46.398]                     }
[01:27:46.398]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.398]                   }
[01:27:46.398]                 }
[01:27:46.398]             }
[01:27:46.398]         }))
[01:27:46.398]     }, error = function(ex) {
[01:27:46.398]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.398]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.398]                 ...future.rng), started = ...future.startTime, 
[01:27:46.398]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.398]             version = "1.8"), class = "FutureResult")
[01:27:46.398]     }, finally = {
[01:27:46.398]         if (!identical(...future.workdir, getwd())) 
[01:27:46.398]             setwd(...future.workdir)
[01:27:46.398]         {
[01:27:46.398]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.398]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.398]             }
[01:27:46.398]             base::options(...future.oldOptions)
[01:27:46.398]             if (.Platform$OS.type == "windows") {
[01:27:46.398]                 old_names <- names(...future.oldEnvVars)
[01:27:46.398]                 envs <- base::Sys.getenv()
[01:27:46.398]                 names <- names(envs)
[01:27:46.398]                 common <- intersect(names, old_names)
[01:27:46.398]                 added <- setdiff(names, old_names)
[01:27:46.398]                 removed <- setdiff(old_names, names)
[01:27:46.398]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.398]                   envs[common]]
[01:27:46.398]                 NAMES <- toupper(changed)
[01:27:46.398]                 args <- list()
[01:27:46.398]                 for (kk in seq_along(NAMES)) {
[01:27:46.398]                   name <- changed[[kk]]
[01:27:46.398]                   NAME <- NAMES[[kk]]
[01:27:46.398]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.398]                     next
[01:27:46.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.398]                 }
[01:27:46.398]                 NAMES <- toupper(added)
[01:27:46.398]                 for (kk in seq_along(NAMES)) {
[01:27:46.398]                   name <- added[[kk]]
[01:27:46.398]                   NAME <- NAMES[[kk]]
[01:27:46.398]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.398]                     next
[01:27:46.398]                   args[[name]] <- ""
[01:27:46.398]                 }
[01:27:46.398]                 NAMES <- toupper(removed)
[01:27:46.398]                 for (kk in seq_along(NAMES)) {
[01:27:46.398]                   name <- removed[[kk]]
[01:27:46.398]                   NAME <- NAMES[[kk]]
[01:27:46.398]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.398]                     next
[01:27:46.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.398]                 }
[01:27:46.398]                 if (length(args) > 0) 
[01:27:46.398]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.398]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.398]             }
[01:27:46.398]             else {
[01:27:46.398]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.398]             }
[01:27:46.398]             {
[01:27:46.398]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.398]                   0L) {
[01:27:46.398]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.398]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.398]                   base::options(opts)
[01:27:46.398]                 }
[01:27:46.398]                 {
[01:27:46.398]                   {
[01:27:46.398]                     NULL
[01:27:46.398]                     RNGkind("Mersenne-Twister")
[01:27:46.398]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.398]                       inherits = FALSE)
[01:27:46.398]                   }
[01:27:46.398]                   options(future.plan = NULL)
[01:27:46.398]                   if (is.na(NA_character_)) 
[01:27:46.398]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.398]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.398]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.398]                   {
[01:27:46.398]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.398]                     if (!future$lazy) 
[01:27:46.398]                       future <- run(future)
[01:27:46.398]                     invisible(future)
[01:27:46.398]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.398]                 }
[01:27:46.398]             }
[01:27:46.398]         }
[01:27:46.398]     })
[01:27:46.398]     if (TRUE) {
[01:27:46.398]         base::sink(type = "output", split = FALSE)
[01:27:46.398]         if (TRUE) {
[01:27:46.398]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.398]         }
[01:27:46.398]         else {
[01:27:46.398]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.398]         }
[01:27:46.398]         base::close(...future.stdout)
[01:27:46.398]         ...future.stdout <- NULL
[01:27:46.398]     }
[01:27:46.398]     ...future.result$conditions <- ...future.conditions
[01:27:46.398]     ...future.result$finished <- base::Sys.time()
[01:27:46.398]     ...future.result
[01:27:46.398] }
[01:27:46.402] plan(): Setting new future strategy stack:
[01:27:46.402] List of future strategies:
[01:27:46.402] 1. sequential:
[01:27:46.402]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.402]    - tweaked: FALSE
[01:27:46.402]    - call: NULL
[01:27:46.403] plan(): nbrOfWorkers() = 1
[01:27:46.404] plan(): Setting new future strategy stack:
[01:27:46.404] List of future strategies:
[01:27:46.404] 1. sequential:
[01:27:46.404]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.404]    - tweaked: FALSE
[01:27:46.404]    - call: plan(strategy)
[01:27:46.405] plan(): nbrOfWorkers() = 1
[01:27:46.405] SequentialFuture started (and completed)
[01:27:46.406] - Launch lazy future ... done
[01:27:46.406] run() for 'SequentialFuture' ... done
[01:27:46.407] getGlobalsAndPackages() ...
[01:27:46.407] Searching for globals...
[01:27:46.408] - globals found: [1] '{'
[01:27:46.408] Searching for globals ... DONE
[01:27:46.408] Resolving globals: FALSE
[01:27:46.408] 
[01:27:46.409] 
[01:27:46.409] getGlobalsAndPackages() ... DONE
[01:27:46.409] run() for 'Future' ...
[01:27:46.409] - state: 'created'
[01:27:46.410] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.410] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.410] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.410]   - Field: 'label'
[01:27:46.411]   - Field: 'local'
[01:27:46.411]   - Field: 'owner'
[01:27:46.411]   - Field: 'envir'
[01:27:46.411]   - Field: 'packages'
[01:27:46.411]   - Field: 'gc'
[01:27:46.412]   - Field: 'conditions'
[01:27:46.412]   - Field: 'expr'
[01:27:46.412]   - Field: 'uuid'
[01:27:46.412]   - Field: 'seed'
[01:27:46.412]   - Field: 'version'
[01:27:46.413]   - Field: 'result'
[01:27:46.413]   - Field: 'asynchronous'
[01:27:46.413]   - Field: 'calls'
[01:27:46.413]   - Field: 'globals'
[01:27:46.413]   - Field: 'stdout'
[01:27:46.413]   - Field: 'earlySignal'
[01:27:46.414]   - Field: 'lazy'
[01:27:46.414]   - Field: 'state'
[01:27:46.414] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.414] - Launch lazy future ...
[01:27:46.415] Packages needed by the future expression (n = 0): <none>
[01:27:46.415] Packages needed by future strategies (n = 0): <none>
[01:27:46.415] {
[01:27:46.415]     {
[01:27:46.415]         {
[01:27:46.415]             ...future.startTime <- base::Sys.time()
[01:27:46.415]             {
[01:27:46.415]                 {
[01:27:46.415]                   {
[01:27:46.415]                     base::local({
[01:27:46.415]                       has_future <- base::requireNamespace("future", 
[01:27:46.415]                         quietly = TRUE)
[01:27:46.415]                       if (has_future) {
[01:27:46.415]                         ns <- base::getNamespace("future")
[01:27:46.415]                         version <- ns[[".package"]][["version"]]
[01:27:46.415]                         if (is.null(version)) 
[01:27:46.415]                           version <- utils::packageVersion("future")
[01:27:46.415]                       }
[01:27:46.415]                       else {
[01:27:46.415]                         version <- NULL
[01:27:46.415]                       }
[01:27:46.415]                       if (!has_future || version < "1.8.0") {
[01:27:46.415]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.415]                           "", base::R.version$version.string), 
[01:27:46.415]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.415]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.415]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.415]                             "release", "version")], collapse = " "), 
[01:27:46.415]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.415]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.415]                           info)
[01:27:46.415]                         info <- base::paste(info, collapse = "; ")
[01:27:46.415]                         if (!has_future) {
[01:27:46.415]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.415]                             info)
[01:27:46.415]                         }
[01:27:46.415]                         else {
[01:27:46.415]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.415]                             info, version)
[01:27:46.415]                         }
[01:27:46.415]                         base::stop(msg)
[01:27:46.415]                       }
[01:27:46.415]                     })
[01:27:46.415]                   }
[01:27:46.415]                   options(future.plan = NULL)
[01:27:46.415]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.415]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.415]                 }
[01:27:46.415]                 ...future.workdir <- getwd()
[01:27:46.415]             }
[01:27:46.415]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.415]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.415]         }
[01:27:46.415]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.415]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.415]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.415]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.415]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.415]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.415]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.415]             base::names(...future.oldOptions))
[01:27:46.415]     }
[01:27:46.415]     if (FALSE) {
[01:27:46.415]     }
[01:27:46.415]     else {
[01:27:46.415]         if (TRUE) {
[01:27:46.415]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.415]                 open = "w")
[01:27:46.415]         }
[01:27:46.415]         else {
[01:27:46.415]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.415]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.415]         }
[01:27:46.415]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.415]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.415]             base::sink(type = "output", split = FALSE)
[01:27:46.415]             base::close(...future.stdout)
[01:27:46.415]         }, add = TRUE)
[01:27:46.415]     }
[01:27:46.415]     ...future.frame <- base::sys.nframe()
[01:27:46.415]     ...future.conditions <- base::list()
[01:27:46.415]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.415]     if (FALSE) {
[01:27:46.415]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.415]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.415]     }
[01:27:46.415]     ...future.result <- base::tryCatch({
[01:27:46.415]         base::withCallingHandlers({
[01:27:46.415]             ...future.value <- base::withVisible(base::local({
[01:27:46.415]                 4
[01:27:46.415]             }))
[01:27:46.415]             future::FutureResult(value = ...future.value$value, 
[01:27:46.415]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.415]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.415]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.415]                     ...future.globalenv.names))
[01:27:46.415]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.415]         }, condition = base::local({
[01:27:46.415]             c <- base::c
[01:27:46.415]             inherits <- base::inherits
[01:27:46.415]             invokeRestart <- base::invokeRestart
[01:27:46.415]             length <- base::length
[01:27:46.415]             list <- base::list
[01:27:46.415]             seq.int <- base::seq.int
[01:27:46.415]             signalCondition <- base::signalCondition
[01:27:46.415]             sys.calls <- base::sys.calls
[01:27:46.415]             `[[` <- base::`[[`
[01:27:46.415]             `+` <- base::`+`
[01:27:46.415]             `<<-` <- base::`<<-`
[01:27:46.415]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.415]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.415]                   3L)]
[01:27:46.415]             }
[01:27:46.415]             function(cond) {
[01:27:46.415]                 is_error <- inherits(cond, "error")
[01:27:46.415]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.415]                   NULL)
[01:27:46.415]                 if (is_error) {
[01:27:46.415]                   sessionInformation <- function() {
[01:27:46.415]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.415]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.415]                       search = base::search(), system = base::Sys.info())
[01:27:46.415]                   }
[01:27:46.415]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.415]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.415]                     cond$call), session = sessionInformation(), 
[01:27:46.415]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.415]                   signalCondition(cond)
[01:27:46.415]                 }
[01:27:46.415]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.415]                 "immediateCondition"))) {
[01:27:46.415]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.415]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.415]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.415]                   if (TRUE && !signal) {
[01:27:46.415]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.415]                     {
[01:27:46.415]                       inherits <- base::inherits
[01:27:46.415]                       invokeRestart <- base::invokeRestart
[01:27:46.415]                       is.null <- base::is.null
[01:27:46.415]                       muffled <- FALSE
[01:27:46.415]                       if (inherits(cond, "message")) {
[01:27:46.415]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.415]                         if (muffled) 
[01:27:46.415]                           invokeRestart("muffleMessage")
[01:27:46.415]                       }
[01:27:46.415]                       else if (inherits(cond, "warning")) {
[01:27:46.415]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.415]                         if (muffled) 
[01:27:46.415]                           invokeRestart("muffleWarning")
[01:27:46.415]                       }
[01:27:46.415]                       else if (inherits(cond, "condition")) {
[01:27:46.415]                         if (!is.null(pattern)) {
[01:27:46.415]                           computeRestarts <- base::computeRestarts
[01:27:46.415]                           grepl <- base::grepl
[01:27:46.415]                           restarts <- computeRestarts(cond)
[01:27:46.415]                           for (restart in restarts) {
[01:27:46.415]                             name <- restart$name
[01:27:46.415]                             if (is.null(name)) 
[01:27:46.415]                               next
[01:27:46.415]                             if (!grepl(pattern, name)) 
[01:27:46.415]                               next
[01:27:46.415]                             invokeRestart(restart)
[01:27:46.415]                             muffled <- TRUE
[01:27:46.415]                             break
[01:27:46.415]                           }
[01:27:46.415]                         }
[01:27:46.415]                       }
[01:27:46.415]                       invisible(muffled)
[01:27:46.415]                     }
[01:27:46.415]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.415]                   }
[01:27:46.415]                 }
[01:27:46.415]                 else {
[01:27:46.415]                   if (TRUE) {
[01:27:46.415]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.415]                     {
[01:27:46.415]                       inherits <- base::inherits
[01:27:46.415]                       invokeRestart <- base::invokeRestart
[01:27:46.415]                       is.null <- base::is.null
[01:27:46.415]                       muffled <- FALSE
[01:27:46.415]                       if (inherits(cond, "message")) {
[01:27:46.415]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.415]                         if (muffled) 
[01:27:46.415]                           invokeRestart("muffleMessage")
[01:27:46.415]                       }
[01:27:46.415]                       else if (inherits(cond, "warning")) {
[01:27:46.415]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.415]                         if (muffled) 
[01:27:46.415]                           invokeRestart("muffleWarning")
[01:27:46.415]                       }
[01:27:46.415]                       else if (inherits(cond, "condition")) {
[01:27:46.415]                         if (!is.null(pattern)) {
[01:27:46.415]                           computeRestarts <- base::computeRestarts
[01:27:46.415]                           grepl <- base::grepl
[01:27:46.415]                           restarts <- computeRestarts(cond)
[01:27:46.415]                           for (restart in restarts) {
[01:27:46.415]                             name <- restart$name
[01:27:46.415]                             if (is.null(name)) 
[01:27:46.415]                               next
[01:27:46.415]                             if (!grepl(pattern, name)) 
[01:27:46.415]                               next
[01:27:46.415]                             invokeRestart(restart)
[01:27:46.415]                             muffled <- TRUE
[01:27:46.415]                             break
[01:27:46.415]                           }
[01:27:46.415]                         }
[01:27:46.415]                       }
[01:27:46.415]                       invisible(muffled)
[01:27:46.415]                     }
[01:27:46.415]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.415]                   }
[01:27:46.415]                 }
[01:27:46.415]             }
[01:27:46.415]         }))
[01:27:46.415]     }, error = function(ex) {
[01:27:46.415]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.415]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.415]                 ...future.rng), started = ...future.startTime, 
[01:27:46.415]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.415]             version = "1.8"), class = "FutureResult")
[01:27:46.415]     }, finally = {
[01:27:46.415]         if (!identical(...future.workdir, getwd())) 
[01:27:46.415]             setwd(...future.workdir)
[01:27:46.415]         {
[01:27:46.415]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.415]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.415]             }
[01:27:46.415]             base::options(...future.oldOptions)
[01:27:46.415]             if (.Platform$OS.type == "windows") {
[01:27:46.415]                 old_names <- names(...future.oldEnvVars)
[01:27:46.415]                 envs <- base::Sys.getenv()
[01:27:46.415]                 names <- names(envs)
[01:27:46.415]                 common <- intersect(names, old_names)
[01:27:46.415]                 added <- setdiff(names, old_names)
[01:27:46.415]                 removed <- setdiff(old_names, names)
[01:27:46.415]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.415]                   envs[common]]
[01:27:46.415]                 NAMES <- toupper(changed)
[01:27:46.415]                 args <- list()
[01:27:46.415]                 for (kk in seq_along(NAMES)) {
[01:27:46.415]                   name <- changed[[kk]]
[01:27:46.415]                   NAME <- NAMES[[kk]]
[01:27:46.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.415]                     next
[01:27:46.415]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.415]                 }
[01:27:46.415]                 NAMES <- toupper(added)
[01:27:46.415]                 for (kk in seq_along(NAMES)) {
[01:27:46.415]                   name <- added[[kk]]
[01:27:46.415]                   NAME <- NAMES[[kk]]
[01:27:46.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.415]                     next
[01:27:46.415]                   args[[name]] <- ""
[01:27:46.415]                 }
[01:27:46.415]                 NAMES <- toupper(removed)
[01:27:46.415]                 for (kk in seq_along(NAMES)) {
[01:27:46.415]                   name <- removed[[kk]]
[01:27:46.415]                   NAME <- NAMES[[kk]]
[01:27:46.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.415]                     next
[01:27:46.415]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.415]                 }
[01:27:46.415]                 if (length(args) > 0) 
[01:27:46.415]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.415]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.415]             }
[01:27:46.415]             else {
[01:27:46.415]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.415]             }
[01:27:46.415]             {
[01:27:46.415]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.415]                   0L) {
[01:27:46.415]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.415]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.415]                   base::options(opts)
[01:27:46.415]                 }
[01:27:46.415]                 {
[01:27:46.415]                   {
[01:27:46.415]                     NULL
[01:27:46.415]                     RNGkind("Mersenne-Twister")
[01:27:46.415]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.415]                       inherits = FALSE)
[01:27:46.415]                   }
[01:27:46.415]                   options(future.plan = NULL)
[01:27:46.415]                   if (is.na(NA_character_)) 
[01:27:46.415]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.415]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.415]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.415]                   {
[01:27:46.415]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.415]                     if (!future$lazy) 
[01:27:46.415]                       future <- run(future)
[01:27:46.415]                     invisible(future)
[01:27:46.415]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.415]                 }
[01:27:46.415]             }
[01:27:46.415]         }
[01:27:46.415]     })
[01:27:46.415]     if (TRUE) {
[01:27:46.415]         base::sink(type = "output", split = FALSE)
[01:27:46.415]         if (TRUE) {
[01:27:46.415]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.415]         }
[01:27:46.415]         else {
[01:27:46.415]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.415]         }
[01:27:46.415]         base::close(...future.stdout)
[01:27:46.415]         ...future.stdout <- NULL
[01:27:46.415]     }
[01:27:46.415]     ...future.result$conditions <- ...future.conditions
[01:27:46.415]     ...future.result$finished <- base::Sys.time()
[01:27:46.415]     ...future.result
[01:27:46.415] }
[01:27:46.420] plan(): Setting new future strategy stack:
[01:27:46.420] List of future strategies:
[01:27:46.420] 1. sequential:
[01:27:46.420]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.420]    - tweaked: FALSE
[01:27:46.420]    - call: NULL
[01:27:46.421] plan(): nbrOfWorkers() = 1
[01:27:46.422] plan(): Setting new future strategy stack:
[01:27:46.422] List of future strategies:
[01:27:46.422] 1. sequential:
[01:27:46.422]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.422]    - tweaked: FALSE
[01:27:46.422]    - call: plan(strategy)
[01:27:46.425] plan(): nbrOfWorkers() = 1
[01:27:46.425] SequentialFuture started (and completed)
[01:27:46.426] - Launch lazy future ... done
[01:27:46.426] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b084181f0> 
Classes 'listenv', 'environment' <environment: 0x0000025b061b7f10> 
 - attr(*, "dim.")= int [1:2] 1 6
 - attr(*, "dimnames.")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
[01:27:46.431] resolved() for 'SequentialFuture' ...
[01:27:46.431] - state: 'finished'
[01:27:46.431] - run: TRUE
[01:27:46.431] - result: 'FutureResult'
[01:27:46.432] resolved() for 'SequentialFuture' ... done
[01:27:46.432] resolved() for 'SequentialFuture' ...
[01:27:46.432] - state: 'finished'
[01:27:46.432] - run: TRUE
[01:27:46.432] - result: 'FutureResult'
[01:27:46.433] resolved() for 'SequentialFuture' ... done
[01:27:46.433] resolved() for 'SequentialFuture' ...
[01:27:46.433] - state: 'finished'
[01:27:46.433] - run: TRUE
[01:27:46.433] - result: 'FutureResult'
[01:27:46.434] 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" ...
[01:27:46.437] resolve() on list environment ...
[01:27:46.437]  recursive: 0
[01:27:46.438]  length: 6
[01:27:46.438]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:46.438] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.439] - nx: 6
[01:27:46.439] - relay: TRUE
[01:27:46.439] - stdout: TRUE
[01:27:46.439] - signal: TRUE
[01:27:46.439] - resignal: FALSE
[01:27:46.439] - force: TRUE
[01:27:46.440] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.440] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.440]  - until=2
[01:27:46.440]  - relaying element #2
[01:27:46.440] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.441] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.441] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.441]  length: 5 (resolved future 1)
[01:27:46.441] resolved() for 'SequentialFuture' ...
[01:27:46.441] - state: 'finished'
[01:27:46.442] - run: TRUE
[01:27:46.442] - result: 'FutureResult'
[01:27:46.442] resolved() for 'SequentialFuture' ... done
[01:27:46.442] Future #2
[01:27:46.442] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.443] - nx: 6
[01:27:46.443] - relay: TRUE
[01:27:46.443] - stdout: TRUE
[01:27:46.443] - signal: TRUE
[01:27:46.443] - resignal: FALSE
[01:27:46.443] - force: TRUE
[01:27:46.443] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.444] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.444]  - until=2
[01:27:46.444]  - relaying element #2
[01:27:46.444] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.444] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.445] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.445]  length: 4 (resolved future 2)
[01:27:46.445] resolved() for 'SequentialFuture' ...
[01:27:46.445] - state: 'finished'
[01:27:46.445] - run: TRUE
[01:27:46.446] - result: 'FutureResult'
[01:27:46.446] resolved() for 'SequentialFuture' ... done
[01:27:46.446] Future #3
[01:27:46.446] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.446] - nx: 6
[01:27:46.447] - relay: TRUE
[01:27:46.447] - stdout: TRUE
[01:27:46.447] - signal: TRUE
[01:27:46.447] - resignal: FALSE
[01:27:46.447] - force: TRUE
[01:27:46.447] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.448] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.448]  - until=3
[01:27:46.448]  - relaying element #3
[01:27:46.448] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.448] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.449] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.449]  length: 3 (resolved future 3)
[01:27:46.449] resolved() for 'SequentialFuture' ...
[01:27:46.449] - state: 'finished'
[01:27:46.449] - run: TRUE
[01:27:46.450] - result: 'FutureResult'
[01:27:46.450] resolved() for 'SequentialFuture' ... done
[01:27:46.450] Future #4
[01:27:46.450] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.450] - nx: 6
[01:27:46.451] - relay: TRUE
[01:27:46.451] - stdout: TRUE
[01:27:46.451] - signal: TRUE
[01:27:46.451] - resignal: FALSE
[01:27:46.451] - force: TRUE
[01:27:46.451] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.452] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.452]  - until=4
[01:27:46.452]  - relaying element #4
[01:27:46.452] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.452] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.453] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.453]  length: 2 (resolved future 4)
[01:27:46.453] signalConditionsASAP(NULL, pos=5) ...
[01:27:46.453] - nx: 6
[01:27:46.453] - relay: TRUE
[01:27:46.453] - stdout: TRUE
[01:27:46.454] - signal: TRUE
[01:27:46.454] - resignal: FALSE
[01:27:46.454] - force: TRUE
[01:27:46.454] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.454] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.454]  - until=6
[01:27:46.455]  - relaying element #6
[01:27:46.455] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.455] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.455] signalConditionsASAP(NULL, pos=5) ... done
[01:27:46.457]  length: 1 (resolved future 5)
[01:27:46.458] signalConditionsASAP(numeric, pos=6) ...
[01:27:46.458] - nx: 6
[01:27:46.458] - relay: TRUE
[01:27:46.458] - stdout: TRUE
[01:27:46.458] - signal: TRUE
[01:27:46.458] - resignal: FALSE
[01:27:46.459] - force: TRUE
[01:27:46.459] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.459] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.459]  - until=6
[01:27:46.459] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.460] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.460] signalConditionsASAP(numeric, pos=6) ... done
[01:27:46.460]  length: 0 (resolved future 6)
[01:27:46.460] Relaying remaining futures
[01:27:46.460] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.461] - nx: 6
[01:27:46.461] - relay: TRUE
[01:27:46.461] - stdout: TRUE
[01:27:46.461] - signal: TRUE
[01:27:46.461] - resignal: FALSE
[01:27:46.461] - force: TRUE
[01:27:46.462] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.462] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:46.462] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.462] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.463] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.463] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x0000025b0636f2d0> 
 - 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)
[01:27:46.466] getGlobalsAndPackages() ...
[01:27:46.466] Searching for globals...
[01:27:46.467] 
[01:27:46.467] Searching for globals ... DONE
[01:27:46.467] - globals: [0] <none>
[01:27:46.468] getGlobalsAndPackages() ... DONE
[01:27:46.468] run() for 'Future' ...
[01:27:46.468] - state: 'created'
[01:27:46.469] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.469] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.469] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.469]   - Field: 'label'
[01:27:46.470]   - Field: 'local'
[01:27:46.470]   - Field: 'owner'
[01:27:46.470]   - Field: 'envir'
[01:27:46.470]   - Field: 'packages'
[01:27:46.470]   - Field: 'gc'
[01:27:46.471]   - Field: 'conditions'
[01:27:46.471]   - Field: 'expr'
[01:27:46.471]   - Field: 'uuid'
[01:27:46.471]   - Field: 'seed'
[01:27:46.471]   - Field: 'version'
[01:27:46.472]   - Field: 'result'
[01:27:46.472]   - Field: 'asynchronous'
[01:27:46.472]   - Field: 'calls'
[01:27:46.472]   - Field: 'globals'
[01:27:46.472]   - Field: 'stdout'
[01:27:46.473]   - Field: 'earlySignal'
[01:27:46.473]   - Field: 'lazy'
[01:27:46.473]   - Field: 'state'
[01:27:46.473] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.473] - Launch lazy future ...
[01:27:46.474] Packages needed by the future expression (n = 0): <none>
[01:27:46.474] Packages needed by future strategies (n = 0): <none>
[01:27:46.475] {
[01:27:46.475]     {
[01:27:46.475]         {
[01:27:46.475]             ...future.startTime <- base::Sys.time()
[01:27:46.475]             {
[01:27:46.475]                 {
[01:27:46.475]                   {
[01:27:46.475]                     base::local({
[01:27:46.475]                       has_future <- base::requireNamespace("future", 
[01:27:46.475]                         quietly = TRUE)
[01:27:46.475]                       if (has_future) {
[01:27:46.475]                         ns <- base::getNamespace("future")
[01:27:46.475]                         version <- ns[[".package"]][["version"]]
[01:27:46.475]                         if (is.null(version)) 
[01:27:46.475]                           version <- utils::packageVersion("future")
[01:27:46.475]                       }
[01:27:46.475]                       else {
[01:27:46.475]                         version <- NULL
[01:27:46.475]                       }
[01:27:46.475]                       if (!has_future || version < "1.8.0") {
[01:27:46.475]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.475]                           "", base::R.version$version.string), 
[01:27:46.475]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.475]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.475]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.475]                             "release", "version")], collapse = " "), 
[01:27:46.475]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.475]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.475]                           info)
[01:27:46.475]                         info <- base::paste(info, collapse = "; ")
[01:27:46.475]                         if (!has_future) {
[01:27:46.475]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.475]                             info)
[01:27:46.475]                         }
[01:27:46.475]                         else {
[01:27:46.475]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.475]                             info, version)
[01:27:46.475]                         }
[01:27:46.475]                         base::stop(msg)
[01:27:46.475]                       }
[01:27:46.475]                     })
[01:27:46.475]                   }
[01:27:46.475]                   options(future.plan = NULL)
[01:27:46.475]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.475]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.475]                 }
[01:27:46.475]                 ...future.workdir <- getwd()
[01:27:46.475]             }
[01:27:46.475]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.475]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.475]         }
[01:27:46.475]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.475]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.475]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.475]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.475]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.475]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.475]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.475]             base::names(...future.oldOptions))
[01:27:46.475]     }
[01:27:46.475]     if (FALSE) {
[01:27:46.475]     }
[01:27:46.475]     else {
[01:27:46.475]         if (TRUE) {
[01:27:46.475]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.475]                 open = "w")
[01:27:46.475]         }
[01:27:46.475]         else {
[01:27:46.475]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.475]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.475]         }
[01:27:46.475]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.475]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.475]             base::sink(type = "output", split = FALSE)
[01:27:46.475]             base::close(...future.stdout)
[01:27:46.475]         }, add = TRUE)
[01:27:46.475]     }
[01:27:46.475]     ...future.frame <- base::sys.nframe()
[01:27:46.475]     ...future.conditions <- base::list()
[01:27:46.475]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.475]     if (FALSE) {
[01:27:46.475]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.475]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.475]     }
[01:27:46.475]     ...future.result <- base::tryCatch({
[01:27:46.475]         base::withCallingHandlers({
[01:27:46.475]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.475]             future::FutureResult(value = ...future.value$value, 
[01:27:46.475]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.475]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.475]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.475]                     ...future.globalenv.names))
[01:27:46.475]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.475]         }, condition = base::local({
[01:27:46.475]             c <- base::c
[01:27:46.475]             inherits <- base::inherits
[01:27:46.475]             invokeRestart <- base::invokeRestart
[01:27:46.475]             length <- base::length
[01:27:46.475]             list <- base::list
[01:27:46.475]             seq.int <- base::seq.int
[01:27:46.475]             signalCondition <- base::signalCondition
[01:27:46.475]             sys.calls <- base::sys.calls
[01:27:46.475]             `[[` <- base::`[[`
[01:27:46.475]             `+` <- base::`+`
[01:27:46.475]             `<<-` <- base::`<<-`
[01:27:46.475]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.475]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.475]                   3L)]
[01:27:46.475]             }
[01:27:46.475]             function(cond) {
[01:27:46.475]                 is_error <- inherits(cond, "error")
[01:27:46.475]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.475]                   NULL)
[01:27:46.475]                 if (is_error) {
[01:27:46.475]                   sessionInformation <- function() {
[01:27:46.475]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.475]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.475]                       search = base::search(), system = base::Sys.info())
[01:27:46.475]                   }
[01:27:46.475]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.475]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.475]                     cond$call), session = sessionInformation(), 
[01:27:46.475]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.475]                   signalCondition(cond)
[01:27:46.475]                 }
[01:27:46.475]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.475]                 "immediateCondition"))) {
[01:27:46.475]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.475]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.475]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.475]                   if (TRUE && !signal) {
[01:27:46.475]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.475]                     {
[01:27:46.475]                       inherits <- base::inherits
[01:27:46.475]                       invokeRestart <- base::invokeRestart
[01:27:46.475]                       is.null <- base::is.null
[01:27:46.475]                       muffled <- FALSE
[01:27:46.475]                       if (inherits(cond, "message")) {
[01:27:46.475]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.475]                         if (muffled) 
[01:27:46.475]                           invokeRestart("muffleMessage")
[01:27:46.475]                       }
[01:27:46.475]                       else if (inherits(cond, "warning")) {
[01:27:46.475]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.475]                         if (muffled) 
[01:27:46.475]                           invokeRestart("muffleWarning")
[01:27:46.475]                       }
[01:27:46.475]                       else if (inherits(cond, "condition")) {
[01:27:46.475]                         if (!is.null(pattern)) {
[01:27:46.475]                           computeRestarts <- base::computeRestarts
[01:27:46.475]                           grepl <- base::grepl
[01:27:46.475]                           restarts <- computeRestarts(cond)
[01:27:46.475]                           for (restart in restarts) {
[01:27:46.475]                             name <- restart$name
[01:27:46.475]                             if (is.null(name)) 
[01:27:46.475]                               next
[01:27:46.475]                             if (!grepl(pattern, name)) 
[01:27:46.475]                               next
[01:27:46.475]                             invokeRestart(restart)
[01:27:46.475]                             muffled <- TRUE
[01:27:46.475]                             break
[01:27:46.475]                           }
[01:27:46.475]                         }
[01:27:46.475]                       }
[01:27:46.475]                       invisible(muffled)
[01:27:46.475]                     }
[01:27:46.475]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.475]                   }
[01:27:46.475]                 }
[01:27:46.475]                 else {
[01:27:46.475]                   if (TRUE) {
[01:27:46.475]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.475]                     {
[01:27:46.475]                       inherits <- base::inherits
[01:27:46.475]                       invokeRestart <- base::invokeRestart
[01:27:46.475]                       is.null <- base::is.null
[01:27:46.475]                       muffled <- FALSE
[01:27:46.475]                       if (inherits(cond, "message")) {
[01:27:46.475]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.475]                         if (muffled) 
[01:27:46.475]                           invokeRestart("muffleMessage")
[01:27:46.475]                       }
[01:27:46.475]                       else if (inherits(cond, "warning")) {
[01:27:46.475]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.475]                         if (muffled) 
[01:27:46.475]                           invokeRestart("muffleWarning")
[01:27:46.475]                       }
[01:27:46.475]                       else if (inherits(cond, "condition")) {
[01:27:46.475]                         if (!is.null(pattern)) {
[01:27:46.475]                           computeRestarts <- base::computeRestarts
[01:27:46.475]                           grepl <- base::grepl
[01:27:46.475]                           restarts <- computeRestarts(cond)
[01:27:46.475]                           for (restart in restarts) {
[01:27:46.475]                             name <- restart$name
[01:27:46.475]                             if (is.null(name)) 
[01:27:46.475]                               next
[01:27:46.475]                             if (!grepl(pattern, name)) 
[01:27:46.475]                               next
[01:27:46.475]                             invokeRestart(restart)
[01:27:46.475]                             muffled <- TRUE
[01:27:46.475]                             break
[01:27:46.475]                           }
[01:27:46.475]                         }
[01:27:46.475]                       }
[01:27:46.475]                       invisible(muffled)
[01:27:46.475]                     }
[01:27:46.475]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.475]                   }
[01:27:46.475]                 }
[01:27:46.475]             }
[01:27:46.475]         }))
[01:27:46.475]     }, error = function(ex) {
[01:27:46.475]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.475]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.475]                 ...future.rng), started = ...future.startTime, 
[01:27:46.475]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.475]             version = "1.8"), class = "FutureResult")
[01:27:46.475]     }, finally = {
[01:27:46.475]         if (!identical(...future.workdir, getwd())) 
[01:27:46.475]             setwd(...future.workdir)
[01:27:46.475]         {
[01:27:46.475]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.475]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.475]             }
[01:27:46.475]             base::options(...future.oldOptions)
[01:27:46.475]             if (.Platform$OS.type == "windows") {
[01:27:46.475]                 old_names <- names(...future.oldEnvVars)
[01:27:46.475]                 envs <- base::Sys.getenv()
[01:27:46.475]                 names <- names(envs)
[01:27:46.475]                 common <- intersect(names, old_names)
[01:27:46.475]                 added <- setdiff(names, old_names)
[01:27:46.475]                 removed <- setdiff(old_names, names)
[01:27:46.475]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.475]                   envs[common]]
[01:27:46.475]                 NAMES <- toupper(changed)
[01:27:46.475]                 args <- list()
[01:27:46.475]                 for (kk in seq_along(NAMES)) {
[01:27:46.475]                   name <- changed[[kk]]
[01:27:46.475]                   NAME <- NAMES[[kk]]
[01:27:46.475]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.475]                     next
[01:27:46.475]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.475]                 }
[01:27:46.475]                 NAMES <- toupper(added)
[01:27:46.475]                 for (kk in seq_along(NAMES)) {
[01:27:46.475]                   name <- added[[kk]]
[01:27:46.475]                   NAME <- NAMES[[kk]]
[01:27:46.475]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.475]                     next
[01:27:46.475]                   args[[name]] <- ""
[01:27:46.475]                 }
[01:27:46.475]                 NAMES <- toupper(removed)
[01:27:46.475]                 for (kk in seq_along(NAMES)) {
[01:27:46.475]                   name <- removed[[kk]]
[01:27:46.475]                   NAME <- NAMES[[kk]]
[01:27:46.475]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.475]                     next
[01:27:46.475]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.475]                 }
[01:27:46.475]                 if (length(args) > 0) 
[01:27:46.475]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.475]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.475]             }
[01:27:46.475]             else {
[01:27:46.475]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.475]             }
[01:27:46.475]             {
[01:27:46.475]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.475]                   0L) {
[01:27:46.475]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.475]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.475]                   base::options(opts)
[01:27:46.475]                 }
[01:27:46.475]                 {
[01:27:46.475]                   {
[01:27:46.475]                     NULL
[01:27:46.475]                     RNGkind("Mersenne-Twister")
[01:27:46.475]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.475]                       inherits = FALSE)
[01:27:46.475]                   }
[01:27:46.475]                   options(future.plan = NULL)
[01:27:46.475]                   if (is.na(NA_character_)) 
[01:27:46.475]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.475]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.475]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.475]                   {
[01:27:46.475]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.475]                     if (!future$lazy) 
[01:27:46.475]                       future <- run(future)
[01:27:46.475]                     invisible(future)
[01:27:46.475]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.475]                 }
[01:27:46.475]             }
[01:27:46.475]         }
[01:27:46.475]     })
[01:27:46.475]     if (TRUE) {
[01:27:46.475]         base::sink(type = "output", split = FALSE)
[01:27:46.475]         if (TRUE) {
[01:27:46.475]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.475]         }
[01:27:46.475]         else {
[01:27:46.475]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.475]         }
[01:27:46.475]         base::close(...future.stdout)
[01:27:46.475]         ...future.stdout <- NULL
[01:27:46.475]     }
[01:27:46.475]     ...future.result$conditions <- ...future.conditions
[01:27:46.475]     ...future.result$finished <- base::Sys.time()
[01:27:46.475]     ...future.result
[01:27:46.475] }
[01:27:46.479] plan(): Setting new future strategy stack:
[01:27:46.480] List of future strategies:
[01:27:46.480] 1. sequential:
[01:27:46.480]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.480]    - tweaked: FALSE
[01:27:46.480]    - call: NULL
[01:27:46.480] plan(): nbrOfWorkers() = 1
[01:27:46.482] plan(): Setting new future strategy stack:
[01:27:46.482] List of future strategies:
[01:27:46.482] 1. sequential:
[01:27:46.482]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.482]    - tweaked: FALSE
[01:27:46.482]    - call: plan(strategy)
[01:27:46.483] plan(): nbrOfWorkers() = 1
[01:27:46.483] SequentialFuture started (and completed)
[01:27:46.483] - Launch lazy future ... done
[01:27:46.483] run() for 'SequentialFuture' ... done
[01:27:46.484] getGlobalsAndPackages() ...
[01:27:46.484] Searching for globals...
[01:27:46.484] 
[01:27:46.485] Searching for globals ... DONE
[01:27:46.485] - globals: [0] <none>
[01:27:46.485] getGlobalsAndPackages() ... DONE
[01:27:46.485] run() for 'Future' ...
[01:27:46.486] - state: 'created'
[01:27:46.486] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.486] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.486] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.487]   - Field: 'label'
[01:27:46.487]   - Field: 'local'
[01:27:46.487]   - Field: 'owner'
[01:27:46.487]   - Field: 'envir'
[01:27:46.488]   - Field: 'packages'
[01:27:46.488]   - Field: 'gc'
[01:27:46.488]   - Field: 'conditions'
[01:27:46.488]   - Field: 'expr'
[01:27:46.488]   - Field: 'uuid'
[01:27:46.489]   - Field: 'seed'
[01:27:46.489]   - Field: 'version'
[01:27:46.489]   - Field: 'result'
[01:27:46.489]   - Field: 'asynchronous'
[01:27:46.489]   - Field: 'calls'
[01:27:46.489]   - Field: 'globals'
[01:27:46.490]   - Field: 'stdout'
[01:27:46.490]   - Field: 'earlySignal'
[01:27:46.490]   - Field: 'lazy'
[01:27:46.490]   - Field: 'state'
[01:27:46.490] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.491] - Launch lazy future ...
[01:27:46.491] Packages needed by the future expression (n = 0): <none>
[01:27:46.491] Packages needed by future strategies (n = 0): <none>
[01:27:46.492] {
[01:27:46.492]     {
[01:27:46.492]         {
[01:27:46.492]             ...future.startTime <- base::Sys.time()
[01:27:46.492]             {
[01:27:46.492]                 {
[01:27:46.492]                   {
[01:27:46.492]                     base::local({
[01:27:46.492]                       has_future <- base::requireNamespace("future", 
[01:27:46.492]                         quietly = TRUE)
[01:27:46.492]                       if (has_future) {
[01:27:46.492]                         ns <- base::getNamespace("future")
[01:27:46.492]                         version <- ns[[".package"]][["version"]]
[01:27:46.492]                         if (is.null(version)) 
[01:27:46.492]                           version <- utils::packageVersion("future")
[01:27:46.492]                       }
[01:27:46.492]                       else {
[01:27:46.492]                         version <- NULL
[01:27:46.492]                       }
[01:27:46.492]                       if (!has_future || version < "1.8.0") {
[01:27:46.492]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.492]                           "", base::R.version$version.string), 
[01:27:46.492]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.492]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.492]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.492]                             "release", "version")], collapse = " "), 
[01:27:46.492]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.492]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.492]                           info)
[01:27:46.492]                         info <- base::paste(info, collapse = "; ")
[01:27:46.492]                         if (!has_future) {
[01:27:46.492]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.492]                             info)
[01:27:46.492]                         }
[01:27:46.492]                         else {
[01:27:46.492]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.492]                             info, version)
[01:27:46.492]                         }
[01:27:46.492]                         base::stop(msg)
[01:27:46.492]                       }
[01:27:46.492]                     })
[01:27:46.492]                   }
[01:27:46.492]                   options(future.plan = NULL)
[01:27:46.492]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.492]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.492]                 }
[01:27:46.492]                 ...future.workdir <- getwd()
[01:27:46.492]             }
[01:27:46.492]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.492]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.492]         }
[01:27:46.492]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.492]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.492]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.492]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.492]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.492]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.492]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.492]             base::names(...future.oldOptions))
[01:27:46.492]     }
[01:27:46.492]     if (FALSE) {
[01:27:46.492]     }
[01:27:46.492]     else {
[01:27:46.492]         if (TRUE) {
[01:27:46.492]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.492]                 open = "w")
[01:27:46.492]         }
[01:27:46.492]         else {
[01:27:46.492]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.492]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.492]         }
[01:27:46.492]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.492]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.492]             base::sink(type = "output", split = FALSE)
[01:27:46.492]             base::close(...future.stdout)
[01:27:46.492]         }, add = TRUE)
[01:27:46.492]     }
[01:27:46.492]     ...future.frame <- base::sys.nframe()
[01:27:46.492]     ...future.conditions <- base::list()
[01:27:46.492]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.492]     if (FALSE) {
[01:27:46.492]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.492]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.492]     }
[01:27:46.492]     ...future.result <- base::tryCatch({
[01:27:46.492]         base::withCallingHandlers({
[01:27:46.492]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.492]             future::FutureResult(value = ...future.value$value, 
[01:27:46.492]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.492]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.492]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.492]                     ...future.globalenv.names))
[01:27:46.492]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.492]         }, condition = base::local({
[01:27:46.492]             c <- base::c
[01:27:46.492]             inherits <- base::inherits
[01:27:46.492]             invokeRestart <- base::invokeRestart
[01:27:46.492]             length <- base::length
[01:27:46.492]             list <- base::list
[01:27:46.492]             seq.int <- base::seq.int
[01:27:46.492]             signalCondition <- base::signalCondition
[01:27:46.492]             sys.calls <- base::sys.calls
[01:27:46.492]             `[[` <- base::`[[`
[01:27:46.492]             `+` <- base::`+`
[01:27:46.492]             `<<-` <- base::`<<-`
[01:27:46.492]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.492]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.492]                   3L)]
[01:27:46.492]             }
[01:27:46.492]             function(cond) {
[01:27:46.492]                 is_error <- inherits(cond, "error")
[01:27:46.492]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.492]                   NULL)
[01:27:46.492]                 if (is_error) {
[01:27:46.492]                   sessionInformation <- function() {
[01:27:46.492]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.492]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.492]                       search = base::search(), system = base::Sys.info())
[01:27:46.492]                   }
[01:27:46.492]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.492]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.492]                     cond$call), session = sessionInformation(), 
[01:27:46.492]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.492]                   signalCondition(cond)
[01:27:46.492]                 }
[01:27:46.492]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.492]                 "immediateCondition"))) {
[01:27:46.492]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.492]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.492]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.492]                   if (TRUE && !signal) {
[01:27:46.492]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.492]                     {
[01:27:46.492]                       inherits <- base::inherits
[01:27:46.492]                       invokeRestart <- base::invokeRestart
[01:27:46.492]                       is.null <- base::is.null
[01:27:46.492]                       muffled <- FALSE
[01:27:46.492]                       if (inherits(cond, "message")) {
[01:27:46.492]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.492]                         if (muffled) 
[01:27:46.492]                           invokeRestart("muffleMessage")
[01:27:46.492]                       }
[01:27:46.492]                       else if (inherits(cond, "warning")) {
[01:27:46.492]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.492]                         if (muffled) 
[01:27:46.492]                           invokeRestart("muffleWarning")
[01:27:46.492]                       }
[01:27:46.492]                       else if (inherits(cond, "condition")) {
[01:27:46.492]                         if (!is.null(pattern)) {
[01:27:46.492]                           computeRestarts <- base::computeRestarts
[01:27:46.492]                           grepl <- base::grepl
[01:27:46.492]                           restarts <- computeRestarts(cond)
[01:27:46.492]                           for (restart in restarts) {
[01:27:46.492]                             name <- restart$name
[01:27:46.492]                             if (is.null(name)) 
[01:27:46.492]                               next
[01:27:46.492]                             if (!grepl(pattern, name)) 
[01:27:46.492]                               next
[01:27:46.492]                             invokeRestart(restart)
[01:27:46.492]                             muffled <- TRUE
[01:27:46.492]                             break
[01:27:46.492]                           }
[01:27:46.492]                         }
[01:27:46.492]                       }
[01:27:46.492]                       invisible(muffled)
[01:27:46.492]                     }
[01:27:46.492]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.492]                   }
[01:27:46.492]                 }
[01:27:46.492]                 else {
[01:27:46.492]                   if (TRUE) {
[01:27:46.492]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.492]                     {
[01:27:46.492]                       inherits <- base::inherits
[01:27:46.492]                       invokeRestart <- base::invokeRestart
[01:27:46.492]                       is.null <- base::is.null
[01:27:46.492]                       muffled <- FALSE
[01:27:46.492]                       if (inherits(cond, "message")) {
[01:27:46.492]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.492]                         if (muffled) 
[01:27:46.492]                           invokeRestart("muffleMessage")
[01:27:46.492]                       }
[01:27:46.492]                       else if (inherits(cond, "warning")) {
[01:27:46.492]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.492]                         if (muffled) 
[01:27:46.492]                           invokeRestart("muffleWarning")
[01:27:46.492]                       }
[01:27:46.492]                       else if (inherits(cond, "condition")) {
[01:27:46.492]                         if (!is.null(pattern)) {
[01:27:46.492]                           computeRestarts <- base::computeRestarts
[01:27:46.492]                           grepl <- base::grepl
[01:27:46.492]                           restarts <- computeRestarts(cond)
[01:27:46.492]                           for (restart in restarts) {
[01:27:46.492]                             name <- restart$name
[01:27:46.492]                             if (is.null(name)) 
[01:27:46.492]                               next
[01:27:46.492]                             if (!grepl(pattern, name)) 
[01:27:46.492]                               next
[01:27:46.492]                             invokeRestart(restart)
[01:27:46.492]                             muffled <- TRUE
[01:27:46.492]                             break
[01:27:46.492]                           }
[01:27:46.492]                         }
[01:27:46.492]                       }
[01:27:46.492]                       invisible(muffled)
[01:27:46.492]                     }
[01:27:46.492]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.492]                   }
[01:27:46.492]                 }
[01:27:46.492]             }
[01:27:46.492]         }))
[01:27:46.492]     }, error = function(ex) {
[01:27:46.492]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.492]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.492]                 ...future.rng), started = ...future.startTime, 
[01:27:46.492]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.492]             version = "1.8"), class = "FutureResult")
[01:27:46.492]     }, finally = {
[01:27:46.492]         if (!identical(...future.workdir, getwd())) 
[01:27:46.492]             setwd(...future.workdir)
[01:27:46.492]         {
[01:27:46.492]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.492]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.492]             }
[01:27:46.492]             base::options(...future.oldOptions)
[01:27:46.492]             if (.Platform$OS.type == "windows") {
[01:27:46.492]                 old_names <- names(...future.oldEnvVars)
[01:27:46.492]                 envs <- base::Sys.getenv()
[01:27:46.492]                 names <- names(envs)
[01:27:46.492]                 common <- intersect(names, old_names)
[01:27:46.492]                 added <- setdiff(names, old_names)
[01:27:46.492]                 removed <- setdiff(old_names, names)
[01:27:46.492]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.492]                   envs[common]]
[01:27:46.492]                 NAMES <- toupper(changed)
[01:27:46.492]                 args <- list()
[01:27:46.492]                 for (kk in seq_along(NAMES)) {
[01:27:46.492]                   name <- changed[[kk]]
[01:27:46.492]                   NAME <- NAMES[[kk]]
[01:27:46.492]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.492]                     next
[01:27:46.492]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.492]                 }
[01:27:46.492]                 NAMES <- toupper(added)
[01:27:46.492]                 for (kk in seq_along(NAMES)) {
[01:27:46.492]                   name <- added[[kk]]
[01:27:46.492]                   NAME <- NAMES[[kk]]
[01:27:46.492]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.492]                     next
[01:27:46.492]                   args[[name]] <- ""
[01:27:46.492]                 }
[01:27:46.492]                 NAMES <- toupper(removed)
[01:27:46.492]                 for (kk in seq_along(NAMES)) {
[01:27:46.492]                   name <- removed[[kk]]
[01:27:46.492]                   NAME <- NAMES[[kk]]
[01:27:46.492]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.492]                     next
[01:27:46.492]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.492]                 }
[01:27:46.492]                 if (length(args) > 0) 
[01:27:46.492]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.492]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.492]             }
[01:27:46.492]             else {
[01:27:46.492]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.492]             }
[01:27:46.492]             {
[01:27:46.492]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.492]                   0L) {
[01:27:46.492]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.492]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.492]                   base::options(opts)
[01:27:46.492]                 }
[01:27:46.492]                 {
[01:27:46.492]                   {
[01:27:46.492]                     NULL
[01:27:46.492]                     RNGkind("Mersenne-Twister")
[01:27:46.492]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.492]                       inherits = FALSE)
[01:27:46.492]                   }
[01:27:46.492]                   options(future.plan = NULL)
[01:27:46.492]                   if (is.na(NA_character_)) 
[01:27:46.492]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.492]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.492]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.492]                   {
[01:27:46.492]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.492]                     if (!future$lazy) 
[01:27:46.492]                       future <- run(future)
[01:27:46.492]                     invisible(future)
[01:27:46.492]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.492]                 }
[01:27:46.492]             }
[01:27:46.492]         }
[01:27:46.492]     })
[01:27:46.492]     if (TRUE) {
[01:27:46.492]         base::sink(type = "output", split = FALSE)
[01:27:46.492]         if (TRUE) {
[01:27:46.492]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.492]         }
[01:27:46.492]         else {
[01:27:46.492]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.492]         }
[01:27:46.492]         base::close(...future.stdout)
[01:27:46.492]         ...future.stdout <- NULL
[01:27:46.492]     }
[01:27:46.492]     ...future.result$conditions <- ...future.conditions
[01:27:46.492]     ...future.result$finished <- base::Sys.time()
[01:27:46.492]     ...future.result
[01:27:46.492] }
[01:27:46.496] plan(): Setting new future strategy stack:
[01:27:46.497] List of future strategies:
[01:27:46.497] 1. sequential:
[01:27:46.497]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.497]    - tweaked: FALSE
[01:27:46.497]    - call: NULL
[01:27:46.497] plan(): nbrOfWorkers() = 1
[01:27:46.499] plan(): Setting new future strategy stack:
[01:27:46.499] List of future strategies:
[01:27:46.499] 1. sequential:
[01:27:46.499]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.499]    - tweaked: FALSE
[01:27:46.499]    - call: plan(strategy)
[01:27:46.500] plan(): nbrOfWorkers() = 1
[01:27:46.500] SequentialFuture started (and completed)
[01:27:46.500] - Launch lazy future ... done
[01:27:46.500] run() for 'SequentialFuture' ... done
[01:27:46.501] getGlobalsAndPackages() ...
[01:27:46.501] Searching for globals...
[01:27:46.502] - globals found: [1] '{'
[01:27:46.502] Searching for globals ... DONE
[01:27:46.503] Resolving globals: FALSE
[01:27:46.507] 
[01:27:46.507] 
[01:27:46.507] getGlobalsAndPackages() ... DONE
[01:27:46.508] run() for 'Future' ...
[01:27:46.508] - state: 'created'
[01:27:46.508] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.509] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.509] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.509]   - Field: 'label'
[01:27:46.510]   - Field: 'local'
[01:27:46.510]   - Field: 'owner'
[01:27:46.510]   - Field: 'envir'
[01:27:46.510]   - Field: 'packages'
[01:27:46.510]   - Field: 'gc'
[01:27:46.511]   - Field: 'conditions'
[01:27:46.511]   - Field: 'expr'
[01:27:46.511]   - Field: 'uuid'
[01:27:46.511]   - Field: 'seed'
[01:27:46.511]   - Field: 'version'
[01:27:46.512]   - Field: 'result'
[01:27:46.512]   - Field: 'asynchronous'
[01:27:46.512]   - Field: 'calls'
[01:27:46.512]   - Field: 'globals'
[01:27:46.512]   - Field: 'stdout'
[01:27:46.513]   - Field: 'earlySignal'
[01:27:46.513]   - Field: 'lazy'
[01:27:46.513]   - Field: 'state'
[01:27:46.513] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.513] - Launch lazy future ...
[01:27:46.514] Packages needed by the future expression (n = 0): <none>
[01:27:46.514] Packages needed by future strategies (n = 0): <none>
[01:27:46.515] {
[01:27:46.515]     {
[01:27:46.515]         {
[01:27:46.515]             ...future.startTime <- base::Sys.time()
[01:27:46.515]             {
[01:27:46.515]                 {
[01:27:46.515]                   {
[01:27:46.515]                     base::local({
[01:27:46.515]                       has_future <- base::requireNamespace("future", 
[01:27:46.515]                         quietly = TRUE)
[01:27:46.515]                       if (has_future) {
[01:27:46.515]                         ns <- base::getNamespace("future")
[01:27:46.515]                         version <- ns[[".package"]][["version"]]
[01:27:46.515]                         if (is.null(version)) 
[01:27:46.515]                           version <- utils::packageVersion("future")
[01:27:46.515]                       }
[01:27:46.515]                       else {
[01:27:46.515]                         version <- NULL
[01:27:46.515]                       }
[01:27:46.515]                       if (!has_future || version < "1.8.0") {
[01:27:46.515]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.515]                           "", base::R.version$version.string), 
[01:27:46.515]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.515]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.515]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.515]                             "release", "version")], collapse = " "), 
[01:27:46.515]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.515]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.515]                           info)
[01:27:46.515]                         info <- base::paste(info, collapse = "; ")
[01:27:46.515]                         if (!has_future) {
[01:27:46.515]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.515]                             info)
[01:27:46.515]                         }
[01:27:46.515]                         else {
[01:27:46.515]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.515]                             info, version)
[01:27:46.515]                         }
[01:27:46.515]                         base::stop(msg)
[01:27:46.515]                       }
[01:27:46.515]                     })
[01:27:46.515]                   }
[01:27:46.515]                   options(future.plan = NULL)
[01:27:46.515]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.515]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.515]                 }
[01:27:46.515]                 ...future.workdir <- getwd()
[01:27:46.515]             }
[01:27:46.515]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.515]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.515]         }
[01:27:46.515]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.515]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.515]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.515]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.515]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.515]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.515]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.515]             base::names(...future.oldOptions))
[01:27:46.515]     }
[01:27:46.515]     if (FALSE) {
[01:27:46.515]     }
[01:27:46.515]     else {
[01:27:46.515]         if (TRUE) {
[01:27:46.515]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.515]                 open = "w")
[01:27:46.515]         }
[01:27:46.515]         else {
[01:27:46.515]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.515]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.515]         }
[01:27:46.515]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.515]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.515]             base::sink(type = "output", split = FALSE)
[01:27:46.515]             base::close(...future.stdout)
[01:27:46.515]         }, add = TRUE)
[01:27:46.515]     }
[01:27:46.515]     ...future.frame <- base::sys.nframe()
[01:27:46.515]     ...future.conditions <- base::list()
[01:27:46.515]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.515]     if (FALSE) {
[01:27:46.515]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.515]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.515]     }
[01:27:46.515]     ...future.result <- base::tryCatch({
[01:27:46.515]         base::withCallingHandlers({
[01:27:46.515]             ...future.value <- base::withVisible(base::local({
[01:27:46.515]                 4
[01:27:46.515]             }))
[01:27:46.515]             future::FutureResult(value = ...future.value$value, 
[01:27:46.515]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.515]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.515]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.515]                     ...future.globalenv.names))
[01:27:46.515]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.515]         }, condition = base::local({
[01:27:46.515]             c <- base::c
[01:27:46.515]             inherits <- base::inherits
[01:27:46.515]             invokeRestart <- base::invokeRestart
[01:27:46.515]             length <- base::length
[01:27:46.515]             list <- base::list
[01:27:46.515]             seq.int <- base::seq.int
[01:27:46.515]             signalCondition <- base::signalCondition
[01:27:46.515]             sys.calls <- base::sys.calls
[01:27:46.515]             `[[` <- base::`[[`
[01:27:46.515]             `+` <- base::`+`
[01:27:46.515]             `<<-` <- base::`<<-`
[01:27:46.515]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.515]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.515]                   3L)]
[01:27:46.515]             }
[01:27:46.515]             function(cond) {
[01:27:46.515]                 is_error <- inherits(cond, "error")
[01:27:46.515]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.515]                   NULL)
[01:27:46.515]                 if (is_error) {
[01:27:46.515]                   sessionInformation <- function() {
[01:27:46.515]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.515]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.515]                       search = base::search(), system = base::Sys.info())
[01:27:46.515]                   }
[01:27:46.515]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.515]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.515]                     cond$call), session = sessionInformation(), 
[01:27:46.515]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.515]                   signalCondition(cond)
[01:27:46.515]                 }
[01:27:46.515]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.515]                 "immediateCondition"))) {
[01:27:46.515]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.515]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.515]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.515]                   if (TRUE && !signal) {
[01:27:46.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.515]                     {
[01:27:46.515]                       inherits <- base::inherits
[01:27:46.515]                       invokeRestart <- base::invokeRestart
[01:27:46.515]                       is.null <- base::is.null
[01:27:46.515]                       muffled <- FALSE
[01:27:46.515]                       if (inherits(cond, "message")) {
[01:27:46.515]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.515]                         if (muffled) 
[01:27:46.515]                           invokeRestart("muffleMessage")
[01:27:46.515]                       }
[01:27:46.515]                       else if (inherits(cond, "warning")) {
[01:27:46.515]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.515]                         if (muffled) 
[01:27:46.515]                           invokeRestart("muffleWarning")
[01:27:46.515]                       }
[01:27:46.515]                       else if (inherits(cond, "condition")) {
[01:27:46.515]                         if (!is.null(pattern)) {
[01:27:46.515]                           computeRestarts <- base::computeRestarts
[01:27:46.515]                           grepl <- base::grepl
[01:27:46.515]                           restarts <- computeRestarts(cond)
[01:27:46.515]                           for (restart in restarts) {
[01:27:46.515]                             name <- restart$name
[01:27:46.515]                             if (is.null(name)) 
[01:27:46.515]                               next
[01:27:46.515]                             if (!grepl(pattern, name)) 
[01:27:46.515]                               next
[01:27:46.515]                             invokeRestart(restart)
[01:27:46.515]                             muffled <- TRUE
[01:27:46.515]                             break
[01:27:46.515]                           }
[01:27:46.515]                         }
[01:27:46.515]                       }
[01:27:46.515]                       invisible(muffled)
[01:27:46.515]                     }
[01:27:46.515]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.515]                   }
[01:27:46.515]                 }
[01:27:46.515]                 else {
[01:27:46.515]                   if (TRUE) {
[01:27:46.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.515]                     {
[01:27:46.515]                       inherits <- base::inherits
[01:27:46.515]                       invokeRestart <- base::invokeRestart
[01:27:46.515]                       is.null <- base::is.null
[01:27:46.515]                       muffled <- FALSE
[01:27:46.515]                       if (inherits(cond, "message")) {
[01:27:46.515]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.515]                         if (muffled) 
[01:27:46.515]                           invokeRestart("muffleMessage")
[01:27:46.515]                       }
[01:27:46.515]                       else if (inherits(cond, "warning")) {
[01:27:46.515]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.515]                         if (muffled) 
[01:27:46.515]                           invokeRestart("muffleWarning")
[01:27:46.515]                       }
[01:27:46.515]                       else if (inherits(cond, "condition")) {
[01:27:46.515]                         if (!is.null(pattern)) {
[01:27:46.515]                           computeRestarts <- base::computeRestarts
[01:27:46.515]                           grepl <- base::grepl
[01:27:46.515]                           restarts <- computeRestarts(cond)
[01:27:46.515]                           for (restart in restarts) {
[01:27:46.515]                             name <- restart$name
[01:27:46.515]                             if (is.null(name)) 
[01:27:46.515]                               next
[01:27:46.515]                             if (!grepl(pattern, name)) 
[01:27:46.515]                               next
[01:27:46.515]                             invokeRestart(restart)
[01:27:46.515]                             muffled <- TRUE
[01:27:46.515]                             break
[01:27:46.515]                           }
[01:27:46.515]                         }
[01:27:46.515]                       }
[01:27:46.515]                       invisible(muffled)
[01:27:46.515]                     }
[01:27:46.515]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.515]                   }
[01:27:46.515]                 }
[01:27:46.515]             }
[01:27:46.515]         }))
[01:27:46.515]     }, error = function(ex) {
[01:27:46.515]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.515]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.515]                 ...future.rng), started = ...future.startTime, 
[01:27:46.515]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.515]             version = "1.8"), class = "FutureResult")
[01:27:46.515]     }, finally = {
[01:27:46.515]         if (!identical(...future.workdir, getwd())) 
[01:27:46.515]             setwd(...future.workdir)
[01:27:46.515]         {
[01:27:46.515]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.515]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.515]             }
[01:27:46.515]             base::options(...future.oldOptions)
[01:27:46.515]             if (.Platform$OS.type == "windows") {
[01:27:46.515]                 old_names <- names(...future.oldEnvVars)
[01:27:46.515]                 envs <- base::Sys.getenv()
[01:27:46.515]                 names <- names(envs)
[01:27:46.515]                 common <- intersect(names, old_names)
[01:27:46.515]                 added <- setdiff(names, old_names)
[01:27:46.515]                 removed <- setdiff(old_names, names)
[01:27:46.515]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.515]                   envs[common]]
[01:27:46.515]                 NAMES <- toupper(changed)
[01:27:46.515]                 args <- list()
[01:27:46.515]                 for (kk in seq_along(NAMES)) {
[01:27:46.515]                   name <- changed[[kk]]
[01:27:46.515]                   NAME <- NAMES[[kk]]
[01:27:46.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.515]                     next
[01:27:46.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.515]                 }
[01:27:46.515]                 NAMES <- toupper(added)
[01:27:46.515]                 for (kk in seq_along(NAMES)) {
[01:27:46.515]                   name <- added[[kk]]
[01:27:46.515]                   NAME <- NAMES[[kk]]
[01:27:46.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.515]                     next
[01:27:46.515]                   args[[name]] <- ""
[01:27:46.515]                 }
[01:27:46.515]                 NAMES <- toupper(removed)
[01:27:46.515]                 for (kk in seq_along(NAMES)) {
[01:27:46.515]                   name <- removed[[kk]]
[01:27:46.515]                   NAME <- NAMES[[kk]]
[01:27:46.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.515]                     next
[01:27:46.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.515]                 }
[01:27:46.515]                 if (length(args) > 0) 
[01:27:46.515]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.515]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.515]             }
[01:27:46.515]             else {
[01:27:46.515]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.515]             }
[01:27:46.515]             {
[01:27:46.515]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.515]                   0L) {
[01:27:46.515]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.515]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.515]                   base::options(opts)
[01:27:46.515]                 }
[01:27:46.515]                 {
[01:27:46.515]                   {
[01:27:46.515]                     NULL
[01:27:46.515]                     RNGkind("Mersenne-Twister")
[01:27:46.515]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.515]                       inherits = FALSE)
[01:27:46.515]                   }
[01:27:46.515]                   options(future.plan = NULL)
[01:27:46.515]                   if (is.na(NA_character_)) 
[01:27:46.515]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.515]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.515]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.515]                   {
[01:27:46.515]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.515]                     if (!future$lazy) 
[01:27:46.515]                       future <- run(future)
[01:27:46.515]                     invisible(future)
[01:27:46.515]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.515]                 }
[01:27:46.515]             }
[01:27:46.515]         }
[01:27:46.515]     })
[01:27:46.515]     if (TRUE) {
[01:27:46.515]         base::sink(type = "output", split = FALSE)
[01:27:46.515]         if (TRUE) {
[01:27:46.515]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.515]         }
[01:27:46.515]         else {
[01:27:46.515]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.515]         }
[01:27:46.515]         base::close(...future.stdout)
[01:27:46.515]         ...future.stdout <- NULL
[01:27:46.515]     }
[01:27:46.515]     ...future.result$conditions <- ...future.conditions
[01:27:46.515]     ...future.result$finished <- base::Sys.time()
[01:27:46.515]     ...future.result
[01:27:46.515] }
[01:27:46.519] plan(): Setting new future strategy stack:
[01:27:46.519] List of future strategies:
[01:27:46.519] 1. sequential:
[01:27:46.519]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.519]    - tweaked: FALSE
[01:27:46.519]    - call: NULL
[01:27:46.520] plan(): nbrOfWorkers() = 1
[01:27:46.521] plan(): Setting new future strategy stack:
[01:27:46.521] List of future strategies:
[01:27:46.521] 1. sequential:
[01:27:46.521]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.521]    - tweaked: FALSE
[01:27:46.521]    - call: plan(strategy)
[01:27:46.522] plan(): nbrOfWorkers() = 1
[01:27:46.522] SequentialFuture started (and completed)
[01:27:46.522] - Launch lazy future ... done
[01:27:46.523] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b04ad2378> 
Classes 'listenv', 'environment' <environment: 0x0000025b0602e260> 
 - attr(*, "dim.")= int [1:2] 2 3
 - attr(*, "dimnames.")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
[01:27:46.528] resolved() for 'SequentialFuture' ...
[01:27:46.528] - state: 'finished'
[01:27:46.528] - run: TRUE
[01:27:46.528] - result: 'FutureResult'
[01:27:46.529] resolved() for 'SequentialFuture' ... done
[01:27:46.529] resolved() for 'SequentialFuture' ...
[01:27:46.529] - state: 'finished'
[01:27:46.529] - run: TRUE
[01:27:46.529] - result: 'FutureResult'
[01:27:46.530] resolved() for 'SequentialFuture' ... done
[01:27:46.530] resolved() for 'SequentialFuture' ...
[01:27:46.530] - state: 'finished'
[01:27:46.530] - run: TRUE
[01:27:46.531] - result: 'FutureResult'
[01:27:46.531] 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" ...
[01:27:46.534] resolve() on list environment ...
[01:27:46.534]  recursive: 0
[01:27:46.535]  length: 6
[01:27:46.536]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:46.536] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.536] - nx: 6
[01:27:46.536] - relay: TRUE
[01:27:46.536] - stdout: TRUE
[01:27:46.537] - signal: TRUE
[01:27:46.537] - resignal: FALSE
[01:27:46.537] - force: TRUE
[01:27:46.537] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.537] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.538]  - until=2
[01:27:46.538]  - relaying element #2
[01:27:46.538] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.538] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.538] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.538]  length: 5 (resolved future 1)
[01:27:46.539] resolved() for 'SequentialFuture' ...
[01:27:46.539] - state: 'finished'
[01:27:46.539] - run: TRUE
[01:27:46.539] - result: 'FutureResult'
[01:27:46.540] resolved() for 'SequentialFuture' ... done
[01:27:46.540] Future #2
[01:27:46.540] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.540] - nx: 6
[01:27:46.540] - relay: TRUE
[01:27:46.541] - stdout: TRUE
[01:27:46.541] - signal: TRUE
[01:27:46.541] - resignal: FALSE
[01:27:46.541] - force: TRUE
[01:27:46.541] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.541] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.542]  - until=2
[01:27:46.542]  - relaying element #2
[01:27:46.542] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.542] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.543] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.543]  length: 4 (resolved future 2)
[01:27:46.547] resolved() for 'SequentialFuture' ...
[01:27:46.547] - state: 'finished'
[01:27:46.548] - run: TRUE
[01:27:46.548] - result: 'FutureResult'
[01:27:46.548] resolved() for 'SequentialFuture' ... done
[01:27:46.548] Future #3
[01:27:46.549] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.549] - nx: 6
[01:27:46.549] - relay: TRUE
[01:27:46.550] - stdout: TRUE
[01:27:46.550] - signal: TRUE
[01:27:46.550] - resignal: FALSE
[01:27:46.550] - force: TRUE
[01:27:46.550] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.551] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.551]  - until=3
[01:27:46.551]  - relaying element #3
[01:27:46.551] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.552] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.552] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.552]  length: 3 (resolved future 3)
[01:27:46.552] resolved() for 'SequentialFuture' ...
[01:27:46.553] - state: 'finished'
[01:27:46.553] - run: TRUE
[01:27:46.553] - result: 'FutureResult'
[01:27:46.553] resolved() for 'SequentialFuture' ... done
[01:27:46.553] Future #4
[01:27:46.554] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.554] - nx: 6
[01:27:46.554] - relay: TRUE
[01:27:46.554] - stdout: TRUE
[01:27:46.554] - signal: TRUE
[01:27:46.555] - resignal: FALSE
[01:27:46.555] - force: TRUE
[01:27:46.555] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.555] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.555]  - until=4
[01:27:46.556]  - relaying element #4
[01:27:46.556] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.556] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.556] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.557]  length: 2 (resolved future 4)
[01:27:46.557] signalConditionsASAP(NULL, pos=5) ...
[01:27:46.557] - nx: 6
[01:27:46.557] - relay: TRUE
[01:27:46.557] - stdout: TRUE
[01:27:46.557] - signal: TRUE
[01:27:46.558] - resignal: FALSE
[01:27:46.558] - force: TRUE
[01:27:46.558] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.558] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.558]  - until=6
[01:27:46.558]  - relaying element #6
[01:27:46.559] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.559] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.559] signalConditionsASAP(NULL, pos=5) ... done
[01:27:46.559]  length: 1 (resolved future 5)
[01:27:46.559] signalConditionsASAP(numeric, pos=6) ...
[01:27:46.560] - nx: 6
[01:27:46.560] - relay: TRUE
[01:27:46.560] - stdout: TRUE
[01:27:46.560] - signal: TRUE
[01:27:46.560] - resignal: FALSE
[01:27:46.560] - force: TRUE
[01:27:46.561] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.561] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.561]  - until=6
[01:27:46.561] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.561] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.562] signalConditionsASAP(numeric, pos=6) ... done
[01:27:46.562]  length: 0 (resolved future 6)
[01:27:46.562] Relaying remaining futures
[01:27:46.562] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.562] - nx: 6
[01:27:46.562] - relay: TRUE
[01:27:46.563] - stdout: TRUE
[01:27:46.563] - signal: TRUE
[01:27:46.563] - resignal: FALSE
[01:27:46.563] - force: TRUE
[01:27:46.563] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.564] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:46.564] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.564] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.564] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.564] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x0000025b07d77d50> 
 - 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)
[01:27:46.568] getGlobalsAndPackages() ...
[01:27:46.568] Searching for globals...
[01:27:46.569] 
[01:27:46.569] Searching for globals ... DONE
[01:27:46.569] - globals: [0] <none>
[01:27:46.570] getGlobalsAndPackages() ... DONE
[01:27:46.570] run() for 'Future' ...
[01:27:46.570] - state: 'created'
[01:27:46.571] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.572] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.573] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.573]   - Field: 'label'
[01:27:46.573]   - Field: 'local'
[01:27:46.574]   - Field: 'owner'
[01:27:46.574]   - Field: 'envir'
[01:27:46.574]   - Field: 'packages'
[01:27:46.574]   - Field: 'gc'
[01:27:46.574]   - Field: 'conditions'
[01:27:46.575]   - Field: 'expr'
[01:27:46.575]   - Field: 'uuid'
[01:27:46.575]   - Field: 'seed'
[01:27:46.575]   - Field: 'version'
[01:27:46.575]   - Field: 'result'
[01:27:46.576]   - Field: 'asynchronous'
[01:27:46.576]   - Field: 'calls'
[01:27:46.576]   - Field: 'globals'
[01:27:46.577]   - Field: 'stdout'
[01:27:46.577]   - Field: 'earlySignal'
[01:27:46.577]   - Field: 'lazy'
[01:27:46.577]   - Field: 'state'
[01:27:46.578] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.578] - Launch lazy future ...
[01:27:46.578] Packages needed by the future expression (n = 0): <none>
[01:27:46.579] Packages needed by future strategies (n = 0): <none>
[01:27:46.580] {
[01:27:46.580]     {
[01:27:46.580]         {
[01:27:46.580]             ...future.startTime <- base::Sys.time()
[01:27:46.580]             {
[01:27:46.580]                 {
[01:27:46.580]                   {
[01:27:46.580]                     base::local({
[01:27:46.580]                       has_future <- base::requireNamespace("future", 
[01:27:46.580]                         quietly = TRUE)
[01:27:46.580]                       if (has_future) {
[01:27:46.580]                         ns <- base::getNamespace("future")
[01:27:46.580]                         version <- ns[[".package"]][["version"]]
[01:27:46.580]                         if (is.null(version)) 
[01:27:46.580]                           version <- utils::packageVersion("future")
[01:27:46.580]                       }
[01:27:46.580]                       else {
[01:27:46.580]                         version <- NULL
[01:27:46.580]                       }
[01:27:46.580]                       if (!has_future || version < "1.8.0") {
[01:27:46.580]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.580]                           "", base::R.version$version.string), 
[01:27:46.580]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.580]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.580]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.580]                             "release", "version")], collapse = " "), 
[01:27:46.580]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.580]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.580]                           info)
[01:27:46.580]                         info <- base::paste(info, collapse = "; ")
[01:27:46.580]                         if (!has_future) {
[01:27:46.580]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.580]                             info)
[01:27:46.580]                         }
[01:27:46.580]                         else {
[01:27:46.580]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.580]                             info, version)
[01:27:46.580]                         }
[01:27:46.580]                         base::stop(msg)
[01:27:46.580]                       }
[01:27:46.580]                     })
[01:27:46.580]                   }
[01:27:46.580]                   options(future.plan = NULL)
[01:27:46.580]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.580]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.580]                 }
[01:27:46.580]                 ...future.workdir <- getwd()
[01:27:46.580]             }
[01:27:46.580]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.580]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.580]         }
[01:27:46.580]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.580]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.580]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.580]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.580]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.580]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.580]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.580]             base::names(...future.oldOptions))
[01:27:46.580]     }
[01:27:46.580]     if (FALSE) {
[01:27:46.580]     }
[01:27:46.580]     else {
[01:27:46.580]         if (TRUE) {
[01:27:46.580]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.580]                 open = "w")
[01:27:46.580]         }
[01:27:46.580]         else {
[01:27:46.580]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.580]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.580]         }
[01:27:46.580]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.580]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.580]             base::sink(type = "output", split = FALSE)
[01:27:46.580]             base::close(...future.stdout)
[01:27:46.580]         }, add = TRUE)
[01:27:46.580]     }
[01:27:46.580]     ...future.frame <- base::sys.nframe()
[01:27:46.580]     ...future.conditions <- base::list()
[01:27:46.580]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.580]     if (FALSE) {
[01:27:46.580]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.580]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.580]     }
[01:27:46.580]     ...future.result <- base::tryCatch({
[01:27:46.580]         base::withCallingHandlers({
[01:27:46.580]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.580]             future::FutureResult(value = ...future.value$value, 
[01:27:46.580]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.580]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.580]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.580]                     ...future.globalenv.names))
[01:27:46.580]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.580]         }, condition = base::local({
[01:27:46.580]             c <- base::c
[01:27:46.580]             inherits <- base::inherits
[01:27:46.580]             invokeRestart <- base::invokeRestart
[01:27:46.580]             length <- base::length
[01:27:46.580]             list <- base::list
[01:27:46.580]             seq.int <- base::seq.int
[01:27:46.580]             signalCondition <- base::signalCondition
[01:27:46.580]             sys.calls <- base::sys.calls
[01:27:46.580]             `[[` <- base::`[[`
[01:27:46.580]             `+` <- base::`+`
[01:27:46.580]             `<<-` <- base::`<<-`
[01:27:46.580]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.580]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.580]                   3L)]
[01:27:46.580]             }
[01:27:46.580]             function(cond) {
[01:27:46.580]                 is_error <- inherits(cond, "error")
[01:27:46.580]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.580]                   NULL)
[01:27:46.580]                 if (is_error) {
[01:27:46.580]                   sessionInformation <- function() {
[01:27:46.580]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.580]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.580]                       search = base::search(), system = base::Sys.info())
[01:27:46.580]                   }
[01:27:46.580]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.580]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.580]                     cond$call), session = sessionInformation(), 
[01:27:46.580]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.580]                   signalCondition(cond)
[01:27:46.580]                 }
[01:27:46.580]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.580]                 "immediateCondition"))) {
[01:27:46.580]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.580]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.580]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.580]                   if (TRUE && !signal) {
[01:27:46.580]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.580]                     {
[01:27:46.580]                       inherits <- base::inherits
[01:27:46.580]                       invokeRestart <- base::invokeRestart
[01:27:46.580]                       is.null <- base::is.null
[01:27:46.580]                       muffled <- FALSE
[01:27:46.580]                       if (inherits(cond, "message")) {
[01:27:46.580]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.580]                         if (muffled) 
[01:27:46.580]                           invokeRestart("muffleMessage")
[01:27:46.580]                       }
[01:27:46.580]                       else if (inherits(cond, "warning")) {
[01:27:46.580]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.580]                         if (muffled) 
[01:27:46.580]                           invokeRestart("muffleWarning")
[01:27:46.580]                       }
[01:27:46.580]                       else if (inherits(cond, "condition")) {
[01:27:46.580]                         if (!is.null(pattern)) {
[01:27:46.580]                           computeRestarts <- base::computeRestarts
[01:27:46.580]                           grepl <- base::grepl
[01:27:46.580]                           restarts <- computeRestarts(cond)
[01:27:46.580]                           for (restart in restarts) {
[01:27:46.580]                             name <- restart$name
[01:27:46.580]                             if (is.null(name)) 
[01:27:46.580]                               next
[01:27:46.580]                             if (!grepl(pattern, name)) 
[01:27:46.580]                               next
[01:27:46.580]                             invokeRestart(restart)
[01:27:46.580]                             muffled <- TRUE
[01:27:46.580]                             break
[01:27:46.580]                           }
[01:27:46.580]                         }
[01:27:46.580]                       }
[01:27:46.580]                       invisible(muffled)
[01:27:46.580]                     }
[01:27:46.580]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.580]                   }
[01:27:46.580]                 }
[01:27:46.580]                 else {
[01:27:46.580]                   if (TRUE) {
[01:27:46.580]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.580]                     {
[01:27:46.580]                       inherits <- base::inherits
[01:27:46.580]                       invokeRestart <- base::invokeRestart
[01:27:46.580]                       is.null <- base::is.null
[01:27:46.580]                       muffled <- FALSE
[01:27:46.580]                       if (inherits(cond, "message")) {
[01:27:46.580]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.580]                         if (muffled) 
[01:27:46.580]                           invokeRestart("muffleMessage")
[01:27:46.580]                       }
[01:27:46.580]                       else if (inherits(cond, "warning")) {
[01:27:46.580]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.580]                         if (muffled) 
[01:27:46.580]                           invokeRestart("muffleWarning")
[01:27:46.580]                       }
[01:27:46.580]                       else if (inherits(cond, "condition")) {
[01:27:46.580]                         if (!is.null(pattern)) {
[01:27:46.580]                           computeRestarts <- base::computeRestarts
[01:27:46.580]                           grepl <- base::grepl
[01:27:46.580]                           restarts <- computeRestarts(cond)
[01:27:46.580]                           for (restart in restarts) {
[01:27:46.580]                             name <- restart$name
[01:27:46.580]                             if (is.null(name)) 
[01:27:46.580]                               next
[01:27:46.580]                             if (!grepl(pattern, name)) 
[01:27:46.580]                               next
[01:27:46.580]                             invokeRestart(restart)
[01:27:46.580]                             muffled <- TRUE
[01:27:46.580]                             break
[01:27:46.580]                           }
[01:27:46.580]                         }
[01:27:46.580]                       }
[01:27:46.580]                       invisible(muffled)
[01:27:46.580]                     }
[01:27:46.580]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.580]                   }
[01:27:46.580]                 }
[01:27:46.580]             }
[01:27:46.580]         }))
[01:27:46.580]     }, error = function(ex) {
[01:27:46.580]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.580]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.580]                 ...future.rng), started = ...future.startTime, 
[01:27:46.580]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.580]             version = "1.8"), class = "FutureResult")
[01:27:46.580]     }, finally = {
[01:27:46.580]         if (!identical(...future.workdir, getwd())) 
[01:27:46.580]             setwd(...future.workdir)
[01:27:46.580]         {
[01:27:46.580]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.580]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.580]             }
[01:27:46.580]             base::options(...future.oldOptions)
[01:27:46.580]             if (.Platform$OS.type == "windows") {
[01:27:46.580]                 old_names <- names(...future.oldEnvVars)
[01:27:46.580]                 envs <- base::Sys.getenv()
[01:27:46.580]                 names <- names(envs)
[01:27:46.580]                 common <- intersect(names, old_names)
[01:27:46.580]                 added <- setdiff(names, old_names)
[01:27:46.580]                 removed <- setdiff(old_names, names)
[01:27:46.580]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.580]                   envs[common]]
[01:27:46.580]                 NAMES <- toupper(changed)
[01:27:46.580]                 args <- list()
[01:27:46.580]                 for (kk in seq_along(NAMES)) {
[01:27:46.580]                   name <- changed[[kk]]
[01:27:46.580]                   NAME <- NAMES[[kk]]
[01:27:46.580]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.580]                     next
[01:27:46.580]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.580]                 }
[01:27:46.580]                 NAMES <- toupper(added)
[01:27:46.580]                 for (kk in seq_along(NAMES)) {
[01:27:46.580]                   name <- added[[kk]]
[01:27:46.580]                   NAME <- NAMES[[kk]]
[01:27:46.580]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.580]                     next
[01:27:46.580]                   args[[name]] <- ""
[01:27:46.580]                 }
[01:27:46.580]                 NAMES <- toupper(removed)
[01:27:46.580]                 for (kk in seq_along(NAMES)) {
[01:27:46.580]                   name <- removed[[kk]]
[01:27:46.580]                   NAME <- NAMES[[kk]]
[01:27:46.580]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.580]                     next
[01:27:46.580]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.580]                 }
[01:27:46.580]                 if (length(args) > 0) 
[01:27:46.580]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.580]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.580]             }
[01:27:46.580]             else {
[01:27:46.580]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.580]             }
[01:27:46.580]             {
[01:27:46.580]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.580]                   0L) {
[01:27:46.580]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.580]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.580]                   base::options(opts)
[01:27:46.580]                 }
[01:27:46.580]                 {
[01:27:46.580]                   {
[01:27:46.580]                     NULL
[01:27:46.580]                     RNGkind("Mersenne-Twister")
[01:27:46.580]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.580]                       inherits = FALSE)
[01:27:46.580]                   }
[01:27:46.580]                   options(future.plan = NULL)
[01:27:46.580]                   if (is.na(NA_character_)) 
[01:27:46.580]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.580]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.580]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.580]                   {
[01:27:46.580]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.580]                     if (!future$lazy) 
[01:27:46.580]                       future <- run(future)
[01:27:46.580]                     invisible(future)
[01:27:46.580]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.580]                 }
[01:27:46.580]             }
[01:27:46.580]         }
[01:27:46.580]     })
[01:27:46.580]     if (TRUE) {
[01:27:46.580]         base::sink(type = "output", split = FALSE)
[01:27:46.580]         if (TRUE) {
[01:27:46.580]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.580]         }
[01:27:46.580]         else {
[01:27:46.580]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.580]         }
[01:27:46.580]         base::close(...future.stdout)
[01:27:46.580]         ...future.stdout <- NULL
[01:27:46.580]     }
[01:27:46.580]     ...future.result$conditions <- ...future.conditions
[01:27:46.580]     ...future.result$finished <- base::Sys.time()
[01:27:46.580]     ...future.result
[01:27:46.580] }
[01:27:46.584] plan(): Setting new future strategy stack:
[01:27:46.585] List of future strategies:
[01:27:46.585] 1. sequential:
[01:27:46.585]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.585]    - tweaked: FALSE
[01:27:46.585]    - call: NULL
[01:27:46.586] plan(): nbrOfWorkers() = 1
[01:27:46.588] plan(): Setting new future strategy stack:
[01:27:46.588] List of future strategies:
[01:27:46.588] 1. sequential:
[01:27:46.588]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.588]    - tweaked: FALSE
[01:27:46.588]    - call: plan(strategy)
[01:27:46.589] plan(): nbrOfWorkers() = 1
[01:27:46.590] SequentialFuture started (and completed)
[01:27:46.590] - Launch lazy future ... done
[01:27:46.590] run() for 'SequentialFuture' ... done
[01:27:46.591] getGlobalsAndPackages() ...
[01:27:46.591] Searching for globals...
[01:27:46.592] 
[01:27:46.592] Searching for globals ... DONE
[01:27:46.592] - globals: [0] <none>
[01:27:46.592] getGlobalsAndPackages() ... DONE
[01:27:46.593] run() for 'Future' ...
[01:27:46.593] - state: 'created'
[01:27:46.594] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.594] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.595] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.595]   - Field: 'label'
[01:27:46.595]   - Field: 'local'
[01:27:46.595]   - Field: 'owner'
[01:27:46.596]   - Field: 'envir'
[01:27:46.600]   - Field: 'packages'
[01:27:46.600]   - Field: 'gc'
[01:27:46.601]   - Field: 'conditions'
[01:27:46.601]   - Field: 'expr'
[01:27:46.601]   - Field: 'uuid'
[01:27:46.601]   - Field: 'seed'
[01:27:46.602]   - Field: 'version'
[01:27:46.602]   - Field: 'result'
[01:27:46.603]   - Field: 'asynchronous'
[01:27:46.603]   - Field: 'calls'
[01:27:46.604]   - Field: 'globals'
[01:27:46.604]   - Field: 'stdout'
[01:27:46.604]   - Field: 'earlySignal'
[01:27:46.605]   - Field: 'lazy'
[01:27:46.605]   - Field: 'state'
[01:27:46.605] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.606] - Launch lazy future ...
[01:27:46.607] Packages needed by the future expression (n = 0): <none>
[01:27:46.607] Packages needed by future strategies (n = 0): <none>
[01:27:46.609] {
[01:27:46.609]     {
[01:27:46.609]         {
[01:27:46.609]             ...future.startTime <- base::Sys.time()
[01:27:46.609]             {
[01:27:46.609]                 {
[01:27:46.609]                   {
[01:27:46.609]                     base::local({
[01:27:46.609]                       has_future <- base::requireNamespace("future", 
[01:27:46.609]                         quietly = TRUE)
[01:27:46.609]                       if (has_future) {
[01:27:46.609]                         ns <- base::getNamespace("future")
[01:27:46.609]                         version <- ns[[".package"]][["version"]]
[01:27:46.609]                         if (is.null(version)) 
[01:27:46.609]                           version <- utils::packageVersion("future")
[01:27:46.609]                       }
[01:27:46.609]                       else {
[01:27:46.609]                         version <- NULL
[01:27:46.609]                       }
[01:27:46.609]                       if (!has_future || version < "1.8.0") {
[01:27:46.609]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.609]                           "", base::R.version$version.string), 
[01:27:46.609]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.609]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.609]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.609]                             "release", "version")], collapse = " "), 
[01:27:46.609]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.609]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.609]                           info)
[01:27:46.609]                         info <- base::paste(info, collapse = "; ")
[01:27:46.609]                         if (!has_future) {
[01:27:46.609]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.609]                             info)
[01:27:46.609]                         }
[01:27:46.609]                         else {
[01:27:46.609]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.609]                             info, version)
[01:27:46.609]                         }
[01:27:46.609]                         base::stop(msg)
[01:27:46.609]                       }
[01:27:46.609]                     })
[01:27:46.609]                   }
[01:27:46.609]                   options(future.plan = NULL)
[01:27:46.609]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.609]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.609]                 }
[01:27:46.609]                 ...future.workdir <- getwd()
[01:27:46.609]             }
[01:27:46.609]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.609]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.609]         }
[01:27:46.609]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.609]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.609]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.609]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.609]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.609]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.609]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.609]             base::names(...future.oldOptions))
[01:27:46.609]     }
[01:27:46.609]     if (FALSE) {
[01:27:46.609]     }
[01:27:46.609]     else {
[01:27:46.609]         if (TRUE) {
[01:27:46.609]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.609]                 open = "w")
[01:27:46.609]         }
[01:27:46.609]         else {
[01:27:46.609]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.609]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.609]         }
[01:27:46.609]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.609]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.609]             base::sink(type = "output", split = FALSE)
[01:27:46.609]             base::close(...future.stdout)
[01:27:46.609]         }, add = TRUE)
[01:27:46.609]     }
[01:27:46.609]     ...future.frame <- base::sys.nframe()
[01:27:46.609]     ...future.conditions <- base::list()
[01:27:46.609]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.609]     if (FALSE) {
[01:27:46.609]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.609]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.609]     }
[01:27:46.609]     ...future.result <- base::tryCatch({
[01:27:46.609]         base::withCallingHandlers({
[01:27:46.609]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.609]             future::FutureResult(value = ...future.value$value, 
[01:27:46.609]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.609]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.609]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.609]                     ...future.globalenv.names))
[01:27:46.609]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.609]         }, condition = base::local({
[01:27:46.609]             c <- base::c
[01:27:46.609]             inherits <- base::inherits
[01:27:46.609]             invokeRestart <- base::invokeRestart
[01:27:46.609]             length <- base::length
[01:27:46.609]             list <- base::list
[01:27:46.609]             seq.int <- base::seq.int
[01:27:46.609]             signalCondition <- base::signalCondition
[01:27:46.609]             sys.calls <- base::sys.calls
[01:27:46.609]             `[[` <- base::`[[`
[01:27:46.609]             `+` <- base::`+`
[01:27:46.609]             `<<-` <- base::`<<-`
[01:27:46.609]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.609]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.609]                   3L)]
[01:27:46.609]             }
[01:27:46.609]             function(cond) {
[01:27:46.609]                 is_error <- inherits(cond, "error")
[01:27:46.609]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.609]                   NULL)
[01:27:46.609]                 if (is_error) {
[01:27:46.609]                   sessionInformation <- function() {
[01:27:46.609]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.609]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.609]                       search = base::search(), system = base::Sys.info())
[01:27:46.609]                   }
[01:27:46.609]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.609]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.609]                     cond$call), session = sessionInformation(), 
[01:27:46.609]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.609]                   signalCondition(cond)
[01:27:46.609]                 }
[01:27:46.609]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.609]                 "immediateCondition"))) {
[01:27:46.609]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.609]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.609]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.609]                   if (TRUE && !signal) {
[01:27:46.609]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.609]                     {
[01:27:46.609]                       inherits <- base::inherits
[01:27:46.609]                       invokeRestart <- base::invokeRestart
[01:27:46.609]                       is.null <- base::is.null
[01:27:46.609]                       muffled <- FALSE
[01:27:46.609]                       if (inherits(cond, "message")) {
[01:27:46.609]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.609]                         if (muffled) 
[01:27:46.609]                           invokeRestart("muffleMessage")
[01:27:46.609]                       }
[01:27:46.609]                       else if (inherits(cond, "warning")) {
[01:27:46.609]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.609]                         if (muffled) 
[01:27:46.609]                           invokeRestart("muffleWarning")
[01:27:46.609]                       }
[01:27:46.609]                       else if (inherits(cond, "condition")) {
[01:27:46.609]                         if (!is.null(pattern)) {
[01:27:46.609]                           computeRestarts <- base::computeRestarts
[01:27:46.609]                           grepl <- base::grepl
[01:27:46.609]                           restarts <- computeRestarts(cond)
[01:27:46.609]                           for (restart in restarts) {
[01:27:46.609]                             name <- restart$name
[01:27:46.609]                             if (is.null(name)) 
[01:27:46.609]                               next
[01:27:46.609]                             if (!grepl(pattern, name)) 
[01:27:46.609]                               next
[01:27:46.609]                             invokeRestart(restart)
[01:27:46.609]                             muffled <- TRUE
[01:27:46.609]                             break
[01:27:46.609]                           }
[01:27:46.609]                         }
[01:27:46.609]                       }
[01:27:46.609]                       invisible(muffled)
[01:27:46.609]                     }
[01:27:46.609]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.609]                   }
[01:27:46.609]                 }
[01:27:46.609]                 else {
[01:27:46.609]                   if (TRUE) {
[01:27:46.609]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.609]                     {
[01:27:46.609]                       inherits <- base::inherits
[01:27:46.609]                       invokeRestart <- base::invokeRestart
[01:27:46.609]                       is.null <- base::is.null
[01:27:46.609]                       muffled <- FALSE
[01:27:46.609]                       if (inherits(cond, "message")) {
[01:27:46.609]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.609]                         if (muffled) 
[01:27:46.609]                           invokeRestart("muffleMessage")
[01:27:46.609]                       }
[01:27:46.609]                       else if (inherits(cond, "warning")) {
[01:27:46.609]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.609]                         if (muffled) 
[01:27:46.609]                           invokeRestart("muffleWarning")
[01:27:46.609]                       }
[01:27:46.609]                       else if (inherits(cond, "condition")) {
[01:27:46.609]                         if (!is.null(pattern)) {
[01:27:46.609]                           computeRestarts <- base::computeRestarts
[01:27:46.609]                           grepl <- base::grepl
[01:27:46.609]                           restarts <- computeRestarts(cond)
[01:27:46.609]                           for (restart in restarts) {
[01:27:46.609]                             name <- restart$name
[01:27:46.609]                             if (is.null(name)) 
[01:27:46.609]                               next
[01:27:46.609]                             if (!grepl(pattern, name)) 
[01:27:46.609]                               next
[01:27:46.609]                             invokeRestart(restart)
[01:27:46.609]                             muffled <- TRUE
[01:27:46.609]                             break
[01:27:46.609]                           }
[01:27:46.609]                         }
[01:27:46.609]                       }
[01:27:46.609]                       invisible(muffled)
[01:27:46.609]                     }
[01:27:46.609]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.609]                   }
[01:27:46.609]                 }
[01:27:46.609]             }
[01:27:46.609]         }))
[01:27:46.609]     }, error = function(ex) {
[01:27:46.609]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.609]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.609]                 ...future.rng), started = ...future.startTime, 
[01:27:46.609]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.609]             version = "1.8"), class = "FutureResult")
[01:27:46.609]     }, finally = {
[01:27:46.609]         if (!identical(...future.workdir, getwd())) 
[01:27:46.609]             setwd(...future.workdir)
[01:27:46.609]         {
[01:27:46.609]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.609]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.609]             }
[01:27:46.609]             base::options(...future.oldOptions)
[01:27:46.609]             if (.Platform$OS.type == "windows") {
[01:27:46.609]                 old_names <- names(...future.oldEnvVars)
[01:27:46.609]                 envs <- base::Sys.getenv()
[01:27:46.609]                 names <- names(envs)
[01:27:46.609]                 common <- intersect(names, old_names)
[01:27:46.609]                 added <- setdiff(names, old_names)
[01:27:46.609]                 removed <- setdiff(old_names, names)
[01:27:46.609]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.609]                   envs[common]]
[01:27:46.609]                 NAMES <- toupper(changed)
[01:27:46.609]                 args <- list()
[01:27:46.609]                 for (kk in seq_along(NAMES)) {
[01:27:46.609]                   name <- changed[[kk]]
[01:27:46.609]                   NAME <- NAMES[[kk]]
[01:27:46.609]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.609]                     next
[01:27:46.609]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.609]                 }
[01:27:46.609]                 NAMES <- toupper(added)
[01:27:46.609]                 for (kk in seq_along(NAMES)) {
[01:27:46.609]                   name <- added[[kk]]
[01:27:46.609]                   NAME <- NAMES[[kk]]
[01:27:46.609]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.609]                     next
[01:27:46.609]                   args[[name]] <- ""
[01:27:46.609]                 }
[01:27:46.609]                 NAMES <- toupper(removed)
[01:27:46.609]                 for (kk in seq_along(NAMES)) {
[01:27:46.609]                   name <- removed[[kk]]
[01:27:46.609]                   NAME <- NAMES[[kk]]
[01:27:46.609]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.609]                     next
[01:27:46.609]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.609]                 }
[01:27:46.609]                 if (length(args) > 0) 
[01:27:46.609]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.609]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.609]             }
[01:27:46.609]             else {
[01:27:46.609]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.609]             }
[01:27:46.609]             {
[01:27:46.609]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.609]                   0L) {
[01:27:46.609]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.609]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.609]                   base::options(opts)
[01:27:46.609]                 }
[01:27:46.609]                 {
[01:27:46.609]                   {
[01:27:46.609]                     NULL
[01:27:46.609]                     RNGkind("Mersenne-Twister")
[01:27:46.609]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.609]                       inherits = FALSE)
[01:27:46.609]                   }
[01:27:46.609]                   options(future.plan = NULL)
[01:27:46.609]                   if (is.na(NA_character_)) 
[01:27:46.609]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.609]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.609]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.609]                   {
[01:27:46.609]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.609]                     if (!future$lazy) 
[01:27:46.609]                       future <- run(future)
[01:27:46.609]                     invisible(future)
[01:27:46.609]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.609]                 }
[01:27:46.609]             }
[01:27:46.609]         }
[01:27:46.609]     })
[01:27:46.609]     if (TRUE) {
[01:27:46.609]         base::sink(type = "output", split = FALSE)
[01:27:46.609]         if (TRUE) {
[01:27:46.609]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.609]         }
[01:27:46.609]         else {
[01:27:46.609]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.609]         }
[01:27:46.609]         base::close(...future.stdout)
[01:27:46.609]         ...future.stdout <- NULL
[01:27:46.609]     }
[01:27:46.609]     ...future.result$conditions <- ...future.conditions
[01:27:46.609]     ...future.result$finished <- base::Sys.time()
[01:27:46.609]     ...future.result
[01:27:46.609] }
[01:27:46.614] plan(): Setting new future strategy stack:
[01:27:46.614] List of future strategies:
[01:27:46.614] 1. sequential:
[01:27:46.614]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.614]    - tweaked: FALSE
[01:27:46.614]    - call: NULL
[01:27:46.615] plan(): nbrOfWorkers() = 1
[01:27:46.616] plan(): Setting new future strategy stack:
[01:27:46.617] List of future strategies:
[01:27:46.617] 1. sequential:
[01:27:46.617]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.617]    - tweaked: FALSE
[01:27:46.617]    - call: plan(strategy)
[01:27:46.617] plan(): nbrOfWorkers() = 1
[01:27:46.618] SequentialFuture started (and completed)
[01:27:46.618] - Launch lazy future ... done
[01:27:46.618] run() for 'SequentialFuture' ... done
[01:27:46.619] getGlobalsAndPackages() ...
[01:27:46.619] Searching for globals...
[01:27:46.620] - globals found: [1] '{'
[01:27:46.620] Searching for globals ... DONE
[01:27:46.620] Resolving globals: FALSE
[01:27:46.621] 
[01:27:46.621] 
[01:27:46.621] getGlobalsAndPackages() ... DONE
[01:27:46.622] run() for 'Future' ...
[01:27:46.622] - state: 'created'
[01:27:46.622] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.623] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.623] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.623]   - Field: 'label'
[01:27:46.623]   - Field: 'local'
[01:27:46.623]   - Field: 'owner'
[01:27:46.624]   - Field: 'envir'
[01:27:46.624]   - Field: 'packages'
[01:27:46.624]   - Field: 'gc'
[01:27:46.624]   - Field: 'conditions'
[01:27:46.624]   - Field: 'expr'
[01:27:46.625]   - Field: 'uuid'
[01:27:46.625]   - Field: 'seed'
[01:27:46.625]   - Field: 'version'
[01:27:46.625]   - Field: 'result'
[01:27:46.625]   - Field: 'asynchronous'
[01:27:46.626]   - Field: 'calls'
[01:27:46.626]   - Field: 'globals'
[01:27:46.626]   - Field: 'stdout'
[01:27:46.626]   - Field: 'earlySignal'
[01:27:46.626]   - Field: 'lazy'
[01:27:46.627]   - Field: 'state'
[01:27:46.627] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.627] - Launch lazy future ...
[01:27:46.627] Packages needed by the future expression (n = 0): <none>
[01:27:46.628] Packages needed by future strategies (n = 0): <none>
[01:27:46.628] {
[01:27:46.628]     {
[01:27:46.628]         {
[01:27:46.628]             ...future.startTime <- base::Sys.time()
[01:27:46.628]             {
[01:27:46.628]                 {
[01:27:46.628]                   {
[01:27:46.628]                     base::local({
[01:27:46.628]                       has_future <- base::requireNamespace("future", 
[01:27:46.628]                         quietly = TRUE)
[01:27:46.628]                       if (has_future) {
[01:27:46.628]                         ns <- base::getNamespace("future")
[01:27:46.628]                         version <- ns[[".package"]][["version"]]
[01:27:46.628]                         if (is.null(version)) 
[01:27:46.628]                           version <- utils::packageVersion("future")
[01:27:46.628]                       }
[01:27:46.628]                       else {
[01:27:46.628]                         version <- NULL
[01:27:46.628]                       }
[01:27:46.628]                       if (!has_future || version < "1.8.0") {
[01:27:46.628]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.628]                           "", base::R.version$version.string), 
[01:27:46.628]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.628]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.628]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.628]                             "release", "version")], collapse = " "), 
[01:27:46.628]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.628]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.628]                           info)
[01:27:46.628]                         info <- base::paste(info, collapse = "; ")
[01:27:46.628]                         if (!has_future) {
[01:27:46.628]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.628]                             info)
[01:27:46.628]                         }
[01:27:46.628]                         else {
[01:27:46.628]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.628]                             info, version)
[01:27:46.628]                         }
[01:27:46.628]                         base::stop(msg)
[01:27:46.628]                       }
[01:27:46.628]                     })
[01:27:46.628]                   }
[01:27:46.628]                   options(future.plan = NULL)
[01:27:46.628]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.628]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.628]                 }
[01:27:46.628]                 ...future.workdir <- getwd()
[01:27:46.628]             }
[01:27:46.628]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.628]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.628]         }
[01:27:46.628]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.628]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.628]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.628]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.628]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.628]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.628]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.628]             base::names(...future.oldOptions))
[01:27:46.628]     }
[01:27:46.628]     if (FALSE) {
[01:27:46.628]     }
[01:27:46.628]     else {
[01:27:46.628]         if (TRUE) {
[01:27:46.628]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.628]                 open = "w")
[01:27:46.628]         }
[01:27:46.628]         else {
[01:27:46.628]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.628]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.628]         }
[01:27:46.628]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.628]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.628]             base::sink(type = "output", split = FALSE)
[01:27:46.628]             base::close(...future.stdout)
[01:27:46.628]         }, add = TRUE)
[01:27:46.628]     }
[01:27:46.628]     ...future.frame <- base::sys.nframe()
[01:27:46.628]     ...future.conditions <- base::list()
[01:27:46.628]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.628]     if (FALSE) {
[01:27:46.628]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.628]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.628]     }
[01:27:46.628]     ...future.result <- base::tryCatch({
[01:27:46.628]         base::withCallingHandlers({
[01:27:46.628]             ...future.value <- base::withVisible(base::local({
[01:27:46.628]                 4
[01:27:46.628]             }))
[01:27:46.628]             future::FutureResult(value = ...future.value$value, 
[01:27:46.628]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.628]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.628]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.628]                     ...future.globalenv.names))
[01:27:46.628]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.628]         }, condition = base::local({
[01:27:46.628]             c <- base::c
[01:27:46.628]             inherits <- base::inherits
[01:27:46.628]             invokeRestart <- base::invokeRestart
[01:27:46.628]             length <- base::length
[01:27:46.628]             list <- base::list
[01:27:46.628]             seq.int <- base::seq.int
[01:27:46.628]             signalCondition <- base::signalCondition
[01:27:46.628]             sys.calls <- base::sys.calls
[01:27:46.628]             `[[` <- base::`[[`
[01:27:46.628]             `+` <- base::`+`
[01:27:46.628]             `<<-` <- base::`<<-`
[01:27:46.628]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.628]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.628]                   3L)]
[01:27:46.628]             }
[01:27:46.628]             function(cond) {
[01:27:46.628]                 is_error <- inherits(cond, "error")
[01:27:46.628]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.628]                   NULL)
[01:27:46.628]                 if (is_error) {
[01:27:46.628]                   sessionInformation <- function() {
[01:27:46.628]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.628]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.628]                       search = base::search(), system = base::Sys.info())
[01:27:46.628]                   }
[01:27:46.628]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.628]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.628]                     cond$call), session = sessionInformation(), 
[01:27:46.628]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.628]                   signalCondition(cond)
[01:27:46.628]                 }
[01:27:46.628]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.628]                 "immediateCondition"))) {
[01:27:46.628]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.628]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.628]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.628]                   if (TRUE && !signal) {
[01:27:46.628]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.628]                     {
[01:27:46.628]                       inherits <- base::inherits
[01:27:46.628]                       invokeRestart <- base::invokeRestart
[01:27:46.628]                       is.null <- base::is.null
[01:27:46.628]                       muffled <- FALSE
[01:27:46.628]                       if (inherits(cond, "message")) {
[01:27:46.628]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.628]                         if (muffled) 
[01:27:46.628]                           invokeRestart("muffleMessage")
[01:27:46.628]                       }
[01:27:46.628]                       else if (inherits(cond, "warning")) {
[01:27:46.628]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.628]                         if (muffled) 
[01:27:46.628]                           invokeRestart("muffleWarning")
[01:27:46.628]                       }
[01:27:46.628]                       else if (inherits(cond, "condition")) {
[01:27:46.628]                         if (!is.null(pattern)) {
[01:27:46.628]                           computeRestarts <- base::computeRestarts
[01:27:46.628]                           grepl <- base::grepl
[01:27:46.628]                           restarts <- computeRestarts(cond)
[01:27:46.628]                           for (restart in restarts) {
[01:27:46.628]                             name <- restart$name
[01:27:46.628]                             if (is.null(name)) 
[01:27:46.628]                               next
[01:27:46.628]                             if (!grepl(pattern, name)) 
[01:27:46.628]                               next
[01:27:46.628]                             invokeRestart(restart)
[01:27:46.628]                             muffled <- TRUE
[01:27:46.628]                             break
[01:27:46.628]                           }
[01:27:46.628]                         }
[01:27:46.628]                       }
[01:27:46.628]                       invisible(muffled)
[01:27:46.628]                     }
[01:27:46.628]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.628]                   }
[01:27:46.628]                 }
[01:27:46.628]                 else {
[01:27:46.628]                   if (TRUE) {
[01:27:46.628]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.628]                     {
[01:27:46.628]                       inherits <- base::inherits
[01:27:46.628]                       invokeRestart <- base::invokeRestart
[01:27:46.628]                       is.null <- base::is.null
[01:27:46.628]                       muffled <- FALSE
[01:27:46.628]                       if (inherits(cond, "message")) {
[01:27:46.628]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.628]                         if (muffled) 
[01:27:46.628]                           invokeRestart("muffleMessage")
[01:27:46.628]                       }
[01:27:46.628]                       else if (inherits(cond, "warning")) {
[01:27:46.628]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.628]                         if (muffled) 
[01:27:46.628]                           invokeRestart("muffleWarning")
[01:27:46.628]                       }
[01:27:46.628]                       else if (inherits(cond, "condition")) {
[01:27:46.628]                         if (!is.null(pattern)) {
[01:27:46.628]                           computeRestarts <- base::computeRestarts
[01:27:46.628]                           grepl <- base::grepl
[01:27:46.628]                           restarts <- computeRestarts(cond)
[01:27:46.628]                           for (restart in restarts) {
[01:27:46.628]                             name <- restart$name
[01:27:46.628]                             if (is.null(name)) 
[01:27:46.628]                               next
[01:27:46.628]                             if (!grepl(pattern, name)) 
[01:27:46.628]                               next
[01:27:46.628]                             invokeRestart(restart)
[01:27:46.628]                             muffled <- TRUE
[01:27:46.628]                             break
[01:27:46.628]                           }
[01:27:46.628]                         }
[01:27:46.628]                       }
[01:27:46.628]                       invisible(muffled)
[01:27:46.628]                     }
[01:27:46.628]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.628]                   }
[01:27:46.628]                 }
[01:27:46.628]             }
[01:27:46.628]         }))
[01:27:46.628]     }, error = function(ex) {
[01:27:46.628]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.628]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.628]                 ...future.rng), started = ...future.startTime, 
[01:27:46.628]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.628]             version = "1.8"), class = "FutureResult")
[01:27:46.628]     }, finally = {
[01:27:46.628]         if (!identical(...future.workdir, getwd())) 
[01:27:46.628]             setwd(...future.workdir)
[01:27:46.628]         {
[01:27:46.628]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.628]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.628]             }
[01:27:46.628]             base::options(...future.oldOptions)
[01:27:46.628]             if (.Platform$OS.type == "windows") {
[01:27:46.628]                 old_names <- names(...future.oldEnvVars)
[01:27:46.628]                 envs <- base::Sys.getenv()
[01:27:46.628]                 names <- names(envs)
[01:27:46.628]                 common <- intersect(names, old_names)
[01:27:46.628]                 added <- setdiff(names, old_names)
[01:27:46.628]                 removed <- setdiff(old_names, names)
[01:27:46.628]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.628]                   envs[common]]
[01:27:46.628]                 NAMES <- toupper(changed)
[01:27:46.628]                 args <- list()
[01:27:46.628]                 for (kk in seq_along(NAMES)) {
[01:27:46.628]                   name <- changed[[kk]]
[01:27:46.628]                   NAME <- NAMES[[kk]]
[01:27:46.628]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.628]                     next
[01:27:46.628]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.628]                 }
[01:27:46.628]                 NAMES <- toupper(added)
[01:27:46.628]                 for (kk in seq_along(NAMES)) {
[01:27:46.628]                   name <- added[[kk]]
[01:27:46.628]                   NAME <- NAMES[[kk]]
[01:27:46.628]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.628]                     next
[01:27:46.628]                   args[[name]] <- ""
[01:27:46.628]                 }
[01:27:46.628]                 NAMES <- toupper(removed)
[01:27:46.628]                 for (kk in seq_along(NAMES)) {
[01:27:46.628]                   name <- removed[[kk]]
[01:27:46.628]                   NAME <- NAMES[[kk]]
[01:27:46.628]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.628]                     next
[01:27:46.628]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.628]                 }
[01:27:46.628]                 if (length(args) > 0) 
[01:27:46.628]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.628]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.628]             }
[01:27:46.628]             else {
[01:27:46.628]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.628]             }
[01:27:46.628]             {
[01:27:46.628]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.628]                   0L) {
[01:27:46.628]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.628]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.628]                   base::options(opts)
[01:27:46.628]                 }
[01:27:46.628]                 {
[01:27:46.628]                   {
[01:27:46.628]                     NULL
[01:27:46.628]                     RNGkind("Mersenne-Twister")
[01:27:46.628]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.628]                       inherits = FALSE)
[01:27:46.628]                   }
[01:27:46.628]                   options(future.plan = NULL)
[01:27:46.628]                   if (is.na(NA_character_)) 
[01:27:46.628]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.628]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.628]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.628]                   {
[01:27:46.628]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.628]                     if (!future$lazy) 
[01:27:46.628]                       future <- run(future)
[01:27:46.628]                     invisible(future)
[01:27:46.628]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.628]                 }
[01:27:46.628]             }
[01:27:46.628]         }
[01:27:46.628]     })
[01:27:46.628]     if (TRUE) {
[01:27:46.628]         base::sink(type = "output", split = FALSE)
[01:27:46.628]         if (TRUE) {
[01:27:46.628]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.628]         }
[01:27:46.628]         else {
[01:27:46.628]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.628]         }
[01:27:46.628]         base::close(...future.stdout)
[01:27:46.628]         ...future.stdout <- NULL
[01:27:46.628]     }
[01:27:46.628]     ...future.result$conditions <- ...future.conditions
[01:27:46.628]     ...future.result$finished <- base::Sys.time()
[01:27:46.628]     ...future.result
[01:27:46.628] }
[01:27:46.633] plan(): Setting new future strategy stack:
[01:27:46.633] List of future strategies:
[01:27:46.633] 1. sequential:
[01:27:46.633]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.633]    - tweaked: FALSE
[01:27:46.633]    - call: NULL
[01:27:46.634] plan(): nbrOfWorkers() = 1
[01:27:46.635] plan(): Setting new future strategy stack:
[01:27:46.635] List of future strategies:
[01:27:46.635] 1. sequential:
[01:27:46.635]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.635]    - tweaked: FALSE
[01:27:46.635]    - call: plan(strategy)
[01:27:46.636] plan(): nbrOfWorkers() = 1
[01:27:46.636] SequentialFuture started (and completed)
[01:27:46.637] - Launch lazy future ... done
[01:27:46.637] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b07751260> 
Classes 'listenv', 'environment' <environment: 0x0000025b07d1e110> 
 - 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"
[01:27:46.643] resolved() for 'SequentialFuture' ...
[01:27:46.643] - state: 'finished'
[01:27:46.643] - run: TRUE
[01:27:46.643] - result: 'FutureResult'
[01:27:46.644] resolved() for 'SequentialFuture' ... done
[01:27:46.644] resolved() for 'SequentialFuture' ...
[01:27:46.644] - state: 'finished'
[01:27:46.644] - run: TRUE
[01:27:46.644] - result: 'FutureResult'
[01:27:46.645] resolved() for 'SequentialFuture' ... done
[01:27:46.645] resolved() for 'SequentialFuture' ...
[01:27:46.645] - state: 'finished'
[01:27:46.645] - run: TRUE
[01:27:46.646] - result: 'FutureResult'
[01:27:46.646] 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" ...
[01:27:46.654] resolve() on list environment ...
[01:27:46.655]  recursive: 0
[01:27:46.656]  length: 6
[01:27:46.657]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:46.657] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.657] - nx: 6
[01:27:46.657] - relay: TRUE
[01:27:46.657] - stdout: TRUE
[01:27:46.658] - signal: TRUE
[01:27:46.658] - resignal: FALSE
[01:27:46.658] - force: TRUE
[01:27:46.658] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.659] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.659]  - until=2
[01:27:46.659]  - relaying element #2
[01:27:46.659] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.659] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.660] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.660]  length: 5 (resolved future 1)
[01:27:46.660] resolved() for 'SequentialFuture' ...
[01:27:46.661] - state: 'finished'
[01:27:46.661] - run: TRUE
[01:27:46.661] - result: 'FutureResult'
[01:27:46.661] resolved() for 'SequentialFuture' ... done
[01:27:46.661] Future #2
[01:27:46.662] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.662] - nx: 6
[01:27:46.662] - relay: TRUE
[01:27:46.662] - stdout: TRUE
[01:27:46.663] - signal: TRUE
[01:27:46.663] - resignal: FALSE
[01:27:46.663] - force: TRUE
[01:27:46.663] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.663] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.664]  - until=2
[01:27:46.664]  - relaying element #2
[01:27:46.664] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.665] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.665] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.665]  length: 4 (resolved future 2)
[01:27:46.665] resolved() for 'SequentialFuture' ...
[01:27:46.666] - state: 'finished'
[01:27:46.666] - run: TRUE
[01:27:46.666] - result: 'FutureResult'
[01:27:46.666] resolved() for 'SequentialFuture' ... done
[01:27:46.667] Future #3
[01:27:46.667] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.667] - nx: 6
[01:27:46.667] - relay: TRUE
[01:27:46.667] - stdout: TRUE
[01:27:46.668] - signal: TRUE
[01:27:46.668] - resignal: FALSE
[01:27:46.668] - force: TRUE
[01:27:46.668] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.669] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.669]  - until=3
[01:27:46.669]  - relaying element #3
[01:27:46.669] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.670] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.670] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.670]  length: 3 (resolved future 3)
[01:27:46.670] resolved() for 'SequentialFuture' ...
[01:27:46.671] - state: 'finished'
[01:27:46.671] - run: TRUE
[01:27:46.671] - result: 'FutureResult'
[01:27:46.671] resolved() for 'SequentialFuture' ... done
[01:27:46.671] Future #4
[01:27:46.672] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.672] - nx: 6
[01:27:46.672] - relay: TRUE
[01:27:46.672] - stdout: TRUE
[01:27:46.672] - signal: TRUE
[01:27:46.673] - resignal: FALSE
[01:27:46.673] - force: TRUE
[01:27:46.673] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.673] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.673]  - until=4
[01:27:46.674]  - relaying element #4
[01:27:46.674] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.674] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.674] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.675]  length: 2 (resolved future 4)
[01:27:46.675] signalConditionsASAP(NULL, pos=5) ...
[01:27:46.675] - nx: 6
[01:27:46.675] - relay: TRUE
[01:27:46.675] - stdout: TRUE
[01:27:46.676] - signal: TRUE
[01:27:46.676] - resignal: FALSE
[01:27:46.676] - force: TRUE
[01:27:46.676] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.676] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.677]  - until=6
[01:27:46.677]  - relaying element #6
[01:27:46.677] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.677] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.678] signalConditionsASAP(NULL, pos=5) ... done
[01:27:46.678]  length: 1 (resolved future 5)
[01:27:46.678] signalConditionsASAP(numeric, pos=6) ...
[01:27:46.678] - nx: 6
[01:27:46.679] - relay: TRUE
[01:27:46.679] - stdout: TRUE
[01:27:46.679] - signal: TRUE
[01:27:46.679] - resignal: FALSE
[01:27:46.679] - force: TRUE
[01:27:46.680] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.680] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.680]  - until=6
[01:27:46.680] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.680] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.681] signalConditionsASAP(numeric, pos=6) ... done
[01:27:46.681]  length: 0 (resolved future 6)
[01:27:46.681] Relaying remaining futures
[01:27:46.681] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.681] - nx: 6
[01:27:46.682] - relay: TRUE
[01:27:46.682] - stdout: TRUE
[01:27:46.682] - signal: TRUE
[01:27:46.682] - resignal: FALSE
[01:27:46.682] - force: TRUE
[01:27:46.682] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.683] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:46.683] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.683] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.683] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.683] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x0000025b066abf08> 
 - 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)
[01:27:46.687] getGlobalsAndPackages() ...
[01:27:46.687] Searching for globals...
[01:27:46.687] 
[01:27:46.688] Searching for globals ... DONE
[01:27:46.688] - globals: [0] <none>
[01:27:46.688] getGlobalsAndPackages() ... DONE
[01:27:46.688] run() for 'Future' ...
[01:27:46.689] - state: 'created'
[01:27:46.689] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.693] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.693] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.693]   - Field: 'label'
[01:27:46.693]   - Field: 'local'
[01:27:46.694]   - Field: 'owner'
[01:27:46.694]   - Field: 'envir'
[01:27:46.694]   - Field: 'packages'
[01:27:46.694]   - Field: 'gc'
[01:27:46.695]   - Field: 'conditions'
[01:27:46.695]   - Field: 'expr'
[01:27:46.695]   - Field: 'uuid'
[01:27:46.695]   - Field: 'seed'
[01:27:46.695]   - Field: 'version'
[01:27:46.696]   - Field: 'result'
[01:27:46.696]   - Field: 'asynchronous'
[01:27:46.696]   - Field: 'calls'
[01:27:46.696]   - Field: 'globals'
[01:27:46.696]   - Field: 'stdout'
[01:27:46.697]   - Field: 'earlySignal'
[01:27:46.697]   - Field: 'lazy'
[01:27:46.697]   - Field: 'state'
[01:27:46.697] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.697] - Launch lazy future ...
[01:27:46.698] Packages needed by the future expression (n = 0): <none>
[01:27:46.698] Packages needed by future strategies (n = 0): <none>
[01:27:46.699] {
[01:27:46.699]     {
[01:27:46.699]         {
[01:27:46.699]             ...future.startTime <- base::Sys.time()
[01:27:46.699]             {
[01:27:46.699]                 {
[01:27:46.699]                   {
[01:27:46.699]                     base::local({
[01:27:46.699]                       has_future <- base::requireNamespace("future", 
[01:27:46.699]                         quietly = TRUE)
[01:27:46.699]                       if (has_future) {
[01:27:46.699]                         ns <- base::getNamespace("future")
[01:27:46.699]                         version <- ns[[".package"]][["version"]]
[01:27:46.699]                         if (is.null(version)) 
[01:27:46.699]                           version <- utils::packageVersion("future")
[01:27:46.699]                       }
[01:27:46.699]                       else {
[01:27:46.699]                         version <- NULL
[01:27:46.699]                       }
[01:27:46.699]                       if (!has_future || version < "1.8.0") {
[01:27:46.699]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.699]                           "", base::R.version$version.string), 
[01:27:46.699]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.699]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.699]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.699]                             "release", "version")], collapse = " "), 
[01:27:46.699]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.699]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.699]                           info)
[01:27:46.699]                         info <- base::paste(info, collapse = "; ")
[01:27:46.699]                         if (!has_future) {
[01:27:46.699]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.699]                             info)
[01:27:46.699]                         }
[01:27:46.699]                         else {
[01:27:46.699]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.699]                             info, version)
[01:27:46.699]                         }
[01:27:46.699]                         base::stop(msg)
[01:27:46.699]                       }
[01:27:46.699]                     })
[01:27:46.699]                   }
[01:27:46.699]                   options(future.plan = NULL)
[01:27:46.699]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.699]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.699]                 }
[01:27:46.699]                 ...future.workdir <- getwd()
[01:27:46.699]             }
[01:27:46.699]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.699]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.699]         }
[01:27:46.699]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.699]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.699]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.699]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.699]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.699]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.699]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.699]             base::names(...future.oldOptions))
[01:27:46.699]     }
[01:27:46.699]     if (FALSE) {
[01:27:46.699]     }
[01:27:46.699]     else {
[01:27:46.699]         if (TRUE) {
[01:27:46.699]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.699]                 open = "w")
[01:27:46.699]         }
[01:27:46.699]         else {
[01:27:46.699]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.699]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.699]         }
[01:27:46.699]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.699]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.699]             base::sink(type = "output", split = FALSE)
[01:27:46.699]             base::close(...future.stdout)
[01:27:46.699]         }, add = TRUE)
[01:27:46.699]     }
[01:27:46.699]     ...future.frame <- base::sys.nframe()
[01:27:46.699]     ...future.conditions <- base::list()
[01:27:46.699]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.699]     if (FALSE) {
[01:27:46.699]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.699]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.699]     }
[01:27:46.699]     ...future.result <- base::tryCatch({
[01:27:46.699]         base::withCallingHandlers({
[01:27:46.699]             ...future.value <- base::withVisible(base::local(2))
[01:27:46.699]             future::FutureResult(value = ...future.value$value, 
[01:27:46.699]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.699]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.699]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.699]                     ...future.globalenv.names))
[01:27:46.699]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.699]         }, condition = base::local({
[01:27:46.699]             c <- base::c
[01:27:46.699]             inherits <- base::inherits
[01:27:46.699]             invokeRestart <- base::invokeRestart
[01:27:46.699]             length <- base::length
[01:27:46.699]             list <- base::list
[01:27:46.699]             seq.int <- base::seq.int
[01:27:46.699]             signalCondition <- base::signalCondition
[01:27:46.699]             sys.calls <- base::sys.calls
[01:27:46.699]             `[[` <- base::`[[`
[01:27:46.699]             `+` <- base::`+`
[01:27:46.699]             `<<-` <- base::`<<-`
[01:27:46.699]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.699]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.699]                   3L)]
[01:27:46.699]             }
[01:27:46.699]             function(cond) {
[01:27:46.699]                 is_error <- inherits(cond, "error")
[01:27:46.699]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.699]                   NULL)
[01:27:46.699]                 if (is_error) {
[01:27:46.699]                   sessionInformation <- function() {
[01:27:46.699]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.699]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.699]                       search = base::search(), system = base::Sys.info())
[01:27:46.699]                   }
[01:27:46.699]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.699]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.699]                     cond$call), session = sessionInformation(), 
[01:27:46.699]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.699]                   signalCondition(cond)
[01:27:46.699]                 }
[01:27:46.699]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.699]                 "immediateCondition"))) {
[01:27:46.699]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.699]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.699]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.699]                   if (TRUE && !signal) {
[01:27:46.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.699]                     {
[01:27:46.699]                       inherits <- base::inherits
[01:27:46.699]                       invokeRestart <- base::invokeRestart
[01:27:46.699]                       is.null <- base::is.null
[01:27:46.699]                       muffled <- FALSE
[01:27:46.699]                       if (inherits(cond, "message")) {
[01:27:46.699]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.699]                         if (muffled) 
[01:27:46.699]                           invokeRestart("muffleMessage")
[01:27:46.699]                       }
[01:27:46.699]                       else if (inherits(cond, "warning")) {
[01:27:46.699]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.699]                         if (muffled) 
[01:27:46.699]                           invokeRestart("muffleWarning")
[01:27:46.699]                       }
[01:27:46.699]                       else if (inherits(cond, "condition")) {
[01:27:46.699]                         if (!is.null(pattern)) {
[01:27:46.699]                           computeRestarts <- base::computeRestarts
[01:27:46.699]                           grepl <- base::grepl
[01:27:46.699]                           restarts <- computeRestarts(cond)
[01:27:46.699]                           for (restart in restarts) {
[01:27:46.699]                             name <- restart$name
[01:27:46.699]                             if (is.null(name)) 
[01:27:46.699]                               next
[01:27:46.699]                             if (!grepl(pattern, name)) 
[01:27:46.699]                               next
[01:27:46.699]                             invokeRestart(restart)
[01:27:46.699]                             muffled <- TRUE
[01:27:46.699]                             break
[01:27:46.699]                           }
[01:27:46.699]                         }
[01:27:46.699]                       }
[01:27:46.699]                       invisible(muffled)
[01:27:46.699]                     }
[01:27:46.699]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.699]                   }
[01:27:46.699]                 }
[01:27:46.699]                 else {
[01:27:46.699]                   if (TRUE) {
[01:27:46.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.699]                     {
[01:27:46.699]                       inherits <- base::inherits
[01:27:46.699]                       invokeRestart <- base::invokeRestart
[01:27:46.699]                       is.null <- base::is.null
[01:27:46.699]                       muffled <- FALSE
[01:27:46.699]                       if (inherits(cond, "message")) {
[01:27:46.699]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.699]                         if (muffled) 
[01:27:46.699]                           invokeRestart("muffleMessage")
[01:27:46.699]                       }
[01:27:46.699]                       else if (inherits(cond, "warning")) {
[01:27:46.699]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.699]                         if (muffled) 
[01:27:46.699]                           invokeRestart("muffleWarning")
[01:27:46.699]                       }
[01:27:46.699]                       else if (inherits(cond, "condition")) {
[01:27:46.699]                         if (!is.null(pattern)) {
[01:27:46.699]                           computeRestarts <- base::computeRestarts
[01:27:46.699]                           grepl <- base::grepl
[01:27:46.699]                           restarts <- computeRestarts(cond)
[01:27:46.699]                           for (restart in restarts) {
[01:27:46.699]                             name <- restart$name
[01:27:46.699]                             if (is.null(name)) 
[01:27:46.699]                               next
[01:27:46.699]                             if (!grepl(pattern, name)) 
[01:27:46.699]                               next
[01:27:46.699]                             invokeRestart(restart)
[01:27:46.699]                             muffled <- TRUE
[01:27:46.699]                             break
[01:27:46.699]                           }
[01:27:46.699]                         }
[01:27:46.699]                       }
[01:27:46.699]                       invisible(muffled)
[01:27:46.699]                     }
[01:27:46.699]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.699]                   }
[01:27:46.699]                 }
[01:27:46.699]             }
[01:27:46.699]         }))
[01:27:46.699]     }, error = function(ex) {
[01:27:46.699]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.699]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.699]                 ...future.rng), started = ...future.startTime, 
[01:27:46.699]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.699]             version = "1.8"), class = "FutureResult")
[01:27:46.699]     }, finally = {
[01:27:46.699]         if (!identical(...future.workdir, getwd())) 
[01:27:46.699]             setwd(...future.workdir)
[01:27:46.699]         {
[01:27:46.699]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.699]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.699]             }
[01:27:46.699]             base::options(...future.oldOptions)
[01:27:46.699]             if (.Platform$OS.type == "windows") {
[01:27:46.699]                 old_names <- names(...future.oldEnvVars)
[01:27:46.699]                 envs <- base::Sys.getenv()
[01:27:46.699]                 names <- names(envs)
[01:27:46.699]                 common <- intersect(names, old_names)
[01:27:46.699]                 added <- setdiff(names, old_names)
[01:27:46.699]                 removed <- setdiff(old_names, names)
[01:27:46.699]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.699]                   envs[common]]
[01:27:46.699]                 NAMES <- toupper(changed)
[01:27:46.699]                 args <- list()
[01:27:46.699]                 for (kk in seq_along(NAMES)) {
[01:27:46.699]                   name <- changed[[kk]]
[01:27:46.699]                   NAME <- NAMES[[kk]]
[01:27:46.699]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.699]                     next
[01:27:46.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.699]                 }
[01:27:46.699]                 NAMES <- toupper(added)
[01:27:46.699]                 for (kk in seq_along(NAMES)) {
[01:27:46.699]                   name <- added[[kk]]
[01:27:46.699]                   NAME <- NAMES[[kk]]
[01:27:46.699]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.699]                     next
[01:27:46.699]                   args[[name]] <- ""
[01:27:46.699]                 }
[01:27:46.699]                 NAMES <- toupper(removed)
[01:27:46.699]                 for (kk in seq_along(NAMES)) {
[01:27:46.699]                   name <- removed[[kk]]
[01:27:46.699]                   NAME <- NAMES[[kk]]
[01:27:46.699]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.699]                     next
[01:27:46.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.699]                 }
[01:27:46.699]                 if (length(args) > 0) 
[01:27:46.699]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.699]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.699]             }
[01:27:46.699]             else {
[01:27:46.699]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.699]             }
[01:27:46.699]             {
[01:27:46.699]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.699]                   0L) {
[01:27:46.699]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.699]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.699]                   base::options(opts)
[01:27:46.699]                 }
[01:27:46.699]                 {
[01:27:46.699]                   {
[01:27:46.699]                     NULL
[01:27:46.699]                     RNGkind("Mersenne-Twister")
[01:27:46.699]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.699]                       inherits = FALSE)
[01:27:46.699]                   }
[01:27:46.699]                   options(future.plan = NULL)
[01:27:46.699]                   if (is.na(NA_character_)) 
[01:27:46.699]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.699]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.699]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.699]                   {
[01:27:46.699]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.699]                     if (!future$lazy) 
[01:27:46.699]                       future <- run(future)
[01:27:46.699]                     invisible(future)
[01:27:46.699]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.699]                 }
[01:27:46.699]             }
[01:27:46.699]         }
[01:27:46.699]     })
[01:27:46.699]     if (TRUE) {
[01:27:46.699]         base::sink(type = "output", split = FALSE)
[01:27:46.699]         if (TRUE) {
[01:27:46.699]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.699]         }
[01:27:46.699]         else {
[01:27:46.699]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.699]         }
[01:27:46.699]         base::close(...future.stdout)
[01:27:46.699]         ...future.stdout <- NULL
[01:27:46.699]     }
[01:27:46.699]     ...future.result$conditions <- ...future.conditions
[01:27:46.699]     ...future.result$finished <- base::Sys.time()
[01:27:46.699]     ...future.result
[01:27:46.699] }
[01:27:46.704] plan(): Setting new future strategy stack:
[01:27:46.704] List of future strategies:
[01:27:46.704] 1. sequential:
[01:27:46.704]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.704]    - tweaked: FALSE
[01:27:46.704]    - call: NULL
[01:27:46.704] plan(): nbrOfWorkers() = 1
[01:27:46.706] plan(): Setting new future strategy stack:
[01:27:46.706] List of future strategies:
[01:27:46.706] 1. sequential:
[01:27:46.706]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.706]    - tweaked: FALSE
[01:27:46.706]    - call: plan(strategy)
[01:27:46.707] plan(): nbrOfWorkers() = 1
[01:27:46.707] SequentialFuture started (and completed)
[01:27:46.707] - Launch lazy future ... done
[01:27:46.708] run() for 'SequentialFuture' ... done
[01:27:46.708] getGlobalsAndPackages() ...
[01:27:46.708] Searching for globals...
[01:27:46.709] 
[01:27:46.709] Searching for globals ... DONE
[01:27:46.709] - globals: [0] <none>
[01:27:46.709] getGlobalsAndPackages() ... DONE
[01:27:46.709] run() for 'Future' ...
[01:27:46.710] - state: 'created'
[01:27:46.710] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.710] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.711] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.711]   - Field: 'label'
[01:27:46.711]   - Field: 'local'
[01:27:46.711]   - Field: 'owner'
[01:27:46.711]   - Field: 'envir'
[01:27:46.712]   - Field: 'packages'
[01:27:46.712]   - Field: 'gc'
[01:27:46.712]   - Field: 'conditions'
[01:27:46.712]   - Field: 'expr'
[01:27:46.712]   - Field: 'uuid'
[01:27:46.713]   - Field: 'seed'
[01:27:46.713]   - Field: 'version'
[01:27:46.713]   - Field: 'result'
[01:27:46.713]   - Field: 'asynchronous'
[01:27:46.713]   - Field: 'calls'
[01:27:46.714]   - Field: 'globals'
[01:27:46.714]   - Field: 'stdout'
[01:27:46.714]   - Field: 'earlySignal'
[01:27:46.714]   - Field: 'lazy'
[01:27:46.714]   - Field: 'state'
[01:27:46.715] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.715] - Launch lazy future ...
[01:27:46.715] Packages needed by the future expression (n = 0): <none>
[01:27:46.715] Packages needed by future strategies (n = 0): <none>
[01:27:46.716] {
[01:27:46.716]     {
[01:27:46.716]         {
[01:27:46.716]             ...future.startTime <- base::Sys.time()
[01:27:46.716]             {
[01:27:46.716]                 {
[01:27:46.716]                   {
[01:27:46.716]                     base::local({
[01:27:46.716]                       has_future <- base::requireNamespace("future", 
[01:27:46.716]                         quietly = TRUE)
[01:27:46.716]                       if (has_future) {
[01:27:46.716]                         ns <- base::getNamespace("future")
[01:27:46.716]                         version <- ns[[".package"]][["version"]]
[01:27:46.716]                         if (is.null(version)) 
[01:27:46.716]                           version <- utils::packageVersion("future")
[01:27:46.716]                       }
[01:27:46.716]                       else {
[01:27:46.716]                         version <- NULL
[01:27:46.716]                       }
[01:27:46.716]                       if (!has_future || version < "1.8.0") {
[01:27:46.716]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.716]                           "", base::R.version$version.string), 
[01:27:46.716]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.716]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.716]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.716]                             "release", "version")], collapse = " "), 
[01:27:46.716]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.716]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.716]                           info)
[01:27:46.716]                         info <- base::paste(info, collapse = "; ")
[01:27:46.716]                         if (!has_future) {
[01:27:46.716]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.716]                             info)
[01:27:46.716]                         }
[01:27:46.716]                         else {
[01:27:46.716]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.716]                             info, version)
[01:27:46.716]                         }
[01:27:46.716]                         base::stop(msg)
[01:27:46.716]                       }
[01:27:46.716]                     })
[01:27:46.716]                   }
[01:27:46.716]                   options(future.plan = NULL)
[01:27:46.716]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.716]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.716]                 }
[01:27:46.716]                 ...future.workdir <- getwd()
[01:27:46.716]             }
[01:27:46.716]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.716]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.716]         }
[01:27:46.716]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.716]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.716]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.716]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.716]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.716]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.716]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.716]             base::names(...future.oldOptions))
[01:27:46.716]     }
[01:27:46.716]     if (FALSE) {
[01:27:46.716]     }
[01:27:46.716]     else {
[01:27:46.716]         if (TRUE) {
[01:27:46.716]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.716]                 open = "w")
[01:27:46.716]         }
[01:27:46.716]         else {
[01:27:46.716]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.716]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.716]         }
[01:27:46.716]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.716]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.716]             base::sink(type = "output", split = FALSE)
[01:27:46.716]             base::close(...future.stdout)
[01:27:46.716]         }, add = TRUE)
[01:27:46.716]     }
[01:27:46.716]     ...future.frame <- base::sys.nframe()
[01:27:46.716]     ...future.conditions <- base::list()
[01:27:46.716]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.716]     if (FALSE) {
[01:27:46.716]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.716]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.716]     }
[01:27:46.716]     ...future.result <- base::tryCatch({
[01:27:46.716]         base::withCallingHandlers({
[01:27:46.716]             ...future.value <- base::withVisible(base::local(NULL))
[01:27:46.716]             future::FutureResult(value = ...future.value$value, 
[01:27:46.716]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.716]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.716]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.716]                     ...future.globalenv.names))
[01:27:46.716]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.716]         }, condition = base::local({
[01:27:46.716]             c <- base::c
[01:27:46.716]             inherits <- base::inherits
[01:27:46.716]             invokeRestart <- base::invokeRestart
[01:27:46.716]             length <- base::length
[01:27:46.716]             list <- base::list
[01:27:46.716]             seq.int <- base::seq.int
[01:27:46.716]             signalCondition <- base::signalCondition
[01:27:46.716]             sys.calls <- base::sys.calls
[01:27:46.716]             `[[` <- base::`[[`
[01:27:46.716]             `+` <- base::`+`
[01:27:46.716]             `<<-` <- base::`<<-`
[01:27:46.716]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.716]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.716]                   3L)]
[01:27:46.716]             }
[01:27:46.716]             function(cond) {
[01:27:46.716]                 is_error <- inherits(cond, "error")
[01:27:46.716]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.716]                   NULL)
[01:27:46.716]                 if (is_error) {
[01:27:46.716]                   sessionInformation <- function() {
[01:27:46.716]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.716]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.716]                       search = base::search(), system = base::Sys.info())
[01:27:46.716]                   }
[01:27:46.716]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.716]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.716]                     cond$call), session = sessionInformation(), 
[01:27:46.716]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.716]                   signalCondition(cond)
[01:27:46.716]                 }
[01:27:46.716]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.716]                 "immediateCondition"))) {
[01:27:46.716]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.716]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.716]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.716]                   if (TRUE && !signal) {
[01:27:46.716]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.716]                     {
[01:27:46.716]                       inherits <- base::inherits
[01:27:46.716]                       invokeRestart <- base::invokeRestart
[01:27:46.716]                       is.null <- base::is.null
[01:27:46.716]                       muffled <- FALSE
[01:27:46.716]                       if (inherits(cond, "message")) {
[01:27:46.716]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.716]                         if (muffled) 
[01:27:46.716]                           invokeRestart("muffleMessage")
[01:27:46.716]                       }
[01:27:46.716]                       else if (inherits(cond, "warning")) {
[01:27:46.716]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.716]                         if (muffled) 
[01:27:46.716]                           invokeRestart("muffleWarning")
[01:27:46.716]                       }
[01:27:46.716]                       else if (inherits(cond, "condition")) {
[01:27:46.716]                         if (!is.null(pattern)) {
[01:27:46.716]                           computeRestarts <- base::computeRestarts
[01:27:46.716]                           grepl <- base::grepl
[01:27:46.716]                           restarts <- computeRestarts(cond)
[01:27:46.716]                           for (restart in restarts) {
[01:27:46.716]                             name <- restart$name
[01:27:46.716]                             if (is.null(name)) 
[01:27:46.716]                               next
[01:27:46.716]                             if (!grepl(pattern, name)) 
[01:27:46.716]                               next
[01:27:46.716]                             invokeRestart(restart)
[01:27:46.716]                             muffled <- TRUE
[01:27:46.716]                             break
[01:27:46.716]                           }
[01:27:46.716]                         }
[01:27:46.716]                       }
[01:27:46.716]                       invisible(muffled)
[01:27:46.716]                     }
[01:27:46.716]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.716]                   }
[01:27:46.716]                 }
[01:27:46.716]                 else {
[01:27:46.716]                   if (TRUE) {
[01:27:46.716]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.716]                     {
[01:27:46.716]                       inherits <- base::inherits
[01:27:46.716]                       invokeRestart <- base::invokeRestart
[01:27:46.716]                       is.null <- base::is.null
[01:27:46.716]                       muffled <- FALSE
[01:27:46.716]                       if (inherits(cond, "message")) {
[01:27:46.716]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.716]                         if (muffled) 
[01:27:46.716]                           invokeRestart("muffleMessage")
[01:27:46.716]                       }
[01:27:46.716]                       else if (inherits(cond, "warning")) {
[01:27:46.716]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.716]                         if (muffled) 
[01:27:46.716]                           invokeRestart("muffleWarning")
[01:27:46.716]                       }
[01:27:46.716]                       else if (inherits(cond, "condition")) {
[01:27:46.716]                         if (!is.null(pattern)) {
[01:27:46.716]                           computeRestarts <- base::computeRestarts
[01:27:46.716]                           grepl <- base::grepl
[01:27:46.716]                           restarts <- computeRestarts(cond)
[01:27:46.716]                           for (restart in restarts) {
[01:27:46.716]                             name <- restart$name
[01:27:46.716]                             if (is.null(name)) 
[01:27:46.716]                               next
[01:27:46.716]                             if (!grepl(pattern, name)) 
[01:27:46.716]                               next
[01:27:46.716]                             invokeRestart(restart)
[01:27:46.716]                             muffled <- TRUE
[01:27:46.716]                             break
[01:27:46.716]                           }
[01:27:46.716]                         }
[01:27:46.716]                       }
[01:27:46.716]                       invisible(muffled)
[01:27:46.716]                     }
[01:27:46.716]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.716]                   }
[01:27:46.716]                 }
[01:27:46.716]             }
[01:27:46.716]         }))
[01:27:46.716]     }, error = function(ex) {
[01:27:46.716]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.716]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.716]                 ...future.rng), started = ...future.startTime, 
[01:27:46.716]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.716]             version = "1.8"), class = "FutureResult")
[01:27:46.716]     }, finally = {
[01:27:46.716]         if (!identical(...future.workdir, getwd())) 
[01:27:46.716]             setwd(...future.workdir)
[01:27:46.716]         {
[01:27:46.716]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.716]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.716]             }
[01:27:46.716]             base::options(...future.oldOptions)
[01:27:46.716]             if (.Platform$OS.type == "windows") {
[01:27:46.716]                 old_names <- names(...future.oldEnvVars)
[01:27:46.716]                 envs <- base::Sys.getenv()
[01:27:46.716]                 names <- names(envs)
[01:27:46.716]                 common <- intersect(names, old_names)
[01:27:46.716]                 added <- setdiff(names, old_names)
[01:27:46.716]                 removed <- setdiff(old_names, names)
[01:27:46.716]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.716]                   envs[common]]
[01:27:46.716]                 NAMES <- toupper(changed)
[01:27:46.716]                 args <- list()
[01:27:46.716]                 for (kk in seq_along(NAMES)) {
[01:27:46.716]                   name <- changed[[kk]]
[01:27:46.716]                   NAME <- NAMES[[kk]]
[01:27:46.716]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.716]                     next
[01:27:46.716]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.716]                 }
[01:27:46.716]                 NAMES <- toupper(added)
[01:27:46.716]                 for (kk in seq_along(NAMES)) {
[01:27:46.716]                   name <- added[[kk]]
[01:27:46.716]                   NAME <- NAMES[[kk]]
[01:27:46.716]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.716]                     next
[01:27:46.716]                   args[[name]] <- ""
[01:27:46.716]                 }
[01:27:46.716]                 NAMES <- toupper(removed)
[01:27:46.716]                 for (kk in seq_along(NAMES)) {
[01:27:46.716]                   name <- removed[[kk]]
[01:27:46.716]                   NAME <- NAMES[[kk]]
[01:27:46.716]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.716]                     next
[01:27:46.716]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.716]                 }
[01:27:46.716]                 if (length(args) > 0) 
[01:27:46.716]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.716]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.716]             }
[01:27:46.716]             else {
[01:27:46.716]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.716]             }
[01:27:46.716]             {
[01:27:46.716]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.716]                   0L) {
[01:27:46.716]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.716]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.716]                   base::options(opts)
[01:27:46.716]                 }
[01:27:46.716]                 {
[01:27:46.716]                   {
[01:27:46.716]                     NULL
[01:27:46.716]                     RNGkind("Mersenne-Twister")
[01:27:46.716]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.716]                       inherits = FALSE)
[01:27:46.716]                   }
[01:27:46.716]                   options(future.plan = NULL)
[01:27:46.716]                   if (is.na(NA_character_)) 
[01:27:46.716]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.716]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.716]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.716]                   {
[01:27:46.716]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.716]                     if (!future$lazy) 
[01:27:46.716]                       future <- run(future)
[01:27:46.716]                     invisible(future)
[01:27:46.716]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.716]                 }
[01:27:46.716]             }
[01:27:46.716]         }
[01:27:46.716]     })
[01:27:46.716]     if (TRUE) {
[01:27:46.716]         base::sink(type = "output", split = FALSE)
[01:27:46.716]         if (TRUE) {
[01:27:46.716]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.716]         }
[01:27:46.716]         else {
[01:27:46.716]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.716]         }
[01:27:46.716]         base::close(...future.stdout)
[01:27:46.716]         ...future.stdout <- NULL
[01:27:46.716]     }
[01:27:46.716]     ...future.result$conditions <- ...future.conditions
[01:27:46.716]     ...future.result$finished <- base::Sys.time()
[01:27:46.716]     ...future.result
[01:27:46.716] }
[01:27:46.720] plan(): Setting new future strategy stack:
[01:27:46.721] List of future strategies:
[01:27:46.721] 1. sequential:
[01:27:46.721]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.721]    - tweaked: FALSE
[01:27:46.721]    - call: NULL
[01:27:46.721] plan(): nbrOfWorkers() = 1
[01:27:46.723] plan(): Setting new future strategy stack:
[01:27:46.723] List of future strategies:
[01:27:46.723] 1. sequential:
[01:27:46.723]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.723]    - tweaked: FALSE
[01:27:46.723]    - call: plan(strategy)
[01:27:46.723] plan(): nbrOfWorkers() = 1
[01:27:46.724] SequentialFuture started (and completed)
[01:27:46.724] - Launch lazy future ... done
[01:27:46.724] run() for 'SequentialFuture' ... done
[01:27:46.725] getGlobalsAndPackages() ...
[01:27:46.725] Searching for globals...
[01:27:46.726] - globals found: [1] '{'
[01:27:46.726] Searching for globals ... DONE
[01:27:46.726] Resolving globals: FALSE
[01:27:46.727] 
[01:27:46.727] 
[01:27:46.727] getGlobalsAndPackages() ... DONE
[01:27:46.728] run() for 'Future' ...
[01:27:46.728] - state: 'created'
[01:27:46.728] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:27:46.728] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:27:46.729] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:27:46.729]   - Field: 'label'
[01:27:46.729]   - Field: 'local'
[01:27:46.729]   - Field: 'owner'
[01:27:46.729]   - Field: 'envir'
[01:27:46.730]   - Field: 'packages'
[01:27:46.730]   - Field: 'gc'
[01:27:46.730]   - Field: 'conditions'
[01:27:46.730]   - Field: 'expr'
[01:27:46.730]   - Field: 'uuid'
[01:27:46.731]   - Field: 'seed'
[01:27:46.731]   - Field: 'version'
[01:27:46.731]   - Field: 'result'
[01:27:46.731]   - Field: 'asynchronous'
[01:27:46.731]   - Field: 'calls'
[01:27:46.732]   - Field: 'globals'
[01:27:46.732]   - Field: 'stdout'
[01:27:46.732]   - Field: 'earlySignal'
[01:27:46.732]   - Field: 'lazy'
[01:27:46.732]   - Field: 'state'
[01:27:46.733] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:27:46.733] - Launch lazy future ...
[01:27:46.733] Packages needed by the future expression (n = 0): <none>
[01:27:46.733] Packages needed by future strategies (n = 0): <none>
[01:27:46.734] {
[01:27:46.734]     {
[01:27:46.734]         {
[01:27:46.734]             ...future.startTime <- base::Sys.time()
[01:27:46.734]             {
[01:27:46.734]                 {
[01:27:46.734]                   {
[01:27:46.734]                     base::local({
[01:27:46.734]                       has_future <- base::requireNamespace("future", 
[01:27:46.734]                         quietly = TRUE)
[01:27:46.734]                       if (has_future) {
[01:27:46.734]                         ns <- base::getNamespace("future")
[01:27:46.734]                         version <- ns[[".package"]][["version"]]
[01:27:46.734]                         if (is.null(version)) 
[01:27:46.734]                           version <- utils::packageVersion("future")
[01:27:46.734]                       }
[01:27:46.734]                       else {
[01:27:46.734]                         version <- NULL
[01:27:46.734]                       }
[01:27:46.734]                       if (!has_future || version < "1.8.0") {
[01:27:46.734]                         info <- base::c(r_version = base::gsub("R version ", 
[01:27:46.734]                           "", base::R.version$version.string), 
[01:27:46.734]                           platform = base::sprintf("%s (%s-bit)", 
[01:27:46.734]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:46.734]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:46.734]                             "release", "version")], collapse = " "), 
[01:27:46.734]                           hostname = base::Sys.info()[["nodename"]])
[01:27:46.734]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:27:46.734]                           info)
[01:27:46.734]                         info <- base::paste(info, collapse = "; ")
[01:27:46.734]                         if (!has_future) {
[01:27:46.734]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:46.734]                             info)
[01:27:46.734]                         }
[01:27:46.734]                         else {
[01:27:46.734]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:46.734]                             info, version)
[01:27:46.734]                         }
[01:27:46.734]                         base::stop(msg)
[01:27:46.734]                       }
[01:27:46.734]                     })
[01:27:46.734]                   }
[01:27:46.734]                   options(future.plan = NULL)
[01:27:46.734]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.734]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:46.734]                 }
[01:27:46.734]                 ...future.workdir <- getwd()
[01:27:46.734]             }
[01:27:46.734]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:46.734]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:46.734]         }
[01:27:46.734]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:46.734]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:46.734]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:46.734]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:46.734]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:46.734]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:46.734]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:46.734]             base::names(...future.oldOptions))
[01:27:46.734]     }
[01:27:46.734]     if (FALSE) {
[01:27:46.734]     }
[01:27:46.734]     else {
[01:27:46.734]         if (TRUE) {
[01:27:46.734]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:46.734]                 open = "w")
[01:27:46.734]         }
[01:27:46.734]         else {
[01:27:46.734]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:46.734]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:46.734]         }
[01:27:46.734]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:46.734]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:46.734]             base::sink(type = "output", split = FALSE)
[01:27:46.734]             base::close(...future.stdout)
[01:27:46.734]         }, add = TRUE)
[01:27:46.734]     }
[01:27:46.734]     ...future.frame <- base::sys.nframe()
[01:27:46.734]     ...future.conditions <- base::list()
[01:27:46.734]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:46.734]     if (FALSE) {
[01:27:46.734]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:46.734]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:46.734]     }
[01:27:46.734]     ...future.result <- base::tryCatch({
[01:27:46.734]         base::withCallingHandlers({
[01:27:46.734]             ...future.value <- base::withVisible(base::local({
[01:27:46.734]                 4
[01:27:46.734]             }))
[01:27:46.734]             future::FutureResult(value = ...future.value$value, 
[01:27:46.734]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.734]                   ...future.rng), globalenv = if (FALSE) 
[01:27:46.734]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:46.734]                     ...future.globalenv.names))
[01:27:46.734]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:46.734]         }, condition = base::local({
[01:27:46.734]             c <- base::c
[01:27:46.734]             inherits <- base::inherits
[01:27:46.734]             invokeRestart <- base::invokeRestart
[01:27:46.734]             length <- base::length
[01:27:46.734]             list <- base::list
[01:27:46.734]             seq.int <- base::seq.int
[01:27:46.734]             signalCondition <- base::signalCondition
[01:27:46.734]             sys.calls <- base::sys.calls
[01:27:46.734]             `[[` <- base::`[[`
[01:27:46.734]             `+` <- base::`+`
[01:27:46.734]             `<<-` <- base::`<<-`
[01:27:46.734]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:46.734]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:46.734]                   3L)]
[01:27:46.734]             }
[01:27:46.734]             function(cond) {
[01:27:46.734]                 is_error <- inherits(cond, "error")
[01:27:46.734]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:46.734]                   NULL)
[01:27:46.734]                 if (is_error) {
[01:27:46.734]                   sessionInformation <- function() {
[01:27:46.734]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:46.734]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:46.734]                       search = base::search(), system = base::Sys.info())
[01:27:46.734]                   }
[01:27:46.734]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.734]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:46.734]                     cond$call), session = sessionInformation(), 
[01:27:46.734]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:46.734]                   signalCondition(cond)
[01:27:46.734]                 }
[01:27:46.734]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:46.734]                 "immediateCondition"))) {
[01:27:46.734]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:46.734]                   ...future.conditions[[length(...future.conditions) + 
[01:27:46.734]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:46.734]                   if (TRUE && !signal) {
[01:27:46.734]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.734]                     {
[01:27:46.734]                       inherits <- base::inherits
[01:27:46.734]                       invokeRestart <- base::invokeRestart
[01:27:46.734]                       is.null <- base::is.null
[01:27:46.734]                       muffled <- FALSE
[01:27:46.734]                       if (inherits(cond, "message")) {
[01:27:46.734]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.734]                         if (muffled) 
[01:27:46.734]                           invokeRestart("muffleMessage")
[01:27:46.734]                       }
[01:27:46.734]                       else if (inherits(cond, "warning")) {
[01:27:46.734]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.734]                         if (muffled) 
[01:27:46.734]                           invokeRestart("muffleWarning")
[01:27:46.734]                       }
[01:27:46.734]                       else if (inherits(cond, "condition")) {
[01:27:46.734]                         if (!is.null(pattern)) {
[01:27:46.734]                           computeRestarts <- base::computeRestarts
[01:27:46.734]                           grepl <- base::grepl
[01:27:46.734]                           restarts <- computeRestarts(cond)
[01:27:46.734]                           for (restart in restarts) {
[01:27:46.734]                             name <- restart$name
[01:27:46.734]                             if (is.null(name)) 
[01:27:46.734]                               next
[01:27:46.734]                             if (!grepl(pattern, name)) 
[01:27:46.734]                               next
[01:27:46.734]                             invokeRestart(restart)
[01:27:46.734]                             muffled <- TRUE
[01:27:46.734]                             break
[01:27:46.734]                           }
[01:27:46.734]                         }
[01:27:46.734]                       }
[01:27:46.734]                       invisible(muffled)
[01:27:46.734]                     }
[01:27:46.734]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.734]                   }
[01:27:46.734]                 }
[01:27:46.734]                 else {
[01:27:46.734]                   if (TRUE) {
[01:27:46.734]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:46.734]                     {
[01:27:46.734]                       inherits <- base::inherits
[01:27:46.734]                       invokeRestart <- base::invokeRestart
[01:27:46.734]                       is.null <- base::is.null
[01:27:46.734]                       muffled <- FALSE
[01:27:46.734]                       if (inherits(cond, "message")) {
[01:27:46.734]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:46.734]                         if (muffled) 
[01:27:46.734]                           invokeRestart("muffleMessage")
[01:27:46.734]                       }
[01:27:46.734]                       else if (inherits(cond, "warning")) {
[01:27:46.734]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:46.734]                         if (muffled) 
[01:27:46.734]                           invokeRestart("muffleWarning")
[01:27:46.734]                       }
[01:27:46.734]                       else if (inherits(cond, "condition")) {
[01:27:46.734]                         if (!is.null(pattern)) {
[01:27:46.734]                           computeRestarts <- base::computeRestarts
[01:27:46.734]                           grepl <- base::grepl
[01:27:46.734]                           restarts <- computeRestarts(cond)
[01:27:46.734]                           for (restart in restarts) {
[01:27:46.734]                             name <- restart$name
[01:27:46.734]                             if (is.null(name)) 
[01:27:46.734]                               next
[01:27:46.734]                             if (!grepl(pattern, name)) 
[01:27:46.734]                               next
[01:27:46.734]                             invokeRestart(restart)
[01:27:46.734]                             muffled <- TRUE
[01:27:46.734]                             break
[01:27:46.734]                           }
[01:27:46.734]                         }
[01:27:46.734]                       }
[01:27:46.734]                       invisible(muffled)
[01:27:46.734]                     }
[01:27:46.734]                     muffleCondition(cond, pattern = "^muffle")
[01:27:46.734]                   }
[01:27:46.734]                 }
[01:27:46.734]             }
[01:27:46.734]         }))
[01:27:46.734]     }, error = function(ex) {
[01:27:46.734]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:46.734]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:46.734]                 ...future.rng), started = ...future.startTime, 
[01:27:46.734]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:46.734]             version = "1.8"), class = "FutureResult")
[01:27:46.734]     }, finally = {
[01:27:46.734]         if (!identical(...future.workdir, getwd())) 
[01:27:46.734]             setwd(...future.workdir)
[01:27:46.734]         {
[01:27:46.734]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:46.734]                 ...future.oldOptions$nwarnings <- NULL
[01:27:46.734]             }
[01:27:46.734]             base::options(...future.oldOptions)
[01:27:46.734]             if (.Platform$OS.type == "windows") {
[01:27:46.734]                 old_names <- names(...future.oldEnvVars)
[01:27:46.734]                 envs <- base::Sys.getenv()
[01:27:46.734]                 names <- names(envs)
[01:27:46.734]                 common <- intersect(names, old_names)
[01:27:46.734]                 added <- setdiff(names, old_names)
[01:27:46.734]                 removed <- setdiff(old_names, names)
[01:27:46.734]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:46.734]                   envs[common]]
[01:27:46.734]                 NAMES <- toupper(changed)
[01:27:46.734]                 args <- list()
[01:27:46.734]                 for (kk in seq_along(NAMES)) {
[01:27:46.734]                   name <- changed[[kk]]
[01:27:46.734]                   NAME <- NAMES[[kk]]
[01:27:46.734]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.734]                     next
[01:27:46.734]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.734]                 }
[01:27:46.734]                 NAMES <- toupper(added)
[01:27:46.734]                 for (kk in seq_along(NAMES)) {
[01:27:46.734]                   name <- added[[kk]]
[01:27:46.734]                   NAME <- NAMES[[kk]]
[01:27:46.734]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.734]                     next
[01:27:46.734]                   args[[name]] <- ""
[01:27:46.734]                 }
[01:27:46.734]                 NAMES <- toupper(removed)
[01:27:46.734]                 for (kk in seq_along(NAMES)) {
[01:27:46.734]                   name <- removed[[kk]]
[01:27:46.734]                   NAME <- NAMES[[kk]]
[01:27:46.734]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:46.734]                     next
[01:27:46.734]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:46.734]                 }
[01:27:46.734]                 if (length(args) > 0) 
[01:27:46.734]                   base::do.call(base::Sys.setenv, args = args)
[01:27:46.734]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:46.734]             }
[01:27:46.734]             else {
[01:27:46.734]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:46.734]             }
[01:27:46.734]             {
[01:27:46.734]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:46.734]                   0L) {
[01:27:46.734]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:46.734]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:46.734]                   base::options(opts)
[01:27:46.734]                 }
[01:27:46.734]                 {
[01:27:46.734]                   {
[01:27:46.734]                     NULL
[01:27:46.734]                     RNGkind("Mersenne-Twister")
[01:27:46.734]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:27:46.734]                       inherits = FALSE)
[01:27:46.734]                   }
[01:27:46.734]                   options(future.plan = NULL)
[01:27:46.734]                   if (is.na(NA_character_)) 
[01:27:46.734]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:46.734]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:46.734]                   future::plan(list(function (..., envir = parent.frame()) 
[01:27:46.734]                   {
[01:27:46.734]                     future <- SequentialFuture(..., envir = envir)
[01:27:46.734]                     if (!future$lazy) 
[01:27:46.734]                       future <- run(future)
[01:27:46.734]                     invisible(future)
[01:27:46.734]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:46.734]                 }
[01:27:46.734]             }
[01:27:46.734]         }
[01:27:46.734]     })
[01:27:46.734]     if (TRUE) {
[01:27:46.734]         base::sink(type = "output", split = FALSE)
[01:27:46.734]         if (TRUE) {
[01:27:46.734]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:46.734]         }
[01:27:46.734]         else {
[01:27:46.734]             ...future.result["stdout"] <- base::list(NULL)
[01:27:46.734]         }
[01:27:46.734]         base::close(...future.stdout)
[01:27:46.734]         ...future.stdout <- NULL
[01:27:46.734]     }
[01:27:46.734]     ...future.result$conditions <- ...future.conditions
[01:27:46.734]     ...future.result$finished <- base::Sys.time()
[01:27:46.734]     ...future.result
[01:27:46.734] }
[01:27:46.738] plan(): Setting new future strategy stack:
[01:27:46.738] List of future strategies:
[01:27:46.738] 1. sequential:
[01:27:46.738]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.738]    - tweaked: FALSE
[01:27:46.738]    - call: NULL
[01:27:46.739] plan(): nbrOfWorkers() = 1
[01:27:46.743] plan(): Setting new future strategy stack:
[01:27:46.744] List of future strategies:
[01:27:46.744] 1. sequential:
[01:27:46.744]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:46.744]    - tweaked: FALSE
[01:27:46.744]    - call: plan(strategy)
[01:27:46.744] plan(): nbrOfWorkers() = 1
[01:27:46.745] SequentialFuture started (and completed)
[01:27:46.745] - Launch lazy future ... done
[01:27:46.745] run() for 'SequentialFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b080baab0> 
Classes 'listenv', 'environment' <environment: 0x0000025b0605ebc8> 
 - 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"
[01:27:46.751] resolved() for 'SequentialFuture' ...
[01:27:46.751] - state: 'finished'
[01:27:46.751] - run: TRUE
[01:27:46.751] - result: 'FutureResult'
[01:27:46.751] resolved() for 'SequentialFuture' ... done
[01:27:46.752] resolved() for 'SequentialFuture' ...
[01:27:46.752] - state: 'finished'
[01:27:46.752] - run: TRUE
[01:27:46.752] - result: 'FutureResult'
[01:27:46.752] resolved() for 'SequentialFuture' ... done
[01:27:46.753] resolved() for 'SequentialFuture' ...
[01:27:46.753] - state: 'finished'
[01:27:46.753] - run: TRUE
[01:27:46.753] - result: 'FutureResult'
[01:27:46.753] 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" ...
[01:27:46.757] resolve() on list environment ...
[01:27:46.757]  recursive: 0
[01:27:46.759]  length: 6
[01:27:46.759]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:46.759] signalConditionsASAP(numeric, pos=1) ...
[01:27:46.759] - nx: 6
[01:27:46.759] - relay: TRUE
[01:27:46.760] - stdout: TRUE
[01:27:46.760] - signal: TRUE
[01:27:46.760] - resignal: FALSE
[01:27:46.760] - force: TRUE
[01:27:46.760] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.760] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.761]  - until=2
[01:27:46.761]  - relaying element #2
[01:27:46.761] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.761] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.761] signalConditionsASAP(NULL, pos=1) ... done
[01:27:46.761]  length: 5 (resolved future 1)
[01:27:46.762] resolved() for 'SequentialFuture' ...
[01:27:46.762] - state: 'finished'
[01:27:46.762] - run: TRUE
[01:27:46.762] - result: 'FutureResult'
[01:27:46.762] resolved() for 'SequentialFuture' ... done
[01:27:46.762] Future #2
[01:27:46.763] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:27:46.763] - nx: 6
[01:27:46.763] - relay: TRUE
[01:27:46.763] - stdout: TRUE
[01:27:46.763] - signal: TRUE
[01:27:46.763] - resignal: FALSE
[01:27:46.764] - force: TRUE
[01:27:46.764] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.764] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:46.764]  - until=2
[01:27:46.764]  - relaying element #2
[01:27:46.765] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.765] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.765] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:27:46.765]  length: 4 (resolved future 2)
[01:27:46.765] resolved() for 'SequentialFuture' ...
[01:27:46.766] - state: 'finished'
[01:27:46.766] - run: TRUE
[01:27:46.766] - result: 'FutureResult'
[01:27:46.766] resolved() for 'SequentialFuture' ... done
[01:27:46.766] Future #3
[01:27:46.767] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:27:46.767] - nx: 6
[01:27:46.767] - relay: TRUE
[01:27:46.767] - stdout: TRUE
[01:27:46.767] - signal: TRUE
[01:27:46.767] - resignal: FALSE
[01:27:46.768] - force: TRUE
[01:27:46.768] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.768] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:46.768]  - until=3
[01:27:46.768]  - relaying element #3
[01:27:46.769] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.769] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.769] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:27:46.769]  length: 3 (resolved future 3)
[01:27:46.769] resolved() for 'SequentialFuture' ...
[01:27:46.769] - state: 'finished'
[01:27:46.770] - run: TRUE
[01:27:46.770] - result: 'FutureResult'
[01:27:46.770] resolved() for 'SequentialFuture' ... done
[01:27:46.770] Future #4
[01:27:46.770] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:27:46.771] - nx: 6
[01:27:46.771] - relay: TRUE
[01:27:46.771] - stdout: TRUE
[01:27:46.772] - signal: TRUE
[01:27:46.773] - resignal: FALSE
[01:27:46.773] - force: TRUE
[01:27:46.773] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.773] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:46.773]  - until=4
[01:27:46.773]  - relaying element #4
[01:27:46.774] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.774] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.774] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:27:46.774]  length: 2 (resolved future 4)
[01:27:46.774] signalConditionsASAP(NULL, pos=5) ...
[01:27:46.775] - nx: 6
[01:27:46.775] - relay: TRUE
[01:27:46.775] - stdout: TRUE
[01:27:46.775] - signal: TRUE
[01:27:46.775] - resignal: FALSE
[01:27:46.775] - force: TRUE
[01:27:46.775] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.776] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.776]  - until=6
[01:27:46.776]  - relaying element #6
[01:27:46.776] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.776] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.776] signalConditionsASAP(NULL, pos=5) ... done
[01:27:46.777]  length: 1 (resolved future 5)
[01:27:46.777] signalConditionsASAP(numeric, pos=6) ...
[01:27:46.777] - nx: 6
[01:27:46.777] - relay: TRUE
[01:27:46.777] - stdout: TRUE
[01:27:46.778] - signal: TRUE
[01:27:46.778] - resignal: FALSE
[01:27:46.778] - force: TRUE
[01:27:46.778] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:46.778] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.778]  - until=6
[01:27:46.778] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.779] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.779] signalConditionsASAP(numeric, pos=6) ... done
[01:27:46.779]  length: 0 (resolved future 6)
[01:27:46.779] Relaying remaining futures
[01:27:46.779] signalConditionsASAP(NULL, pos=0) ...
[01:27:46.779] - nx: 6
[01:27:46.779] - relay: TRUE
[01:27:46.780] - stdout: TRUE
[01:27:46.780] - signal: TRUE
[01:27:46.780] - resignal: FALSE
[01:27:46.780] - force: TRUE
[01:27:46.780] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.780] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:46.781] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:46.781] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:46.781] signalConditionsASAP(NULL, pos=0) ... done
[01:27:46.781] resolve() on list environment ... DONE
Classes 'listenv', 'environment' <environment: 0x0000025b07649f48> 
 - 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
[01:27:46.784] plan(): Setting new future strategy stack:
[01:27:46.785] List of future strategies:
[01:27:46.785] 1. multisession:
[01:27:46.785]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:27:46.785]    - tweaked: FALSE
[01:27:46.785]    - call: plan(strategy)
[01:27:46.785] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:27:46.785] multisession:
[01:27:46.785] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:27:46.785] - tweaked: FALSE
[01:27:46.785] - call: plan(strategy)
[01:27:46.790] getGlobalsAndPackages() ...
[01:27:46.790] Not searching for globals
[01:27:46.791] - globals: [0] <none>
[01:27:46.791] getGlobalsAndPackages() ... DONE
[01:27:46.791] [local output] makeClusterPSOCK() ...
[01:27:46.882] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:27:46.889] [local output] Base port: 37513
[01:27:46.890] [local output] Getting setup options for 2 cluster nodes ...
[01:27:46.890] [local output]  - Node 1 of 2 ...
[01:27:46.890] [local output] localMachine=TRUE => revtunnel=FALSE

[01:27:46.892] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da471d86bbe.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da471d86bbe.pid\")"'
[01:27:47.228] - Possible to infer worker's PID: TRUE
[01:27:47.229] [local output] Rscript port: 37513

[01:27:47.230] [local output]  - Node 2 of 2 ...
[01:27:47.230] [local output] localMachine=TRUE => revtunnel=FALSE

[01:27:47.232] [local output] Rscript port: 37513

[01:27:47.233] [local output] Getting setup options for 2 cluster nodes ... done
[01:27:47.233] [local output]  - Parallel setup requested for some PSOCK nodes
[01:27:47.234] [local output] Setting up PSOCK nodes in parallel
[01:27:47.234] List of 36
[01:27:47.234]  $ worker          : chr "localhost"
[01:27:47.234]   ..- attr(*, "localhost")= logi TRUE
[01:27:47.234]  $ master          : chr "localhost"
[01:27:47.234]  $ port            : int 37513
[01:27:47.234]  $ connectTimeout  : num 120
[01:27:47.234]  $ timeout         : num 120
[01:27:47.234]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:27:47.234]  $ homogeneous     : logi TRUE
[01:27:47.234]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futures.R:3492:CRANWIN3:CRAN\" -"| __truncated__
[01:27:47.234]  $ rscript_envs    : NULL
[01:27:47.234]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:27:47.234]  $ rscript_startup : NULL
[01:27:47.234]  $ rscript_sh      : chr "cmd"
[01:27:47.234]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:27:47.234]  $ methods         : logi TRUE
[01:27:47.234]  $ socketOptions   : chr "no-delay"
[01:27:47.234]  $ useXDR          : logi FALSE
[01:27:47.234]  $ outfile         : chr "/dev/null"
[01:27:47.234]  $ renice          : int NA
[01:27:47.234]  $ rshcmd          : NULL
[01:27:47.234]  $ user            : chr(0) 
[01:27:47.234]  $ revtunnel       : logi FALSE
[01:27:47.234]  $ rshlogfile      : NULL
[01:27:47.234]  $ rshopts         : chr(0) 
[01:27:47.234]  $ rank            : int 1
[01:27:47.234]  $ manual          : logi FALSE
[01:27:47.234]  $ dryrun          : logi FALSE
[01:27:47.234]  $ quiet           : logi FALSE
[01:27:47.234]  $ setup_strategy  : chr "parallel"
[01:27:47.234]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:27:47.234]  $ pidfile         : chr "D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da471d86bbe.pid"
[01:27:47.234]  $ rshcmd_label    : NULL
[01:27:47.234]  $ rsh_call        : NULL
[01:27:47.234]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:27:47.234]  $ localMachine    : logi TRUE
[01:27:47.234]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:27:47.234]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:27:47.234]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:27:47.234]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:27:47.234]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:27:47.234]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:27:47.234]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:27:47.234]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:27:47.234]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:27:47.234]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:27:47.234]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:27:47.234]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:27:47.234]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:27:47.234]  $ arguments       :List of 28
[01:27:47.234]   ..$ worker          : chr "localhost"
[01:27:47.234]   ..$ master          : NULL
[01:27:47.234]   ..$ port            : int 37513
[01:27:47.234]   ..$ connectTimeout  : num 120
[01:27:47.234]   ..$ timeout         : num 120
[01:27:47.234]   ..$ rscript         : NULL
[01:27:47.234]   ..$ homogeneous     : NULL
[01:27:47.234]   ..$ rscript_args    : NULL
[01:27:47.234]   ..$ rscript_envs    : NULL
[01:27:47.234]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:27:47.234]   ..$ rscript_startup : NULL
[01:27:47.234]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:27:47.234]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:27:47.234]   ..$ methods         : logi TRUE
[01:27:47.234]   ..$ socketOptions   : chr "no-delay"
[01:27:47.234]   ..$ useXDR          : logi FALSE
[01:27:47.234]   ..$ outfile         : chr "/dev/null"
[01:27:47.234]   ..$ renice          : int NA
[01:27:47.234]   ..$ rshcmd          : NULL
[01:27:47.234]   ..$ user            : NULL
[01:27:47.234]   ..$ revtunnel       : logi NA
[01:27:47.234]   ..$ rshlogfile      : NULL
[01:27:47.234]   ..$ rshopts         : NULL
[01:27:47.234]   ..$ rank            : int 1
[01:27:47.234]   ..$ manual          : logi FALSE
[01:27:47.234]   ..$ dryrun          : logi FALSE
[01:27:47.234]   ..$ quiet           : logi FALSE
[01:27:47.234]   ..$ setup_strategy  : chr "parallel"
[01:27:47.234]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:27:47.267] [local output] System call to launch all workers:
[01:27:47.268] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futures.R:3492:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da471d86bbe.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=37513 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:27:47.268] [local output] Starting PSOCK main server
[01:27:47.275] [local output] Workers launched
[01:27:47.276] [local output] Waiting for workers to connect back
[01:27:47.276]  - [local output] 0 workers out of 2 ready
[01:27:47.459]  - [local output] 0 workers out of 2 ready
[01:27:47.459]  - [local output] 1 workers out of 2 ready
[01:27:47.481]  - [local output] 1 workers out of 2 ready
[01:27:47.482]  - [local output] 2 workers out of 2 ready
[01:27:47.482] [local output] Launching of workers completed
[01:27:47.482] [local output] Collecting session information from workers
[01:27:47.483] [local output]  - Worker #1 of 2
[01:27:47.484] [local output]  - Worker #2 of 2
[01:27:47.484] [local output] makeClusterPSOCK() ... done
[01:27:47.498] Packages needed by the future expression (n = 0): <none>
[01:27:47.498] Packages needed by future strategies (n = 0): <none>
[01:27:47.499] {
[01:27:47.499]     {
[01:27:47.499]         {
[01:27:47.499]             ...future.startTime <- base::Sys.time()
[01:27:47.499]             {
[01:27:47.499]                 {
[01:27:47.499]                   {
[01:27:47.499]                     {
[01:27:47.499]                       base::local({
[01:27:47.499]                         has_future <- base::requireNamespace("future", 
[01:27:47.499]                           quietly = TRUE)
[01:27:47.499]                         if (has_future) {
[01:27:47.499]                           ns <- base::getNamespace("future")
[01:27:47.499]                           version <- ns[[".package"]][["version"]]
[01:27:47.499]                           if (is.null(version)) 
[01:27:47.499]                             version <- utils::packageVersion("future")
[01:27:47.499]                         }
[01:27:47.499]                         else {
[01:27:47.499]                           version <- NULL
[01:27:47.499]                         }
[01:27:47.499]                         if (!has_future || version < "1.8.0") {
[01:27:47.499]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:47.499]                             "", base::R.version$version.string), 
[01:27:47.499]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:47.499]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:47.499]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:47.499]                               "release", "version")], collapse = " "), 
[01:27:47.499]                             hostname = base::Sys.info()[["nodename"]])
[01:27:47.499]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:47.499]                             info)
[01:27:47.499]                           info <- base::paste(info, collapse = "; ")
[01:27:47.499]                           if (!has_future) {
[01:27:47.499]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:47.499]                               info)
[01:27:47.499]                           }
[01:27:47.499]                           else {
[01:27:47.499]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:47.499]                               info, version)
[01:27:47.499]                           }
[01:27:47.499]                           base::stop(msg)
[01:27:47.499]                         }
[01:27:47.499]                       })
[01:27:47.499]                     }
[01:27:47.499]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:47.499]                     base::options(mc.cores = 1L)
[01:27:47.499]                   }
[01:27:47.499]                   options(future.plan = NULL)
[01:27:47.499]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.499]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:47.499]                 }
[01:27:47.499]                 ...future.workdir <- getwd()
[01:27:47.499]             }
[01:27:47.499]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:47.499]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:47.499]         }
[01:27:47.499]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:47.499]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:47.499]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:47.499]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:47.499]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:47.499]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:47.499]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:47.499]             base::names(...future.oldOptions))
[01:27:47.499]     }
[01:27:47.499]     if (FALSE) {
[01:27:47.499]     }
[01:27:47.499]     else {
[01:27:47.499]         if (TRUE) {
[01:27:47.499]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:47.499]                 open = "w")
[01:27:47.499]         }
[01:27:47.499]         else {
[01:27:47.499]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:47.499]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:47.499]         }
[01:27:47.499]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:47.499]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:47.499]             base::sink(type = "output", split = FALSE)
[01:27:47.499]             base::close(...future.stdout)
[01:27:47.499]         }, add = TRUE)
[01:27:47.499]     }
[01:27:47.499]     ...future.frame <- base::sys.nframe()
[01:27:47.499]     ...future.conditions <- base::list()
[01:27:47.499]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:47.499]     if (FALSE) {
[01:27:47.499]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:47.499]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:47.499]     }
[01:27:47.499]     ...future.result <- base::tryCatch({
[01:27:47.499]         base::withCallingHandlers({
[01:27:47.499]             ...future.value <- base::withVisible(base::local({
[01:27:47.499]                 ...future.makeSendCondition <- base::local({
[01:27:47.499]                   sendCondition <- NULL
[01:27:47.499]                   function(frame = 1L) {
[01:27:47.499]                     if (is.function(sendCondition)) 
[01:27:47.499]                       return(sendCondition)
[01:27:47.499]                     ns <- getNamespace("parallel")
[01:27:47.499]                     if (exists("sendData", mode = "function", 
[01:27:47.499]                       envir = ns)) {
[01:27:47.499]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:47.499]                         envir = ns)
[01:27:47.499]                       envir <- sys.frame(frame)
[01:27:47.499]                       master <- NULL
[01:27:47.499]                       while (!identical(envir, .GlobalEnv) && 
[01:27:47.499]                         !identical(envir, emptyenv())) {
[01:27:47.499]                         if (exists("master", mode = "list", envir = envir, 
[01:27:47.499]                           inherits = FALSE)) {
[01:27:47.499]                           master <- get("master", mode = "list", 
[01:27:47.499]                             envir = envir, inherits = FALSE)
[01:27:47.499]                           if (inherits(master, c("SOCKnode", 
[01:27:47.499]                             "SOCK0node"))) {
[01:27:47.499]                             sendCondition <<- function(cond) {
[01:27:47.499]                               data <- list(type = "VALUE", value = cond, 
[01:27:47.499]                                 success = TRUE)
[01:27:47.499]                               parallel_sendData(master, data)
[01:27:47.499]                             }
[01:27:47.499]                             return(sendCondition)
[01:27:47.499]                           }
[01:27:47.499]                         }
[01:27:47.499]                         frame <- frame + 1L
[01:27:47.499]                         envir <- sys.frame(frame)
[01:27:47.499]                       }
[01:27:47.499]                     }
[01:27:47.499]                     sendCondition <<- function(cond) NULL
[01:27:47.499]                   }
[01:27:47.499]                 })
[01:27:47.499]                 withCallingHandlers({
[01:27:47.499]                   NA
[01:27:47.499]                 }, immediateCondition = function(cond) {
[01:27:47.499]                   sendCondition <- ...future.makeSendCondition()
[01:27:47.499]                   sendCondition(cond)
[01:27:47.499]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.499]                   {
[01:27:47.499]                     inherits <- base::inherits
[01:27:47.499]                     invokeRestart <- base::invokeRestart
[01:27:47.499]                     is.null <- base::is.null
[01:27:47.499]                     muffled <- FALSE
[01:27:47.499]                     if (inherits(cond, "message")) {
[01:27:47.499]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:47.499]                       if (muffled) 
[01:27:47.499]                         invokeRestart("muffleMessage")
[01:27:47.499]                     }
[01:27:47.499]                     else if (inherits(cond, "warning")) {
[01:27:47.499]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:47.499]                       if (muffled) 
[01:27:47.499]                         invokeRestart("muffleWarning")
[01:27:47.499]                     }
[01:27:47.499]                     else if (inherits(cond, "condition")) {
[01:27:47.499]                       if (!is.null(pattern)) {
[01:27:47.499]                         computeRestarts <- base::computeRestarts
[01:27:47.499]                         grepl <- base::grepl
[01:27:47.499]                         restarts <- computeRestarts(cond)
[01:27:47.499]                         for (restart in restarts) {
[01:27:47.499]                           name <- restart$name
[01:27:47.499]                           if (is.null(name)) 
[01:27:47.499]                             next
[01:27:47.499]                           if (!grepl(pattern, name)) 
[01:27:47.499]                             next
[01:27:47.499]                           invokeRestart(restart)
[01:27:47.499]                           muffled <- TRUE
[01:27:47.499]                           break
[01:27:47.499]                         }
[01:27:47.499]                       }
[01:27:47.499]                     }
[01:27:47.499]                     invisible(muffled)
[01:27:47.499]                   }
[01:27:47.499]                   muffleCondition(cond)
[01:27:47.499]                 })
[01:27:47.499]             }))
[01:27:47.499]             future::FutureResult(value = ...future.value$value, 
[01:27:47.499]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.499]                   ...future.rng), globalenv = if (FALSE) 
[01:27:47.499]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:47.499]                     ...future.globalenv.names))
[01:27:47.499]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:47.499]         }, condition = base::local({
[01:27:47.499]             c <- base::c
[01:27:47.499]             inherits <- base::inherits
[01:27:47.499]             invokeRestart <- base::invokeRestart
[01:27:47.499]             length <- base::length
[01:27:47.499]             list <- base::list
[01:27:47.499]             seq.int <- base::seq.int
[01:27:47.499]             signalCondition <- base::signalCondition
[01:27:47.499]             sys.calls <- base::sys.calls
[01:27:47.499]             `[[` <- base::`[[`
[01:27:47.499]             `+` <- base::`+`
[01:27:47.499]             `<<-` <- base::`<<-`
[01:27:47.499]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:47.499]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:47.499]                   3L)]
[01:27:47.499]             }
[01:27:47.499]             function(cond) {
[01:27:47.499]                 is_error <- inherits(cond, "error")
[01:27:47.499]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:47.499]                   NULL)
[01:27:47.499]                 if (is_error) {
[01:27:47.499]                   sessionInformation <- function() {
[01:27:47.499]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:47.499]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:47.499]                       search = base::search(), system = base::Sys.info())
[01:27:47.499]                   }
[01:27:47.499]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.499]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:47.499]                     cond$call), session = sessionInformation(), 
[01:27:47.499]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:47.499]                   signalCondition(cond)
[01:27:47.499]                 }
[01:27:47.499]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:47.499]                 "immediateCondition"))) {
[01:27:47.499]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:47.499]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.499]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:47.499]                   if (TRUE && !signal) {
[01:27:47.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.499]                     {
[01:27:47.499]                       inherits <- base::inherits
[01:27:47.499]                       invokeRestart <- base::invokeRestart
[01:27:47.499]                       is.null <- base::is.null
[01:27:47.499]                       muffled <- FALSE
[01:27:47.499]                       if (inherits(cond, "message")) {
[01:27:47.499]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.499]                         if (muffled) 
[01:27:47.499]                           invokeRestart("muffleMessage")
[01:27:47.499]                       }
[01:27:47.499]                       else if (inherits(cond, "warning")) {
[01:27:47.499]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.499]                         if (muffled) 
[01:27:47.499]                           invokeRestart("muffleWarning")
[01:27:47.499]                       }
[01:27:47.499]                       else if (inherits(cond, "condition")) {
[01:27:47.499]                         if (!is.null(pattern)) {
[01:27:47.499]                           computeRestarts <- base::computeRestarts
[01:27:47.499]                           grepl <- base::grepl
[01:27:47.499]                           restarts <- computeRestarts(cond)
[01:27:47.499]                           for (restart in restarts) {
[01:27:47.499]                             name <- restart$name
[01:27:47.499]                             if (is.null(name)) 
[01:27:47.499]                               next
[01:27:47.499]                             if (!grepl(pattern, name)) 
[01:27:47.499]                               next
[01:27:47.499]                             invokeRestart(restart)
[01:27:47.499]                             muffled <- TRUE
[01:27:47.499]                             break
[01:27:47.499]                           }
[01:27:47.499]                         }
[01:27:47.499]                       }
[01:27:47.499]                       invisible(muffled)
[01:27:47.499]                     }
[01:27:47.499]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.499]                   }
[01:27:47.499]                 }
[01:27:47.499]                 else {
[01:27:47.499]                   if (TRUE) {
[01:27:47.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.499]                     {
[01:27:47.499]                       inherits <- base::inherits
[01:27:47.499]                       invokeRestart <- base::invokeRestart
[01:27:47.499]                       is.null <- base::is.null
[01:27:47.499]                       muffled <- FALSE
[01:27:47.499]                       if (inherits(cond, "message")) {
[01:27:47.499]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.499]                         if (muffled) 
[01:27:47.499]                           invokeRestart("muffleMessage")
[01:27:47.499]                       }
[01:27:47.499]                       else if (inherits(cond, "warning")) {
[01:27:47.499]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.499]                         if (muffled) 
[01:27:47.499]                           invokeRestart("muffleWarning")
[01:27:47.499]                       }
[01:27:47.499]                       else if (inherits(cond, "condition")) {
[01:27:47.499]                         if (!is.null(pattern)) {
[01:27:47.499]                           computeRestarts <- base::computeRestarts
[01:27:47.499]                           grepl <- base::grepl
[01:27:47.499]                           restarts <- computeRestarts(cond)
[01:27:47.499]                           for (restart in restarts) {
[01:27:47.499]                             name <- restart$name
[01:27:47.499]                             if (is.null(name)) 
[01:27:47.499]                               next
[01:27:47.499]                             if (!grepl(pattern, name)) 
[01:27:47.499]                               next
[01:27:47.499]                             invokeRestart(restart)
[01:27:47.499]                             muffled <- TRUE
[01:27:47.499]                             break
[01:27:47.499]                           }
[01:27:47.499]                         }
[01:27:47.499]                       }
[01:27:47.499]                       invisible(muffled)
[01:27:47.499]                     }
[01:27:47.499]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.499]                   }
[01:27:47.499]                 }
[01:27:47.499]             }
[01:27:47.499]         }))
[01:27:47.499]     }, error = function(ex) {
[01:27:47.499]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:47.499]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.499]                 ...future.rng), started = ...future.startTime, 
[01:27:47.499]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:47.499]             version = "1.8"), class = "FutureResult")
[01:27:47.499]     }, finally = {
[01:27:47.499]         if (!identical(...future.workdir, getwd())) 
[01:27:47.499]             setwd(...future.workdir)
[01:27:47.499]         {
[01:27:47.499]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:47.499]                 ...future.oldOptions$nwarnings <- NULL
[01:27:47.499]             }
[01:27:47.499]             base::options(...future.oldOptions)
[01:27:47.499]             if (.Platform$OS.type == "windows") {
[01:27:47.499]                 old_names <- names(...future.oldEnvVars)
[01:27:47.499]                 envs <- base::Sys.getenv()
[01:27:47.499]                 names <- names(envs)
[01:27:47.499]                 common <- intersect(names, old_names)
[01:27:47.499]                 added <- setdiff(names, old_names)
[01:27:47.499]                 removed <- setdiff(old_names, names)
[01:27:47.499]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:47.499]                   envs[common]]
[01:27:47.499]                 NAMES <- toupper(changed)
[01:27:47.499]                 args <- list()
[01:27:47.499]                 for (kk in seq_along(NAMES)) {
[01:27:47.499]                   name <- changed[[kk]]
[01:27:47.499]                   NAME <- NAMES[[kk]]
[01:27:47.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.499]                     next
[01:27:47.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.499]                 }
[01:27:47.499]                 NAMES <- toupper(added)
[01:27:47.499]                 for (kk in seq_along(NAMES)) {
[01:27:47.499]                   name <- added[[kk]]
[01:27:47.499]                   NAME <- NAMES[[kk]]
[01:27:47.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.499]                     next
[01:27:47.499]                   args[[name]] <- ""
[01:27:47.499]                 }
[01:27:47.499]                 NAMES <- toupper(removed)
[01:27:47.499]                 for (kk in seq_along(NAMES)) {
[01:27:47.499]                   name <- removed[[kk]]
[01:27:47.499]                   NAME <- NAMES[[kk]]
[01:27:47.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.499]                     next
[01:27:47.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.499]                 }
[01:27:47.499]                 if (length(args) > 0) 
[01:27:47.499]                   base::do.call(base::Sys.setenv, args = args)
[01:27:47.499]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:47.499]             }
[01:27:47.499]             else {
[01:27:47.499]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:47.499]             }
[01:27:47.499]             {
[01:27:47.499]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:47.499]                   0L) {
[01:27:47.499]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:47.499]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:47.499]                   base::options(opts)
[01:27:47.499]                 }
[01:27:47.499]                 {
[01:27:47.499]                   {
[01:27:47.499]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:47.499]                     NULL
[01:27:47.499]                   }
[01:27:47.499]                   options(future.plan = NULL)
[01:27:47.499]                   if (is.na(NA_character_)) 
[01:27:47.499]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.499]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:47.499]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:47.499]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:47.499]                     envir = parent.frame()) 
[01:27:47.499]                   {
[01:27:47.499]                     if (is.function(workers)) 
[01:27:47.499]                       workers <- workers()
[01:27:47.499]                     workers <- structure(as.integer(workers), 
[01:27:47.499]                       class = class(workers))
[01:27:47.499]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:47.499]                       workers >= 1)
[01:27:47.499]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:47.499]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:47.499]                     }
[01:27:47.499]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:47.499]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:47.499]                       envir = envir)
[01:27:47.499]                     if (!future$lazy) 
[01:27:47.499]                       future <- run(future)
[01:27:47.499]                     invisible(future)
[01:27:47.499]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:47.499]                 }
[01:27:47.499]             }
[01:27:47.499]         }
[01:27:47.499]     })
[01:27:47.499]     if (TRUE) {
[01:27:47.499]         base::sink(type = "output", split = FALSE)
[01:27:47.499]         if (TRUE) {
[01:27:47.499]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:47.499]         }
[01:27:47.499]         else {
[01:27:47.499]             ...future.result["stdout"] <- base::list(NULL)
[01:27:47.499]         }
[01:27:47.499]         base::close(...future.stdout)
[01:27:47.499]         ...future.stdout <- NULL
[01:27:47.499]     }
[01:27:47.499]     ...future.result$conditions <- ...future.conditions
[01:27:47.499]     ...future.result$finished <- base::Sys.time()
[01:27:47.499]     ...future.result
[01:27:47.499] }
[01:27:47.594] MultisessionFuture started
[01:27:47.595] result() for ClusterFuture ...
[01:27:47.595] receiveMessageFromWorker() for ClusterFuture ...
[01:27:47.596] - Validating connection of MultisessionFuture
[01:27:47.674] - received message: FutureResult
[01:27:47.675] - Received FutureResult
[01:27:47.678] - Erased future from FutureRegistry
[01:27:47.678] result() for ClusterFuture ...
[01:27:47.679] - result already collected: FutureResult
[01:27:47.679] result() for ClusterFuture ... done
[01:27:47.679] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:47.679] result() for ClusterFuture ... done
[01:27:47.679] result() for ClusterFuture ...
[01:27:47.680] - result already collected: FutureResult
[01:27:47.680] result() for ClusterFuture ... done
[01:27:47.680] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:27:47.683] plan(): nbrOfWorkers() = 2
Dimensions: NULL
[01:27:47.683] getGlobalsAndPackages() ...
[01:27:47.683] Searching for globals...
[01:27:47.684] 
[01:27:47.684] Searching for globals ... DONE
[01:27:47.684] - globals: [0] <none>
[01:27:47.684] getGlobalsAndPackages() ... DONE
[01:27:47.685] run() for 'Future' ...
[01:27:47.685] - state: 'created'
[01:27:47.685] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:47.700] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:47.700] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:47.700]   - Field: 'node'
[01:27:47.701]   - Field: 'label'
[01:27:47.701]   - Field: 'local'
[01:27:47.701]   - Field: 'owner'
[01:27:47.701]   - Field: 'envir'
[01:27:47.701]   - Field: 'workers'
[01:27:47.702]   - Field: 'packages'
[01:27:47.702]   - Field: 'gc'
[01:27:47.702]   - Field: 'conditions'
[01:27:47.702]   - Field: 'persistent'
[01:27:47.702]   - Field: 'expr'
[01:27:47.703]   - Field: 'uuid'
[01:27:47.703]   - Field: 'seed'
[01:27:47.703]   - Field: 'version'
[01:27:47.703]   - Field: 'result'
[01:27:47.703]   - Field: 'asynchronous'
[01:27:47.704]   - Field: 'calls'
[01:27:47.704]   - Field: 'globals'
[01:27:47.704]   - Field: 'stdout'
[01:27:47.704]   - Field: 'earlySignal'
[01:27:47.705]   - Field: 'lazy'
[01:27:47.705]   - Field: 'state'
[01:27:47.705] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:47.705] - Launch lazy future ...
[01:27:47.706] Packages needed by the future expression (n = 0): <none>
[01:27:47.706] Packages needed by future strategies (n = 0): <none>
[01:27:47.706] {
[01:27:47.706]     {
[01:27:47.706]         {
[01:27:47.706]             ...future.startTime <- base::Sys.time()
[01:27:47.706]             {
[01:27:47.706]                 {
[01:27:47.706]                   {
[01:27:47.706]                     {
[01:27:47.706]                       base::local({
[01:27:47.706]                         has_future <- base::requireNamespace("future", 
[01:27:47.706]                           quietly = TRUE)
[01:27:47.706]                         if (has_future) {
[01:27:47.706]                           ns <- base::getNamespace("future")
[01:27:47.706]                           version <- ns[[".package"]][["version"]]
[01:27:47.706]                           if (is.null(version)) 
[01:27:47.706]                             version <- utils::packageVersion("future")
[01:27:47.706]                         }
[01:27:47.706]                         else {
[01:27:47.706]                           version <- NULL
[01:27:47.706]                         }
[01:27:47.706]                         if (!has_future || version < "1.8.0") {
[01:27:47.706]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:47.706]                             "", base::R.version$version.string), 
[01:27:47.706]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:47.706]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:47.706]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:47.706]                               "release", "version")], collapse = " "), 
[01:27:47.706]                             hostname = base::Sys.info()[["nodename"]])
[01:27:47.706]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:47.706]                             info)
[01:27:47.706]                           info <- base::paste(info, collapse = "; ")
[01:27:47.706]                           if (!has_future) {
[01:27:47.706]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:47.706]                               info)
[01:27:47.706]                           }
[01:27:47.706]                           else {
[01:27:47.706]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:47.706]                               info, version)
[01:27:47.706]                           }
[01:27:47.706]                           base::stop(msg)
[01:27:47.706]                         }
[01:27:47.706]                       })
[01:27:47.706]                     }
[01:27:47.706]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:47.706]                     base::options(mc.cores = 1L)
[01:27:47.706]                   }
[01:27:47.706]                   options(future.plan = NULL)
[01:27:47.706]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.706]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:47.706]                 }
[01:27:47.706]                 ...future.workdir <- getwd()
[01:27:47.706]             }
[01:27:47.706]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:47.706]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:47.706]         }
[01:27:47.706]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:47.706]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:47.706]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:47.706]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:47.706]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:47.706]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:47.706]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:47.706]             base::names(...future.oldOptions))
[01:27:47.706]     }
[01:27:47.706]     if (FALSE) {
[01:27:47.706]     }
[01:27:47.706]     else {
[01:27:47.706]         if (TRUE) {
[01:27:47.706]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:47.706]                 open = "w")
[01:27:47.706]         }
[01:27:47.706]         else {
[01:27:47.706]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:47.706]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:47.706]         }
[01:27:47.706]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:47.706]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:47.706]             base::sink(type = "output", split = FALSE)
[01:27:47.706]             base::close(...future.stdout)
[01:27:47.706]         }, add = TRUE)
[01:27:47.706]     }
[01:27:47.706]     ...future.frame <- base::sys.nframe()
[01:27:47.706]     ...future.conditions <- base::list()
[01:27:47.706]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:47.706]     if (FALSE) {
[01:27:47.706]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:47.706]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:47.706]     }
[01:27:47.706]     ...future.result <- base::tryCatch({
[01:27:47.706]         base::withCallingHandlers({
[01:27:47.706]             ...future.value <- base::withVisible(base::local({
[01:27:47.706]                 ...future.makeSendCondition <- base::local({
[01:27:47.706]                   sendCondition <- NULL
[01:27:47.706]                   function(frame = 1L) {
[01:27:47.706]                     if (is.function(sendCondition)) 
[01:27:47.706]                       return(sendCondition)
[01:27:47.706]                     ns <- getNamespace("parallel")
[01:27:47.706]                     if (exists("sendData", mode = "function", 
[01:27:47.706]                       envir = ns)) {
[01:27:47.706]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:47.706]                         envir = ns)
[01:27:47.706]                       envir <- sys.frame(frame)
[01:27:47.706]                       master <- NULL
[01:27:47.706]                       while (!identical(envir, .GlobalEnv) && 
[01:27:47.706]                         !identical(envir, emptyenv())) {
[01:27:47.706]                         if (exists("master", mode = "list", envir = envir, 
[01:27:47.706]                           inherits = FALSE)) {
[01:27:47.706]                           master <- get("master", mode = "list", 
[01:27:47.706]                             envir = envir, inherits = FALSE)
[01:27:47.706]                           if (inherits(master, c("SOCKnode", 
[01:27:47.706]                             "SOCK0node"))) {
[01:27:47.706]                             sendCondition <<- function(cond) {
[01:27:47.706]                               data <- list(type = "VALUE", value = cond, 
[01:27:47.706]                                 success = TRUE)
[01:27:47.706]                               parallel_sendData(master, data)
[01:27:47.706]                             }
[01:27:47.706]                             return(sendCondition)
[01:27:47.706]                           }
[01:27:47.706]                         }
[01:27:47.706]                         frame <- frame + 1L
[01:27:47.706]                         envir <- sys.frame(frame)
[01:27:47.706]                       }
[01:27:47.706]                     }
[01:27:47.706]                     sendCondition <<- function(cond) NULL
[01:27:47.706]                   }
[01:27:47.706]                 })
[01:27:47.706]                 withCallingHandlers({
[01:27:47.706]                   2
[01:27:47.706]                 }, immediateCondition = function(cond) {
[01:27:47.706]                   sendCondition <- ...future.makeSendCondition()
[01:27:47.706]                   sendCondition(cond)
[01:27:47.706]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.706]                   {
[01:27:47.706]                     inherits <- base::inherits
[01:27:47.706]                     invokeRestart <- base::invokeRestart
[01:27:47.706]                     is.null <- base::is.null
[01:27:47.706]                     muffled <- FALSE
[01:27:47.706]                     if (inherits(cond, "message")) {
[01:27:47.706]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:47.706]                       if (muffled) 
[01:27:47.706]                         invokeRestart("muffleMessage")
[01:27:47.706]                     }
[01:27:47.706]                     else if (inherits(cond, "warning")) {
[01:27:47.706]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:47.706]                       if (muffled) 
[01:27:47.706]                         invokeRestart("muffleWarning")
[01:27:47.706]                     }
[01:27:47.706]                     else if (inherits(cond, "condition")) {
[01:27:47.706]                       if (!is.null(pattern)) {
[01:27:47.706]                         computeRestarts <- base::computeRestarts
[01:27:47.706]                         grepl <- base::grepl
[01:27:47.706]                         restarts <- computeRestarts(cond)
[01:27:47.706]                         for (restart in restarts) {
[01:27:47.706]                           name <- restart$name
[01:27:47.706]                           if (is.null(name)) 
[01:27:47.706]                             next
[01:27:47.706]                           if (!grepl(pattern, name)) 
[01:27:47.706]                             next
[01:27:47.706]                           invokeRestart(restart)
[01:27:47.706]                           muffled <- TRUE
[01:27:47.706]                           break
[01:27:47.706]                         }
[01:27:47.706]                       }
[01:27:47.706]                     }
[01:27:47.706]                     invisible(muffled)
[01:27:47.706]                   }
[01:27:47.706]                   muffleCondition(cond)
[01:27:47.706]                 })
[01:27:47.706]             }))
[01:27:47.706]             future::FutureResult(value = ...future.value$value, 
[01:27:47.706]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.706]                   ...future.rng), globalenv = if (FALSE) 
[01:27:47.706]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:47.706]                     ...future.globalenv.names))
[01:27:47.706]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:47.706]         }, condition = base::local({
[01:27:47.706]             c <- base::c
[01:27:47.706]             inherits <- base::inherits
[01:27:47.706]             invokeRestart <- base::invokeRestart
[01:27:47.706]             length <- base::length
[01:27:47.706]             list <- base::list
[01:27:47.706]             seq.int <- base::seq.int
[01:27:47.706]             signalCondition <- base::signalCondition
[01:27:47.706]             sys.calls <- base::sys.calls
[01:27:47.706]             `[[` <- base::`[[`
[01:27:47.706]             `+` <- base::`+`
[01:27:47.706]             `<<-` <- base::`<<-`
[01:27:47.706]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:47.706]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:47.706]                   3L)]
[01:27:47.706]             }
[01:27:47.706]             function(cond) {
[01:27:47.706]                 is_error <- inherits(cond, "error")
[01:27:47.706]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:47.706]                   NULL)
[01:27:47.706]                 if (is_error) {
[01:27:47.706]                   sessionInformation <- function() {
[01:27:47.706]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:47.706]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:47.706]                       search = base::search(), system = base::Sys.info())
[01:27:47.706]                   }
[01:27:47.706]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.706]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:47.706]                     cond$call), session = sessionInformation(), 
[01:27:47.706]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:47.706]                   signalCondition(cond)
[01:27:47.706]                 }
[01:27:47.706]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:47.706]                 "immediateCondition"))) {
[01:27:47.706]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:47.706]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.706]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:47.706]                   if (TRUE && !signal) {
[01:27:47.706]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.706]                     {
[01:27:47.706]                       inherits <- base::inherits
[01:27:47.706]                       invokeRestart <- base::invokeRestart
[01:27:47.706]                       is.null <- base::is.null
[01:27:47.706]                       muffled <- FALSE
[01:27:47.706]                       if (inherits(cond, "message")) {
[01:27:47.706]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.706]                         if (muffled) 
[01:27:47.706]                           invokeRestart("muffleMessage")
[01:27:47.706]                       }
[01:27:47.706]                       else if (inherits(cond, "warning")) {
[01:27:47.706]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.706]                         if (muffled) 
[01:27:47.706]                           invokeRestart("muffleWarning")
[01:27:47.706]                       }
[01:27:47.706]                       else if (inherits(cond, "condition")) {
[01:27:47.706]                         if (!is.null(pattern)) {
[01:27:47.706]                           computeRestarts <- base::computeRestarts
[01:27:47.706]                           grepl <- base::grepl
[01:27:47.706]                           restarts <- computeRestarts(cond)
[01:27:47.706]                           for (restart in restarts) {
[01:27:47.706]                             name <- restart$name
[01:27:47.706]                             if (is.null(name)) 
[01:27:47.706]                               next
[01:27:47.706]                             if (!grepl(pattern, name)) 
[01:27:47.706]                               next
[01:27:47.706]                             invokeRestart(restart)
[01:27:47.706]                             muffled <- TRUE
[01:27:47.706]                             break
[01:27:47.706]                           }
[01:27:47.706]                         }
[01:27:47.706]                       }
[01:27:47.706]                       invisible(muffled)
[01:27:47.706]                     }
[01:27:47.706]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.706]                   }
[01:27:47.706]                 }
[01:27:47.706]                 else {
[01:27:47.706]                   if (TRUE) {
[01:27:47.706]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.706]                     {
[01:27:47.706]                       inherits <- base::inherits
[01:27:47.706]                       invokeRestart <- base::invokeRestart
[01:27:47.706]                       is.null <- base::is.null
[01:27:47.706]                       muffled <- FALSE
[01:27:47.706]                       if (inherits(cond, "message")) {
[01:27:47.706]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.706]                         if (muffled) 
[01:27:47.706]                           invokeRestart("muffleMessage")
[01:27:47.706]                       }
[01:27:47.706]                       else if (inherits(cond, "warning")) {
[01:27:47.706]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.706]                         if (muffled) 
[01:27:47.706]                           invokeRestart("muffleWarning")
[01:27:47.706]                       }
[01:27:47.706]                       else if (inherits(cond, "condition")) {
[01:27:47.706]                         if (!is.null(pattern)) {
[01:27:47.706]                           computeRestarts <- base::computeRestarts
[01:27:47.706]                           grepl <- base::grepl
[01:27:47.706]                           restarts <- computeRestarts(cond)
[01:27:47.706]                           for (restart in restarts) {
[01:27:47.706]                             name <- restart$name
[01:27:47.706]                             if (is.null(name)) 
[01:27:47.706]                               next
[01:27:47.706]                             if (!grepl(pattern, name)) 
[01:27:47.706]                               next
[01:27:47.706]                             invokeRestart(restart)
[01:27:47.706]                             muffled <- TRUE
[01:27:47.706]                             break
[01:27:47.706]                           }
[01:27:47.706]                         }
[01:27:47.706]                       }
[01:27:47.706]                       invisible(muffled)
[01:27:47.706]                     }
[01:27:47.706]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.706]                   }
[01:27:47.706]                 }
[01:27:47.706]             }
[01:27:47.706]         }))
[01:27:47.706]     }, error = function(ex) {
[01:27:47.706]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:47.706]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.706]                 ...future.rng), started = ...future.startTime, 
[01:27:47.706]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:47.706]             version = "1.8"), class = "FutureResult")
[01:27:47.706]     }, finally = {
[01:27:47.706]         if (!identical(...future.workdir, getwd())) 
[01:27:47.706]             setwd(...future.workdir)
[01:27:47.706]         {
[01:27:47.706]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:47.706]                 ...future.oldOptions$nwarnings <- NULL
[01:27:47.706]             }
[01:27:47.706]             base::options(...future.oldOptions)
[01:27:47.706]             if (.Platform$OS.type == "windows") {
[01:27:47.706]                 old_names <- names(...future.oldEnvVars)
[01:27:47.706]                 envs <- base::Sys.getenv()
[01:27:47.706]                 names <- names(envs)
[01:27:47.706]                 common <- intersect(names, old_names)
[01:27:47.706]                 added <- setdiff(names, old_names)
[01:27:47.706]                 removed <- setdiff(old_names, names)
[01:27:47.706]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:47.706]                   envs[common]]
[01:27:47.706]                 NAMES <- toupper(changed)
[01:27:47.706]                 args <- list()
[01:27:47.706]                 for (kk in seq_along(NAMES)) {
[01:27:47.706]                   name <- changed[[kk]]
[01:27:47.706]                   NAME <- NAMES[[kk]]
[01:27:47.706]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.706]                     next
[01:27:47.706]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.706]                 }
[01:27:47.706]                 NAMES <- toupper(added)
[01:27:47.706]                 for (kk in seq_along(NAMES)) {
[01:27:47.706]                   name <- added[[kk]]
[01:27:47.706]                   NAME <- NAMES[[kk]]
[01:27:47.706]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.706]                     next
[01:27:47.706]                   args[[name]] <- ""
[01:27:47.706]                 }
[01:27:47.706]                 NAMES <- toupper(removed)
[01:27:47.706]                 for (kk in seq_along(NAMES)) {
[01:27:47.706]                   name <- removed[[kk]]
[01:27:47.706]                   NAME <- NAMES[[kk]]
[01:27:47.706]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.706]                     next
[01:27:47.706]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.706]                 }
[01:27:47.706]                 if (length(args) > 0) 
[01:27:47.706]                   base::do.call(base::Sys.setenv, args = args)
[01:27:47.706]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:47.706]             }
[01:27:47.706]             else {
[01:27:47.706]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:47.706]             }
[01:27:47.706]             {
[01:27:47.706]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:47.706]                   0L) {
[01:27:47.706]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:47.706]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:47.706]                   base::options(opts)
[01:27:47.706]                 }
[01:27:47.706]                 {
[01:27:47.706]                   {
[01:27:47.706]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:47.706]                     NULL
[01:27:47.706]                   }
[01:27:47.706]                   options(future.plan = NULL)
[01:27:47.706]                   if (is.na(NA_character_)) 
[01:27:47.706]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.706]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:47.706]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:47.706]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:47.706]                     envir = parent.frame()) 
[01:27:47.706]                   {
[01:27:47.706]                     if (is.function(workers)) 
[01:27:47.706]                       workers <- workers()
[01:27:47.706]                     workers <- structure(as.integer(workers), 
[01:27:47.706]                       class = class(workers))
[01:27:47.706]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:47.706]                       workers >= 1)
[01:27:47.706]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:47.706]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:47.706]                     }
[01:27:47.706]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:47.706]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:47.706]                       envir = envir)
[01:27:47.706]                     if (!future$lazy) 
[01:27:47.706]                       future <- run(future)
[01:27:47.706]                     invisible(future)
[01:27:47.706]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:47.706]                 }
[01:27:47.706]             }
[01:27:47.706]         }
[01:27:47.706]     })
[01:27:47.706]     if (TRUE) {
[01:27:47.706]         base::sink(type = "output", split = FALSE)
[01:27:47.706]         if (TRUE) {
[01:27:47.706]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:47.706]         }
[01:27:47.706]         else {
[01:27:47.706]             ...future.result["stdout"] <- base::list(NULL)
[01:27:47.706]         }
[01:27:47.706]         base::close(...future.stdout)
[01:27:47.706]         ...future.stdout <- NULL
[01:27:47.706]     }
[01:27:47.706]     ...future.result$conditions <- ...future.conditions
[01:27:47.706]     ...future.result$finished <- base::Sys.time()
[01:27:47.706]     ...future.result
[01:27:47.706] }
[01:27:47.713] MultisessionFuture started
[01:27:47.713] - Launch lazy future ... done
[01:27:47.713] run() for 'MultisessionFuture' ... done
[01:27:47.713] getGlobalsAndPackages() ...
[01:27:47.714] Searching for globals...
[01:27:47.714] 
[01:27:47.714] Searching for globals ... DONE
[01:27:47.714] - globals: [0] <none>
[01:27:47.715] getGlobalsAndPackages() ... DONE
[01:27:47.715] run() for 'Future' ...
[01:27:47.715] - state: 'created'
[01:27:47.715] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:47.730] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:47.730] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:47.731]   - Field: 'node'
[01:27:47.731]   - Field: 'label'
[01:27:47.731]   - Field: 'local'
[01:27:47.731]   - Field: 'owner'
[01:27:47.731]   - Field: 'envir'
[01:27:47.732]   - Field: 'workers'
[01:27:47.732]   - Field: 'packages'
[01:27:47.732]   - Field: 'gc'
[01:27:47.732]   - Field: 'conditions'
[01:27:47.732]   - Field: 'persistent'
[01:27:47.733]   - Field: 'expr'
[01:27:47.733]   - Field: 'uuid'
[01:27:47.733]   - Field: 'seed'
[01:27:47.733]   - Field: 'version'
[01:27:47.733]   - Field: 'result'
[01:27:47.734]   - Field: 'asynchronous'
[01:27:47.734]   - Field: 'calls'
[01:27:47.734]   - Field: 'globals'
[01:27:47.734]   - Field: 'stdout'
[01:27:47.735]   - Field: 'earlySignal'
[01:27:47.735]   - Field: 'lazy'
[01:27:47.735]   - Field: 'state'
[01:27:47.735] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:47.735] - Launch lazy future ...
[01:27:47.736] Packages needed by the future expression (n = 0): <none>
[01:27:47.736] Packages needed by future strategies (n = 0): <none>
[01:27:47.737] {
[01:27:47.737]     {
[01:27:47.737]         {
[01:27:47.737]             ...future.startTime <- base::Sys.time()
[01:27:47.737]             {
[01:27:47.737]                 {
[01:27:47.737]                   {
[01:27:47.737]                     {
[01:27:47.737]                       base::local({
[01:27:47.737]                         has_future <- base::requireNamespace("future", 
[01:27:47.737]                           quietly = TRUE)
[01:27:47.737]                         if (has_future) {
[01:27:47.737]                           ns <- base::getNamespace("future")
[01:27:47.737]                           version <- ns[[".package"]][["version"]]
[01:27:47.737]                           if (is.null(version)) 
[01:27:47.737]                             version <- utils::packageVersion("future")
[01:27:47.737]                         }
[01:27:47.737]                         else {
[01:27:47.737]                           version <- NULL
[01:27:47.737]                         }
[01:27:47.737]                         if (!has_future || version < "1.8.0") {
[01:27:47.737]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:47.737]                             "", base::R.version$version.string), 
[01:27:47.737]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:47.737]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:47.737]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:47.737]                               "release", "version")], collapse = " "), 
[01:27:47.737]                             hostname = base::Sys.info()[["nodename"]])
[01:27:47.737]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:47.737]                             info)
[01:27:47.737]                           info <- base::paste(info, collapse = "; ")
[01:27:47.737]                           if (!has_future) {
[01:27:47.737]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:47.737]                               info)
[01:27:47.737]                           }
[01:27:47.737]                           else {
[01:27:47.737]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:47.737]                               info, version)
[01:27:47.737]                           }
[01:27:47.737]                           base::stop(msg)
[01:27:47.737]                         }
[01:27:47.737]                       })
[01:27:47.737]                     }
[01:27:47.737]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:47.737]                     base::options(mc.cores = 1L)
[01:27:47.737]                   }
[01:27:47.737]                   options(future.plan = NULL)
[01:27:47.737]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.737]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:47.737]                 }
[01:27:47.737]                 ...future.workdir <- getwd()
[01:27:47.737]             }
[01:27:47.737]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:47.737]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:47.737]         }
[01:27:47.737]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:47.737]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:47.737]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:47.737]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:47.737]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:47.737]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:47.737]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:47.737]             base::names(...future.oldOptions))
[01:27:47.737]     }
[01:27:47.737]     if (FALSE) {
[01:27:47.737]     }
[01:27:47.737]     else {
[01:27:47.737]         if (TRUE) {
[01:27:47.737]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:47.737]                 open = "w")
[01:27:47.737]         }
[01:27:47.737]         else {
[01:27:47.737]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:47.737]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:47.737]         }
[01:27:47.737]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:47.737]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:47.737]             base::sink(type = "output", split = FALSE)
[01:27:47.737]             base::close(...future.stdout)
[01:27:47.737]         }, add = TRUE)
[01:27:47.737]     }
[01:27:47.737]     ...future.frame <- base::sys.nframe()
[01:27:47.737]     ...future.conditions <- base::list()
[01:27:47.737]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:47.737]     if (FALSE) {
[01:27:47.737]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:47.737]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:47.737]     }
[01:27:47.737]     ...future.result <- base::tryCatch({
[01:27:47.737]         base::withCallingHandlers({
[01:27:47.737]             ...future.value <- base::withVisible(base::local({
[01:27:47.737]                 ...future.makeSendCondition <- base::local({
[01:27:47.737]                   sendCondition <- NULL
[01:27:47.737]                   function(frame = 1L) {
[01:27:47.737]                     if (is.function(sendCondition)) 
[01:27:47.737]                       return(sendCondition)
[01:27:47.737]                     ns <- getNamespace("parallel")
[01:27:47.737]                     if (exists("sendData", mode = "function", 
[01:27:47.737]                       envir = ns)) {
[01:27:47.737]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:47.737]                         envir = ns)
[01:27:47.737]                       envir <- sys.frame(frame)
[01:27:47.737]                       master <- NULL
[01:27:47.737]                       while (!identical(envir, .GlobalEnv) && 
[01:27:47.737]                         !identical(envir, emptyenv())) {
[01:27:47.737]                         if (exists("master", mode = "list", envir = envir, 
[01:27:47.737]                           inherits = FALSE)) {
[01:27:47.737]                           master <- get("master", mode = "list", 
[01:27:47.737]                             envir = envir, inherits = FALSE)
[01:27:47.737]                           if (inherits(master, c("SOCKnode", 
[01:27:47.737]                             "SOCK0node"))) {
[01:27:47.737]                             sendCondition <<- function(cond) {
[01:27:47.737]                               data <- list(type = "VALUE", value = cond, 
[01:27:47.737]                                 success = TRUE)
[01:27:47.737]                               parallel_sendData(master, data)
[01:27:47.737]                             }
[01:27:47.737]                             return(sendCondition)
[01:27:47.737]                           }
[01:27:47.737]                         }
[01:27:47.737]                         frame <- frame + 1L
[01:27:47.737]                         envir <- sys.frame(frame)
[01:27:47.737]                       }
[01:27:47.737]                     }
[01:27:47.737]                     sendCondition <<- function(cond) NULL
[01:27:47.737]                   }
[01:27:47.737]                 })
[01:27:47.737]                 withCallingHandlers({
[01:27:47.737]                   NULL
[01:27:47.737]                 }, immediateCondition = function(cond) {
[01:27:47.737]                   sendCondition <- ...future.makeSendCondition()
[01:27:47.737]                   sendCondition(cond)
[01:27:47.737]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.737]                   {
[01:27:47.737]                     inherits <- base::inherits
[01:27:47.737]                     invokeRestart <- base::invokeRestart
[01:27:47.737]                     is.null <- base::is.null
[01:27:47.737]                     muffled <- FALSE
[01:27:47.737]                     if (inherits(cond, "message")) {
[01:27:47.737]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:47.737]                       if (muffled) 
[01:27:47.737]                         invokeRestart("muffleMessage")
[01:27:47.737]                     }
[01:27:47.737]                     else if (inherits(cond, "warning")) {
[01:27:47.737]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:47.737]                       if (muffled) 
[01:27:47.737]                         invokeRestart("muffleWarning")
[01:27:47.737]                     }
[01:27:47.737]                     else if (inherits(cond, "condition")) {
[01:27:47.737]                       if (!is.null(pattern)) {
[01:27:47.737]                         computeRestarts <- base::computeRestarts
[01:27:47.737]                         grepl <- base::grepl
[01:27:47.737]                         restarts <- computeRestarts(cond)
[01:27:47.737]                         for (restart in restarts) {
[01:27:47.737]                           name <- restart$name
[01:27:47.737]                           if (is.null(name)) 
[01:27:47.737]                             next
[01:27:47.737]                           if (!grepl(pattern, name)) 
[01:27:47.737]                             next
[01:27:47.737]                           invokeRestart(restart)
[01:27:47.737]                           muffled <- TRUE
[01:27:47.737]                           break
[01:27:47.737]                         }
[01:27:47.737]                       }
[01:27:47.737]                     }
[01:27:47.737]                     invisible(muffled)
[01:27:47.737]                   }
[01:27:47.737]                   muffleCondition(cond)
[01:27:47.737]                 })
[01:27:47.737]             }))
[01:27:47.737]             future::FutureResult(value = ...future.value$value, 
[01:27:47.737]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.737]                   ...future.rng), globalenv = if (FALSE) 
[01:27:47.737]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:47.737]                     ...future.globalenv.names))
[01:27:47.737]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:47.737]         }, condition = base::local({
[01:27:47.737]             c <- base::c
[01:27:47.737]             inherits <- base::inherits
[01:27:47.737]             invokeRestart <- base::invokeRestart
[01:27:47.737]             length <- base::length
[01:27:47.737]             list <- base::list
[01:27:47.737]             seq.int <- base::seq.int
[01:27:47.737]             signalCondition <- base::signalCondition
[01:27:47.737]             sys.calls <- base::sys.calls
[01:27:47.737]             `[[` <- base::`[[`
[01:27:47.737]             `+` <- base::`+`
[01:27:47.737]             `<<-` <- base::`<<-`
[01:27:47.737]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:47.737]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:47.737]                   3L)]
[01:27:47.737]             }
[01:27:47.737]             function(cond) {
[01:27:47.737]                 is_error <- inherits(cond, "error")
[01:27:47.737]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:47.737]                   NULL)
[01:27:47.737]                 if (is_error) {
[01:27:47.737]                   sessionInformation <- function() {
[01:27:47.737]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:47.737]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:47.737]                       search = base::search(), system = base::Sys.info())
[01:27:47.737]                   }
[01:27:47.737]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.737]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:47.737]                     cond$call), session = sessionInformation(), 
[01:27:47.737]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:47.737]                   signalCondition(cond)
[01:27:47.737]                 }
[01:27:47.737]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:47.737]                 "immediateCondition"))) {
[01:27:47.737]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:47.737]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.737]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:47.737]                   if (TRUE && !signal) {
[01:27:47.737]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.737]                     {
[01:27:47.737]                       inherits <- base::inherits
[01:27:47.737]                       invokeRestart <- base::invokeRestart
[01:27:47.737]                       is.null <- base::is.null
[01:27:47.737]                       muffled <- FALSE
[01:27:47.737]                       if (inherits(cond, "message")) {
[01:27:47.737]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.737]                         if (muffled) 
[01:27:47.737]                           invokeRestart("muffleMessage")
[01:27:47.737]                       }
[01:27:47.737]                       else if (inherits(cond, "warning")) {
[01:27:47.737]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.737]                         if (muffled) 
[01:27:47.737]                           invokeRestart("muffleWarning")
[01:27:47.737]                       }
[01:27:47.737]                       else if (inherits(cond, "condition")) {
[01:27:47.737]                         if (!is.null(pattern)) {
[01:27:47.737]                           computeRestarts <- base::computeRestarts
[01:27:47.737]                           grepl <- base::grepl
[01:27:47.737]                           restarts <- computeRestarts(cond)
[01:27:47.737]                           for (restart in restarts) {
[01:27:47.737]                             name <- restart$name
[01:27:47.737]                             if (is.null(name)) 
[01:27:47.737]                               next
[01:27:47.737]                             if (!grepl(pattern, name)) 
[01:27:47.737]                               next
[01:27:47.737]                             invokeRestart(restart)
[01:27:47.737]                             muffled <- TRUE
[01:27:47.737]                             break
[01:27:47.737]                           }
[01:27:47.737]                         }
[01:27:47.737]                       }
[01:27:47.737]                       invisible(muffled)
[01:27:47.737]                     }
[01:27:47.737]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.737]                   }
[01:27:47.737]                 }
[01:27:47.737]                 else {
[01:27:47.737]                   if (TRUE) {
[01:27:47.737]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.737]                     {
[01:27:47.737]                       inherits <- base::inherits
[01:27:47.737]                       invokeRestart <- base::invokeRestart
[01:27:47.737]                       is.null <- base::is.null
[01:27:47.737]                       muffled <- FALSE
[01:27:47.737]                       if (inherits(cond, "message")) {
[01:27:47.737]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.737]                         if (muffled) 
[01:27:47.737]                           invokeRestart("muffleMessage")
[01:27:47.737]                       }
[01:27:47.737]                       else if (inherits(cond, "warning")) {
[01:27:47.737]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.737]                         if (muffled) 
[01:27:47.737]                           invokeRestart("muffleWarning")
[01:27:47.737]                       }
[01:27:47.737]                       else if (inherits(cond, "condition")) {
[01:27:47.737]                         if (!is.null(pattern)) {
[01:27:47.737]                           computeRestarts <- base::computeRestarts
[01:27:47.737]                           grepl <- base::grepl
[01:27:47.737]                           restarts <- computeRestarts(cond)
[01:27:47.737]                           for (restart in restarts) {
[01:27:47.737]                             name <- restart$name
[01:27:47.737]                             if (is.null(name)) 
[01:27:47.737]                               next
[01:27:47.737]                             if (!grepl(pattern, name)) 
[01:27:47.737]                               next
[01:27:47.737]                             invokeRestart(restart)
[01:27:47.737]                             muffled <- TRUE
[01:27:47.737]                             break
[01:27:47.737]                           }
[01:27:47.737]                         }
[01:27:47.737]                       }
[01:27:47.737]                       invisible(muffled)
[01:27:47.737]                     }
[01:27:47.737]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.737]                   }
[01:27:47.737]                 }
[01:27:47.737]             }
[01:27:47.737]         }))
[01:27:47.737]     }, error = function(ex) {
[01:27:47.737]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:47.737]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.737]                 ...future.rng), started = ...future.startTime, 
[01:27:47.737]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:47.737]             version = "1.8"), class = "FutureResult")
[01:27:47.737]     }, finally = {
[01:27:47.737]         if (!identical(...future.workdir, getwd())) 
[01:27:47.737]             setwd(...future.workdir)
[01:27:47.737]         {
[01:27:47.737]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:47.737]                 ...future.oldOptions$nwarnings <- NULL
[01:27:47.737]             }
[01:27:47.737]             base::options(...future.oldOptions)
[01:27:47.737]             if (.Platform$OS.type == "windows") {
[01:27:47.737]                 old_names <- names(...future.oldEnvVars)
[01:27:47.737]                 envs <- base::Sys.getenv()
[01:27:47.737]                 names <- names(envs)
[01:27:47.737]                 common <- intersect(names, old_names)
[01:27:47.737]                 added <- setdiff(names, old_names)
[01:27:47.737]                 removed <- setdiff(old_names, names)
[01:27:47.737]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:47.737]                   envs[common]]
[01:27:47.737]                 NAMES <- toupper(changed)
[01:27:47.737]                 args <- list()
[01:27:47.737]                 for (kk in seq_along(NAMES)) {
[01:27:47.737]                   name <- changed[[kk]]
[01:27:47.737]                   NAME <- NAMES[[kk]]
[01:27:47.737]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.737]                     next
[01:27:47.737]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.737]                 }
[01:27:47.737]                 NAMES <- toupper(added)
[01:27:47.737]                 for (kk in seq_along(NAMES)) {
[01:27:47.737]                   name <- added[[kk]]
[01:27:47.737]                   NAME <- NAMES[[kk]]
[01:27:47.737]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.737]                     next
[01:27:47.737]                   args[[name]] <- ""
[01:27:47.737]                 }
[01:27:47.737]                 NAMES <- toupper(removed)
[01:27:47.737]                 for (kk in seq_along(NAMES)) {
[01:27:47.737]                   name <- removed[[kk]]
[01:27:47.737]                   NAME <- NAMES[[kk]]
[01:27:47.737]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.737]                     next
[01:27:47.737]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.737]                 }
[01:27:47.737]                 if (length(args) > 0) 
[01:27:47.737]                   base::do.call(base::Sys.setenv, args = args)
[01:27:47.737]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:47.737]             }
[01:27:47.737]             else {
[01:27:47.737]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:47.737]             }
[01:27:47.737]             {
[01:27:47.737]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:47.737]                   0L) {
[01:27:47.737]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:47.737]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:47.737]                   base::options(opts)
[01:27:47.737]                 }
[01:27:47.737]                 {
[01:27:47.737]                   {
[01:27:47.737]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:47.737]                     NULL
[01:27:47.737]                   }
[01:27:47.737]                   options(future.plan = NULL)
[01:27:47.737]                   if (is.na(NA_character_)) 
[01:27:47.737]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.737]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:47.737]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:47.737]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:47.737]                     envir = parent.frame()) 
[01:27:47.737]                   {
[01:27:47.737]                     if (is.function(workers)) 
[01:27:47.737]                       workers <- workers()
[01:27:47.737]                     workers <- structure(as.integer(workers), 
[01:27:47.737]                       class = class(workers))
[01:27:47.737]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:47.737]                       workers >= 1)
[01:27:47.737]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:47.737]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:47.737]                     }
[01:27:47.737]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:47.737]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:47.737]                       envir = envir)
[01:27:47.737]                     if (!future$lazy) 
[01:27:47.737]                       future <- run(future)
[01:27:47.737]                     invisible(future)
[01:27:47.737]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:47.737]                 }
[01:27:47.737]             }
[01:27:47.737]         }
[01:27:47.737]     })
[01:27:47.737]     if (TRUE) {
[01:27:47.737]         base::sink(type = "output", split = FALSE)
[01:27:47.737]         if (TRUE) {
[01:27:47.737]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:47.737]         }
[01:27:47.737]         else {
[01:27:47.737]             ...future.result["stdout"] <- base::list(NULL)
[01:27:47.737]         }
[01:27:47.737]         base::close(...future.stdout)
[01:27:47.737]         ...future.stdout <- NULL
[01:27:47.737]     }
[01:27:47.737]     ...future.result$conditions <- ...future.conditions
[01:27:47.737]     ...future.result$finished <- base::Sys.time()
[01:27:47.737]     ...future.result
[01:27:47.737] }
[01:27:47.817] MultisessionFuture started
[01:27:47.817] - Launch lazy future ... done
[01:27:47.818] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0a6c02e8> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0ac50808> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0a6c02e8> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0ac50808> 
 $  : NULL
 $  : NULL
 $  : num 6
[01:27:47.824] receiveMessageFromWorker() for ClusterFuture ...
[01:27:47.824] - Validating connection of MultisessionFuture
[01:27:47.825] - received message: FutureResult
[01:27:47.825] - Received FutureResult
[01:27:47.825] - Erased future from FutureRegistry
[01:27:47.825] result() for ClusterFuture ...
[01:27:47.825] - result already collected: FutureResult
[01:27:47.826] result() for ClusterFuture ... done
[01:27:47.826] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:47.876] receiveMessageFromWorker() for ClusterFuture ...
[01:27:47.877] - Validating connection of MultisessionFuture
[01:27:47.877] - received message: FutureResult
[01:27:47.877] - Received FutureResult
[01:27:47.877] - Erased future from FutureRegistry
[01:27:47.878] result() for ClusterFuture ...
[01:27:47.878] - result already collected: FutureResult
[01:27:47.878] result() for ClusterFuture ... done
[01:27:47.878] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
[01:27:47.879] resolve() on list ...
[01:27:47.879]  recursive: 0
[01:27:47.879]  length: 6
[01:27:47.880]  elements: 'a', 'b', 'c', '', '', ''
[01:27:47.880] signalConditionsASAP(numeric, pos=1) ...
[01:27:47.880] - nx: 6
[01:27:47.880] - relay: TRUE
[01:27:47.880] - stdout: TRUE
[01:27:47.881] - signal: TRUE
[01:27:47.881] - resignal: FALSE
[01:27:47.881] - force: TRUE
[01:27:47.881] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:47.881] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:47.882]  - until=2
[01:27:47.882]  - relaying element #2
[01:27:47.882] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:47.882] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:47.882] signalConditionsASAP(NULL, pos=1) ... done
[01:27:47.882]  length: 5 (resolved future 1)
[01:27:47.883] Future #2
[01:27:47.883] result() for ClusterFuture ...
[01:27:47.883] - result already collected: FutureResult
[01:27:47.883] result() for ClusterFuture ... done
[01:27:47.884] result() for ClusterFuture ...
[01:27:47.884] - result already collected: FutureResult
[01:27:47.884] result() for ClusterFuture ... done
[01:27:47.884] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:47.884] - nx: 6
[01:27:47.885] - relay: TRUE
[01:27:47.885] - stdout: TRUE
[01:27:47.885] - signal: TRUE
[01:27:47.885] - resignal: FALSE
[01:27:47.885] - force: TRUE
[01:27:47.885] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:47.886] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:47.886]  - until=2
[01:27:47.886]  - relaying element #2
[01:27:47.886] result() for ClusterFuture ...
[01:27:47.886] - result already collected: FutureResult
[01:27:47.886] result() for ClusterFuture ... done
[01:27:47.887] result() for ClusterFuture ...
[01:27:47.887] - result already collected: FutureResult
[01:27:47.887] result() for ClusterFuture ... done
[01:27:47.887] result() for ClusterFuture ...
[01:27:47.887] - result already collected: FutureResult
[01:27:47.888] result() for ClusterFuture ... done
[01:27:47.888] result() for ClusterFuture ...
[01:27:47.888] - result already collected: FutureResult
[01:27:47.888] result() for ClusterFuture ... done
[01:27:47.888] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:47.888] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:47.889] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:47.889]  length: 4 (resolved future 2)
[01:27:47.889] Future #3
[01:27:47.889] result() for ClusterFuture ...
[01:27:47.889] - result already collected: FutureResult
[01:27:47.890] result() for ClusterFuture ... done
[01:27:47.890] result() for ClusterFuture ...
[01:27:47.890] - result already collected: FutureResult
[01:27:47.890] result() for ClusterFuture ... done
[01:27:47.890] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:47.890] - nx: 6
[01:27:47.891] - relay: TRUE
[01:27:47.891] - stdout: TRUE
[01:27:47.891] - signal: TRUE
[01:27:47.891] - resignal: FALSE
[01:27:47.891] - force: TRUE
[01:27:47.891] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:47.892] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:47.892]  - until=3
[01:27:47.892]  - relaying element #3
[01:27:47.892] result() for ClusterFuture ...
[01:27:47.892] - result already collected: FutureResult
[01:27:47.893] result() for ClusterFuture ... done
[01:27:47.893] result() for ClusterFuture ...
[01:27:47.893] - result already collected: FutureResult
[01:27:47.893] result() for ClusterFuture ... done
[01:27:47.893] result() for ClusterFuture ...
[01:27:47.893] - result already collected: FutureResult
[01:27:47.894] result() for ClusterFuture ... done
[01:27:47.894] result() for ClusterFuture ...
[01:27:47.894] - result already collected: FutureResult
[01:27:47.894] result() for ClusterFuture ... done
[01:27:47.894] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.895] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.895] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:47.895]  length: 3 (resolved future 3)
[01:27:47.895] signalConditionsASAP(NULL, pos=4) ...
[01:27:47.895] - nx: 6
[01:27:47.895] - relay: TRUE
[01:27:47.896] - stdout: TRUE
[01:27:47.896] - signal: TRUE
[01:27:47.896] - resignal: FALSE
[01:27:47.896] - force: TRUE
[01:27:47.896] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.897] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.897]  - until=5
[01:27:47.897]  - relaying element #5
[01:27:47.897] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:47.897] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.898] signalConditionsASAP(NULL, pos=4) ... done
[01:27:47.898]  length: 2 (resolved future 4)
[01:27:47.898] signalConditionsASAP(NULL, pos=5) ...
[01:27:47.898] - nx: 6
[01:27:47.898] - relay: TRUE
[01:27:47.899] - stdout: TRUE
[01:27:47.899] - signal: TRUE
[01:27:47.899] - resignal: FALSE
[01:27:47.899] - force: TRUE
[01:27:47.899] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:47.899] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.900]  - until=6
[01:27:47.900]  - relaying element #6
[01:27:47.900] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:47.900] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.900] signalConditionsASAP(NULL, pos=5) ... done
[01:27:47.901]  length: 1 (resolved future 5)
[01:27:47.901] signalConditionsASAP(numeric, pos=6) ...
[01:27:47.901] - nx: 6
[01:27:47.901] - relay: TRUE
[01:27:47.901] - stdout: TRUE
[01:27:47.901] - signal: TRUE
[01:27:47.902] - resignal: FALSE
[01:27:47.902] - force: TRUE
[01:27:47.902] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:47.902] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.902]  - until=6
[01:27:47.903] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:47.903] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.903] signalConditionsASAP(numeric, pos=6) ... done
[01:27:47.903]  length: 0 (resolved future 6)
[01:27:47.903] Relaying remaining futures
[01:27:47.905] signalConditionsASAP(NULL, pos=0) ...
[01:27:47.906] - nx: 6
[01:27:47.906] - relay: TRUE
[01:27:47.906] - stdout: TRUE
[01:27:47.906] - signal: TRUE
[01:27:47.906] - resignal: FALSE
[01:27:47.906] - force: TRUE
[01:27:47.907] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:47.907] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:47.907] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:47.907] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:47.907] signalConditionsASAP(NULL, pos=0) ... done
[01:27:47.907] resolve() on list ... DONE
[01:27:47.908] result() for ClusterFuture ...
[01:27:47.908] - result already collected: FutureResult
[01:27:47.908] result() for ClusterFuture ... done
[01:27:47.908] result() for ClusterFuture ...
[01:27:47.908] - result already collected: FutureResult
[01:27:47.908] result() for ClusterFuture ... done
[01:27:47.909] result() for ClusterFuture ...
[01:27:47.909] - result already collected: FutureResult
[01:27:47.909] result() for ClusterFuture ... done
[01:27:47.909] result() for ClusterFuture ...
[01:27:47.909] - result already collected: FutureResult
[01:27:47.909] result() for ClusterFuture ... done
List of 6
 $ a: num 1
 $ b: num 2
 $ c: NULL
 $  : NULL
 $  : NULL
 $  : num 6
Dimensions: c(1, 6)
[01:27:47.912] getGlobalsAndPackages() ...
[01:27:47.912] Searching for globals...
[01:27:47.912] 
[01:27:47.913] Searching for globals ... DONE
[01:27:47.913] - globals: [0] <none>
[01:27:47.913] getGlobalsAndPackages() ... DONE
[01:27:47.913] run() for 'Future' ...
[01:27:47.913] - state: 'created'
[01:27:47.914] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:47.928] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:47.928] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:47.928]   - Field: 'node'
[01:27:47.928]   - Field: 'label'
[01:27:47.928]   - Field: 'local'
[01:27:47.929]   - Field: 'owner'
[01:27:47.929]   - Field: 'envir'
[01:27:47.929]   - Field: 'workers'
[01:27:47.929]   - Field: 'packages'
[01:27:47.929]   - Field: 'gc'
[01:27:47.930]   - Field: 'conditions'
[01:27:47.930]   - Field: 'persistent'
[01:27:47.930]   - Field: 'expr'
[01:27:47.930]   - Field: 'uuid'
[01:27:47.930]   - Field: 'seed'
[01:27:47.931]   - Field: 'version'
[01:27:47.931]   - Field: 'result'
[01:27:47.931]   - Field: 'asynchronous'
[01:27:47.931]   - Field: 'calls'
[01:27:47.932]   - Field: 'globals'
[01:27:47.932]   - Field: 'stdout'
[01:27:47.932]   - Field: 'earlySignal'
[01:27:47.932]   - Field: 'lazy'
[01:27:47.932]   - Field: 'state'
[01:27:47.933] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:47.933] - Launch lazy future ...
[01:27:47.933] Packages needed by the future expression (n = 0): <none>
[01:27:47.933] Packages needed by future strategies (n = 0): <none>
[01:27:47.934] {
[01:27:47.934]     {
[01:27:47.934]         {
[01:27:47.934]             ...future.startTime <- base::Sys.time()
[01:27:47.934]             {
[01:27:47.934]                 {
[01:27:47.934]                   {
[01:27:47.934]                     {
[01:27:47.934]                       base::local({
[01:27:47.934]                         has_future <- base::requireNamespace("future", 
[01:27:47.934]                           quietly = TRUE)
[01:27:47.934]                         if (has_future) {
[01:27:47.934]                           ns <- base::getNamespace("future")
[01:27:47.934]                           version <- ns[[".package"]][["version"]]
[01:27:47.934]                           if (is.null(version)) 
[01:27:47.934]                             version <- utils::packageVersion("future")
[01:27:47.934]                         }
[01:27:47.934]                         else {
[01:27:47.934]                           version <- NULL
[01:27:47.934]                         }
[01:27:47.934]                         if (!has_future || version < "1.8.0") {
[01:27:47.934]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:47.934]                             "", base::R.version$version.string), 
[01:27:47.934]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:47.934]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:47.934]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:47.934]                               "release", "version")], collapse = " "), 
[01:27:47.934]                             hostname = base::Sys.info()[["nodename"]])
[01:27:47.934]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:47.934]                             info)
[01:27:47.934]                           info <- base::paste(info, collapse = "; ")
[01:27:47.934]                           if (!has_future) {
[01:27:47.934]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:47.934]                               info)
[01:27:47.934]                           }
[01:27:47.934]                           else {
[01:27:47.934]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:47.934]                               info, version)
[01:27:47.934]                           }
[01:27:47.934]                           base::stop(msg)
[01:27:47.934]                         }
[01:27:47.934]                       })
[01:27:47.934]                     }
[01:27:47.934]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:47.934]                     base::options(mc.cores = 1L)
[01:27:47.934]                   }
[01:27:47.934]                   options(future.plan = NULL)
[01:27:47.934]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.934]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:47.934]                 }
[01:27:47.934]                 ...future.workdir <- getwd()
[01:27:47.934]             }
[01:27:47.934]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:47.934]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:47.934]         }
[01:27:47.934]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:47.934]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:47.934]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:47.934]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:47.934]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:47.934]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:47.934]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:47.934]             base::names(...future.oldOptions))
[01:27:47.934]     }
[01:27:47.934]     if (FALSE) {
[01:27:47.934]     }
[01:27:47.934]     else {
[01:27:47.934]         if (TRUE) {
[01:27:47.934]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:47.934]                 open = "w")
[01:27:47.934]         }
[01:27:47.934]         else {
[01:27:47.934]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:47.934]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:47.934]         }
[01:27:47.934]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:47.934]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:47.934]             base::sink(type = "output", split = FALSE)
[01:27:47.934]             base::close(...future.stdout)
[01:27:47.934]         }, add = TRUE)
[01:27:47.934]     }
[01:27:47.934]     ...future.frame <- base::sys.nframe()
[01:27:47.934]     ...future.conditions <- base::list()
[01:27:47.934]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:47.934]     if (FALSE) {
[01:27:47.934]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:47.934]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:47.934]     }
[01:27:47.934]     ...future.result <- base::tryCatch({
[01:27:47.934]         base::withCallingHandlers({
[01:27:47.934]             ...future.value <- base::withVisible(base::local({
[01:27:47.934]                 ...future.makeSendCondition <- base::local({
[01:27:47.934]                   sendCondition <- NULL
[01:27:47.934]                   function(frame = 1L) {
[01:27:47.934]                     if (is.function(sendCondition)) 
[01:27:47.934]                       return(sendCondition)
[01:27:47.934]                     ns <- getNamespace("parallel")
[01:27:47.934]                     if (exists("sendData", mode = "function", 
[01:27:47.934]                       envir = ns)) {
[01:27:47.934]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:47.934]                         envir = ns)
[01:27:47.934]                       envir <- sys.frame(frame)
[01:27:47.934]                       master <- NULL
[01:27:47.934]                       while (!identical(envir, .GlobalEnv) && 
[01:27:47.934]                         !identical(envir, emptyenv())) {
[01:27:47.934]                         if (exists("master", mode = "list", envir = envir, 
[01:27:47.934]                           inherits = FALSE)) {
[01:27:47.934]                           master <- get("master", mode = "list", 
[01:27:47.934]                             envir = envir, inherits = FALSE)
[01:27:47.934]                           if (inherits(master, c("SOCKnode", 
[01:27:47.934]                             "SOCK0node"))) {
[01:27:47.934]                             sendCondition <<- function(cond) {
[01:27:47.934]                               data <- list(type = "VALUE", value = cond, 
[01:27:47.934]                                 success = TRUE)
[01:27:47.934]                               parallel_sendData(master, data)
[01:27:47.934]                             }
[01:27:47.934]                             return(sendCondition)
[01:27:47.934]                           }
[01:27:47.934]                         }
[01:27:47.934]                         frame <- frame + 1L
[01:27:47.934]                         envir <- sys.frame(frame)
[01:27:47.934]                       }
[01:27:47.934]                     }
[01:27:47.934]                     sendCondition <<- function(cond) NULL
[01:27:47.934]                   }
[01:27:47.934]                 })
[01:27:47.934]                 withCallingHandlers({
[01:27:47.934]                   2
[01:27:47.934]                 }, immediateCondition = function(cond) {
[01:27:47.934]                   sendCondition <- ...future.makeSendCondition()
[01:27:47.934]                   sendCondition(cond)
[01:27:47.934]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.934]                   {
[01:27:47.934]                     inherits <- base::inherits
[01:27:47.934]                     invokeRestart <- base::invokeRestart
[01:27:47.934]                     is.null <- base::is.null
[01:27:47.934]                     muffled <- FALSE
[01:27:47.934]                     if (inherits(cond, "message")) {
[01:27:47.934]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:47.934]                       if (muffled) 
[01:27:47.934]                         invokeRestart("muffleMessage")
[01:27:47.934]                     }
[01:27:47.934]                     else if (inherits(cond, "warning")) {
[01:27:47.934]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:47.934]                       if (muffled) 
[01:27:47.934]                         invokeRestart("muffleWarning")
[01:27:47.934]                     }
[01:27:47.934]                     else if (inherits(cond, "condition")) {
[01:27:47.934]                       if (!is.null(pattern)) {
[01:27:47.934]                         computeRestarts <- base::computeRestarts
[01:27:47.934]                         grepl <- base::grepl
[01:27:47.934]                         restarts <- computeRestarts(cond)
[01:27:47.934]                         for (restart in restarts) {
[01:27:47.934]                           name <- restart$name
[01:27:47.934]                           if (is.null(name)) 
[01:27:47.934]                             next
[01:27:47.934]                           if (!grepl(pattern, name)) 
[01:27:47.934]                             next
[01:27:47.934]                           invokeRestart(restart)
[01:27:47.934]                           muffled <- TRUE
[01:27:47.934]                           break
[01:27:47.934]                         }
[01:27:47.934]                       }
[01:27:47.934]                     }
[01:27:47.934]                     invisible(muffled)
[01:27:47.934]                   }
[01:27:47.934]                   muffleCondition(cond)
[01:27:47.934]                 })
[01:27:47.934]             }))
[01:27:47.934]             future::FutureResult(value = ...future.value$value, 
[01:27:47.934]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.934]                   ...future.rng), globalenv = if (FALSE) 
[01:27:47.934]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:47.934]                     ...future.globalenv.names))
[01:27:47.934]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:47.934]         }, condition = base::local({
[01:27:47.934]             c <- base::c
[01:27:47.934]             inherits <- base::inherits
[01:27:47.934]             invokeRestart <- base::invokeRestart
[01:27:47.934]             length <- base::length
[01:27:47.934]             list <- base::list
[01:27:47.934]             seq.int <- base::seq.int
[01:27:47.934]             signalCondition <- base::signalCondition
[01:27:47.934]             sys.calls <- base::sys.calls
[01:27:47.934]             `[[` <- base::`[[`
[01:27:47.934]             `+` <- base::`+`
[01:27:47.934]             `<<-` <- base::`<<-`
[01:27:47.934]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:47.934]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:47.934]                   3L)]
[01:27:47.934]             }
[01:27:47.934]             function(cond) {
[01:27:47.934]                 is_error <- inherits(cond, "error")
[01:27:47.934]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:47.934]                   NULL)
[01:27:47.934]                 if (is_error) {
[01:27:47.934]                   sessionInformation <- function() {
[01:27:47.934]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:47.934]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:47.934]                       search = base::search(), system = base::Sys.info())
[01:27:47.934]                   }
[01:27:47.934]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.934]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:47.934]                     cond$call), session = sessionInformation(), 
[01:27:47.934]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:47.934]                   signalCondition(cond)
[01:27:47.934]                 }
[01:27:47.934]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:47.934]                 "immediateCondition"))) {
[01:27:47.934]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:47.934]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.934]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:47.934]                   if (TRUE && !signal) {
[01:27:47.934]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.934]                     {
[01:27:47.934]                       inherits <- base::inherits
[01:27:47.934]                       invokeRestart <- base::invokeRestart
[01:27:47.934]                       is.null <- base::is.null
[01:27:47.934]                       muffled <- FALSE
[01:27:47.934]                       if (inherits(cond, "message")) {
[01:27:47.934]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.934]                         if (muffled) 
[01:27:47.934]                           invokeRestart("muffleMessage")
[01:27:47.934]                       }
[01:27:47.934]                       else if (inherits(cond, "warning")) {
[01:27:47.934]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.934]                         if (muffled) 
[01:27:47.934]                           invokeRestart("muffleWarning")
[01:27:47.934]                       }
[01:27:47.934]                       else if (inherits(cond, "condition")) {
[01:27:47.934]                         if (!is.null(pattern)) {
[01:27:47.934]                           computeRestarts <- base::computeRestarts
[01:27:47.934]                           grepl <- base::grepl
[01:27:47.934]                           restarts <- computeRestarts(cond)
[01:27:47.934]                           for (restart in restarts) {
[01:27:47.934]                             name <- restart$name
[01:27:47.934]                             if (is.null(name)) 
[01:27:47.934]                               next
[01:27:47.934]                             if (!grepl(pattern, name)) 
[01:27:47.934]                               next
[01:27:47.934]                             invokeRestart(restart)
[01:27:47.934]                             muffled <- TRUE
[01:27:47.934]                             break
[01:27:47.934]                           }
[01:27:47.934]                         }
[01:27:47.934]                       }
[01:27:47.934]                       invisible(muffled)
[01:27:47.934]                     }
[01:27:47.934]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.934]                   }
[01:27:47.934]                 }
[01:27:47.934]                 else {
[01:27:47.934]                   if (TRUE) {
[01:27:47.934]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.934]                     {
[01:27:47.934]                       inherits <- base::inherits
[01:27:47.934]                       invokeRestart <- base::invokeRestart
[01:27:47.934]                       is.null <- base::is.null
[01:27:47.934]                       muffled <- FALSE
[01:27:47.934]                       if (inherits(cond, "message")) {
[01:27:47.934]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.934]                         if (muffled) 
[01:27:47.934]                           invokeRestart("muffleMessage")
[01:27:47.934]                       }
[01:27:47.934]                       else if (inherits(cond, "warning")) {
[01:27:47.934]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.934]                         if (muffled) 
[01:27:47.934]                           invokeRestart("muffleWarning")
[01:27:47.934]                       }
[01:27:47.934]                       else if (inherits(cond, "condition")) {
[01:27:47.934]                         if (!is.null(pattern)) {
[01:27:47.934]                           computeRestarts <- base::computeRestarts
[01:27:47.934]                           grepl <- base::grepl
[01:27:47.934]                           restarts <- computeRestarts(cond)
[01:27:47.934]                           for (restart in restarts) {
[01:27:47.934]                             name <- restart$name
[01:27:47.934]                             if (is.null(name)) 
[01:27:47.934]                               next
[01:27:47.934]                             if (!grepl(pattern, name)) 
[01:27:47.934]                               next
[01:27:47.934]                             invokeRestart(restart)
[01:27:47.934]                             muffled <- TRUE
[01:27:47.934]                             break
[01:27:47.934]                           }
[01:27:47.934]                         }
[01:27:47.934]                       }
[01:27:47.934]                       invisible(muffled)
[01:27:47.934]                     }
[01:27:47.934]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.934]                   }
[01:27:47.934]                 }
[01:27:47.934]             }
[01:27:47.934]         }))
[01:27:47.934]     }, error = function(ex) {
[01:27:47.934]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:47.934]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.934]                 ...future.rng), started = ...future.startTime, 
[01:27:47.934]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:47.934]             version = "1.8"), class = "FutureResult")
[01:27:47.934]     }, finally = {
[01:27:47.934]         if (!identical(...future.workdir, getwd())) 
[01:27:47.934]             setwd(...future.workdir)
[01:27:47.934]         {
[01:27:47.934]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:47.934]                 ...future.oldOptions$nwarnings <- NULL
[01:27:47.934]             }
[01:27:47.934]             base::options(...future.oldOptions)
[01:27:47.934]             if (.Platform$OS.type == "windows") {
[01:27:47.934]                 old_names <- names(...future.oldEnvVars)
[01:27:47.934]                 envs <- base::Sys.getenv()
[01:27:47.934]                 names <- names(envs)
[01:27:47.934]                 common <- intersect(names, old_names)
[01:27:47.934]                 added <- setdiff(names, old_names)
[01:27:47.934]                 removed <- setdiff(old_names, names)
[01:27:47.934]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:47.934]                   envs[common]]
[01:27:47.934]                 NAMES <- toupper(changed)
[01:27:47.934]                 args <- list()
[01:27:47.934]                 for (kk in seq_along(NAMES)) {
[01:27:47.934]                   name <- changed[[kk]]
[01:27:47.934]                   NAME <- NAMES[[kk]]
[01:27:47.934]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.934]                     next
[01:27:47.934]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.934]                 }
[01:27:47.934]                 NAMES <- toupper(added)
[01:27:47.934]                 for (kk in seq_along(NAMES)) {
[01:27:47.934]                   name <- added[[kk]]
[01:27:47.934]                   NAME <- NAMES[[kk]]
[01:27:47.934]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.934]                     next
[01:27:47.934]                   args[[name]] <- ""
[01:27:47.934]                 }
[01:27:47.934]                 NAMES <- toupper(removed)
[01:27:47.934]                 for (kk in seq_along(NAMES)) {
[01:27:47.934]                   name <- removed[[kk]]
[01:27:47.934]                   NAME <- NAMES[[kk]]
[01:27:47.934]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.934]                     next
[01:27:47.934]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.934]                 }
[01:27:47.934]                 if (length(args) > 0) 
[01:27:47.934]                   base::do.call(base::Sys.setenv, args = args)
[01:27:47.934]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:47.934]             }
[01:27:47.934]             else {
[01:27:47.934]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:47.934]             }
[01:27:47.934]             {
[01:27:47.934]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:47.934]                   0L) {
[01:27:47.934]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:47.934]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:47.934]                   base::options(opts)
[01:27:47.934]                 }
[01:27:47.934]                 {
[01:27:47.934]                   {
[01:27:47.934]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:47.934]                     NULL
[01:27:47.934]                   }
[01:27:47.934]                   options(future.plan = NULL)
[01:27:47.934]                   if (is.na(NA_character_)) 
[01:27:47.934]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.934]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:47.934]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:47.934]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:47.934]                     envir = parent.frame()) 
[01:27:47.934]                   {
[01:27:47.934]                     if (is.function(workers)) 
[01:27:47.934]                       workers <- workers()
[01:27:47.934]                     workers <- structure(as.integer(workers), 
[01:27:47.934]                       class = class(workers))
[01:27:47.934]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:47.934]                       workers >= 1)
[01:27:47.934]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:47.934]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:47.934]                     }
[01:27:47.934]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:47.934]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:47.934]                       envir = envir)
[01:27:47.934]                     if (!future$lazy) 
[01:27:47.934]                       future <- run(future)
[01:27:47.934]                     invisible(future)
[01:27:47.934]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:47.934]                 }
[01:27:47.934]             }
[01:27:47.934]         }
[01:27:47.934]     })
[01:27:47.934]     if (TRUE) {
[01:27:47.934]         base::sink(type = "output", split = FALSE)
[01:27:47.934]         if (TRUE) {
[01:27:47.934]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:47.934]         }
[01:27:47.934]         else {
[01:27:47.934]             ...future.result["stdout"] <- base::list(NULL)
[01:27:47.934]         }
[01:27:47.934]         base::close(...future.stdout)
[01:27:47.934]         ...future.stdout <- NULL
[01:27:47.934]     }
[01:27:47.934]     ...future.result$conditions <- ...future.conditions
[01:27:47.934]     ...future.result$finished <- base::Sys.time()
[01:27:47.934]     ...future.result
[01:27:47.934] }
[01:27:47.940] MultisessionFuture started
[01:27:47.940] - Launch lazy future ... done
[01:27:47.940] run() for 'MultisessionFuture' ... done
[01:27:47.941] getGlobalsAndPackages() ...
[01:27:47.941] Searching for globals...
[01:27:47.941] 
[01:27:47.941] Searching for globals ... DONE
[01:27:47.942] - globals: [0] <none>
[01:27:47.942] getGlobalsAndPackages() ... DONE
[01:27:47.942] run() for 'Future' ...
[01:27:47.942] - state: 'created'
[01:27:47.942] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:47.960] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:47.960] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:47.960]   - Field: 'node'
[01:27:47.961]   - Field: 'label'
[01:27:47.961]   - Field: 'local'
[01:27:47.961]   - Field: 'owner'
[01:27:47.961]   - Field: 'envir'
[01:27:47.962]   - Field: 'workers'
[01:27:47.962]   - Field: 'packages'
[01:27:47.962]   - Field: 'gc'
[01:27:47.962]   - Field: 'conditions'
[01:27:47.962]   - Field: 'persistent'
[01:27:47.963]   - Field: 'expr'
[01:27:47.963]   - Field: 'uuid'
[01:27:47.963]   - Field: 'seed'
[01:27:47.963]   - Field: 'version'
[01:27:47.964]   - Field: 'result'
[01:27:47.964]   - Field: 'asynchronous'
[01:27:47.964]   - Field: 'calls'
[01:27:47.964]   - Field: 'globals'
[01:27:47.965]   - Field: 'stdout'
[01:27:47.965]   - Field: 'earlySignal'
[01:27:47.965]   - Field: 'lazy'
[01:27:47.966]   - Field: 'state'
[01:27:47.966] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:47.966] - Launch lazy future ...
[01:27:47.967] Packages needed by the future expression (n = 0): <none>
[01:27:47.967] Packages needed by future strategies (n = 0): <none>
[01:27:47.968] {
[01:27:47.968]     {
[01:27:47.968]         {
[01:27:47.968]             ...future.startTime <- base::Sys.time()
[01:27:47.968]             {
[01:27:47.968]                 {
[01:27:47.968]                   {
[01:27:47.968]                     {
[01:27:47.968]                       base::local({
[01:27:47.968]                         has_future <- base::requireNamespace("future", 
[01:27:47.968]                           quietly = TRUE)
[01:27:47.968]                         if (has_future) {
[01:27:47.968]                           ns <- base::getNamespace("future")
[01:27:47.968]                           version <- ns[[".package"]][["version"]]
[01:27:47.968]                           if (is.null(version)) 
[01:27:47.968]                             version <- utils::packageVersion("future")
[01:27:47.968]                         }
[01:27:47.968]                         else {
[01:27:47.968]                           version <- NULL
[01:27:47.968]                         }
[01:27:47.968]                         if (!has_future || version < "1.8.0") {
[01:27:47.968]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:47.968]                             "", base::R.version$version.string), 
[01:27:47.968]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:47.968]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:47.968]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:47.968]                               "release", "version")], collapse = " "), 
[01:27:47.968]                             hostname = base::Sys.info()[["nodename"]])
[01:27:47.968]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:47.968]                             info)
[01:27:47.968]                           info <- base::paste(info, collapse = "; ")
[01:27:47.968]                           if (!has_future) {
[01:27:47.968]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:47.968]                               info)
[01:27:47.968]                           }
[01:27:47.968]                           else {
[01:27:47.968]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:47.968]                               info, version)
[01:27:47.968]                           }
[01:27:47.968]                           base::stop(msg)
[01:27:47.968]                         }
[01:27:47.968]                       })
[01:27:47.968]                     }
[01:27:47.968]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:47.968]                     base::options(mc.cores = 1L)
[01:27:47.968]                   }
[01:27:47.968]                   options(future.plan = NULL)
[01:27:47.968]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.968]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:47.968]                 }
[01:27:47.968]                 ...future.workdir <- getwd()
[01:27:47.968]             }
[01:27:47.968]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:47.968]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:47.968]         }
[01:27:47.968]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:47.968]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:47.968]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:47.968]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:47.968]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:47.968]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:47.968]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:47.968]             base::names(...future.oldOptions))
[01:27:47.968]     }
[01:27:47.968]     if (FALSE) {
[01:27:47.968]     }
[01:27:47.968]     else {
[01:27:47.968]         if (TRUE) {
[01:27:47.968]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:47.968]                 open = "w")
[01:27:47.968]         }
[01:27:47.968]         else {
[01:27:47.968]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:47.968]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:47.968]         }
[01:27:47.968]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:47.968]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:47.968]             base::sink(type = "output", split = FALSE)
[01:27:47.968]             base::close(...future.stdout)
[01:27:47.968]         }, add = TRUE)
[01:27:47.968]     }
[01:27:47.968]     ...future.frame <- base::sys.nframe()
[01:27:47.968]     ...future.conditions <- base::list()
[01:27:47.968]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:47.968]     if (FALSE) {
[01:27:47.968]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:47.968]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:47.968]     }
[01:27:47.968]     ...future.result <- base::tryCatch({
[01:27:47.968]         base::withCallingHandlers({
[01:27:47.968]             ...future.value <- base::withVisible(base::local({
[01:27:47.968]                 ...future.makeSendCondition <- base::local({
[01:27:47.968]                   sendCondition <- NULL
[01:27:47.968]                   function(frame = 1L) {
[01:27:47.968]                     if (is.function(sendCondition)) 
[01:27:47.968]                       return(sendCondition)
[01:27:47.968]                     ns <- getNamespace("parallel")
[01:27:47.968]                     if (exists("sendData", mode = "function", 
[01:27:47.968]                       envir = ns)) {
[01:27:47.968]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:47.968]                         envir = ns)
[01:27:47.968]                       envir <- sys.frame(frame)
[01:27:47.968]                       master <- NULL
[01:27:47.968]                       while (!identical(envir, .GlobalEnv) && 
[01:27:47.968]                         !identical(envir, emptyenv())) {
[01:27:47.968]                         if (exists("master", mode = "list", envir = envir, 
[01:27:47.968]                           inherits = FALSE)) {
[01:27:47.968]                           master <- get("master", mode = "list", 
[01:27:47.968]                             envir = envir, inherits = FALSE)
[01:27:47.968]                           if (inherits(master, c("SOCKnode", 
[01:27:47.968]                             "SOCK0node"))) {
[01:27:47.968]                             sendCondition <<- function(cond) {
[01:27:47.968]                               data <- list(type = "VALUE", value = cond, 
[01:27:47.968]                                 success = TRUE)
[01:27:47.968]                               parallel_sendData(master, data)
[01:27:47.968]                             }
[01:27:47.968]                             return(sendCondition)
[01:27:47.968]                           }
[01:27:47.968]                         }
[01:27:47.968]                         frame <- frame + 1L
[01:27:47.968]                         envir <- sys.frame(frame)
[01:27:47.968]                       }
[01:27:47.968]                     }
[01:27:47.968]                     sendCondition <<- function(cond) NULL
[01:27:47.968]                   }
[01:27:47.968]                 })
[01:27:47.968]                 withCallingHandlers({
[01:27:47.968]                   NULL
[01:27:47.968]                 }, immediateCondition = function(cond) {
[01:27:47.968]                   sendCondition <- ...future.makeSendCondition()
[01:27:47.968]                   sendCondition(cond)
[01:27:47.968]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.968]                   {
[01:27:47.968]                     inherits <- base::inherits
[01:27:47.968]                     invokeRestart <- base::invokeRestart
[01:27:47.968]                     is.null <- base::is.null
[01:27:47.968]                     muffled <- FALSE
[01:27:47.968]                     if (inherits(cond, "message")) {
[01:27:47.968]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:47.968]                       if (muffled) 
[01:27:47.968]                         invokeRestart("muffleMessage")
[01:27:47.968]                     }
[01:27:47.968]                     else if (inherits(cond, "warning")) {
[01:27:47.968]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:47.968]                       if (muffled) 
[01:27:47.968]                         invokeRestart("muffleWarning")
[01:27:47.968]                     }
[01:27:47.968]                     else if (inherits(cond, "condition")) {
[01:27:47.968]                       if (!is.null(pattern)) {
[01:27:47.968]                         computeRestarts <- base::computeRestarts
[01:27:47.968]                         grepl <- base::grepl
[01:27:47.968]                         restarts <- computeRestarts(cond)
[01:27:47.968]                         for (restart in restarts) {
[01:27:47.968]                           name <- restart$name
[01:27:47.968]                           if (is.null(name)) 
[01:27:47.968]                             next
[01:27:47.968]                           if (!grepl(pattern, name)) 
[01:27:47.968]                             next
[01:27:47.968]                           invokeRestart(restart)
[01:27:47.968]                           muffled <- TRUE
[01:27:47.968]                           break
[01:27:47.968]                         }
[01:27:47.968]                       }
[01:27:47.968]                     }
[01:27:47.968]                     invisible(muffled)
[01:27:47.968]                   }
[01:27:47.968]                   muffleCondition(cond)
[01:27:47.968]                 })
[01:27:47.968]             }))
[01:27:47.968]             future::FutureResult(value = ...future.value$value, 
[01:27:47.968]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.968]                   ...future.rng), globalenv = if (FALSE) 
[01:27:47.968]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:47.968]                     ...future.globalenv.names))
[01:27:47.968]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:47.968]         }, condition = base::local({
[01:27:47.968]             c <- base::c
[01:27:47.968]             inherits <- base::inherits
[01:27:47.968]             invokeRestart <- base::invokeRestart
[01:27:47.968]             length <- base::length
[01:27:47.968]             list <- base::list
[01:27:47.968]             seq.int <- base::seq.int
[01:27:47.968]             signalCondition <- base::signalCondition
[01:27:47.968]             sys.calls <- base::sys.calls
[01:27:47.968]             `[[` <- base::`[[`
[01:27:47.968]             `+` <- base::`+`
[01:27:47.968]             `<<-` <- base::`<<-`
[01:27:47.968]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:47.968]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:47.968]                   3L)]
[01:27:47.968]             }
[01:27:47.968]             function(cond) {
[01:27:47.968]                 is_error <- inherits(cond, "error")
[01:27:47.968]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:47.968]                   NULL)
[01:27:47.968]                 if (is_error) {
[01:27:47.968]                   sessionInformation <- function() {
[01:27:47.968]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:47.968]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:47.968]                       search = base::search(), system = base::Sys.info())
[01:27:47.968]                   }
[01:27:47.968]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.968]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:47.968]                     cond$call), session = sessionInformation(), 
[01:27:47.968]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:47.968]                   signalCondition(cond)
[01:27:47.968]                 }
[01:27:47.968]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:47.968]                 "immediateCondition"))) {
[01:27:47.968]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:47.968]                   ...future.conditions[[length(...future.conditions) + 
[01:27:47.968]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:47.968]                   if (TRUE && !signal) {
[01:27:47.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.968]                     {
[01:27:47.968]                       inherits <- base::inherits
[01:27:47.968]                       invokeRestart <- base::invokeRestart
[01:27:47.968]                       is.null <- base::is.null
[01:27:47.968]                       muffled <- FALSE
[01:27:47.968]                       if (inherits(cond, "message")) {
[01:27:47.968]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.968]                         if (muffled) 
[01:27:47.968]                           invokeRestart("muffleMessage")
[01:27:47.968]                       }
[01:27:47.968]                       else if (inherits(cond, "warning")) {
[01:27:47.968]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.968]                         if (muffled) 
[01:27:47.968]                           invokeRestart("muffleWarning")
[01:27:47.968]                       }
[01:27:47.968]                       else if (inherits(cond, "condition")) {
[01:27:47.968]                         if (!is.null(pattern)) {
[01:27:47.968]                           computeRestarts <- base::computeRestarts
[01:27:47.968]                           grepl <- base::grepl
[01:27:47.968]                           restarts <- computeRestarts(cond)
[01:27:47.968]                           for (restart in restarts) {
[01:27:47.968]                             name <- restart$name
[01:27:47.968]                             if (is.null(name)) 
[01:27:47.968]                               next
[01:27:47.968]                             if (!grepl(pattern, name)) 
[01:27:47.968]                               next
[01:27:47.968]                             invokeRestart(restart)
[01:27:47.968]                             muffled <- TRUE
[01:27:47.968]                             break
[01:27:47.968]                           }
[01:27:47.968]                         }
[01:27:47.968]                       }
[01:27:47.968]                       invisible(muffled)
[01:27:47.968]                     }
[01:27:47.968]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.968]                   }
[01:27:47.968]                 }
[01:27:47.968]                 else {
[01:27:47.968]                   if (TRUE) {
[01:27:47.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:47.968]                     {
[01:27:47.968]                       inherits <- base::inherits
[01:27:47.968]                       invokeRestart <- base::invokeRestart
[01:27:47.968]                       is.null <- base::is.null
[01:27:47.968]                       muffled <- FALSE
[01:27:47.968]                       if (inherits(cond, "message")) {
[01:27:47.968]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:47.968]                         if (muffled) 
[01:27:47.968]                           invokeRestart("muffleMessage")
[01:27:47.968]                       }
[01:27:47.968]                       else if (inherits(cond, "warning")) {
[01:27:47.968]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:47.968]                         if (muffled) 
[01:27:47.968]                           invokeRestart("muffleWarning")
[01:27:47.968]                       }
[01:27:47.968]                       else if (inherits(cond, "condition")) {
[01:27:47.968]                         if (!is.null(pattern)) {
[01:27:47.968]                           computeRestarts <- base::computeRestarts
[01:27:47.968]                           grepl <- base::grepl
[01:27:47.968]                           restarts <- computeRestarts(cond)
[01:27:47.968]                           for (restart in restarts) {
[01:27:47.968]                             name <- restart$name
[01:27:47.968]                             if (is.null(name)) 
[01:27:47.968]                               next
[01:27:47.968]                             if (!grepl(pattern, name)) 
[01:27:47.968]                               next
[01:27:47.968]                             invokeRestart(restart)
[01:27:47.968]                             muffled <- TRUE
[01:27:47.968]                             break
[01:27:47.968]                           }
[01:27:47.968]                         }
[01:27:47.968]                       }
[01:27:47.968]                       invisible(muffled)
[01:27:47.968]                     }
[01:27:47.968]                     muffleCondition(cond, pattern = "^muffle")
[01:27:47.968]                   }
[01:27:47.968]                 }
[01:27:47.968]             }
[01:27:47.968]         }))
[01:27:47.968]     }, error = function(ex) {
[01:27:47.968]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:47.968]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:47.968]                 ...future.rng), started = ...future.startTime, 
[01:27:47.968]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:47.968]             version = "1.8"), class = "FutureResult")
[01:27:47.968]     }, finally = {
[01:27:47.968]         if (!identical(...future.workdir, getwd())) 
[01:27:47.968]             setwd(...future.workdir)
[01:27:47.968]         {
[01:27:47.968]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:47.968]                 ...future.oldOptions$nwarnings <- NULL
[01:27:47.968]             }
[01:27:47.968]             base::options(...future.oldOptions)
[01:27:47.968]             if (.Platform$OS.type == "windows") {
[01:27:47.968]                 old_names <- names(...future.oldEnvVars)
[01:27:47.968]                 envs <- base::Sys.getenv()
[01:27:47.968]                 names <- names(envs)
[01:27:47.968]                 common <- intersect(names, old_names)
[01:27:47.968]                 added <- setdiff(names, old_names)
[01:27:47.968]                 removed <- setdiff(old_names, names)
[01:27:47.968]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:47.968]                   envs[common]]
[01:27:47.968]                 NAMES <- toupper(changed)
[01:27:47.968]                 args <- list()
[01:27:47.968]                 for (kk in seq_along(NAMES)) {
[01:27:47.968]                   name <- changed[[kk]]
[01:27:47.968]                   NAME <- NAMES[[kk]]
[01:27:47.968]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.968]                     next
[01:27:47.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.968]                 }
[01:27:47.968]                 NAMES <- toupper(added)
[01:27:47.968]                 for (kk in seq_along(NAMES)) {
[01:27:47.968]                   name <- added[[kk]]
[01:27:47.968]                   NAME <- NAMES[[kk]]
[01:27:47.968]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.968]                     next
[01:27:47.968]                   args[[name]] <- ""
[01:27:47.968]                 }
[01:27:47.968]                 NAMES <- toupper(removed)
[01:27:47.968]                 for (kk in seq_along(NAMES)) {
[01:27:47.968]                   name <- removed[[kk]]
[01:27:47.968]                   NAME <- NAMES[[kk]]
[01:27:47.968]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:47.968]                     next
[01:27:47.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:47.968]                 }
[01:27:47.968]                 if (length(args) > 0) 
[01:27:47.968]                   base::do.call(base::Sys.setenv, args = args)
[01:27:47.968]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:47.968]             }
[01:27:47.968]             else {
[01:27:47.968]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:47.968]             }
[01:27:47.968]             {
[01:27:47.968]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:47.968]                   0L) {
[01:27:47.968]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:47.968]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:47.968]                   base::options(opts)
[01:27:47.968]                 }
[01:27:47.968]                 {
[01:27:47.968]                   {
[01:27:47.968]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:47.968]                     NULL
[01:27:47.968]                   }
[01:27:47.968]                   options(future.plan = NULL)
[01:27:47.968]                   if (is.na(NA_character_)) 
[01:27:47.968]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:47.968]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:47.968]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:47.968]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:47.968]                     envir = parent.frame()) 
[01:27:47.968]                   {
[01:27:47.968]                     if (is.function(workers)) 
[01:27:47.968]                       workers <- workers()
[01:27:47.968]                     workers <- structure(as.integer(workers), 
[01:27:47.968]                       class = class(workers))
[01:27:47.968]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:47.968]                       workers >= 1)
[01:27:47.968]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:47.968]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:47.968]                     }
[01:27:47.968]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:47.968]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:47.968]                       envir = envir)
[01:27:47.968]                     if (!future$lazy) 
[01:27:47.968]                       future <- run(future)
[01:27:47.968]                     invisible(future)
[01:27:47.968]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:47.968]                 }
[01:27:47.968]             }
[01:27:47.968]         }
[01:27:47.968]     })
[01:27:47.968]     if (TRUE) {
[01:27:47.968]         base::sink(type = "output", split = FALSE)
[01:27:47.968]         if (TRUE) {
[01:27:47.968]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:47.968]         }
[01:27:47.968]         else {
[01:27:47.968]             ...future.result["stdout"] <- base::list(NULL)
[01:27:47.968]         }
[01:27:47.968]         base::close(...future.stdout)
[01:27:47.968]         ...future.stdout <- NULL
[01:27:47.968]     }
[01:27:47.968]     ...future.result$conditions <- ...future.conditions
[01:27:47.968]     ...future.result$finished <- base::Sys.time()
[01:27:47.968]     ...future.result
[01:27:47.968] }
[01:27:47.976] MultisessionFuture started
[01:27:47.976] - Launch lazy future ... done
[01:27:47.977] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0831cb20> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b07c207d8> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0831cb20> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b07c207d8> 
 $  : 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" ...
[01:27:47.984] receiveMessageFromWorker() for ClusterFuture ...
[01:27:47.984] - Validating connection of MultisessionFuture
[01:27:47.984] - received message: FutureResult
[01:27:47.985] - Received FutureResult
[01:27:47.985] - Erased future from FutureRegistry
[01:27:47.985] result() for ClusterFuture ...
[01:27:47.985] - result already collected: FutureResult
[01:27:47.985] result() for ClusterFuture ... done
[01:27:47.986] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:47.995] receiveMessageFromWorker() for ClusterFuture ...
[01:27:47.995] - Validating connection of MultisessionFuture
[01:27:47.996] - received message: FutureResult
[01:27:47.996] - Received FutureResult
[01:27:47.996] - Erased future from FutureRegistry
[01:27:47.996] result() for ClusterFuture ...
[01:27:47.996] - result already collected: FutureResult
[01:27:47.997] result() for ClusterFuture ... done
[01:27:47.997] 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" "" ...
[01:27:47.999] resolve() on list ...
[01:27:47.999]  recursive: 0
[01:27:47.999]  length: 6
[01:27:47.999]  elements: 'a', 'b', 'c', '', '', ''
[01:27:48.000] signalConditionsASAP(numeric, pos=1) ...
[01:27:48.000] - nx: 6
[01:27:48.000] - relay: TRUE
[01:27:48.000] - stdout: TRUE
[01:27:48.000] - signal: TRUE
[01:27:48.001] - resignal: FALSE
[01:27:48.001] - force: TRUE
[01:27:48.001] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.001] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.001]  - until=2
[01:27:48.001]  - relaying element #2
[01:27:48.002] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.002] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.002] signalConditionsASAP(NULL, pos=1) ... done
[01:27:48.002]  length: 5 (resolved future 1)
[01:27:48.002] Future #2
[01:27:48.003] result() for ClusterFuture ...
[01:27:48.003] - result already collected: FutureResult
[01:27:48.003] result() for ClusterFuture ... done
[01:27:48.003] result() for ClusterFuture ...
[01:27:48.003] - result already collected: FutureResult
[01:27:48.003] result() for ClusterFuture ... done
[01:27:48.004] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:48.004] - nx: 6
[01:27:48.004] - relay: TRUE
[01:27:48.004] - stdout: TRUE
[01:27:48.004] - signal: TRUE
[01:27:48.004] - resignal: FALSE
[01:27:48.005] - force: TRUE
[01:27:48.005] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.005] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.005]  - until=2
[01:27:48.005]  - relaying element #2
[01:27:48.006] result() for ClusterFuture ...
[01:27:48.006] - result already collected: FutureResult
[01:27:48.006] result() for ClusterFuture ... done
[01:27:48.006] result() for ClusterFuture ...
[01:27:48.006] - result already collected: FutureResult
[01:27:48.006] result() for ClusterFuture ... done
[01:27:48.007] result() for ClusterFuture ...
[01:27:48.007] - result already collected: FutureResult
[01:27:48.007] result() for ClusterFuture ... done
[01:27:48.007] result() for ClusterFuture ...
[01:27:48.007] - result already collected: FutureResult
[01:27:48.007] result() for ClusterFuture ... done
[01:27:48.008] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.008] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.008] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:48.008]  length: 4 (resolved future 2)
[01:27:48.009] Future #3
[01:27:48.009] result() for ClusterFuture ...
[01:27:48.009] - result already collected: FutureResult
[01:27:48.009] result() for ClusterFuture ... done
[01:27:48.009] result() for ClusterFuture ...
[01:27:48.009] - result already collected: FutureResult
[01:27:48.010] result() for ClusterFuture ... done
[01:27:48.010] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:48.010] - nx: 6
[01:27:48.010] - relay: TRUE
[01:27:48.010] - stdout: TRUE
[01:27:48.010] - signal: TRUE
[01:27:48.011] - resignal: FALSE
[01:27:48.011] - force: TRUE
[01:27:48.011] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.011] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.011]  - until=3
[01:27:48.011]  - relaying element #3
[01:27:48.012] result() for ClusterFuture ...
[01:27:48.012] - result already collected: FutureResult
[01:27:48.012] result() for ClusterFuture ... done
[01:27:48.012] result() for ClusterFuture ...
[01:27:48.012] - result already collected: FutureResult
[01:27:48.012] result() for ClusterFuture ... done
[01:27:48.013] result() for ClusterFuture ...
[01:27:48.013] - result already collected: FutureResult
[01:27:48.013] result() for ClusterFuture ... done
[01:27:48.013] result() for ClusterFuture ...
[01:27:48.013] - result already collected: FutureResult
[01:27:48.014] result() for ClusterFuture ... done
[01:27:48.014] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.014] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.014] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:48.014]  length: 3 (resolved future 3)
[01:27:48.014] signalConditionsASAP(NULL, pos=4) ...
[01:27:48.015] - nx: 6
[01:27:48.015] - relay: TRUE
[01:27:48.015] - stdout: TRUE
[01:27:48.015] - signal: TRUE
[01:27:48.015] - resignal: FALSE
[01:27:48.015] - force: TRUE
[01:27:48.016] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.016] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.016]  - until=5
[01:27:48.016]  - relaying element #5
[01:27:48.016] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.016] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.017] signalConditionsASAP(NULL, pos=4) ... done
[01:27:48.017]  length: 2 (resolved future 4)
[01:27:48.017] signalConditionsASAP(NULL, pos=5) ...
[01:27:48.017] - nx: 6
[01:27:48.017] - relay: TRUE
[01:27:48.017] - stdout: TRUE
[01:27:48.018] - signal: TRUE
[01:27:48.018] - resignal: FALSE
[01:27:48.018] - force: TRUE
[01:27:48.018] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.018] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.018]  - until=6
[01:27:48.019]  - relaying element #6
[01:27:48.019] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.019] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.019] signalConditionsASAP(NULL, pos=5) ... done
[01:27:48.019]  length: 1 (resolved future 5)
[01:27:48.019] signalConditionsASAP(numeric, pos=6) ...
[01:27:48.020] - nx: 6
[01:27:48.020] - relay: TRUE
[01:27:48.020] - stdout: TRUE
[01:27:48.020] - signal: TRUE
[01:27:48.020] - resignal: FALSE
[01:27:48.020] - force: TRUE
[01:27:48.021] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.021] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.021]  - until=6
[01:27:48.021] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.021] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.022] signalConditionsASAP(numeric, pos=6) ... done
[01:27:48.022]  length: 0 (resolved future 6)
[01:27:48.022] Relaying remaining futures
[01:27:48.022] signalConditionsASAP(NULL, pos=0) ...
[01:27:48.022] - nx: 6
[01:27:48.022] - relay: TRUE
[01:27:48.023] - stdout: TRUE
[01:27:48.023] - signal: TRUE
[01:27:48.023] - resignal: FALSE
[01:27:48.023] - force: TRUE
[01:27:48.023] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.023] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:48.024] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.024] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.024] signalConditionsASAP(NULL, pos=0) ... done
[01:27:48.025] resolve() on list ... DONE
[01:27:48.025] result() for ClusterFuture ...
[01:27:48.026] - result already collected: FutureResult
[01:27:48.026] result() for ClusterFuture ... done
[01:27:48.026] result() for ClusterFuture ...
[01:27:48.027] - result already collected: FutureResult
[01:27:48.027] result() for ClusterFuture ... done
[01:27:48.027] result() for ClusterFuture ...
[01:27:48.028] - result already collected: FutureResult
[01:27:48.028] result() for ClusterFuture ... done
[01:27:48.028] result() for ClusterFuture ...
[01:27:48.028] - result already collected: FutureResult
[01:27:48.029] 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)
[01:27:48.036] getGlobalsAndPackages() ...
[01:27:48.036] Searching for globals...
[01:27:48.037] 
[01:27:48.038] Searching for globals ... DONE
[01:27:48.038] - globals: [0] <none>
[01:27:48.038] getGlobalsAndPackages() ... DONE
[01:27:48.039] run() for 'Future' ...
[01:27:48.039] - state: 'created'
[01:27:48.040] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.055] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.055] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.056]   - Field: 'node'
[01:27:48.056]   - Field: 'label'
[01:27:48.056]   - Field: 'local'
[01:27:48.056]   - Field: 'owner'
[01:27:48.057]   - Field: 'envir'
[01:27:48.057]   - Field: 'workers'
[01:27:48.057]   - Field: 'packages'
[01:27:48.057]   - Field: 'gc'
[01:27:48.057]   - Field: 'conditions'
[01:27:48.058]   - Field: 'persistent'
[01:27:48.058]   - Field: 'expr'
[01:27:48.058]   - Field: 'uuid'
[01:27:48.058]   - Field: 'seed'
[01:27:48.058]   - Field: 'version'
[01:27:48.058]   - Field: 'result'
[01:27:48.059]   - Field: 'asynchronous'
[01:27:48.059]   - Field: 'calls'
[01:27:48.059]   - Field: 'globals'
[01:27:48.059]   - Field: 'stdout'
[01:27:48.059]   - Field: 'earlySignal'
[01:27:48.059]   - Field: 'lazy'
[01:27:48.060]   - Field: 'state'
[01:27:48.060] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.060] - Launch lazy future ...
[01:27:48.060] Packages needed by the future expression (n = 0): <none>
[01:27:48.061] Packages needed by future strategies (n = 0): <none>
[01:27:48.061] {
[01:27:48.061]     {
[01:27:48.061]         {
[01:27:48.061]             ...future.startTime <- base::Sys.time()
[01:27:48.061]             {
[01:27:48.061]                 {
[01:27:48.061]                   {
[01:27:48.061]                     {
[01:27:48.061]                       base::local({
[01:27:48.061]                         has_future <- base::requireNamespace("future", 
[01:27:48.061]                           quietly = TRUE)
[01:27:48.061]                         if (has_future) {
[01:27:48.061]                           ns <- base::getNamespace("future")
[01:27:48.061]                           version <- ns[[".package"]][["version"]]
[01:27:48.061]                           if (is.null(version)) 
[01:27:48.061]                             version <- utils::packageVersion("future")
[01:27:48.061]                         }
[01:27:48.061]                         else {
[01:27:48.061]                           version <- NULL
[01:27:48.061]                         }
[01:27:48.061]                         if (!has_future || version < "1.8.0") {
[01:27:48.061]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.061]                             "", base::R.version$version.string), 
[01:27:48.061]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.061]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.061]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.061]                               "release", "version")], collapse = " "), 
[01:27:48.061]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.061]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.061]                             info)
[01:27:48.061]                           info <- base::paste(info, collapse = "; ")
[01:27:48.061]                           if (!has_future) {
[01:27:48.061]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.061]                               info)
[01:27:48.061]                           }
[01:27:48.061]                           else {
[01:27:48.061]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.061]                               info, version)
[01:27:48.061]                           }
[01:27:48.061]                           base::stop(msg)
[01:27:48.061]                         }
[01:27:48.061]                       })
[01:27:48.061]                     }
[01:27:48.061]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.061]                     base::options(mc.cores = 1L)
[01:27:48.061]                   }
[01:27:48.061]                   options(future.plan = NULL)
[01:27:48.061]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.061]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.061]                 }
[01:27:48.061]                 ...future.workdir <- getwd()
[01:27:48.061]             }
[01:27:48.061]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.061]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.061]         }
[01:27:48.061]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.061]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.061]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.061]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.061]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.061]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.061]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.061]             base::names(...future.oldOptions))
[01:27:48.061]     }
[01:27:48.061]     if (FALSE) {
[01:27:48.061]     }
[01:27:48.061]     else {
[01:27:48.061]         if (TRUE) {
[01:27:48.061]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.061]                 open = "w")
[01:27:48.061]         }
[01:27:48.061]         else {
[01:27:48.061]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.061]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.061]         }
[01:27:48.061]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.061]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.061]             base::sink(type = "output", split = FALSE)
[01:27:48.061]             base::close(...future.stdout)
[01:27:48.061]         }, add = TRUE)
[01:27:48.061]     }
[01:27:48.061]     ...future.frame <- base::sys.nframe()
[01:27:48.061]     ...future.conditions <- base::list()
[01:27:48.061]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.061]     if (FALSE) {
[01:27:48.061]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.061]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.061]     }
[01:27:48.061]     ...future.result <- base::tryCatch({
[01:27:48.061]         base::withCallingHandlers({
[01:27:48.061]             ...future.value <- base::withVisible(base::local({
[01:27:48.061]                 ...future.makeSendCondition <- base::local({
[01:27:48.061]                   sendCondition <- NULL
[01:27:48.061]                   function(frame = 1L) {
[01:27:48.061]                     if (is.function(sendCondition)) 
[01:27:48.061]                       return(sendCondition)
[01:27:48.061]                     ns <- getNamespace("parallel")
[01:27:48.061]                     if (exists("sendData", mode = "function", 
[01:27:48.061]                       envir = ns)) {
[01:27:48.061]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.061]                         envir = ns)
[01:27:48.061]                       envir <- sys.frame(frame)
[01:27:48.061]                       master <- NULL
[01:27:48.061]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.061]                         !identical(envir, emptyenv())) {
[01:27:48.061]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.061]                           inherits = FALSE)) {
[01:27:48.061]                           master <- get("master", mode = "list", 
[01:27:48.061]                             envir = envir, inherits = FALSE)
[01:27:48.061]                           if (inherits(master, c("SOCKnode", 
[01:27:48.061]                             "SOCK0node"))) {
[01:27:48.061]                             sendCondition <<- function(cond) {
[01:27:48.061]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.061]                                 success = TRUE)
[01:27:48.061]                               parallel_sendData(master, data)
[01:27:48.061]                             }
[01:27:48.061]                             return(sendCondition)
[01:27:48.061]                           }
[01:27:48.061]                         }
[01:27:48.061]                         frame <- frame + 1L
[01:27:48.061]                         envir <- sys.frame(frame)
[01:27:48.061]                       }
[01:27:48.061]                     }
[01:27:48.061]                     sendCondition <<- function(cond) NULL
[01:27:48.061]                   }
[01:27:48.061]                 })
[01:27:48.061]                 withCallingHandlers({
[01:27:48.061]                   2
[01:27:48.061]                 }, immediateCondition = function(cond) {
[01:27:48.061]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.061]                   sendCondition(cond)
[01:27:48.061]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.061]                   {
[01:27:48.061]                     inherits <- base::inherits
[01:27:48.061]                     invokeRestart <- base::invokeRestart
[01:27:48.061]                     is.null <- base::is.null
[01:27:48.061]                     muffled <- FALSE
[01:27:48.061]                     if (inherits(cond, "message")) {
[01:27:48.061]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.061]                       if (muffled) 
[01:27:48.061]                         invokeRestart("muffleMessage")
[01:27:48.061]                     }
[01:27:48.061]                     else if (inherits(cond, "warning")) {
[01:27:48.061]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.061]                       if (muffled) 
[01:27:48.061]                         invokeRestart("muffleWarning")
[01:27:48.061]                     }
[01:27:48.061]                     else if (inherits(cond, "condition")) {
[01:27:48.061]                       if (!is.null(pattern)) {
[01:27:48.061]                         computeRestarts <- base::computeRestarts
[01:27:48.061]                         grepl <- base::grepl
[01:27:48.061]                         restarts <- computeRestarts(cond)
[01:27:48.061]                         for (restart in restarts) {
[01:27:48.061]                           name <- restart$name
[01:27:48.061]                           if (is.null(name)) 
[01:27:48.061]                             next
[01:27:48.061]                           if (!grepl(pattern, name)) 
[01:27:48.061]                             next
[01:27:48.061]                           invokeRestart(restart)
[01:27:48.061]                           muffled <- TRUE
[01:27:48.061]                           break
[01:27:48.061]                         }
[01:27:48.061]                       }
[01:27:48.061]                     }
[01:27:48.061]                     invisible(muffled)
[01:27:48.061]                   }
[01:27:48.061]                   muffleCondition(cond)
[01:27:48.061]                 })
[01:27:48.061]             }))
[01:27:48.061]             future::FutureResult(value = ...future.value$value, 
[01:27:48.061]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.061]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.061]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.061]                     ...future.globalenv.names))
[01:27:48.061]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.061]         }, condition = base::local({
[01:27:48.061]             c <- base::c
[01:27:48.061]             inherits <- base::inherits
[01:27:48.061]             invokeRestart <- base::invokeRestart
[01:27:48.061]             length <- base::length
[01:27:48.061]             list <- base::list
[01:27:48.061]             seq.int <- base::seq.int
[01:27:48.061]             signalCondition <- base::signalCondition
[01:27:48.061]             sys.calls <- base::sys.calls
[01:27:48.061]             `[[` <- base::`[[`
[01:27:48.061]             `+` <- base::`+`
[01:27:48.061]             `<<-` <- base::`<<-`
[01:27:48.061]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.061]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.061]                   3L)]
[01:27:48.061]             }
[01:27:48.061]             function(cond) {
[01:27:48.061]                 is_error <- inherits(cond, "error")
[01:27:48.061]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.061]                   NULL)
[01:27:48.061]                 if (is_error) {
[01:27:48.061]                   sessionInformation <- function() {
[01:27:48.061]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.061]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.061]                       search = base::search(), system = base::Sys.info())
[01:27:48.061]                   }
[01:27:48.061]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.061]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.061]                     cond$call), session = sessionInformation(), 
[01:27:48.061]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.061]                   signalCondition(cond)
[01:27:48.061]                 }
[01:27:48.061]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.061]                 "immediateCondition"))) {
[01:27:48.061]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.061]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.061]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.061]                   if (TRUE && !signal) {
[01:27:48.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.061]                     {
[01:27:48.061]                       inherits <- base::inherits
[01:27:48.061]                       invokeRestart <- base::invokeRestart
[01:27:48.061]                       is.null <- base::is.null
[01:27:48.061]                       muffled <- FALSE
[01:27:48.061]                       if (inherits(cond, "message")) {
[01:27:48.061]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.061]                         if (muffled) 
[01:27:48.061]                           invokeRestart("muffleMessage")
[01:27:48.061]                       }
[01:27:48.061]                       else if (inherits(cond, "warning")) {
[01:27:48.061]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.061]                         if (muffled) 
[01:27:48.061]                           invokeRestart("muffleWarning")
[01:27:48.061]                       }
[01:27:48.061]                       else if (inherits(cond, "condition")) {
[01:27:48.061]                         if (!is.null(pattern)) {
[01:27:48.061]                           computeRestarts <- base::computeRestarts
[01:27:48.061]                           grepl <- base::grepl
[01:27:48.061]                           restarts <- computeRestarts(cond)
[01:27:48.061]                           for (restart in restarts) {
[01:27:48.061]                             name <- restart$name
[01:27:48.061]                             if (is.null(name)) 
[01:27:48.061]                               next
[01:27:48.061]                             if (!grepl(pattern, name)) 
[01:27:48.061]                               next
[01:27:48.061]                             invokeRestart(restart)
[01:27:48.061]                             muffled <- TRUE
[01:27:48.061]                             break
[01:27:48.061]                           }
[01:27:48.061]                         }
[01:27:48.061]                       }
[01:27:48.061]                       invisible(muffled)
[01:27:48.061]                     }
[01:27:48.061]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.061]                   }
[01:27:48.061]                 }
[01:27:48.061]                 else {
[01:27:48.061]                   if (TRUE) {
[01:27:48.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.061]                     {
[01:27:48.061]                       inherits <- base::inherits
[01:27:48.061]                       invokeRestart <- base::invokeRestart
[01:27:48.061]                       is.null <- base::is.null
[01:27:48.061]                       muffled <- FALSE
[01:27:48.061]                       if (inherits(cond, "message")) {
[01:27:48.061]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.061]                         if (muffled) 
[01:27:48.061]                           invokeRestart("muffleMessage")
[01:27:48.061]                       }
[01:27:48.061]                       else if (inherits(cond, "warning")) {
[01:27:48.061]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.061]                         if (muffled) 
[01:27:48.061]                           invokeRestart("muffleWarning")
[01:27:48.061]                       }
[01:27:48.061]                       else if (inherits(cond, "condition")) {
[01:27:48.061]                         if (!is.null(pattern)) {
[01:27:48.061]                           computeRestarts <- base::computeRestarts
[01:27:48.061]                           grepl <- base::grepl
[01:27:48.061]                           restarts <- computeRestarts(cond)
[01:27:48.061]                           for (restart in restarts) {
[01:27:48.061]                             name <- restart$name
[01:27:48.061]                             if (is.null(name)) 
[01:27:48.061]                               next
[01:27:48.061]                             if (!grepl(pattern, name)) 
[01:27:48.061]                               next
[01:27:48.061]                             invokeRestart(restart)
[01:27:48.061]                             muffled <- TRUE
[01:27:48.061]                             break
[01:27:48.061]                           }
[01:27:48.061]                         }
[01:27:48.061]                       }
[01:27:48.061]                       invisible(muffled)
[01:27:48.061]                     }
[01:27:48.061]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.061]                   }
[01:27:48.061]                 }
[01:27:48.061]             }
[01:27:48.061]         }))
[01:27:48.061]     }, error = function(ex) {
[01:27:48.061]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.061]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.061]                 ...future.rng), started = ...future.startTime, 
[01:27:48.061]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.061]             version = "1.8"), class = "FutureResult")
[01:27:48.061]     }, finally = {
[01:27:48.061]         if (!identical(...future.workdir, getwd())) 
[01:27:48.061]             setwd(...future.workdir)
[01:27:48.061]         {
[01:27:48.061]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.061]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.061]             }
[01:27:48.061]             base::options(...future.oldOptions)
[01:27:48.061]             if (.Platform$OS.type == "windows") {
[01:27:48.061]                 old_names <- names(...future.oldEnvVars)
[01:27:48.061]                 envs <- base::Sys.getenv()
[01:27:48.061]                 names <- names(envs)
[01:27:48.061]                 common <- intersect(names, old_names)
[01:27:48.061]                 added <- setdiff(names, old_names)
[01:27:48.061]                 removed <- setdiff(old_names, names)
[01:27:48.061]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.061]                   envs[common]]
[01:27:48.061]                 NAMES <- toupper(changed)
[01:27:48.061]                 args <- list()
[01:27:48.061]                 for (kk in seq_along(NAMES)) {
[01:27:48.061]                   name <- changed[[kk]]
[01:27:48.061]                   NAME <- NAMES[[kk]]
[01:27:48.061]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.061]                     next
[01:27:48.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.061]                 }
[01:27:48.061]                 NAMES <- toupper(added)
[01:27:48.061]                 for (kk in seq_along(NAMES)) {
[01:27:48.061]                   name <- added[[kk]]
[01:27:48.061]                   NAME <- NAMES[[kk]]
[01:27:48.061]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.061]                     next
[01:27:48.061]                   args[[name]] <- ""
[01:27:48.061]                 }
[01:27:48.061]                 NAMES <- toupper(removed)
[01:27:48.061]                 for (kk in seq_along(NAMES)) {
[01:27:48.061]                   name <- removed[[kk]]
[01:27:48.061]                   NAME <- NAMES[[kk]]
[01:27:48.061]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.061]                     next
[01:27:48.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.061]                 }
[01:27:48.061]                 if (length(args) > 0) 
[01:27:48.061]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.061]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.061]             }
[01:27:48.061]             else {
[01:27:48.061]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.061]             }
[01:27:48.061]             {
[01:27:48.061]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.061]                   0L) {
[01:27:48.061]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.061]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.061]                   base::options(opts)
[01:27:48.061]                 }
[01:27:48.061]                 {
[01:27:48.061]                   {
[01:27:48.061]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.061]                     NULL
[01:27:48.061]                   }
[01:27:48.061]                   options(future.plan = NULL)
[01:27:48.061]                   if (is.na(NA_character_)) 
[01:27:48.061]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.061]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.061]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.061]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.061]                     envir = parent.frame()) 
[01:27:48.061]                   {
[01:27:48.061]                     if (is.function(workers)) 
[01:27:48.061]                       workers <- workers()
[01:27:48.061]                     workers <- structure(as.integer(workers), 
[01:27:48.061]                       class = class(workers))
[01:27:48.061]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.061]                       workers >= 1)
[01:27:48.061]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.061]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.061]                     }
[01:27:48.061]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.061]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.061]                       envir = envir)
[01:27:48.061]                     if (!future$lazy) 
[01:27:48.061]                       future <- run(future)
[01:27:48.061]                     invisible(future)
[01:27:48.061]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.061]                 }
[01:27:48.061]             }
[01:27:48.061]         }
[01:27:48.061]     })
[01:27:48.061]     if (TRUE) {
[01:27:48.061]         base::sink(type = "output", split = FALSE)
[01:27:48.061]         if (TRUE) {
[01:27:48.061]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.061]         }
[01:27:48.061]         else {
[01:27:48.061]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.061]         }
[01:27:48.061]         base::close(...future.stdout)
[01:27:48.061]         ...future.stdout <- NULL
[01:27:48.061]     }
[01:27:48.061]     ...future.result$conditions <- ...future.conditions
[01:27:48.061]     ...future.result$finished <- base::Sys.time()
[01:27:48.061]     ...future.result
[01:27:48.061] }
[01:27:48.067] MultisessionFuture started
[01:27:48.068] - Launch lazy future ... done
[01:27:48.068] run() for 'MultisessionFuture' ... done
[01:27:48.068] getGlobalsAndPackages() ...
[01:27:48.068] Searching for globals...
[01:27:48.069] 
[01:27:48.069] Searching for globals ... DONE
[01:27:48.069] - globals: [0] <none>
[01:27:48.069] getGlobalsAndPackages() ... DONE
[01:27:48.070] run() for 'Future' ...
[01:27:48.070] - state: 'created'
[01:27:48.070] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.084] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.084] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.084]   - Field: 'node'
[01:27:48.085]   - Field: 'label'
[01:27:48.085]   - Field: 'local'
[01:27:48.085]   - Field: 'owner'
[01:27:48.085]   - Field: 'envir'
[01:27:48.085]   - Field: 'workers'
[01:27:48.086]   - Field: 'packages'
[01:27:48.086]   - Field: 'gc'
[01:27:48.086]   - Field: 'conditions'
[01:27:48.086]   - Field: 'persistent'
[01:27:48.086]   - Field: 'expr'
[01:27:48.087]   - Field: 'uuid'
[01:27:48.087]   - Field: 'seed'
[01:27:48.087]   - Field: 'version'
[01:27:48.087]   - Field: 'result'
[01:27:48.087]   - Field: 'asynchronous'
[01:27:48.087]   - Field: 'calls'
[01:27:48.088]   - Field: 'globals'
[01:27:48.088]   - Field: 'stdout'
[01:27:48.088]   - Field: 'earlySignal'
[01:27:48.088]   - Field: 'lazy'
[01:27:48.088]   - Field: 'state'
[01:27:48.088] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.089] - Launch lazy future ...
[01:27:48.089] Packages needed by the future expression (n = 0): <none>
[01:27:48.089] Packages needed by future strategies (n = 0): <none>
[01:27:48.090] {
[01:27:48.090]     {
[01:27:48.090]         {
[01:27:48.090]             ...future.startTime <- base::Sys.time()
[01:27:48.090]             {
[01:27:48.090]                 {
[01:27:48.090]                   {
[01:27:48.090]                     {
[01:27:48.090]                       base::local({
[01:27:48.090]                         has_future <- base::requireNamespace("future", 
[01:27:48.090]                           quietly = TRUE)
[01:27:48.090]                         if (has_future) {
[01:27:48.090]                           ns <- base::getNamespace("future")
[01:27:48.090]                           version <- ns[[".package"]][["version"]]
[01:27:48.090]                           if (is.null(version)) 
[01:27:48.090]                             version <- utils::packageVersion("future")
[01:27:48.090]                         }
[01:27:48.090]                         else {
[01:27:48.090]                           version <- NULL
[01:27:48.090]                         }
[01:27:48.090]                         if (!has_future || version < "1.8.0") {
[01:27:48.090]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.090]                             "", base::R.version$version.string), 
[01:27:48.090]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.090]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.090]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.090]                               "release", "version")], collapse = " "), 
[01:27:48.090]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.090]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.090]                             info)
[01:27:48.090]                           info <- base::paste(info, collapse = "; ")
[01:27:48.090]                           if (!has_future) {
[01:27:48.090]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.090]                               info)
[01:27:48.090]                           }
[01:27:48.090]                           else {
[01:27:48.090]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.090]                               info, version)
[01:27:48.090]                           }
[01:27:48.090]                           base::stop(msg)
[01:27:48.090]                         }
[01:27:48.090]                       })
[01:27:48.090]                     }
[01:27:48.090]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.090]                     base::options(mc.cores = 1L)
[01:27:48.090]                   }
[01:27:48.090]                   options(future.plan = NULL)
[01:27:48.090]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.090]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.090]                 }
[01:27:48.090]                 ...future.workdir <- getwd()
[01:27:48.090]             }
[01:27:48.090]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.090]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.090]         }
[01:27:48.090]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.090]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.090]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.090]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.090]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.090]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.090]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.090]             base::names(...future.oldOptions))
[01:27:48.090]     }
[01:27:48.090]     if (FALSE) {
[01:27:48.090]     }
[01:27:48.090]     else {
[01:27:48.090]         if (TRUE) {
[01:27:48.090]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.090]                 open = "w")
[01:27:48.090]         }
[01:27:48.090]         else {
[01:27:48.090]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.090]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.090]         }
[01:27:48.090]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.090]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.090]             base::sink(type = "output", split = FALSE)
[01:27:48.090]             base::close(...future.stdout)
[01:27:48.090]         }, add = TRUE)
[01:27:48.090]     }
[01:27:48.090]     ...future.frame <- base::sys.nframe()
[01:27:48.090]     ...future.conditions <- base::list()
[01:27:48.090]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.090]     if (FALSE) {
[01:27:48.090]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.090]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.090]     }
[01:27:48.090]     ...future.result <- base::tryCatch({
[01:27:48.090]         base::withCallingHandlers({
[01:27:48.090]             ...future.value <- base::withVisible(base::local({
[01:27:48.090]                 ...future.makeSendCondition <- base::local({
[01:27:48.090]                   sendCondition <- NULL
[01:27:48.090]                   function(frame = 1L) {
[01:27:48.090]                     if (is.function(sendCondition)) 
[01:27:48.090]                       return(sendCondition)
[01:27:48.090]                     ns <- getNamespace("parallel")
[01:27:48.090]                     if (exists("sendData", mode = "function", 
[01:27:48.090]                       envir = ns)) {
[01:27:48.090]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.090]                         envir = ns)
[01:27:48.090]                       envir <- sys.frame(frame)
[01:27:48.090]                       master <- NULL
[01:27:48.090]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.090]                         !identical(envir, emptyenv())) {
[01:27:48.090]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.090]                           inherits = FALSE)) {
[01:27:48.090]                           master <- get("master", mode = "list", 
[01:27:48.090]                             envir = envir, inherits = FALSE)
[01:27:48.090]                           if (inherits(master, c("SOCKnode", 
[01:27:48.090]                             "SOCK0node"))) {
[01:27:48.090]                             sendCondition <<- function(cond) {
[01:27:48.090]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.090]                                 success = TRUE)
[01:27:48.090]                               parallel_sendData(master, data)
[01:27:48.090]                             }
[01:27:48.090]                             return(sendCondition)
[01:27:48.090]                           }
[01:27:48.090]                         }
[01:27:48.090]                         frame <- frame + 1L
[01:27:48.090]                         envir <- sys.frame(frame)
[01:27:48.090]                       }
[01:27:48.090]                     }
[01:27:48.090]                     sendCondition <<- function(cond) NULL
[01:27:48.090]                   }
[01:27:48.090]                 })
[01:27:48.090]                 withCallingHandlers({
[01:27:48.090]                   NULL
[01:27:48.090]                 }, immediateCondition = function(cond) {
[01:27:48.090]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.090]                   sendCondition(cond)
[01:27:48.090]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.090]                   {
[01:27:48.090]                     inherits <- base::inherits
[01:27:48.090]                     invokeRestart <- base::invokeRestart
[01:27:48.090]                     is.null <- base::is.null
[01:27:48.090]                     muffled <- FALSE
[01:27:48.090]                     if (inherits(cond, "message")) {
[01:27:48.090]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.090]                       if (muffled) 
[01:27:48.090]                         invokeRestart("muffleMessage")
[01:27:48.090]                     }
[01:27:48.090]                     else if (inherits(cond, "warning")) {
[01:27:48.090]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.090]                       if (muffled) 
[01:27:48.090]                         invokeRestart("muffleWarning")
[01:27:48.090]                     }
[01:27:48.090]                     else if (inherits(cond, "condition")) {
[01:27:48.090]                       if (!is.null(pattern)) {
[01:27:48.090]                         computeRestarts <- base::computeRestarts
[01:27:48.090]                         grepl <- base::grepl
[01:27:48.090]                         restarts <- computeRestarts(cond)
[01:27:48.090]                         for (restart in restarts) {
[01:27:48.090]                           name <- restart$name
[01:27:48.090]                           if (is.null(name)) 
[01:27:48.090]                             next
[01:27:48.090]                           if (!grepl(pattern, name)) 
[01:27:48.090]                             next
[01:27:48.090]                           invokeRestart(restart)
[01:27:48.090]                           muffled <- TRUE
[01:27:48.090]                           break
[01:27:48.090]                         }
[01:27:48.090]                       }
[01:27:48.090]                     }
[01:27:48.090]                     invisible(muffled)
[01:27:48.090]                   }
[01:27:48.090]                   muffleCondition(cond)
[01:27:48.090]                 })
[01:27:48.090]             }))
[01:27:48.090]             future::FutureResult(value = ...future.value$value, 
[01:27:48.090]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.090]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.090]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.090]                     ...future.globalenv.names))
[01:27:48.090]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.090]         }, condition = base::local({
[01:27:48.090]             c <- base::c
[01:27:48.090]             inherits <- base::inherits
[01:27:48.090]             invokeRestart <- base::invokeRestart
[01:27:48.090]             length <- base::length
[01:27:48.090]             list <- base::list
[01:27:48.090]             seq.int <- base::seq.int
[01:27:48.090]             signalCondition <- base::signalCondition
[01:27:48.090]             sys.calls <- base::sys.calls
[01:27:48.090]             `[[` <- base::`[[`
[01:27:48.090]             `+` <- base::`+`
[01:27:48.090]             `<<-` <- base::`<<-`
[01:27:48.090]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.090]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.090]                   3L)]
[01:27:48.090]             }
[01:27:48.090]             function(cond) {
[01:27:48.090]                 is_error <- inherits(cond, "error")
[01:27:48.090]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.090]                   NULL)
[01:27:48.090]                 if (is_error) {
[01:27:48.090]                   sessionInformation <- function() {
[01:27:48.090]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.090]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.090]                       search = base::search(), system = base::Sys.info())
[01:27:48.090]                   }
[01:27:48.090]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.090]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.090]                     cond$call), session = sessionInformation(), 
[01:27:48.090]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.090]                   signalCondition(cond)
[01:27:48.090]                 }
[01:27:48.090]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.090]                 "immediateCondition"))) {
[01:27:48.090]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.090]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.090]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.090]                   if (TRUE && !signal) {
[01:27:48.090]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.090]                     {
[01:27:48.090]                       inherits <- base::inherits
[01:27:48.090]                       invokeRestart <- base::invokeRestart
[01:27:48.090]                       is.null <- base::is.null
[01:27:48.090]                       muffled <- FALSE
[01:27:48.090]                       if (inherits(cond, "message")) {
[01:27:48.090]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.090]                         if (muffled) 
[01:27:48.090]                           invokeRestart("muffleMessage")
[01:27:48.090]                       }
[01:27:48.090]                       else if (inherits(cond, "warning")) {
[01:27:48.090]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.090]                         if (muffled) 
[01:27:48.090]                           invokeRestart("muffleWarning")
[01:27:48.090]                       }
[01:27:48.090]                       else if (inherits(cond, "condition")) {
[01:27:48.090]                         if (!is.null(pattern)) {
[01:27:48.090]                           computeRestarts <- base::computeRestarts
[01:27:48.090]                           grepl <- base::grepl
[01:27:48.090]                           restarts <- computeRestarts(cond)
[01:27:48.090]                           for (restart in restarts) {
[01:27:48.090]                             name <- restart$name
[01:27:48.090]                             if (is.null(name)) 
[01:27:48.090]                               next
[01:27:48.090]                             if (!grepl(pattern, name)) 
[01:27:48.090]                               next
[01:27:48.090]                             invokeRestart(restart)
[01:27:48.090]                             muffled <- TRUE
[01:27:48.090]                             break
[01:27:48.090]                           }
[01:27:48.090]                         }
[01:27:48.090]                       }
[01:27:48.090]                       invisible(muffled)
[01:27:48.090]                     }
[01:27:48.090]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.090]                   }
[01:27:48.090]                 }
[01:27:48.090]                 else {
[01:27:48.090]                   if (TRUE) {
[01:27:48.090]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.090]                     {
[01:27:48.090]                       inherits <- base::inherits
[01:27:48.090]                       invokeRestart <- base::invokeRestart
[01:27:48.090]                       is.null <- base::is.null
[01:27:48.090]                       muffled <- FALSE
[01:27:48.090]                       if (inherits(cond, "message")) {
[01:27:48.090]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.090]                         if (muffled) 
[01:27:48.090]                           invokeRestart("muffleMessage")
[01:27:48.090]                       }
[01:27:48.090]                       else if (inherits(cond, "warning")) {
[01:27:48.090]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.090]                         if (muffled) 
[01:27:48.090]                           invokeRestart("muffleWarning")
[01:27:48.090]                       }
[01:27:48.090]                       else if (inherits(cond, "condition")) {
[01:27:48.090]                         if (!is.null(pattern)) {
[01:27:48.090]                           computeRestarts <- base::computeRestarts
[01:27:48.090]                           grepl <- base::grepl
[01:27:48.090]                           restarts <- computeRestarts(cond)
[01:27:48.090]                           for (restart in restarts) {
[01:27:48.090]                             name <- restart$name
[01:27:48.090]                             if (is.null(name)) 
[01:27:48.090]                               next
[01:27:48.090]                             if (!grepl(pattern, name)) 
[01:27:48.090]                               next
[01:27:48.090]                             invokeRestart(restart)
[01:27:48.090]                             muffled <- TRUE
[01:27:48.090]                             break
[01:27:48.090]                           }
[01:27:48.090]                         }
[01:27:48.090]                       }
[01:27:48.090]                       invisible(muffled)
[01:27:48.090]                     }
[01:27:48.090]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.090]                   }
[01:27:48.090]                 }
[01:27:48.090]             }
[01:27:48.090]         }))
[01:27:48.090]     }, error = function(ex) {
[01:27:48.090]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.090]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.090]                 ...future.rng), started = ...future.startTime, 
[01:27:48.090]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.090]             version = "1.8"), class = "FutureResult")
[01:27:48.090]     }, finally = {
[01:27:48.090]         if (!identical(...future.workdir, getwd())) 
[01:27:48.090]             setwd(...future.workdir)
[01:27:48.090]         {
[01:27:48.090]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.090]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.090]             }
[01:27:48.090]             base::options(...future.oldOptions)
[01:27:48.090]             if (.Platform$OS.type == "windows") {
[01:27:48.090]                 old_names <- names(...future.oldEnvVars)
[01:27:48.090]                 envs <- base::Sys.getenv()
[01:27:48.090]                 names <- names(envs)
[01:27:48.090]                 common <- intersect(names, old_names)
[01:27:48.090]                 added <- setdiff(names, old_names)
[01:27:48.090]                 removed <- setdiff(old_names, names)
[01:27:48.090]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.090]                   envs[common]]
[01:27:48.090]                 NAMES <- toupper(changed)
[01:27:48.090]                 args <- list()
[01:27:48.090]                 for (kk in seq_along(NAMES)) {
[01:27:48.090]                   name <- changed[[kk]]
[01:27:48.090]                   NAME <- NAMES[[kk]]
[01:27:48.090]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.090]                     next
[01:27:48.090]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.090]                 }
[01:27:48.090]                 NAMES <- toupper(added)
[01:27:48.090]                 for (kk in seq_along(NAMES)) {
[01:27:48.090]                   name <- added[[kk]]
[01:27:48.090]                   NAME <- NAMES[[kk]]
[01:27:48.090]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.090]                     next
[01:27:48.090]                   args[[name]] <- ""
[01:27:48.090]                 }
[01:27:48.090]                 NAMES <- toupper(removed)
[01:27:48.090]                 for (kk in seq_along(NAMES)) {
[01:27:48.090]                   name <- removed[[kk]]
[01:27:48.090]                   NAME <- NAMES[[kk]]
[01:27:48.090]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.090]                     next
[01:27:48.090]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.090]                 }
[01:27:48.090]                 if (length(args) > 0) 
[01:27:48.090]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.090]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.090]             }
[01:27:48.090]             else {
[01:27:48.090]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.090]             }
[01:27:48.090]             {
[01:27:48.090]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.090]                   0L) {
[01:27:48.090]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.090]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.090]                   base::options(opts)
[01:27:48.090]                 }
[01:27:48.090]                 {
[01:27:48.090]                   {
[01:27:48.090]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.090]                     NULL
[01:27:48.090]                   }
[01:27:48.090]                   options(future.plan = NULL)
[01:27:48.090]                   if (is.na(NA_character_)) 
[01:27:48.090]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.090]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.090]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.090]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.090]                     envir = parent.frame()) 
[01:27:48.090]                   {
[01:27:48.090]                     if (is.function(workers)) 
[01:27:48.090]                       workers <- workers()
[01:27:48.090]                     workers <- structure(as.integer(workers), 
[01:27:48.090]                       class = class(workers))
[01:27:48.090]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.090]                       workers >= 1)
[01:27:48.090]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.090]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.090]                     }
[01:27:48.090]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.090]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.090]                       envir = envir)
[01:27:48.090]                     if (!future$lazy) 
[01:27:48.090]                       future <- run(future)
[01:27:48.090]                     invisible(future)
[01:27:48.090]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.090]                 }
[01:27:48.090]             }
[01:27:48.090]         }
[01:27:48.090]     })
[01:27:48.090]     if (TRUE) {
[01:27:48.090]         base::sink(type = "output", split = FALSE)
[01:27:48.090]         if (TRUE) {
[01:27:48.090]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.090]         }
[01:27:48.090]         else {
[01:27:48.090]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.090]         }
[01:27:48.090]         base::close(...future.stdout)
[01:27:48.090]         ...future.stdout <- NULL
[01:27:48.090]     }
[01:27:48.090]     ...future.result$conditions <- ...future.conditions
[01:27:48.090]     ...future.result$finished <- base::Sys.time()
[01:27:48.090]     ...future.result
[01:27:48.090] }
[01:27:48.096] MultisessionFuture started
[01:27:48.096] - Launch lazy future ... done
[01:27:48.096] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0ae18768> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0b39cdc0> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0ae18768> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0b39cdc0> 
 $  : 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"
[01:27:48.102] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.103] - Validating connection of MultisessionFuture
[01:27:48.103] - received message: FutureResult
[01:27:48.103] - Received FutureResult
[01:27:48.103] - Erased future from FutureRegistry
[01:27:48.104] result() for ClusterFuture ...
[01:27:48.104] - result already collected: FutureResult
[01:27:48.104] result() for ClusterFuture ... done
[01:27:48.104] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:48.115] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.115] - Validating connection of MultisessionFuture
[01:27:48.115] - received message: FutureResult
[01:27:48.116] - Received FutureResult
[01:27:48.116] - Erased future from FutureRegistry
[01:27:48.116] result() for ClusterFuture ...
[01:27:48.116] - result already collected: FutureResult
[01:27:48.116] result() for ClusterFuture ... done
[01:27:48.119] 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" "" ...
[01:27:48.121] resolve() on list ...
[01:27:48.121]  recursive: 0
[01:27:48.121]  length: 6
[01:27:48.121]  elements: 'a', 'b', 'c', '', '', ''
[01:27:48.122] signalConditionsASAP(numeric, pos=1) ...
[01:27:48.122] - nx: 6
[01:27:48.122] - relay: TRUE
[01:27:48.122] - stdout: TRUE
[01:27:48.122] - signal: TRUE
[01:27:48.122] - resignal: FALSE
[01:27:48.122] - force: TRUE
[01:27:48.123] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.123] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.123]  - until=2
[01:27:48.123]  - relaying element #2
[01:27:48.123] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.123] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.124] signalConditionsASAP(NULL, pos=1) ... done
[01:27:48.124]  length: 5 (resolved future 1)
[01:27:48.124] Future #2
[01:27:48.124] result() for ClusterFuture ...
[01:27:48.124] - result already collected: FutureResult
[01:27:48.124] result() for ClusterFuture ... done
[01:27:48.125] result() for ClusterFuture ...
[01:27:48.125] - result already collected: FutureResult
[01:27:48.125] result() for ClusterFuture ... done
[01:27:48.125] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:48.125] - nx: 6
[01:27:48.125] - relay: TRUE
[01:27:48.126] - stdout: TRUE
[01:27:48.126] - signal: TRUE
[01:27:48.126] - resignal: FALSE
[01:27:48.126] - force: TRUE
[01:27:48.126] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.126] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.127]  - until=2
[01:27:48.127]  - relaying element #2
[01:27:48.127] result() for ClusterFuture ...
[01:27:48.127] - result already collected: FutureResult
[01:27:48.127] result() for ClusterFuture ... done
[01:27:48.127] result() for ClusterFuture ...
[01:27:48.127] - result already collected: FutureResult
[01:27:48.128] result() for ClusterFuture ... done
[01:27:48.128] result() for ClusterFuture ...
[01:27:48.128] - result already collected: FutureResult
[01:27:48.128] result() for ClusterFuture ... done
[01:27:48.128] result() for ClusterFuture ...
[01:27:48.128] - result already collected: FutureResult
[01:27:48.129] result() for ClusterFuture ... done
[01:27:48.129] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.129] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.129] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:48.129]  length: 4 (resolved future 2)
[01:27:48.130] Future #3
[01:27:48.130] result() for ClusterFuture ...
[01:27:48.130] - result already collected: FutureResult
[01:27:48.130] result() for ClusterFuture ... done
[01:27:48.130] result() for ClusterFuture ...
[01:27:48.130] - result already collected: FutureResult
[01:27:48.130] result() for ClusterFuture ... done
[01:27:48.131] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:48.131] - nx: 6
[01:27:48.131] - relay: TRUE
[01:27:48.131] - stdout: TRUE
[01:27:48.131] - signal: TRUE
[01:27:48.131] - resignal: FALSE
[01:27:48.132] - force: TRUE
[01:27:48.132] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.132] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.132]  - until=3
[01:27:48.132]  - relaying element #3
[01:27:48.132] result() for ClusterFuture ...
[01:27:48.132] - result already collected: FutureResult
[01:27:48.133] result() for ClusterFuture ... done
[01:27:48.133] result() for ClusterFuture ...
[01:27:48.133] - result already collected: FutureResult
[01:27:48.133] result() for ClusterFuture ... done
[01:27:48.133] result() for ClusterFuture ...
[01:27:48.134] - result already collected: FutureResult
[01:27:48.134] result() for ClusterFuture ... done
[01:27:48.134] result() for ClusterFuture ...
[01:27:48.134] - result already collected: FutureResult
[01:27:48.134] result() for ClusterFuture ... done
[01:27:48.134] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.134] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.135] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:48.135]  length: 3 (resolved future 3)
[01:27:48.135] signalConditionsASAP(NULL, pos=4) ...
[01:27:48.135] - nx: 6
[01:27:48.135] - relay: TRUE
[01:27:48.135] - stdout: TRUE
[01:27:48.136] - signal: TRUE
[01:27:48.136] - resignal: FALSE
[01:27:48.136] - force: TRUE
[01:27:48.136] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.136] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.136]  - until=5
[01:27:48.137]  - relaying element #5
[01:27:48.137] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.137] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.137] signalConditionsASAP(NULL, pos=4) ... done
[01:27:48.137]  length: 2 (resolved future 4)
[01:27:48.137] signalConditionsASAP(NULL, pos=5) ...
[01:27:48.138] - nx: 6
[01:27:48.138] - relay: TRUE
[01:27:48.138] - stdout: TRUE
[01:27:48.138] - signal: TRUE
[01:27:48.138] - resignal: FALSE
[01:27:48.138] - force: TRUE
[01:27:48.138] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.139] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.139]  - until=6
[01:27:48.139]  - relaying element #6
[01:27:48.139] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.139] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.139] signalConditionsASAP(NULL, pos=5) ... done
[01:27:48.140]  length: 1 (resolved future 5)
[01:27:48.140] signalConditionsASAP(numeric, pos=6) ...
[01:27:48.140] - nx: 6
[01:27:48.140] - relay: TRUE
[01:27:48.140] - stdout: TRUE
[01:27:48.140] - signal: TRUE
[01:27:48.141] - resignal: FALSE
[01:27:48.141] - force: TRUE
[01:27:48.141] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.141] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.141]  - until=6
[01:27:48.141] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.141] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.142] signalConditionsASAP(numeric, pos=6) ... done
[01:27:48.142]  length: 0 (resolved future 6)
[01:27:48.142] Relaying remaining futures
[01:27:48.142] signalConditionsASAP(NULL, pos=0) ...
[01:27:48.142] - nx: 6
[01:27:48.142] - relay: TRUE
[01:27:48.143] - stdout: TRUE
[01:27:48.143] - signal: TRUE
[01:27:48.143] - resignal: FALSE
[01:27:48.143] - force: TRUE
[01:27:48.143] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.143] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:48.144] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.144] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.144] signalConditionsASAP(NULL, pos=0) ... done
[01:27:48.144] resolve() on list ... DONE
[01:27:48.145] result() for ClusterFuture ...
[01:27:48.145] - result already collected: FutureResult
[01:27:48.145] result() for ClusterFuture ... done
[01:27:48.145] result() for ClusterFuture ...
[01:27:48.145] - result already collected: FutureResult
[01:27:48.145] result() for ClusterFuture ... done
[01:27:48.146] result() for ClusterFuture ...
[01:27:48.146] - result already collected: FutureResult
[01:27:48.146] result() for ClusterFuture ... done
[01:27:48.146] result() for ClusterFuture ...
[01:27:48.146] - result already collected: FutureResult
[01:27:48.147] 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)
[01:27:48.152] getGlobalsAndPackages() ...
[01:27:48.152] Searching for globals...
[01:27:48.153] 
[01:27:48.153] Searching for globals ... DONE
[01:27:48.153] - globals: [0] <none>
[01:27:48.153] getGlobalsAndPackages() ... DONE
[01:27:48.154] run() for 'Future' ...
[01:27:48.154] - state: 'created'
[01:27:48.154] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.169] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.169] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.169]   - Field: 'node'
[01:27:48.169]   - Field: 'label'
[01:27:48.170]   - Field: 'local'
[01:27:48.170]   - Field: 'owner'
[01:27:48.170]   - Field: 'envir'
[01:27:48.170]   - Field: 'workers'
[01:27:48.170]   - Field: 'packages'
[01:27:48.171]   - Field: 'gc'
[01:27:48.171]   - Field: 'conditions'
[01:27:48.171]   - Field: 'persistent'
[01:27:48.171]   - Field: 'expr'
[01:27:48.171]   - Field: 'uuid'
[01:27:48.171]   - Field: 'seed'
[01:27:48.172]   - Field: 'version'
[01:27:48.172]   - Field: 'result'
[01:27:48.172]   - Field: 'asynchronous'
[01:27:48.172]   - Field: 'calls'
[01:27:48.172]   - Field: 'globals'
[01:27:48.172]   - Field: 'stdout'
[01:27:48.173]   - Field: 'earlySignal'
[01:27:48.173]   - Field: 'lazy'
[01:27:48.173]   - Field: 'state'
[01:27:48.173] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.173] - Launch lazy future ...
[01:27:48.174] Packages needed by the future expression (n = 0): <none>
[01:27:48.174] Packages needed by future strategies (n = 0): <none>
[01:27:48.175] {
[01:27:48.175]     {
[01:27:48.175]         {
[01:27:48.175]             ...future.startTime <- base::Sys.time()
[01:27:48.175]             {
[01:27:48.175]                 {
[01:27:48.175]                   {
[01:27:48.175]                     {
[01:27:48.175]                       base::local({
[01:27:48.175]                         has_future <- base::requireNamespace("future", 
[01:27:48.175]                           quietly = TRUE)
[01:27:48.175]                         if (has_future) {
[01:27:48.175]                           ns <- base::getNamespace("future")
[01:27:48.175]                           version <- ns[[".package"]][["version"]]
[01:27:48.175]                           if (is.null(version)) 
[01:27:48.175]                             version <- utils::packageVersion("future")
[01:27:48.175]                         }
[01:27:48.175]                         else {
[01:27:48.175]                           version <- NULL
[01:27:48.175]                         }
[01:27:48.175]                         if (!has_future || version < "1.8.0") {
[01:27:48.175]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.175]                             "", base::R.version$version.string), 
[01:27:48.175]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.175]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.175]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.175]                               "release", "version")], collapse = " "), 
[01:27:48.175]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.175]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.175]                             info)
[01:27:48.175]                           info <- base::paste(info, collapse = "; ")
[01:27:48.175]                           if (!has_future) {
[01:27:48.175]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.175]                               info)
[01:27:48.175]                           }
[01:27:48.175]                           else {
[01:27:48.175]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.175]                               info, version)
[01:27:48.175]                           }
[01:27:48.175]                           base::stop(msg)
[01:27:48.175]                         }
[01:27:48.175]                       })
[01:27:48.175]                     }
[01:27:48.175]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.175]                     base::options(mc.cores = 1L)
[01:27:48.175]                   }
[01:27:48.175]                   options(future.plan = NULL)
[01:27:48.175]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.175]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.175]                 }
[01:27:48.175]                 ...future.workdir <- getwd()
[01:27:48.175]             }
[01:27:48.175]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.175]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.175]         }
[01:27:48.175]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.175]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.175]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.175]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.175]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.175]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.175]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.175]             base::names(...future.oldOptions))
[01:27:48.175]     }
[01:27:48.175]     if (FALSE) {
[01:27:48.175]     }
[01:27:48.175]     else {
[01:27:48.175]         if (TRUE) {
[01:27:48.175]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.175]                 open = "w")
[01:27:48.175]         }
[01:27:48.175]         else {
[01:27:48.175]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.175]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.175]         }
[01:27:48.175]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.175]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.175]             base::sink(type = "output", split = FALSE)
[01:27:48.175]             base::close(...future.stdout)
[01:27:48.175]         }, add = TRUE)
[01:27:48.175]     }
[01:27:48.175]     ...future.frame <- base::sys.nframe()
[01:27:48.175]     ...future.conditions <- base::list()
[01:27:48.175]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.175]     if (FALSE) {
[01:27:48.175]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.175]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.175]     }
[01:27:48.175]     ...future.result <- base::tryCatch({
[01:27:48.175]         base::withCallingHandlers({
[01:27:48.175]             ...future.value <- base::withVisible(base::local({
[01:27:48.175]                 ...future.makeSendCondition <- base::local({
[01:27:48.175]                   sendCondition <- NULL
[01:27:48.175]                   function(frame = 1L) {
[01:27:48.175]                     if (is.function(sendCondition)) 
[01:27:48.175]                       return(sendCondition)
[01:27:48.175]                     ns <- getNamespace("parallel")
[01:27:48.175]                     if (exists("sendData", mode = "function", 
[01:27:48.175]                       envir = ns)) {
[01:27:48.175]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.175]                         envir = ns)
[01:27:48.175]                       envir <- sys.frame(frame)
[01:27:48.175]                       master <- NULL
[01:27:48.175]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.175]                         !identical(envir, emptyenv())) {
[01:27:48.175]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.175]                           inherits = FALSE)) {
[01:27:48.175]                           master <- get("master", mode = "list", 
[01:27:48.175]                             envir = envir, inherits = FALSE)
[01:27:48.175]                           if (inherits(master, c("SOCKnode", 
[01:27:48.175]                             "SOCK0node"))) {
[01:27:48.175]                             sendCondition <<- function(cond) {
[01:27:48.175]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.175]                                 success = TRUE)
[01:27:48.175]                               parallel_sendData(master, data)
[01:27:48.175]                             }
[01:27:48.175]                             return(sendCondition)
[01:27:48.175]                           }
[01:27:48.175]                         }
[01:27:48.175]                         frame <- frame + 1L
[01:27:48.175]                         envir <- sys.frame(frame)
[01:27:48.175]                       }
[01:27:48.175]                     }
[01:27:48.175]                     sendCondition <<- function(cond) NULL
[01:27:48.175]                   }
[01:27:48.175]                 })
[01:27:48.175]                 withCallingHandlers({
[01:27:48.175]                   2
[01:27:48.175]                 }, immediateCondition = function(cond) {
[01:27:48.175]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.175]                   sendCondition(cond)
[01:27:48.175]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.175]                   {
[01:27:48.175]                     inherits <- base::inherits
[01:27:48.175]                     invokeRestart <- base::invokeRestart
[01:27:48.175]                     is.null <- base::is.null
[01:27:48.175]                     muffled <- FALSE
[01:27:48.175]                     if (inherits(cond, "message")) {
[01:27:48.175]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.175]                       if (muffled) 
[01:27:48.175]                         invokeRestart("muffleMessage")
[01:27:48.175]                     }
[01:27:48.175]                     else if (inherits(cond, "warning")) {
[01:27:48.175]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.175]                       if (muffled) 
[01:27:48.175]                         invokeRestart("muffleWarning")
[01:27:48.175]                     }
[01:27:48.175]                     else if (inherits(cond, "condition")) {
[01:27:48.175]                       if (!is.null(pattern)) {
[01:27:48.175]                         computeRestarts <- base::computeRestarts
[01:27:48.175]                         grepl <- base::grepl
[01:27:48.175]                         restarts <- computeRestarts(cond)
[01:27:48.175]                         for (restart in restarts) {
[01:27:48.175]                           name <- restart$name
[01:27:48.175]                           if (is.null(name)) 
[01:27:48.175]                             next
[01:27:48.175]                           if (!grepl(pattern, name)) 
[01:27:48.175]                             next
[01:27:48.175]                           invokeRestart(restart)
[01:27:48.175]                           muffled <- TRUE
[01:27:48.175]                           break
[01:27:48.175]                         }
[01:27:48.175]                       }
[01:27:48.175]                     }
[01:27:48.175]                     invisible(muffled)
[01:27:48.175]                   }
[01:27:48.175]                   muffleCondition(cond)
[01:27:48.175]                 })
[01:27:48.175]             }))
[01:27:48.175]             future::FutureResult(value = ...future.value$value, 
[01:27:48.175]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.175]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.175]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.175]                     ...future.globalenv.names))
[01:27:48.175]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.175]         }, condition = base::local({
[01:27:48.175]             c <- base::c
[01:27:48.175]             inherits <- base::inherits
[01:27:48.175]             invokeRestart <- base::invokeRestart
[01:27:48.175]             length <- base::length
[01:27:48.175]             list <- base::list
[01:27:48.175]             seq.int <- base::seq.int
[01:27:48.175]             signalCondition <- base::signalCondition
[01:27:48.175]             sys.calls <- base::sys.calls
[01:27:48.175]             `[[` <- base::`[[`
[01:27:48.175]             `+` <- base::`+`
[01:27:48.175]             `<<-` <- base::`<<-`
[01:27:48.175]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.175]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.175]                   3L)]
[01:27:48.175]             }
[01:27:48.175]             function(cond) {
[01:27:48.175]                 is_error <- inherits(cond, "error")
[01:27:48.175]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.175]                   NULL)
[01:27:48.175]                 if (is_error) {
[01:27:48.175]                   sessionInformation <- function() {
[01:27:48.175]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.175]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.175]                       search = base::search(), system = base::Sys.info())
[01:27:48.175]                   }
[01:27:48.175]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.175]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.175]                     cond$call), session = sessionInformation(), 
[01:27:48.175]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.175]                   signalCondition(cond)
[01:27:48.175]                 }
[01:27:48.175]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.175]                 "immediateCondition"))) {
[01:27:48.175]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.175]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.175]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.175]                   if (TRUE && !signal) {
[01:27:48.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.175]                     {
[01:27:48.175]                       inherits <- base::inherits
[01:27:48.175]                       invokeRestart <- base::invokeRestart
[01:27:48.175]                       is.null <- base::is.null
[01:27:48.175]                       muffled <- FALSE
[01:27:48.175]                       if (inherits(cond, "message")) {
[01:27:48.175]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.175]                         if (muffled) 
[01:27:48.175]                           invokeRestart("muffleMessage")
[01:27:48.175]                       }
[01:27:48.175]                       else if (inherits(cond, "warning")) {
[01:27:48.175]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.175]                         if (muffled) 
[01:27:48.175]                           invokeRestart("muffleWarning")
[01:27:48.175]                       }
[01:27:48.175]                       else if (inherits(cond, "condition")) {
[01:27:48.175]                         if (!is.null(pattern)) {
[01:27:48.175]                           computeRestarts <- base::computeRestarts
[01:27:48.175]                           grepl <- base::grepl
[01:27:48.175]                           restarts <- computeRestarts(cond)
[01:27:48.175]                           for (restart in restarts) {
[01:27:48.175]                             name <- restart$name
[01:27:48.175]                             if (is.null(name)) 
[01:27:48.175]                               next
[01:27:48.175]                             if (!grepl(pattern, name)) 
[01:27:48.175]                               next
[01:27:48.175]                             invokeRestart(restart)
[01:27:48.175]                             muffled <- TRUE
[01:27:48.175]                             break
[01:27:48.175]                           }
[01:27:48.175]                         }
[01:27:48.175]                       }
[01:27:48.175]                       invisible(muffled)
[01:27:48.175]                     }
[01:27:48.175]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.175]                   }
[01:27:48.175]                 }
[01:27:48.175]                 else {
[01:27:48.175]                   if (TRUE) {
[01:27:48.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.175]                     {
[01:27:48.175]                       inherits <- base::inherits
[01:27:48.175]                       invokeRestart <- base::invokeRestart
[01:27:48.175]                       is.null <- base::is.null
[01:27:48.175]                       muffled <- FALSE
[01:27:48.175]                       if (inherits(cond, "message")) {
[01:27:48.175]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.175]                         if (muffled) 
[01:27:48.175]                           invokeRestart("muffleMessage")
[01:27:48.175]                       }
[01:27:48.175]                       else if (inherits(cond, "warning")) {
[01:27:48.175]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.175]                         if (muffled) 
[01:27:48.175]                           invokeRestart("muffleWarning")
[01:27:48.175]                       }
[01:27:48.175]                       else if (inherits(cond, "condition")) {
[01:27:48.175]                         if (!is.null(pattern)) {
[01:27:48.175]                           computeRestarts <- base::computeRestarts
[01:27:48.175]                           grepl <- base::grepl
[01:27:48.175]                           restarts <- computeRestarts(cond)
[01:27:48.175]                           for (restart in restarts) {
[01:27:48.175]                             name <- restart$name
[01:27:48.175]                             if (is.null(name)) 
[01:27:48.175]                               next
[01:27:48.175]                             if (!grepl(pattern, name)) 
[01:27:48.175]                               next
[01:27:48.175]                             invokeRestart(restart)
[01:27:48.175]                             muffled <- TRUE
[01:27:48.175]                             break
[01:27:48.175]                           }
[01:27:48.175]                         }
[01:27:48.175]                       }
[01:27:48.175]                       invisible(muffled)
[01:27:48.175]                     }
[01:27:48.175]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.175]                   }
[01:27:48.175]                 }
[01:27:48.175]             }
[01:27:48.175]         }))
[01:27:48.175]     }, error = function(ex) {
[01:27:48.175]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.175]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.175]                 ...future.rng), started = ...future.startTime, 
[01:27:48.175]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.175]             version = "1.8"), class = "FutureResult")
[01:27:48.175]     }, finally = {
[01:27:48.175]         if (!identical(...future.workdir, getwd())) 
[01:27:48.175]             setwd(...future.workdir)
[01:27:48.175]         {
[01:27:48.175]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.175]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.175]             }
[01:27:48.175]             base::options(...future.oldOptions)
[01:27:48.175]             if (.Platform$OS.type == "windows") {
[01:27:48.175]                 old_names <- names(...future.oldEnvVars)
[01:27:48.175]                 envs <- base::Sys.getenv()
[01:27:48.175]                 names <- names(envs)
[01:27:48.175]                 common <- intersect(names, old_names)
[01:27:48.175]                 added <- setdiff(names, old_names)
[01:27:48.175]                 removed <- setdiff(old_names, names)
[01:27:48.175]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.175]                   envs[common]]
[01:27:48.175]                 NAMES <- toupper(changed)
[01:27:48.175]                 args <- list()
[01:27:48.175]                 for (kk in seq_along(NAMES)) {
[01:27:48.175]                   name <- changed[[kk]]
[01:27:48.175]                   NAME <- NAMES[[kk]]
[01:27:48.175]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.175]                     next
[01:27:48.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.175]                 }
[01:27:48.175]                 NAMES <- toupper(added)
[01:27:48.175]                 for (kk in seq_along(NAMES)) {
[01:27:48.175]                   name <- added[[kk]]
[01:27:48.175]                   NAME <- NAMES[[kk]]
[01:27:48.175]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.175]                     next
[01:27:48.175]                   args[[name]] <- ""
[01:27:48.175]                 }
[01:27:48.175]                 NAMES <- toupper(removed)
[01:27:48.175]                 for (kk in seq_along(NAMES)) {
[01:27:48.175]                   name <- removed[[kk]]
[01:27:48.175]                   NAME <- NAMES[[kk]]
[01:27:48.175]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.175]                     next
[01:27:48.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.175]                 }
[01:27:48.175]                 if (length(args) > 0) 
[01:27:48.175]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.175]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.175]             }
[01:27:48.175]             else {
[01:27:48.175]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.175]             }
[01:27:48.175]             {
[01:27:48.175]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.175]                   0L) {
[01:27:48.175]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.175]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.175]                   base::options(opts)
[01:27:48.175]                 }
[01:27:48.175]                 {
[01:27:48.175]                   {
[01:27:48.175]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.175]                     NULL
[01:27:48.175]                   }
[01:27:48.175]                   options(future.plan = NULL)
[01:27:48.175]                   if (is.na(NA_character_)) 
[01:27:48.175]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.175]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.175]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.175]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.175]                     envir = parent.frame()) 
[01:27:48.175]                   {
[01:27:48.175]                     if (is.function(workers)) 
[01:27:48.175]                       workers <- workers()
[01:27:48.175]                     workers <- structure(as.integer(workers), 
[01:27:48.175]                       class = class(workers))
[01:27:48.175]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.175]                       workers >= 1)
[01:27:48.175]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.175]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.175]                     }
[01:27:48.175]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.175]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.175]                       envir = envir)
[01:27:48.175]                     if (!future$lazy) 
[01:27:48.175]                       future <- run(future)
[01:27:48.175]                     invisible(future)
[01:27:48.175]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.175]                 }
[01:27:48.175]             }
[01:27:48.175]         }
[01:27:48.175]     })
[01:27:48.175]     if (TRUE) {
[01:27:48.175]         base::sink(type = "output", split = FALSE)
[01:27:48.175]         if (TRUE) {
[01:27:48.175]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.175]         }
[01:27:48.175]         else {
[01:27:48.175]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.175]         }
[01:27:48.175]         base::close(...future.stdout)
[01:27:48.175]         ...future.stdout <- NULL
[01:27:48.175]     }
[01:27:48.175]     ...future.result$conditions <- ...future.conditions
[01:27:48.175]     ...future.result$finished <- base::Sys.time()
[01:27:48.175]     ...future.result
[01:27:48.175] }
[01:27:48.181] MultisessionFuture started
[01:27:48.181] - Launch lazy future ... done
[01:27:48.181] run() for 'MultisessionFuture' ... done
[01:27:48.181] getGlobalsAndPackages() ...
[01:27:48.181] Searching for globals...
[01:27:48.182] 
[01:27:48.182] Searching for globals ... DONE
[01:27:48.182] - globals: [0] <none>
[01:27:48.182] getGlobalsAndPackages() ... DONE
[01:27:48.183] run() for 'Future' ...
[01:27:48.183] - state: 'created'
[01:27:48.183] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.197] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.197] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.198]   - Field: 'node'
[01:27:48.198]   - Field: 'label'
[01:27:48.198]   - Field: 'local'
[01:27:48.198]   - Field: 'owner'
[01:27:48.198]   - Field: 'envir'
[01:27:48.199]   - Field: 'workers'
[01:27:48.199]   - Field: 'packages'
[01:27:48.199]   - Field: 'gc'
[01:27:48.199]   - Field: 'conditions'
[01:27:48.199]   - Field: 'persistent'
[01:27:48.199]   - Field: 'expr'
[01:27:48.200]   - Field: 'uuid'
[01:27:48.200]   - Field: 'seed'
[01:27:48.200]   - Field: 'version'
[01:27:48.200]   - Field: 'result'
[01:27:48.200]   - Field: 'asynchronous'
[01:27:48.200]   - Field: 'calls'
[01:27:48.201]   - Field: 'globals'
[01:27:48.201]   - Field: 'stdout'
[01:27:48.201]   - Field: 'earlySignal'
[01:27:48.201]   - Field: 'lazy'
[01:27:48.201]   - Field: 'state'
[01:27:48.202] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.202] - Launch lazy future ...
[01:27:48.202] Packages needed by the future expression (n = 0): <none>
[01:27:48.202] Packages needed by future strategies (n = 0): <none>
[01:27:48.203] {
[01:27:48.203]     {
[01:27:48.203]         {
[01:27:48.203]             ...future.startTime <- base::Sys.time()
[01:27:48.203]             {
[01:27:48.203]                 {
[01:27:48.203]                   {
[01:27:48.203]                     {
[01:27:48.203]                       base::local({
[01:27:48.203]                         has_future <- base::requireNamespace("future", 
[01:27:48.203]                           quietly = TRUE)
[01:27:48.203]                         if (has_future) {
[01:27:48.203]                           ns <- base::getNamespace("future")
[01:27:48.203]                           version <- ns[[".package"]][["version"]]
[01:27:48.203]                           if (is.null(version)) 
[01:27:48.203]                             version <- utils::packageVersion("future")
[01:27:48.203]                         }
[01:27:48.203]                         else {
[01:27:48.203]                           version <- NULL
[01:27:48.203]                         }
[01:27:48.203]                         if (!has_future || version < "1.8.0") {
[01:27:48.203]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.203]                             "", base::R.version$version.string), 
[01:27:48.203]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.203]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.203]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.203]                               "release", "version")], collapse = " "), 
[01:27:48.203]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.203]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.203]                             info)
[01:27:48.203]                           info <- base::paste(info, collapse = "; ")
[01:27:48.203]                           if (!has_future) {
[01:27:48.203]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.203]                               info)
[01:27:48.203]                           }
[01:27:48.203]                           else {
[01:27:48.203]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.203]                               info, version)
[01:27:48.203]                           }
[01:27:48.203]                           base::stop(msg)
[01:27:48.203]                         }
[01:27:48.203]                       })
[01:27:48.203]                     }
[01:27:48.203]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.203]                     base::options(mc.cores = 1L)
[01:27:48.203]                   }
[01:27:48.203]                   options(future.plan = NULL)
[01:27:48.203]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.203]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.203]                 }
[01:27:48.203]                 ...future.workdir <- getwd()
[01:27:48.203]             }
[01:27:48.203]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.203]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.203]         }
[01:27:48.203]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.203]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.203]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.203]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.203]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.203]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.203]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.203]             base::names(...future.oldOptions))
[01:27:48.203]     }
[01:27:48.203]     if (FALSE) {
[01:27:48.203]     }
[01:27:48.203]     else {
[01:27:48.203]         if (TRUE) {
[01:27:48.203]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.203]                 open = "w")
[01:27:48.203]         }
[01:27:48.203]         else {
[01:27:48.203]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.203]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.203]         }
[01:27:48.203]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.203]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.203]             base::sink(type = "output", split = FALSE)
[01:27:48.203]             base::close(...future.stdout)
[01:27:48.203]         }, add = TRUE)
[01:27:48.203]     }
[01:27:48.203]     ...future.frame <- base::sys.nframe()
[01:27:48.203]     ...future.conditions <- base::list()
[01:27:48.203]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.203]     if (FALSE) {
[01:27:48.203]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.203]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.203]     }
[01:27:48.203]     ...future.result <- base::tryCatch({
[01:27:48.203]         base::withCallingHandlers({
[01:27:48.203]             ...future.value <- base::withVisible(base::local({
[01:27:48.203]                 ...future.makeSendCondition <- base::local({
[01:27:48.203]                   sendCondition <- NULL
[01:27:48.203]                   function(frame = 1L) {
[01:27:48.203]                     if (is.function(sendCondition)) 
[01:27:48.203]                       return(sendCondition)
[01:27:48.203]                     ns <- getNamespace("parallel")
[01:27:48.203]                     if (exists("sendData", mode = "function", 
[01:27:48.203]                       envir = ns)) {
[01:27:48.203]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.203]                         envir = ns)
[01:27:48.203]                       envir <- sys.frame(frame)
[01:27:48.203]                       master <- NULL
[01:27:48.203]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.203]                         !identical(envir, emptyenv())) {
[01:27:48.203]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.203]                           inherits = FALSE)) {
[01:27:48.203]                           master <- get("master", mode = "list", 
[01:27:48.203]                             envir = envir, inherits = FALSE)
[01:27:48.203]                           if (inherits(master, c("SOCKnode", 
[01:27:48.203]                             "SOCK0node"))) {
[01:27:48.203]                             sendCondition <<- function(cond) {
[01:27:48.203]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.203]                                 success = TRUE)
[01:27:48.203]                               parallel_sendData(master, data)
[01:27:48.203]                             }
[01:27:48.203]                             return(sendCondition)
[01:27:48.203]                           }
[01:27:48.203]                         }
[01:27:48.203]                         frame <- frame + 1L
[01:27:48.203]                         envir <- sys.frame(frame)
[01:27:48.203]                       }
[01:27:48.203]                     }
[01:27:48.203]                     sendCondition <<- function(cond) NULL
[01:27:48.203]                   }
[01:27:48.203]                 })
[01:27:48.203]                 withCallingHandlers({
[01:27:48.203]                   NULL
[01:27:48.203]                 }, immediateCondition = function(cond) {
[01:27:48.203]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.203]                   sendCondition(cond)
[01:27:48.203]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.203]                   {
[01:27:48.203]                     inherits <- base::inherits
[01:27:48.203]                     invokeRestart <- base::invokeRestart
[01:27:48.203]                     is.null <- base::is.null
[01:27:48.203]                     muffled <- FALSE
[01:27:48.203]                     if (inherits(cond, "message")) {
[01:27:48.203]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.203]                       if (muffled) 
[01:27:48.203]                         invokeRestart("muffleMessage")
[01:27:48.203]                     }
[01:27:48.203]                     else if (inherits(cond, "warning")) {
[01:27:48.203]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.203]                       if (muffled) 
[01:27:48.203]                         invokeRestart("muffleWarning")
[01:27:48.203]                     }
[01:27:48.203]                     else if (inherits(cond, "condition")) {
[01:27:48.203]                       if (!is.null(pattern)) {
[01:27:48.203]                         computeRestarts <- base::computeRestarts
[01:27:48.203]                         grepl <- base::grepl
[01:27:48.203]                         restarts <- computeRestarts(cond)
[01:27:48.203]                         for (restart in restarts) {
[01:27:48.203]                           name <- restart$name
[01:27:48.203]                           if (is.null(name)) 
[01:27:48.203]                             next
[01:27:48.203]                           if (!grepl(pattern, name)) 
[01:27:48.203]                             next
[01:27:48.203]                           invokeRestart(restart)
[01:27:48.203]                           muffled <- TRUE
[01:27:48.203]                           break
[01:27:48.203]                         }
[01:27:48.203]                       }
[01:27:48.203]                     }
[01:27:48.203]                     invisible(muffled)
[01:27:48.203]                   }
[01:27:48.203]                   muffleCondition(cond)
[01:27:48.203]                 })
[01:27:48.203]             }))
[01:27:48.203]             future::FutureResult(value = ...future.value$value, 
[01:27:48.203]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.203]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.203]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.203]                     ...future.globalenv.names))
[01:27:48.203]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.203]         }, condition = base::local({
[01:27:48.203]             c <- base::c
[01:27:48.203]             inherits <- base::inherits
[01:27:48.203]             invokeRestart <- base::invokeRestart
[01:27:48.203]             length <- base::length
[01:27:48.203]             list <- base::list
[01:27:48.203]             seq.int <- base::seq.int
[01:27:48.203]             signalCondition <- base::signalCondition
[01:27:48.203]             sys.calls <- base::sys.calls
[01:27:48.203]             `[[` <- base::`[[`
[01:27:48.203]             `+` <- base::`+`
[01:27:48.203]             `<<-` <- base::`<<-`
[01:27:48.203]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.203]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.203]                   3L)]
[01:27:48.203]             }
[01:27:48.203]             function(cond) {
[01:27:48.203]                 is_error <- inherits(cond, "error")
[01:27:48.203]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.203]                   NULL)
[01:27:48.203]                 if (is_error) {
[01:27:48.203]                   sessionInformation <- function() {
[01:27:48.203]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.203]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.203]                       search = base::search(), system = base::Sys.info())
[01:27:48.203]                   }
[01:27:48.203]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.203]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.203]                     cond$call), session = sessionInformation(), 
[01:27:48.203]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.203]                   signalCondition(cond)
[01:27:48.203]                 }
[01:27:48.203]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.203]                 "immediateCondition"))) {
[01:27:48.203]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.203]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.203]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.203]                   if (TRUE && !signal) {
[01:27:48.203]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.203]                     {
[01:27:48.203]                       inherits <- base::inherits
[01:27:48.203]                       invokeRestart <- base::invokeRestart
[01:27:48.203]                       is.null <- base::is.null
[01:27:48.203]                       muffled <- FALSE
[01:27:48.203]                       if (inherits(cond, "message")) {
[01:27:48.203]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.203]                         if (muffled) 
[01:27:48.203]                           invokeRestart("muffleMessage")
[01:27:48.203]                       }
[01:27:48.203]                       else if (inherits(cond, "warning")) {
[01:27:48.203]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.203]                         if (muffled) 
[01:27:48.203]                           invokeRestart("muffleWarning")
[01:27:48.203]                       }
[01:27:48.203]                       else if (inherits(cond, "condition")) {
[01:27:48.203]                         if (!is.null(pattern)) {
[01:27:48.203]                           computeRestarts <- base::computeRestarts
[01:27:48.203]                           grepl <- base::grepl
[01:27:48.203]                           restarts <- computeRestarts(cond)
[01:27:48.203]                           for (restart in restarts) {
[01:27:48.203]                             name <- restart$name
[01:27:48.203]                             if (is.null(name)) 
[01:27:48.203]                               next
[01:27:48.203]                             if (!grepl(pattern, name)) 
[01:27:48.203]                               next
[01:27:48.203]                             invokeRestart(restart)
[01:27:48.203]                             muffled <- TRUE
[01:27:48.203]                             break
[01:27:48.203]                           }
[01:27:48.203]                         }
[01:27:48.203]                       }
[01:27:48.203]                       invisible(muffled)
[01:27:48.203]                     }
[01:27:48.203]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.203]                   }
[01:27:48.203]                 }
[01:27:48.203]                 else {
[01:27:48.203]                   if (TRUE) {
[01:27:48.203]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.203]                     {
[01:27:48.203]                       inherits <- base::inherits
[01:27:48.203]                       invokeRestart <- base::invokeRestart
[01:27:48.203]                       is.null <- base::is.null
[01:27:48.203]                       muffled <- FALSE
[01:27:48.203]                       if (inherits(cond, "message")) {
[01:27:48.203]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.203]                         if (muffled) 
[01:27:48.203]                           invokeRestart("muffleMessage")
[01:27:48.203]                       }
[01:27:48.203]                       else if (inherits(cond, "warning")) {
[01:27:48.203]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.203]                         if (muffled) 
[01:27:48.203]                           invokeRestart("muffleWarning")
[01:27:48.203]                       }
[01:27:48.203]                       else if (inherits(cond, "condition")) {
[01:27:48.203]                         if (!is.null(pattern)) {
[01:27:48.203]                           computeRestarts <- base::computeRestarts
[01:27:48.203]                           grepl <- base::grepl
[01:27:48.203]                           restarts <- computeRestarts(cond)
[01:27:48.203]                           for (restart in restarts) {
[01:27:48.203]                             name <- restart$name
[01:27:48.203]                             if (is.null(name)) 
[01:27:48.203]                               next
[01:27:48.203]                             if (!grepl(pattern, name)) 
[01:27:48.203]                               next
[01:27:48.203]                             invokeRestart(restart)
[01:27:48.203]                             muffled <- TRUE
[01:27:48.203]                             break
[01:27:48.203]                           }
[01:27:48.203]                         }
[01:27:48.203]                       }
[01:27:48.203]                       invisible(muffled)
[01:27:48.203]                     }
[01:27:48.203]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.203]                   }
[01:27:48.203]                 }
[01:27:48.203]             }
[01:27:48.203]         }))
[01:27:48.203]     }, error = function(ex) {
[01:27:48.203]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.203]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.203]                 ...future.rng), started = ...future.startTime, 
[01:27:48.203]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.203]             version = "1.8"), class = "FutureResult")
[01:27:48.203]     }, finally = {
[01:27:48.203]         if (!identical(...future.workdir, getwd())) 
[01:27:48.203]             setwd(...future.workdir)
[01:27:48.203]         {
[01:27:48.203]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.203]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.203]             }
[01:27:48.203]             base::options(...future.oldOptions)
[01:27:48.203]             if (.Platform$OS.type == "windows") {
[01:27:48.203]                 old_names <- names(...future.oldEnvVars)
[01:27:48.203]                 envs <- base::Sys.getenv()
[01:27:48.203]                 names <- names(envs)
[01:27:48.203]                 common <- intersect(names, old_names)
[01:27:48.203]                 added <- setdiff(names, old_names)
[01:27:48.203]                 removed <- setdiff(old_names, names)
[01:27:48.203]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.203]                   envs[common]]
[01:27:48.203]                 NAMES <- toupper(changed)
[01:27:48.203]                 args <- list()
[01:27:48.203]                 for (kk in seq_along(NAMES)) {
[01:27:48.203]                   name <- changed[[kk]]
[01:27:48.203]                   NAME <- NAMES[[kk]]
[01:27:48.203]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.203]                     next
[01:27:48.203]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.203]                 }
[01:27:48.203]                 NAMES <- toupper(added)
[01:27:48.203]                 for (kk in seq_along(NAMES)) {
[01:27:48.203]                   name <- added[[kk]]
[01:27:48.203]                   NAME <- NAMES[[kk]]
[01:27:48.203]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.203]                     next
[01:27:48.203]                   args[[name]] <- ""
[01:27:48.203]                 }
[01:27:48.203]                 NAMES <- toupper(removed)
[01:27:48.203]                 for (kk in seq_along(NAMES)) {
[01:27:48.203]                   name <- removed[[kk]]
[01:27:48.203]                   NAME <- NAMES[[kk]]
[01:27:48.203]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.203]                     next
[01:27:48.203]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.203]                 }
[01:27:48.203]                 if (length(args) > 0) 
[01:27:48.203]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.203]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.203]             }
[01:27:48.203]             else {
[01:27:48.203]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.203]             }
[01:27:48.203]             {
[01:27:48.203]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.203]                   0L) {
[01:27:48.203]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.203]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.203]                   base::options(opts)
[01:27:48.203]                 }
[01:27:48.203]                 {
[01:27:48.203]                   {
[01:27:48.203]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.203]                     NULL
[01:27:48.203]                   }
[01:27:48.203]                   options(future.plan = NULL)
[01:27:48.203]                   if (is.na(NA_character_)) 
[01:27:48.203]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.203]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.203]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.203]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.203]                     envir = parent.frame()) 
[01:27:48.203]                   {
[01:27:48.203]                     if (is.function(workers)) 
[01:27:48.203]                       workers <- workers()
[01:27:48.203]                     workers <- structure(as.integer(workers), 
[01:27:48.203]                       class = class(workers))
[01:27:48.203]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.203]                       workers >= 1)
[01:27:48.203]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.203]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.203]                     }
[01:27:48.203]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.203]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.203]                       envir = envir)
[01:27:48.203]                     if (!future$lazy) 
[01:27:48.203]                       future <- run(future)
[01:27:48.203]                     invisible(future)
[01:27:48.203]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.203]                 }
[01:27:48.203]             }
[01:27:48.203]         }
[01:27:48.203]     })
[01:27:48.203]     if (TRUE) {
[01:27:48.203]         base::sink(type = "output", split = FALSE)
[01:27:48.203]         if (TRUE) {
[01:27:48.203]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.203]         }
[01:27:48.203]         else {
[01:27:48.203]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.203]         }
[01:27:48.203]         base::close(...future.stdout)
[01:27:48.203]         ...future.stdout <- NULL
[01:27:48.203]     }
[01:27:48.203]     ...future.result$conditions <- ...future.conditions
[01:27:48.203]     ...future.result$finished <- base::Sys.time()
[01:27:48.203]     ...future.result
[01:27:48.203] }
[01:27:48.208] MultisessionFuture started
[01:27:48.209] - Launch lazy future ... done
[01:27:48.209] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b04af4ae8> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0a1108f0> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b04af4ae8> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0a1108f0> 
 $  : 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"
[01:27:48.215] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.216] - Validating connection of MultisessionFuture
[01:27:48.216] - received message: FutureResult
[01:27:48.216] - Received FutureResult
[01:27:48.216] - Erased future from FutureRegistry
[01:27:48.217] result() for ClusterFuture ...
[01:27:48.217] - result already collected: FutureResult
[01:27:48.217] result() for ClusterFuture ... done
[01:27:48.217] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:48.233] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.233] - Validating connection of MultisessionFuture
[01:27:48.233] - received message: FutureResult
[01:27:48.233] - Received FutureResult
[01:27:48.234] - Erased future from FutureRegistry
[01:27:48.234] result() for ClusterFuture ...
[01:27:48.234] - result already collected: FutureResult
[01:27:48.234] result() for ClusterFuture ... done
[01:27:48.234] 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" "" ...
[01:27:48.237] resolve() on list ...
[01:27:48.237]  recursive: 0
[01:27:48.237]  length: 6
[01:27:48.237]  elements: 'a', 'b', 'c', '', '', ''
[01:27:48.237] signalConditionsASAP(numeric, pos=1) ...
[01:27:48.238] - nx: 6
[01:27:48.238] - relay: TRUE
[01:27:48.238] - stdout: TRUE
[01:27:48.238] - signal: TRUE
[01:27:48.238] - resignal: FALSE
[01:27:48.238] - force: TRUE
[01:27:48.239] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.239] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.239]  - until=2
[01:27:48.239]  - relaying element #2
[01:27:48.239] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.239] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.240] signalConditionsASAP(NULL, pos=1) ... done
[01:27:48.240]  length: 5 (resolved future 1)
[01:27:48.240] Future #2
[01:27:48.240] result() for ClusterFuture ...
[01:27:48.240] - result already collected: FutureResult
[01:27:48.240] result() for ClusterFuture ... done
[01:27:48.241] result() for ClusterFuture ...
[01:27:48.241] - result already collected: FutureResult
[01:27:48.241] result() for ClusterFuture ... done
[01:27:48.241] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:48.241] - nx: 6
[01:27:48.242] - relay: TRUE
[01:27:48.242] - stdout: TRUE
[01:27:48.242] - signal: TRUE
[01:27:48.242] - resignal: FALSE
[01:27:48.242] - force: TRUE
[01:27:48.242] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.243] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.243]  - until=2
[01:27:48.243]  - relaying element #2
[01:27:48.243] result() for ClusterFuture ...
[01:27:48.243] - result already collected: FutureResult
[01:27:48.243] result() for ClusterFuture ... done
[01:27:48.244] result() for ClusterFuture ...
[01:27:48.244] - result already collected: FutureResult
[01:27:48.244] result() for ClusterFuture ... done
[01:27:48.244] result() for ClusterFuture ...
[01:27:48.244] - result already collected: FutureResult
[01:27:48.244] result() for ClusterFuture ... done
[01:27:48.245] result() for ClusterFuture ...
[01:27:48.245] - result already collected: FutureResult
[01:27:48.245] result() for ClusterFuture ... done
[01:27:48.245] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.245] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.245] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:48.246]  length: 4 (resolved future 2)
[01:27:48.246] Future #3
[01:27:48.246] result() for ClusterFuture ...
[01:27:48.246] - result already collected: FutureResult
[01:27:48.246] result() for ClusterFuture ... done
[01:27:48.246] result() for ClusterFuture ...
[01:27:48.246] - result already collected: FutureResult
[01:27:48.247] result() for ClusterFuture ... done
[01:27:48.247] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:48.247] - nx: 6
[01:27:48.247] - relay: TRUE
[01:27:48.247] - stdout: TRUE
[01:27:48.247] - signal: TRUE
[01:27:48.248] - resignal: FALSE
[01:27:48.248] - force: TRUE
[01:27:48.248] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.248] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.248]  - until=3
[01:27:48.248]  - relaying element #3
[01:27:48.249] result() for ClusterFuture ...
[01:27:48.249] - result already collected: FutureResult
[01:27:48.249] result() for ClusterFuture ... done
[01:27:48.249] result() for ClusterFuture ...
[01:27:48.249] - result already collected: FutureResult
[01:27:48.249] result() for ClusterFuture ... done
[01:27:48.250] result() for ClusterFuture ...
[01:27:48.250] - result already collected: FutureResult
[01:27:48.250] result() for ClusterFuture ... done
[01:27:48.250] result() for ClusterFuture ...
[01:27:48.250] - result already collected: FutureResult
[01:27:48.250] result() for ClusterFuture ... done
[01:27:48.250] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.251] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.251] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:48.251]  length: 3 (resolved future 3)
[01:27:48.251] signalConditionsASAP(NULL, pos=4) ...
[01:27:48.251] - nx: 6
[01:27:48.252] - relay: TRUE
[01:27:48.252] - stdout: TRUE
[01:27:48.252] - signal: TRUE
[01:27:48.252] - resignal: FALSE
[01:27:48.252] - force: TRUE
[01:27:48.252] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.253] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.253]  - until=5
[01:27:48.253]  - relaying element #5
[01:27:48.253] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.253] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.254] signalConditionsASAP(NULL, pos=4) ... done
[01:27:48.254]  length: 2 (resolved future 4)
[01:27:48.254] signalConditionsASAP(NULL, pos=5) ...
[01:27:48.254] - nx: 6
[01:27:48.254] - relay: TRUE
[01:27:48.254] - stdout: TRUE
[01:27:48.254] - signal: TRUE
[01:27:48.255] - resignal: FALSE
[01:27:48.255] - force: TRUE
[01:27:48.255] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.255] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.255]  - until=6
[01:27:48.255]  - relaying element #6
[01:27:48.256] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.256] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.256] signalConditionsASAP(NULL, pos=5) ... done
[01:27:48.256]  length: 1 (resolved future 5)
[01:27:48.256] signalConditionsASAP(numeric, pos=6) ...
[01:27:48.256] - nx: 6
[01:27:48.257] - relay: TRUE
[01:27:48.257] - stdout: TRUE
[01:27:48.257] - signal: TRUE
[01:27:48.257] - resignal: FALSE
[01:27:48.257] - force: TRUE
[01:27:48.257] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.257] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.258]  - until=6
[01:27:48.258] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.258] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.258] signalConditionsASAP(numeric, pos=6) ... done
[01:27:48.258]  length: 0 (resolved future 6)
[01:27:48.258] Relaying remaining futures
[01:27:48.259] signalConditionsASAP(NULL, pos=0) ...
[01:27:48.259] - nx: 6
[01:27:48.259] - relay: TRUE
[01:27:48.259] - stdout: TRUE
[01:27:48.259] - signal: TRUE
[01:27:48.259] - resignal: FALSE
[01:27:48.260] - force: TRUE
[01:27:48.260] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.260] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:48.260] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.260] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.260] signalConditionsASAP(NULL, pos=0) ... done
[01:27:48.261] resolve() on list ... DONE
[01:27:48.261] result() for ClusterFuture ...
[01:27:48.261] - result already collected: FutureResult
[01:27:48.261] result() for ClusterFuture ... done
[01:27:48.261] result() for ClusterFuture ...
[01:27:48.261] - result already collected: FutureResult
[01:27:48.262] result() for ClusterFuture ... done
[01:27:48.262] result() for ClusterFuture ...
[01:27:48.262] - result already collected: FutureResult
[01:27:48.262] result() for ClusterFuture ... done
[01:27:48.262] result() for ClusterFuture ...
[01:27:48.262] - result already collected: FutureResult
[01:27:48.263] 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)
[01:27:48.267] getGlobalsAndPackages() ...
[01:27:48.267] Searching for globals...
[01:27:48.267] 
[01:27:48.267] Searching for globals ... DONE
[01:27:48.268] - globals: [0] <none>
[01:27:48.268] getGlobalsAndPackages() ... DONE
[01:27:48.268] run() for 'Future' ...
[01:27:48.268] - state: 'created'
[01:27:48.268] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.283] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.283]   - Field: 'node'
[01:27:48.283]   - Field: 'label'
[01:27:48.283]   - Field: 'local'
[01:27:48.284]   - Field: 'owner'
[01:27:48.284]   - Field: 'envir'
[01:27:48.284]   - Field: 'workers'
[01:27:48.284]   - Field: 'packages'
[01:27:48.284]   - Field: 'gc'
[01:27:48.284]   - Field: 'conditions'
[01:27:48.285]   - Field: 'persistent'
[01:27:48.285]   - Field: 'expr'
[01:27:48.285]   - Field: 'uuid'
[01:27:48.285]   - Field: 'seed'
[01:27:48.285]   - Field: 'version'
[01:27:48.286]   - Field: 'result'
[01:27:48.286]   - Field: 'asynchronous'
[01:27:48.286]   - Field: 'calls'
[01:27:48.286]   - Field: 'globals'
[01:27:48.286]   - Field: 'stdout'
[01:27:48.286]   - Field: 'earlySignal'
[01:27:48.287]   - Field: 'lazy'
[01:27:48.287]   - Field: 'state'
[01:27:48.287] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.287] - Launch lazy future ...
[01:27:48.290] Packages needed by the future expression (n = 0): <none>
[01:27:48.290] Packages needed by future strategies (n = 0): <none>
[01:27:48.290] {
[01:27:48.290]     {
[01:27:48.290]         {
[01:27:48.290]             ...future.startTime <- base::Sys.time()
[01:27:48.290]             {
[01:27:48.290]                 {
[01:27:48.290]                   {
[01:27:48.290]                     {
[01:27:48.290]                       base::local({
[01:27:48.290]                         has_future <- base::requireNamespace("future", 
[01:27:48.290]                           quietly = TRUE)
[01:27:48.290]                         if (has_future) {
[01:27:48.290]                           ns <- base::getNamespace("future")
[01:27:48.290]                           version <- ns[[".package"]][["version"]]
[01:27:48.290]                           if (is.null(version)) 
[01:27:48.290]                             version <- utils::packageVersion("future")
[01:27:48.290]                         }
[01:27:48.290]                         else {
[01:27:48.290]                           version <- NULL
[01:27:48.290]                         }
[01:27:48.290]                         if (!has_future || version < "1.8.0") {
[01:27:48.290]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.290]                             "", base::R.version$version.string), 
[01:27:48.290]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.290]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.290]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.290]                               "release", "version")], collapse = " "), 
[01:27:48.290]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.290]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.290]                             info)
[01:27:48.290]                           info <- base::paste(info, collapse = "; ")
[01:27:48.290]                           if (!has_future) {
[01:27:48.290]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.290]                               info)
[01:27:48.290]                           }
[01:27:48.290]                           else {
[01:27:48.290]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.290]                               info, version)
[01:27:48.290]                           }
[01:27:48.290]                           base::stop(msg)
[01:27:48.290]                         }
[01:27:48.290]                       })
[01:27:48.290]                     }
[01:27:48.290]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.290]                     base::options(mc.cores = 1L)
[01:27:48.290]                   }
[01:27:48.290]                   options(future.plan = NULL)
[01:27:48.290]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.290]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.290]                 }
[01:27:48.290]                 ...future.workdir <- getwd()
[01:27:48.290]             }
[01:27:48.290]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.290]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.290]         }
[01:27:48.290]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.290]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.290]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.290]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.290]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.290]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.290]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.290]             base::names(...future.oldOptions))
[01:27:48.290]     }
[01:27:48.290]     if (FALSE) {
[01:27:48.290]     }
[01:27:48.290]     else {
[01:27:48.290]         if (TRUE) {
[01:27:48.290]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.290]                 open = "w")
[01:27:48.290]         }
[01:27:48.290]         else {
[01:27:48.290]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.290]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.290]         }
[01:27:48.290]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.290]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.290]             base::sink(type = "output", split = FALSE)
[01:27:48.290]             base::close(...future.stdout)
[01:27:48.290]         }, add = TRUE)
[01:27:48.290]     }
[01:27:48.290]     ...future.frame <- base::sys.nframe()
[01:27:48.290]     ...future.conditions <- base::list()
[01:27:48.290]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.290]     if (FALSE) {
[01:27:48.290]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.290]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.290]     }
[01:27:48.290]     ...future.result <- base::tryCatch({
[01:27:48.290]         base::withCallingHandlers({
[01:27:48.290]             ...future.value <- base::withVisible(base::local({
[01:27:48.290]                 ...future.makeSendCondition <- base::local({
[01:27:48.290]                   sendCondition <- NULL
[01:27:48.290]                   function(frame = 1L) {
[01:27:48.290]                     if (is.function(sendCondition)) 
[01:27:48.290]                       return(sendCondition)
[01:27:48.290]                     ns <- getNamespace("parallel")
[01:27:48.290]                     if (exists("sendData", mode = "function", 
[01:27:48.290]                       envir = ns)) {
[01:27:48.290]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.290]                         envir = ns)
[01:27:48.290]                       envir <- sys.frame(frame)
[01:27:48.290]                       master <- NULL
[01:27:48.290]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.290]                         !identical(envir, emptyenv())) {
[01:27:48.290]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.290]                           inherits = FALSE)) {
[01:27:48.290]                           master <- get("master", mode = "list", 
[01:27:48.290]                             envir = envir, inherits = FALSE)
[01:27:48.290]                           if (inherits(master, c("SOCKnode", 
[01:27:48.290]                             "SOCK0node"))) {
[01:27:48.290]                             sendCondition <<- function(cond) {
[01:27:48.290]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.290]                                 success = TRUE)
[01:27:48.290]                               parallel_sendData(master, data)
[01:27:48.290]                             }
[01:27:48.290]                             return(sendCondition)
[01:27:48.290]                           }
[01:27:48.290]                         }
[01:27:48.290]                         frame <- frame + 1L
[01:27:48.290]                         envir <- sys.frame(frame)
[01:27:48.290]                       }
[01:27:48.290]                     }
[01:27:48.290]                     sendCondition <<- function(cond) NULL
[01:27:48.290]                   }
[01:27:48.290]                 })
[01:27:48.290]                 withCallingHandlers({
[01:27:48.290]                   2
[01:27:48.290]                 }, immediateCondition = function(cond) {
[01:27:48.290]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.290]                   sendCondition(cond)
[01:27:48.290]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.290]                   {
[01:27:48.290]                     inherits <- base::inherits
[01:27:48.290]                     invokeRestart <- base::invokeRestart
[01:27:48.290]                     is.null <- base::is.null
[01:27:48.290]                     muffled <- FALSE
[01:27:48.290]                     if (inherits(cond, "message")) {
[01:27:48.290]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.290]                       if (muffled) 
[01:27:48.290]                         invokeRestart("muffleMessage")
[01:27:48.290]                     }
[01:27:48.290]                     else if (inherits(cond, "warning")) {
[01:27:48.290]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.290]                       if (muffled) 
[01:27:48.290]                         invokeRestart("muffleWarning")
[01:27:48.290]                     }
[01:27:48.290]                     else if (inherits(cond, "condition")) {
[01:27:48.290]                       if (!is.null(pattern)) {
[01:27:48.290]                         computeRestarts <- base::computeRestarts
[01:27:48.290]                         grepl <- base::grepl
[01:27:48.290]                         restarts <- computeRestarts(cond)
[01:27:48.290]                         for (restart in restarts) {
[01:27:48.290]                           name <- restart$name
[01:27:48.290]                           if (is.null(name)) 
[01:27:48.290]                             next
[01:27:48.290]                           if (!grepl(pattern, name)) 
[01:27:48.290]                             next
[01:27:48.290]                           invokeRestart(restart)
[01:27:48.290]                           muffled <- TRUE
[01:27:48.290]                           break
[01:27:48.290]                         }
[01:27:48.290]                       }
[01:27:48.290]                     }
[01:27:48.290]                     invisible(muffled)
[01:27:48.290]                   }
[01:27:48.290]                   muffleCondition(cond)
[01:27:48.290]                 })
[01:27:48.290]             }))
[01:27:48.290]             future::FutureResult(value = ...future.value$value, 
[01:27:48.290]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.290]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.290]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.290]                     ...future.globalenv.names))
[01:27:48.290]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.290]         }, condition = base::local({
[01:27:48.290]             c <- base::c
[01:27:48.290]             inherits <- base::inherits
[01:27:48.290]             invokeRestart <- base::invokeRestart
[01:27:48.290]             length <- base::length
[01:27:48.290]             list <- base::list
[01:27:48.290]             seq.int <- base::seq.int
[01:27:48.290]             signalCondition <- base::signalCondition
[01:27:48.290]             sys.calls <- base::sys.calls
[01:27:48.290]             `[[` <- base::`[[`
[01:27:48.290]             `+` <- base::`+`
[01:27:48.290]             `<<-` <- base::`<<-`
[01:27:48.290]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.290]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.290]                   3L)]
[01:27:48.290]             }
[01:27:48.290]             function(cond) {
[01:27:48.290]                 is_error <- inherits(cond, "error")
[01:27:48.290]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.290]                   NULL)
[01:27:48.290]                 if (is_error) {
[01:27:48.290]                   sessionInformation <- function() {
[01:27:48.290]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.290]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.290]                       search = base::search(), system = base::Sys.info())
[01:27:48.290]                   }
[01:27:48.290]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.290]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.290]                     cond$call), session = sessionInformation(), 
[01:27:48.290]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.290]                   signalCondition(cond)
[01:27:48.290]                 }
[01:27:48.290]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.290]                 "immediateCondition"))) {
[01:27:48.290]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.290]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.290]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.290]                   if (TRUE && !signal) {
[01:27:48.290]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.290]                     {
[01:27:48.290]                       inherits <- base::inherits
[01:27:48.290]                       invokeRestart <- base::invokeRestart
[01:27:48.290]                       is.null <- base::is.null
[01:27:48.290]                       muffled <- FALSE
[01:27:48.290]                       if (inherits(cond, "message")) {
[01:27:48.290]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.290]                         if (muffled) 
[01:27:48.290]                           invokeRestart("muffleMessage")
[01:27:48.290]                       }
[01:27:48.290]                       else if (inherits(cond, "warning")) {
[01:27:48.290]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.290]                         if (muffled) 
[01:27:48.290]                           invokeRestart("muffleWarning")
[01:27:48.290]                       }
[01:27:48.290]                       else if (inherits(cond, "condition")) {
[01:27:48.290]                         if (!is.null(pattern)) {
[01:27:48.290]                           computeRestarts <- base::computeRestarts
[01:27:48.290]                           grepl <- base::grepl
[01:27:48.290]                           restarts <- computeRestarts(cond)
[01:27:48.290]                           for (restart in restarts) {
[01:27:48.290]                             name <- restart$name
[01:27:48.290]                             if (is.null(name)) 
[01:27:48.290]                               next
[01:27:48.290]                             if (!grepl(pattern, name)) 
[01:27:48.290]                               next
[01:27:48.290]                             invokeRestart(restart)
[01:27:48.290]                             muffled <- TRUE
[01:27:48.290]                             break
[01:27:48.290]                           }
[01:27:48.290]                         }
[01:27:48.290]                       }
[01:27:48.290]                       invisible(muffled)
[01:27:48.290]                     }
[01:27:48.290]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.290]                   }
[01:27:48.290]                 }
[01:27:48.290]                 else {
[01:27:48.290]                   if (TRUE) {
[01:27:48.290]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.290]                     {
[01:27:48.290]                       inherits <- base::inherits
[01:27:48.290]                       invokeRestart <- base::invokeRestart
[01:27:48.290]                       is.null <- base::is.null
[01:27:48.290]                       muffled <- FALSE
[01:27:48.290]                       if (inherits(cond, "message")) {
[01:27:48.290]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.290]                         if (muffled) 
[01:27:48.290]                           invokeRestart("muffleMessage")
[01:27:48.290]                       }
[01:27:48.290]                       else if (inherits(cond, "warning")) {
[01:27:48.290]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.290]                         if (muffled) 
[01:27:48.290]                           invokeRestart("muffleWarning")
[01:27:48.290]                       }
[01:27:48.290]                       else if (inherits(cond, "condition")) {
[01:27:48.290]                         if (!is.null(pattern)) {
[01:27:48.290]                           computeRestarts <- base::computeRestarts
[01:27:48.290]                           grepl <- base::grepl
[01:27:48.290]                           restarts <- computeRestarts(cond)
[01:27:48.290]                           for (restart in restarts) {
[01:27:48.290]                             name <- restart$name
[01:27:48.290]                             if (is.null(name)) 
[01:27:48.290]                               next
[01:27:48.290]                             if (!grepl(pattern, name)) 
[01:27:48.290]                               next
[01:27:48.290]                             invokeRestart(restart)
[01:27:48.290]                             muffled <- TRUE
[01:27:48.290]                             break
[01:27:48.290]                           }
[01:27:48.290]                         }
[01:27:48.290]                       }
[01:27:48.290]                       invisible(muffled)
[01:27:48.290]                     }
[01:27:48.290]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.290]                   }
[01:27:48.290]                 }
[01:27:48.290]             }
[01:27:48.290]         }))
[01:27:48.290]     }, error = function(ex) {
[01:27:48.290]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.290]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.290]                 ...future.rng), started = ...future.startTime, 
[01:27:48.290]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.290]             version = "1.8"), class = "FutureResult")
[01:27:48.290]     }, finally = {
[01:27:48.290]         if (!identical(...future.workdir, getwd())) 
[01:27:48.290]             setwd(...future.workdir)
[01:27:48.290]         {
[01:27:48.290]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.290]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.290]             }
[01:27:48.290]             base::options(...future.oldOptions)
[01:27:48.290]             if (.Platform$OS.type == "windows") {
[01:27:48.290]                 old_names <- names(...future.oldEnvVars)
[01:27:48.290]                 envs <- base::Sys.getenv()
[01:27:48.290]                 names <- names(envs)
[01:27:48.290]                 common <- intersect(names, old_names)
[01:27:48.290]                 added <- setdiff(names, old_names)
[01:27:48.290]                 removed <- setdiff(old_names, names)
[01:27:48.290]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.290]                   envs[common]]
[01:27:48.290]                 NAMES <- toupper(changed)
[01:27:48.290]                 args <- list()
[01:27:48.290]                 for (kk in seq_along(NAMES)) {
[01:27:48.290]                   name <- changed[[kk]]
[01:27:48.290]                   NAME <- NAMES[[kk]]
[01:27:48.290]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.290]                     next
[01:27:48.290]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.290]                 }
[01:27:48.290]                 NAMES <- toupper(added)
[01:27:48.290]                 for (kk in seq_along(NAMES)) {
[01:27:48.290]                   name <- added[[kk]]
[01:27:48.290]                   NAME <- NAMES[[kk]]
[01:27:48.290]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.290]                     next
[01:27:48.290]                   args[[name]] <- ""
[01:27:48.290]                 }
[01:27:48.290]                 NAMES <- toupper(removed)
[01:27:48.290]                 for (kk in seq_along(NAMES)) {
[01:27:48.290]                   name <- removed[[kk]]
[01:27:48.290]                   NAME <- NAMES[[kk]]
[01:27:48.290]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.290]                     next
[01:27:48.290]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.290]                 }
[01:27:48.290]                 if (length(args) > 0) 
[01:27:48.290]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.290]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.290]             }
[01:27:48.290]             else {
[01:27:48.290]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.290]             }
[01:27:48.290]             {
[01:27:48.290]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.290]                   0L) {
[01:27:48.290]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.290]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.290]                   base::options(opts)
[01:27:48.290]                 }
[01:27:48.290]                 {
[01:27:48.290]                   {
[01:27:48.290]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.290]                     NULL
[01:27:48.290]                   }
[01:27:48.290]                   options(future.plan = NULL)
[01:27:48.290]                   if (is.na(NA_character_)) 
[01:27:48.290]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.290]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.290]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.290]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.290]                     envir = parent.frame()) 
[01:27:48.290]                   {
[01:27:48.290]                     if (is.function(workers)) 
[01:27:48.290]                       workers <- workers()
[01:27:48.290]                     workers <- structure(as.integer(workers), 
[01:27:48.290]                       class = class(workers))
[01:27:48.290]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.290]                       workers >= 1)
[01:27:48.290]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.290]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.290]                     }
[01:27:48.290]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.290]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.290]                       envir = envir)
[01:27:48.290]                     if (!future$lazy) 
[01:27:48.290]                       future <- run(future)
[01:27:48.290]                     invisible(future)
[01:27:48.290]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.290]                 }
[01:27:48.290]             }
[01:27:48.290]         }
[01:27:48.290]     })
[01:27:48.290]     if (TRUE) {
[01:27:48.290]         base::sink(type = "output", split = FALSE)
[01:27:48.290]         if (TRUE) {
[01:27:48.290]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.290]         }
[01:27:48.290]         else {
[01:27:48.290]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.290]         }
[01:27:48.290]         base::close(...future.stdout)
[01:27:48.290]         ...future.stdout <- NULL
[01:27:48.290]     }
[01:27:48.290]     ...future.result$conditions <- ...future.conditions
[01:27:48.290]     ...future.result$finished <- base::Sys.time()
[01:27:48.290]     ...future.result
[01:27:48.290] }
[01:27:48.296] MultisessionFuture started
[01:27:48.296] - Launch lazy future ... done
[01:27:48.297] run() for 'MultisessionFuture' ... done
[01:27:48.297] getGlobalsAndPackages() ...
[01:27:48.297] Searching for globals...
[01:27:48.297] 
[01:27:48.298] Searching for globals ... DONE
[01:27:48.298] - globals: [0] <none>
[01:27:48.298] getGlobalsAndPackages() ... DONE
[01:27:48.298] run() for 'Future' ...
[01:27:48.298] - state: 'created'
[01:27:48.299] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.312] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.313] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.313]   - Field: 'node'
[01:27:48.313]   - Field: 'label'
[01:27:48.313]   - Field: 'local'
[01:27:48.313]   - Field: 'owner'
[01:27:48.314]   - Field: 'envir'
[01:27:48.314]   - Field: 'workers'
[01:27:48.314]   - Field: 'packages'
[01:27:48.314]   - Field: 'gc'
[01:27:48.314]   - Field: 'conditions'
[01:27:48.314]   - Field: 'persistent'
[01:27:48.315]   - Field: 'expr'
[01:27:48.315]   - Field: 'uuid'
[01:27:48.315]   - Field: 'seed'
[01:27:48.315]   - Field: 'version'
[01:27:48.315]   - Field: 'result'
[01:27:48.315]   - Field: 'asynchronous'
[01:27:48.316]   - Field: 'calls'
[01:27:48.316]   - Field: 'globals'
[01:27:48.316]   - Field: 'stdout'
[01:27:48.316]   - Field: 'earlySignal'
[01:27:48.316]   - Field: 'lazy'
[01:27:48.317]   - Field: 'state'
[01:27:48.317] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.317] - Launch lazy future ...
[01:27:48.317] Packages needed by the future expression (n = 0): <none>
[01:27:48.317] Packages needed by future strategies (n = 0): <none>
[01:27:48.318] {
[01:27:48.318]     {
[01:27:48.318]         {
[01:27:48.318]             ...future.startTime <- base::Sys.time()
[01:27:48.318]             {
[01:27:48.318]                 {
[01:27:48.318]                   {
[01:27:48.318]                     {
[01:27:48.318]                       base::local({
[01:27:48.318]                         has_future <- base::requireNamespace("future", 
[01:27:48.318]                           quietly = TRUE)
[01:27:48.318]                         if (has_future) {
[01:27:48.318]                           ns <- base::getNamespace("future")
[01:27:48.318]                           version <- ns[[".package"]][["version"]]
[01:27:48.318]                           if (is.null(version)) 
[01:27:48.318]                             version <- utils::packageVersion("future")
[01:27:48.318]                         }
[01:27:48.318]                         else {
[01:27:48.318]                           version <- NULL
[01:27:48.318]                         }
[01:27:48.318]                         if (!has_future || version < "1.8.0") {
[01:27:48.318]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.318]                             "", base::R.version$version.string), 
[01:27:48.318]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.318]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.318]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.318]                               "release", "version")], collapse = " "), 
[01:27:48.318]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.318]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.318]                             info)
[01:27:48.318]                           info <- base::paste(info, collapse = "; ")
[01:27:48.318]                           if (!has_future) {
[01:27:48.318]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.318]                               info)
[01:27:48.318]                           }
[01:27:48.318]                           else {
[01:27:48.318]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.318]                               info, version)
[01:27:48.318]                           }
[01:27:48.318]                           base::stop(msg)
[01:27:48.318]                         }
[01:27:48.318]                       })
[01:27:48.318]                     }
[01:27:48.318]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.318]                     base::options(mc.cores = 1L)
[01:27:48.318]                   }
[01:27:48.318]                   options(future.plan = NULL)
[01:27:48.318]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.318]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.318]                 }
[01:27:48.318]                 ...future.workdir <- getwd()
[01:27:48.318]             }
[01:27:48.318]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.318]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.318]         }
[01:27:48.318]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.318]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.318]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.318]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.318]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.318]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.318]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.318]             base::names(...future.oldOptions))
[01:27:48.318]     }
[01:27:48.318]     if (FALSE) {
[01:27:48.318]     }
[01:27:48.318]     else {
[01:27:48.318]         if (TRUE) {
[01:27:48.318]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.318]                 open = "w")
[01:27:48.318]         }
[01:27:48.318]         else {
[01:27:48.318]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.318]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.318]         }
[01:27:48.318]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.318]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.318]             base::sink(type = "output", split = FALSE)
[01:27:48.318]             base::close(...future.stdout)
[01:27:48.318]         }, add = TRUE)
[01:27:48.318]     }
[01:27:48.318]     ...future.frame <- base::sys.nframe()
[01:27:48.318]     ...future.conditions <- base::list()
[01:27:48.318]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.318]     if (FALSE) {
[01:27:48.318]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.318]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.318]     }
[01:27:48.318]     ...future.result <- base::tryCatch({
[01:27:48.318]         base::withCallingHandlers({
[01:27:48.318]             ...future.value <- base::withVisible(base::local({
[01:27:48.318]                 ...future.makeSendCondition <- base::local({
[01:27:48.318]                   sendCondition <- NULL
[01:27:48.318]                   function(frame = 1L) {
[01:27:48.318]                     if (is.function(sendCondition)) 
[01:27:48.318]                       return(sendCondition)
[01:27:48.318]                     ns <- getNamespace("parallel")
[01:27:48.318]                     if (exists("sendData", mode = "function", 
[01:27:48.318]                       envir = ns)) {
[01:27:48.318]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.318]                         envir = ns)
[01:27:48.318]                       envir <- sys.frame(frame)
[01:27:48.318]                       master <- NULL
[01:27:48.318]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.318]                         !identical(envir, emptyenv())) {
[01:27:48.318]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.318]                           inherits = FALSE)) {
[01:27:48.318]                           master <- get("master", mode = "list", 
[01:27:48.318]                             envir = envir, inherits = FALSE)
[01:27:48.318]                           if (inherits(master, c("SOCKnode", 
[01:27:48.318]                             "SOCK0node"))) {
[01:27:48.318]                             sendCondition <<- function(cond) {
[01:27:48.318]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.318]                                 success = TRUE)
[01:27:48.318]                               parallel_sendData(master, data)
[01:27:48.318]                             }
[01:27:48.318]                             return(sendCondition)
[01:27:48.318]                           }
[01:27:48.318]                         }
[01:27:48.318]                         frame <- frame + 1L
[01:27:48.318]                         envir <- sys.frame(frame)
[01:27:48.318]                       }
[01:27:48.318]                     }
[01:27:48.318]                     sendCondition <<- function(cond) NULL
[01:27:48.318]                   }
[01:27:48.318]                 })
[01:27:48.318]                 withCallingHandlers({
[01:27:48.318]                   NULL
[01:27:48.318]                 }, immediateCondition = function(cond) {
[01:27:48.318]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.318]                   sendCondition(cond)
[01:27:48.318]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.318]                   {
[01:27:48.318]                     inherits <- base::inherits
[01:27:48.318]                     invokeRestart <- base::invokeRestart
[01:27:48.318]                     is.null <- base::is.null
[01:27:48.318]                     muffled <- FALSE
[01:27:48.318]                     if (inherits(cond, "message")) {
[01:27:48.318]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.318]                       if (muffled) 
[01:27:48.318]                         invokeRestart("muffleMessage")
[01:27:48.318]                     }
[01:27:48.318]                     else if (inherits(cond, "warning")) {
[01:27:48.318]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.318]                       if (muffled) 
[01:27:48.318]                         invokeRestart("muffleWarning")
[01:27:48.318]                     }
[01:27:48.318]                     else if (inherits(cond, "condition")) {
[01:27:48.318]                       if (!is.null(pattern)) {
[01:27:48.318]                         computeRestarts <- base::computeRestarts
[01:27:48.318]                         grepl <- base::grepl
[01:27:48.318]                         restarts <- computeRestarts(cond)
[01:27:48.318]                         for (restart in restarts) {
[01:27:48.318]                           name <- restart$name
[01:27:48.318]                           if (is.null(name)) 
[01:27:48.318]                             next
[01:27:48.318]                           if (!grepl(pattern, name)) 
[01:27:48.318]                             next
[01:27:48.318]                           invokeRestart(restart)
[01:27:48.318]                           muffled <- TRUE
[01:27:48.318]                           break
[01:27:48.318]                         }
[01:27:48.318]                       }
[01:27:48.318]                     }
[01:27:48.318]                     invisible(muffled)
[01:27:48.318]                   }
[01:27:48.318]                   muffleCondition(cond)
[01:27:48.318]                 })
[01:27:48.318]             }))
[01:27:48.318]             future::FutureResult(value = ...future.value$value, 
[01:27:48.318]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.318]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.318]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.318]                     ...future.globalenv.names))
[01:27:48.318]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.318]         }, condition = base::local({
[01:27:48.318]             c <- base::c
[01:27:48.318]             inherits <- base::inherits
[01:27:48.318]             invokeRestart <- base::invokeRestart
[01:27:48.318]             length <- base::length
[01:27:48.318]             list <- base::list
[01:27:48.318]             seq.int <- base::seq.int
[01:27:48.318]             signalCondition <- base::signalCondition
[01:27:48.318]             sys.calls <- base::sys.calls
[01:27:48.318]             `[[` <- base::`[[`
[01:27:48.318]             `+` <- base::`+`
[01:27:48.318]             `<<-` <- base::`<<-`
[01:27:48.318]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.318]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.318]                   3L)]
[01:27:48.318]             }
[01:27:48.318]             function(cond) {
[01:27:48.318]                 is_error <- inherits(cond, "error")
[01:27:48.318]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.318]                   NULL)
[01:27:48.318]                 if (is_error) {
[01:27:48.318]                   sessionInformation <- function() {
[01:27:48.318]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.318]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.318]                       search = base::search(), system = base::Sys.info())
[01:27:48.318]                   }
[01:27:48.318]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.318]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.318]                     cond$call), session = sessionInformation(), 
[01:27:48.318]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.318]                   signalCondition(cond)
[01:27:48.318]                 }
[01:27:48.318]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.318]                 "immediateCondition"))) {
[01:27:48.318]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.318]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.318]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.318]                   if (TRUE && !signal) {
[01:27:48.318]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.318]                     {
[01:27:48.318]                       inherits <- base::inherits
[01:27:48.318]                       invokeRestart <- base::invokeRestart
[01:27:48.318]                       is.null <- base::is.null
[01:27:48.318]                       muffled <- FALSE
[01:27:48.318]                       if (inherits(cond, "message")) {
[01:27:48.318]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.318]                         if (muffled) 
[01:27:48.318]                           invokeRestart("muffleMessage")
[01:27:48.318]                       }
[01:27:48.318]                       else if (inherits(cond, "warning")) {
[01:27:48.318]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.318]                         if (muffled) 
[01:27:48.318]                           invokeRestart("muffleWarning")
[01:27:48.318]                       }
[01:27:48.318]                       else if (inherits(cond, "condition")) {
[01:27:48.318]                         if (!is.null(pattern)) {
[01:27:48.318]                           computeRestarts <- base::computeRestarts
[01:27:48.318]                           grepl <- base::grepl
[01:27:48.318]                           restarts <- computeRestarts(cond)
[01:27:48.318]                           for (restart in restarts) {
[01:27:48.318]                             name <- restart$name
[01:27:48.318]                             if (is.null(name)) 
[01:27:48.318]                               next
[01:27:48.318]                             if (!grepl(pattern, name)) 
[01:27:48.318]                               next
[01:27:48.318]                             invokeRestart(restart)
[01:27:48.318]                             muffled <- TRUE
[01:27:48.318]                             break
[01:27:48.318]                           }
[01:27:48.318]                         }
[01:27:48.318]                       }
[01:27:48.318]                       invisible(muffled)
[01:27:48.318]                     }
[01:27:48.318]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.318]                   }
[01:27:48.318]                 }
[01:27:48.318]                 else {
[01:27:48.318]                   if (TRUE) {
[01:27:48.318]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.318]                     {
[01:27:48.318]                       inherits <- base::inherits
[01:27:48.318]                       invokeRestart <- base::invokeRestart
[01:27:48.318]                       is.null <- base::is.null
[01:27:48.318]                       muffled <- FALSE
[01:27:48.318]                       if (inherits(cond, "message")) {
[01:27:48.318]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.318]                         if (muffled) 
[01:27:48.318]                           invokeRestart("muffleMessage")
[01:27:48.318]                       }
[01:27:48.318]                       else if (inherits(cond, "warning")) {
[01:27:48.318]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.318]                         if (muffled) 
[01:27:48.318]                           invokeRestart("muffleWarning")
[01:27:48.318]                       }
[01:27:48.318]                       else if (inherits(cond, "condition")) {
[01:27:48.318]                         if (!is.null(pattern)) {
[01:27:48.318]                           computeRestarts <- base::computeRestarts
[01:27:48.318]                           grepl <- base::grepl
[01:27:48.318]                           restarts <- computeRestarts(cond)
[01:27:48.318]                           for (restart in restarts) {
[01:27:48.318]                             name <- restart$name
[01:27:48.318]                             if (is.null(name)) 
[01:27:48.318]                               next
[01:27:48.318]                             if (!grepl(pattern, name)) 
[01:27:48.318]                               next
[01:27:48.318]                             invokeRestart(restart)
[01:27:48.318]                             muffled <- TRUE
[01:27:48.318]                             break
[01:27:48.318]                           }
[01:27:48.318]                         }
[01:27:48.318]                       }
[01:27:48.318]                       invisible(muffled)
[01:27:48.318]                     }
[01:27:48.318]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.318]                   }
[01:27:48.318]                 }
[01:27:48.318]             }
[01:27:48.318]         }))
[01:27:48.318]     }, error = function(ex) {
[01:27:48.318]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.318]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.318]                 ...future.rng), started = ...future.startTime, 
[01:27:48.318]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.318]             version = "1.8"), class = "FutureResult")
[01:27:48.318]     }, finally = {
[01:27:48.318]         if (!identical(...future.workdir, getwd())) 
[01:27:48.318]             setwd(...future.workdir)
[01:27:48.318]         {
[01:27:48.318]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.318]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.318]             }
[01:27:48.318]             base::options(...future.oldOptions)
[01:27:48.318]             if (.Platform$OS.type == "windows") {
[01:27:48.318]                 old_names <- names(...future.oldEnvVars)
[01:27:48.318]                 envs <- base::Sys.getenv()
[01:27:48.318]                 names <- names(envs)
[01:27:48.318]                 common <- intersect(names, old_names)
[01:27:48.318]                 added <- setdiff(names, old_names)
[01:27:48.318]                 removed <- setdiff(old_names, names)
[01:27:48.318]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.318]                   envs[common]]
[01:27:48.318]                 NAMES <- toupper(changed)
[01:27:48.318]                 args <- list()
[01:27:48.318]                 for (kk in seq_along(NAMES)) {
[01:27:48.318]                   name <- changed[[kk]]
[01:27:48.318]                   NAME <- NAMES[[kk]]
[01:27:48.318]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.318]                     next
[01:27:48.318]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.318]                 }
[01:27:48.318]                 NAMES <- toupper(added)
[01:27:48.318]                 for (kk in seq_along(NAMES)) {
[01:27:48.318]                   name <- added[[kk]]
[01:27:48.318]                   NAME <- NAMES[[kk]]
[01:27:48.318]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.318]                     next
[01:27:48.318]                   args[[name]] <- ""
[01:27:48.318]                 }
[01:27:48.318]                 NAMES <- toupper(removed)
[01:27:48.318]                 for (kk in seq_along(NAMES)) {
[01:27:48.318]                   name <- removed[[kk]]
[01:27:48.318]                   NAME <- NAMES[[kk]]
[01:27:48.318]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.318]                     next
[01:27:48.318]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.318]                 }
[01:27:48.318]                 if (length(args) > 0) 
[01:27:48.318]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.318]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.318]             }
[01:27:48.318]             else {
[01:27:48.318]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.318]             }
[01:27:48.318]             {
[01:27:48.318]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.318]                   0L) {
[01:27:48.318]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.318]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.318]                   base::options(opts)
[01:27:48.318]                 }
[01:27:48.318]                 {
[01:27:48.318]                   {
[01:27:48.318]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.318]                     NULL
[01:27:48.318]                   }
[01:27:48.318]                   options(future.plan = NULL)
[01:27:48.318]                   if (is.na(NA_character_)) 
[01:27:48.318]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.318]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.318]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.318]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.318]                     envir = parent.frame()) 
[01:27:48.318]                   {
[01:27:48.318]                     if (is.function(workers)) 
[01:27:48.318]                       workers <- workers()
[01:27:48.318]                     workers <- structure(as.integer(workers), 
[01:27:48.318]                       class = class(workers))
[01:27:48.318]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.318]                       workers >= 1)
[01:27:48.318]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.318]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.318]                     }
[01:27:48.318]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.318]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.318]                       envir = envir)
[01:27:48.318]                     if (!future$lazy) 
[01:27:48.318]                       future <- run(future)
[01:27:48.318]                     invisible(future)
[01:27:48.318]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.318]                 }
[01:27:48.318]             }
[01:27:48.318]         }
[01:27:48.318]     })
[01:27:48.318]     if (TRUE) {
[01:27:48.318]         base::sink(type = "output", split = FALSE)
[01:27:48.318]         if (TRUE) {
[01:27:48.318]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.318]         }
[01:27:48.318]         else {
[01:27:48.318]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.318]         }
[01:27:48.318]         base::close(...future.stdout)
[01:27:48.318]         ...future.stdout <- NULL
[01:27:48.318]     }
[01:27:48.318]     ...future.result$conditions <- ...future.conditions
[01:27:48.318]     ...future.result$finished <- base::Sys.time()
[01:27:48.318]     ...future.result
[01:27:48.318] }
[01:27:48.324] MultisessionFuture started
[01:27:48.324] - Launch lazy future ... done
[01:27:48.324] run() for 'MultisessionFuture' ... done
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0b91e908> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0862ea40> 
 $  : NULL
 $  : NULL
 $  : num 6
List of 6
 $ a: num 1
 $ b:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0b91e908> 
 $ c:Classes 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x0000025b0862ea40> 
 $  : 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"
[01:27:48.331] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.331] - Validating connection of MultisessionFuture
[01:27:48.331] - received message: FutureResult
[01:27:48.332] - Received FutureResult
[01:27:48.332] - Erased future from FutureRegistry
[01:27:48.332] result() for ClusterFuture ...
[01:27:48.332] - result already collected: FutureResult
[01:27:48.332] result() for ClusterFuture ... done
[01:27:48.332] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:48.342] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.342] - Validating connection of MultisessionFuture
[01:27:48.343] - received message: FutureResult
[01:27:48.343] - Received FutureResult
[01:27:48.343] - Erased future from FutureRegistry
[01:27:48.343] result() for ClusterFuture ...
[01:27:48.344] - result already collected: FutureResult
[01:27:48.344] result() for ClusterFuture ... done
[01:27:48.344] 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" "" ...
[01:27:48.347] resolve() on list ...
[01:27:48.347]  recursive: 0
[01:27:48.347]  length: 6
[01:27:48.347]  elements: 'a', 'b', 'c', '', '', ''
[01:27:48.348] signalConditionsASAP(numeric, pos=1) ...
[01:27:48.348] - nx: 6
[01:27:48.348] - relay: TRUE
[01:27:48.348] - stdout: TRUE
[01:27:48.348] - signal: TRUE
[01:27:48.349] - resignal: FALSE
[01:27:48.349] - force: TRUE
[01:27:48.349] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.349] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.349]  - until=2
[01:27:48.349]  - relaying element #2
[01:27:48.350] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.350] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.350] signalConditionsASAP(NULL, pos=1) ... done
[01:27:48.350]  length: 5 (resolved future 1)
[01:27:48.350] Future #2
[01:27:48.350] result() for ClusterFuture ...
[01:27:48.351] - result already collected: FutureResult
[01:27:48.351] result() for ClusterFuture ... done
[01:27:48.351] result() for ClusterFuture ...
[01:27:48.351] - result already collected: FutureResult
[01:27:48.351] result() for ClusterFuture ... done
[01:27:48.351] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:48.352] - nx: 6
[01:27:48.352] - relay: TRUE
[01:27:48.352] - stdout: TRUE
[01:27:48.352] - signal: TRUE
[01:27:48.353] - resignal: FALSE
[01:27:48.353] - force: TRUE
[01:27:48.353] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.353] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:48.353]  - until=2
[01:27:48.353]  - relaying element #2
[01:27:48.354] result() for ClusterFuture ...
[01:27:48.354] - result already collected: FutureResult
[01:27:48.354] result() for ClusterFuture ... done
[01:27:48.354] result() for ClusterFuture ...
[01:27:48.354] - result already collected: FutureResult
[01:27:48.354] result() for ClusterFuture ... done
[01:27:48.355] result() for ClusterFuture ...
[01:27:48.355] - result already collected: FutureResult
[01:27:48.355] result() for ClusterFuture ... done
[01:27:48.355] result() for ClusterFuture ...
[01:27:48.356] - result already collected: FutureResult
[01:27:48.356] result() for ClusterFuture ... done
[01:27:48.356] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.356] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.356] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:48.356]  length: 4 (resolved future 2)
[01:27:48.357] Future #3
[01:27:48.357] result() for ClusterFuture ...
[01:27:48.357] - result already collected: FutureResult
[01:27:48.357] result() for ClusterFuture ... done
[01:27:48.357] result() for ClusterFuture ...
[01:27:48.357] - result already collected: FutureResult
[01:27:48.358] result() for ClusterFuture ... done
[01:27:48.358] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:48.358] - nx: 6
[01:27:48.358] - relay: TRUE
[01:27:48.358] - stdout: TRUE
[01:27:48.358] - signal: TRUE
[01:27:48.358] - resignal: FALSE
[01:27:48.359] - force: TRUE
[01:27:48.359] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.359] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:48.359]  - until=3
[01:27:48.359]  - relaying element #3
[01:27:48.359] result() for ClusterFuture ...
[01:27:48.360] - result already collected: FutureResult
[01:27:48.360] result() for ClusterFuture ... done
[01:27:48.360] result() for ClusterFuture ...
[01:27:48.360] - result already collected: FutureResult
[01:27:48.360] result() for ClusterFuture ... done
[01:27:48.360] result() for ClusterFuture ...
[01:27:48.361] - result already collected: FutureResult
[01:27:48.361] result() for ClusterFuture ... done
[01:27:48.361] result() for ClusterFuture ...
[01:27:48.361] - result already collected: FutureResult
[01:27:48.361] result() for ClusterFuture ... done
[01:27:48.361] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.362] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.362] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:48.362]  length: 3 (resolved future 3)
[01:27:48.362] signalConditionsASAP(NULL, pos=4) ...
[01:27:48.362] - nx: 6
[01:27:48.362] - relay: TRUE
[01:27:48.362] - stdout: TRUE
[01:27:48.363] - signal: TRUE
[01:27:48.363] - resignal: FALSE
[01:27:48.363] - force: TRUE
[01:27:48.363] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.363] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.363]  - until=5
[01:27:48.364]  - relaying element #5
[01:27:48.364] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.364] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.364] signalConditionsASAP(NULL, pos=4) ... done
[01:27:48.364]  length: 2 (resolved future 4)
[01:27:48.364] signalConditionsASAP(NULL, pos=5) ...
[01:27:48.365] - nx: 6
[01:27:48.365] - relay: TRUE
[01:27:48.365] - stdout: TRUE
[01:27:48.365] - signal: TRUE
[01:27:48.365] - resignal: FALSE
[01:27:48.365] - force: TRUE
[01:27:48.365] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:48.366] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.366]  - until=6
[01:27:48.366]  - relaying element #6
[01:27:48.366] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.366] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.366] signalConditionsASAP(NULL, pos=5) ... done
[01:27:48.367]  length: 1 (resolved future 5)
[01:27:48.367] signalConditionsASAP(numeric, pos=6) ...
[01:27:48.367] - nx: 6
[01:27:48.367] - relay: TRUE
[01:27:48.367] - stdout: TRUE
[01:27:48.367] - signal: TRUE
[01:27:48.368] - resignal: FALSE
[01:27:48.368] - force: TRUE
[01:27:48.368] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:48.368] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.368]  - until=6
[01:27:48.368] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.369] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.369] signalConditionsASAP(numeric, pos=6) ... done
[01:27:48.369]  length: 0 (resolved future 6)
[01:27:48.369] Relaying remaining futures
[01:27:48.369] signalConditionsASAP(NULL, pos=0) ...
[01:27:48.369] - nx: 6
[01:27:48.370] - relay: TRUE
[01:27:48.370] - stdout: TRUE
[01:27:48.370] - signal: TRUE
[01:27:48.370] - resignal: FALSE
[01:27:48.370] - force: TRUE
[01:27:48.370] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.370] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
 - flush all
[01:27:48.371] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:48.371] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:48.371] signalConditionsASAP(NULL, pos=0) ... done
[01:27:48.371] resolve() on list ... DONE
[01:27:48.371] result() for ClusterFuture ...
[01:27:48.372] - result already collected: FutureResult
[01:27:48.372] result() for ClusterFuture ... done
[01:27:48.372] result() for ClusterFuture ...
[01:27:48.372] - result already collected: FutureResult
[01:27:48.372] result() for ClusterFuture ... done
[01:27:48.372] result() for ClusterFuture ...
[01:27:48.373] - result already collected: FutureResult
[01:27:48.373] result() for ClusterFuture ... done
[01:27:48.373] result() for ClusterFuture ...
[01:27:48.373] - result already collected: FutureResult
[01:27:48.373] 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
[01:27:48.378] plan(): Setting new future strategy stack:
[01:27:48.378] List of future strategies:
[01:27:48.378] 1. multisession:
[01:27:48.378]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:27:48.378]    - tweaked: FALSE
[01:27:48.378]    - call: plan(strategy)
[01:27:48.379] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:27:48.379] multisession:
[01:27:48.379] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:27:48.379] - tweaked: FALSE
[01:27:48.379] - call: plan(strategy)
[01:27:48.383] getGlobalsAndPackages() ...
[01:27:48.383] Not searching for globals
[01:27:48.383] - globals: [0] <none>
[01:27:48.383] getGlobalsAndPackages() ... DONE
[01:27:48.384] [local output] makeClusterPSOCK() ...
[01:27:48.384] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:27:48.387] [local output] Base port: 33998
[01:27:48.388] [local output] Getting setup options for 2 cluster nodes ...
[01:27:48.388] [local output]  - Node 1 of 2 ...
[01:27:48.388] [local output] localMachine=TRUE => revtunnel=FALSE

[01:27:48.390] [local output] Rscript port: 33998

[01:27:48.390] [local output]  - Node 2 of 2 ...
[01:27:48.391] [local output] localMachine=TRUE => revtunnel=FALSE

[01:27:48.392] [local output] Rscript port: 33998

[01:27:48.393] [local output] Getting setup options for 2 cluster nodes ... done
[01:27:48.393] [local output]  - Parallel setup requested for some PSOCK nodes
[01:27:48.393] [local output] Setting up PSOCK nodes in parallel
[01:27:48.393] List of 36
[01:27:48.393]  $ worker          : chr "localhost"
[01:27:48.393]   ..- attr(*, "localhost")= logi TRUE
[01:27:48.393]  $ master          : chr "localhost"
[01:27:48.393]  $ port            : int 33998
[01:27:48.393]  $ connectTimeout  : num 120
[01:27:48.393]  $ timeout         : num 120
[01:27:48.393]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:27:48.393]  $ homogeneous     : logi TRUE
[01:27:48.393]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futures.R:3492:CRANWIN3:CRAN\" -"| __truncated__
[01:27:48.393]  $ rscript_envs    : NULL
[01:27:48.393]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:27:48.393]  $ rscript_startup : NULL
[01:27:48.393]  $ rscript_sh      : chr "cmd"
[01:27:48.393]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:27:48.393]  $ methods         : logi TRUE
[01:27:48.393]  $ socketOptions   : chr "no-delay"
[01:27:48.393]  $ useXDR          : logi FALSE
[01:27:48.393]  $ outfile         : chr "/dev/null"
[01:27:48.393]  $ renice          : int NA
[01:27:48.393]  $ rshcmd          : NULL
[01:27:48.393]  $ user            : chr(0) 
[01:27:48.393]  $ revtunnel       : logi FALSE
[01:27:48.393]  $ rshlogfile      : NULL
[01:27:48.393]  $ rshopts         : chr(0) 
[01:27:48.393]  $ rank            : int 1
[01:27:48.393]  $ manual          : logi FALSE
[01:27:48.393]  $ dryrun          : logi FALSE
[01:27:48.393]  $ quiet           : logi FALSE
[01:27:48.393]  $ setup_strategy  : chr "parallel"
[01:27:48.393]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:27:48.393]  $ pidfile         : chr "D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da47d9a246d.pid"
[01:27:48.393]  $ rshcmd_label    : NULL
[01:27:48.393]  $ rsh_call        : NULL
[01:27:48.393]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:27:48.393]  $ localMachine    : logi TRUE
[01:27:48.393]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:27:48.393]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:27:48.393]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:27:48.393]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:27:48.393]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:27:48.393]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:27:48.393]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:27:48.393]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:27:48.393]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:27:48.393]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:27:48.393]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:27:48.393]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:27:48.393]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:27:48.393]  $ arguments       :List of 28
[01:27:48.393]   ..$ worker          : chr "localhost"
[01:27:48.393]   ..$ master          : NULL
[01:27:48.393]   ..$ port            : int 33998
[01:27:48.393]   ..$ connectTimeout  : num 120
[01:27:48.393]   ..$ timeout         : num 120
[01:27:48.393]   ..$ rscript         : NULL
[01:27:48.393]   ..$ homogeneous     : NULL
[01:27:48.393]   ..$ rscript_args    : NULL
[01:27:48.393]   ..$ rscript_envs    : NULL
[01:27:48.393]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:27:48.393]   ..$ rscript_startup : NULL
[01:27:48.393]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:27:48.393]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:27:48.393]   ..$ methods         : logi TRUE
[01:27:48.393]   ..$ socketOptions   : chr "no-delay"
[01:27:48.393]   ..$ useXDR          : logi FALSE
[01:27:48.393]   ..$ outfile         : chr "/dev/null"
[01:27:48.393]   ..$ renice          : int NA
[01:27:48.393]   ..$ rshcmd          : NULL
[01:27:48.393]   ..$ user            : NULL
[01:27:48.393]   ..$ revtunnel       : logi NA
[01:27:48.393]   ..$ rshlogfile      : NULL
[01:27:48.393]   ..$ rshopts         : NULL
[01:27:48.393]   ..$ rank            : int 1
[01:27:48.393]   ..$ manual          : logi FALSE
[01:27:48.393]   ..$ dryrun          : logi FALSE
[01:27:48.393]   ..$ quiet           : logi FALSE
[01:27:48.393]   ..$ setup_strategy  : chr "parallel"
[01:27:48.393]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:27:48.419] [local output] System call to launch all workers:
[01:27:48.420] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futures.R:3492:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da47d9a246d.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=33998 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:27:48.420] [local output] Starting PSOCK main server
[01:27:48.425] [local output] Workers launched
[01:27:48.425] [local output] Waiting for workers to connect back
[01:27:48.426]  - [local output] 0 workers out of 2 ready
[01:27:48.600]  - [local output] 0 workers out of 2 ready
[01:27:48.600]  - [local output] 1 workers out of 2 ready
[01:27:48.629]  - [local output] 1 workers out of 2 ready
[01:27:48.629]  - [local output] 2 workers out of 2 ready
[01:27:48.630] [local output] Launching of workers completed
[01:27:48.630] [local output] Collecting session information from workers
[01:27:48.631] [local output]  - Worker #1 of 2
[01:27:48.631] [local output]  - Worker #2 of 2
[01:27:48.631] [local output] makeClusterPSOCK() ... done
[01:27:48.644] Packages needed by the future expression (n = 0): <none>
[01:27:48.644] Packages needed by future strategies (n = 0): <none>
[01:27:48.645] {
[01:27:48.645]     {
[01:27:48.645]         {
[01:27:48.645]             ...future.startTime <- base::Sys.time()
[01:27:48.645]             {
[01:27:48.645]                 {
[01:27:48.645]                   {
[01:27:48.645]                     {
[01:27:48.645]                       base::local({
[01:27:48.645]                         has_future <- base::requireNamespace("future", 
[01:27:48.645]                           quietly = TRUE)
[01:27:48.645]                         if (has_future) {
[01:27:48.645]                           ns <- base::getNamespace("future")
[01:27:48.645]                           version <- ns[[".package"]][["version"]]
[01:27:48.645]                           if (is.null(version)) 
[01:27:48.645]                             version <- utils::packageVersion("future")
[01:27:48.645]                         }
[01:27:48.645]                         else {
[01:27:48.645]                           version <- NULL
[01:27:48.645]                         }
[01:27:48.645]                         if (!has_future || version < "1.8.0") {
[01:27:48.645]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.645]                             "", base::R.version$version.string), 
[01:27:48.645]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.645]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.645]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.645]                               "release", "version")], collapse = " "), 
[01:27:48.645]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.645]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.645]                             info)
[01:27:48.645]                           info <- base::paste(info, collapse = "; ")
[01:27:48.645]                           if (!has_future) {
[01:27:48.645]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.645]                               info)
[01:27:48.645]                           }
[01:27:48.645]                           else {
[01:27:48.645]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.645]                               info, version)
[01:27:48.645]                           }
[01:27:48.645]                           base::stop(msg)
[01:27:48.645]                         }
[01:27:48.645]                       })
[01:27:48.645]                     }
[01:27:48.645]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.645]                     base::options(mc.cores = 1L)
[01:27:48.645]                   }
[01:27:48.645]                   options(future.plan = NULL)
[01:27:48.645]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.645]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.645]                 }
[01:27:48.645]                 ...future.workdir <- getwd()
[01:27:48.645]             }
[01:27:48.645]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.645]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.645]         }
[01:27:48.645]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.645]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.645]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.645]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.645]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.645]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.645]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.645]             base::names(...future.oldOptions))
[01:27:48.645]     }
[01:27:48.645]     if (FALSE) {
[01:27:48.645]     }
[01:27:48.645]     else {
[01:27:48.645]         if (TRUE) {
[01:27:48.645]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.645]                 open = "w")
[01:27:48.645]         }
[01:27:48.645]         else {
[01:27:48.645]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.645]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.645]         }
[01:27:48.645]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.645]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.645]             base::sink(type = "output", split = FALSE)
[01:27:48.645]             base::close(...future.stdout)
[01:27:48.645]         }, add = TRUE)
[01:27:48.645]     }
[01:27:48.645]     ...future.frame <- base::sys.nframe()
[01:27:48.645]     ...future.conditions <- base::list()
[01:27:48.645]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.645]     if (FALSE) {
[01:27:48.645]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.645]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.645]     }
[01:27:48.645]     ...future.result <- base::tryCatch({
[01:27:48.645]         base::withCallingHandlers({
[01:27:48.645]             ...future.value <- base::withVisible(base::local({
[01:27:48.645]                 ...future.makeSendCondition <- base::local({
[01:27:48.645]                   sendCondition <- NULL
[01:27:48.645]                   function(frame = 1L) {
[01:27:48.645]                     if (is.function(sendCondition)) 
[01:27:48.645]                       return(sendCondition)
[01:27:48.645]                     ns <- getNamespace("parallel")
[01:27:48.645]                     if (exists("sendData", mode = "function", 
[01:27:48.645]                       envir = ns)) {
[01:27:48.645]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.645]                         envir = ns)
[01:27:48.645]                       envir <- sys.frame(frame)
[01:27:48.645]                       master <- NULL
[01:27:48.645]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.645]                         !identical(envir, emptyenv())) {
[01:27:48.645]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.645]                           inherits = FALSE)) {
[01:27:48.645]                           master <- get("master", mode = "list", 
[01:27:48.645]                             envir = envir, inherits = FALSE)
[01:27:48.645]                           if (inherits(master, c("SOCKnode", 
[01:27:48.645]                             "SOCK0node"))) {
[01:27:48.645]                             sendCondition <<- function(cond) {
[01:27:48.645]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.645]                                 success = TRUE)
[01:27:48.645]                               parallel_sendData(master, data)
[01:27:48.645]                             }
[01:27:48.645]                             return(sendCondition)
[01:27:48.645]                           }
[01:27:48.645]                         }
[01:27:48.645]                         frame <- frame + 1L
[01:27:48.645]                         envir <- sys.frame(frame)
[01:27:48.645]                       }
[01:27:48.645]                     }
[01:27:48.645]                     sendCondition <<- function(cond) NULL
[01:27:48.645]                   }
[01:27:48.645]                 })
[01:27:48.645]                 withCallingHandlers({
[01:27:48.645]                   NA
[01:27:48.645]                 }, immediateCondition = function(cond) {
[01:27:48.645]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.645]                   sendCondition(cond)
[01:27:48.645]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.645]                   {
[01:27:48.645]                     inherits <- base::inherits
[01:27:48.645]                     invokeRestart <- base::invokeRestart
[01:27:48.645]                     is.null <- base::is.null
[01:27:48.645]                     muffled <- FALSE
[01:27:48.645]                     if (inherits(cond, "message")) {
[01:27:48.645]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.645]                       if (muffled) 
[01:27:48.645]                         invokeRestart("muffleMessage")
[01:27:48.645]                     }
[01:27:48.645]                     else if (inherits(cond, "warning")) {
[01:27:48.645]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.645]                       if (muffled) 
[01:27:48.645]                         invokeRestart("muffleWarning")
[01:27:48.645]                     }
[01:27:48.645]                     else if (inherits(cond, "condition")) {
[01:27:48.645]                       if (!is.null(pattern)) {
[01:27:48.645]                         computeRestarts <- base::computeRestarts
[01:27:48.645]                         grepl <- base::grepl
[01:27:48.645]                         restarts <- computeRestarts(cond)
[01:27:48.645]                         for (restart in restarts) {
[01:27:48.645]                           name <- restart$name
[01:27:48.645]                           if (is.null(name)) 
[01:27:48.645]                             next
[01:27:48.645]                           if (!grepl(pattern, name)) 
[01:27:48.645]                             next
[01:27:48.645]                           invokeRestart(restart)
[01:27:48.645]                           muffled <- TRUE
[01:27:48.645]                           break
[01:27:48.645]                         }
[01:27:48.645]                       }
[01:27:48.645]                     }
[01:27:48.645]                     invisible(muffled)
[01:27:48.645]                   }
[01:27:48.645]                   muffleCondition(cond)
[01:27:48.645]                 })
[01:27:48.645]             }))
[01:27:48.645]             future::FutureResult(value = ...future.value$value, 
[01:27:48.645]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.645]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.645]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.645]                     ...future.globalenv.names))
[01:27:48.645]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.645]         }, condition = base::local({
[01:27:48.645]             c <- base::c
[01:27:48.645]             inherits <- base::inherits
[01:27:48.645]             invokeRestart <- base::invokeRestart
[01:27:48.645]             length <- base::length
[01:27:48.645]             list <- base::list
[01:27:48.645]             seq.int <- base::seq.int
[01:27:48.645]             signalCondition <- base::signalCondition
[01:27:48.645]             sys.calls <- base::sys.calls
[01:27:48.645]             `[[` <- base::`[[`
[01:27:48.645]             `+` <- base::`+`
[01:27:48.645]             `<<-` <- base::`<<-`
[01:27:48.645]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.645]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.645]                   3L)]
[01:27:48.645]             }
[01:27:48.645]             function(cond) {
[01:27:48.645]                 is_error <- inherits(cond, "error")
[01:27:48.645]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.645]                   NULL)
[01:27:48.645]                 if (is_error) {
[01:27:48.645]                   sessionInformation <- function() {
[01:27:48.645]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.645]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.645]                       search = base::search(), system = base::Sys.info())
[01:27:48.645]                   }
[01:27:48.645]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.645]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.645]                     cond$call), session = sessionInformation(), 
[01:27:48.645]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.645]                   signalCondition(cond)
[01:27:48.645]                 }
[01:27:48.645]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.645]                 "immediateCondition"))) {
[01:27:48.645]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.645]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.645]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.645]                   if (TRUE && !signal) {
[01:27:48.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.645]                     {
[01:27:48.645]                       inherits <- base::inherits
[01:27:48.645]                       invokeRestart <- base::invokeRestart
[01:27:48.645]                       is.null <- base::is.null
[01:27:48.645]                       muffled <- FALSE
[01:27:48.645]                       if (inherits(cond, "message")) {
[01:27:48.645]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.645]                         if (muffled) 
[01:27:48.645]                           invokeRestart("muffleMessage")
[01:27:48.645]                       }
[01:27:48.645]                       else if (inherits(cond, "warning")) {
[01:27:48.645]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.645]                         if (muffled) 
[01:27:48.645]                           invokeRestart("muffleWarning")
[01:27:48.645]                       }
[01:27:48.645]                       else if (inherits(cond, "condition")) {
[01:27:48.645]                         if (!is.null(pattern)) {
[01:27:48.645]                           computeRestarts <- base::computeRestarts
[01:27:48.645]                           grepl <- base::grepl
[01:27:48.645]                           restarts <- computeRestarts(cond)
[01:27:48.645]                           for (restart in restarts) {
[01:27:48.645]                             name <- restart$name
[01:27:48.645]                             if (is.null(name)) 
[01:27:48.645]                               next
[01:27:48.645]                             if (!grepl(pattern, name)) 
[01:27:48.645]                               next
[01:27:48.645]                             invokeRestart(restart)
[01:27:48.645]                             muffled <- TRUE
[01:27:48.645]                             break
[01:27:48.645]                           }
[01:27:48.645]                         }
[01:27:48.645]                       }
[01:27:48.645]                       invisible(muffled)
[01:27:48.645]                     }
[01:27:48.645]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.645]                   }
[01:27:48.645]                 }
[01:27:48.645]                 else {
[01:27:48.645]                   if (TRUE) {
[01:27:48.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.645]                     {
[01:27:48.645]                       inherits <- base::inherits
[01:27:48.645]                       invokeRestart <- base::invokeRestart
[01:27:48.645]                       is.null <- base::is.null
[01:27:48.645]                       muffled <- FALSE
[01:27:48.645]                       if (inherits(cond, "message")) {
[01:27:48.645]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.645]                         if (muffled) 
[01:27:48.645]                           invokeRestart("muffleMessage")
[01:27:48.645]                       }
[01:27:48.645]                       else if (inherits(cond, "warning")) {
[01:27:48.645]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.645]                         if (muffled) 
[01:27:48.645]                           invokeRestart("muffleWarning")
[01:27:48.645]                       }
[01:27:48.645]                       else if (inherits(cond, "condition")) {
[01:27:48.645]                         if (!is.null(pattern)) {
[01:27:48.645]                           computeRestarts <- base::computeRestarts
[01:27:48.645]                           grepl <- base::grepl
[01:27:48.645]                           restarts <- computeRestarts(cond)
[01:27:48.645]                           for (restart in restarts) {
[01:27:48.645]                             name <- restart$name
[01:27:48.645]                             if (is.null(name)) 
[01:27:48.645]                               next
[01:27:48.645]                             if (!grepl(pattern, name)) 
[01:27:48.645]                               next
[01:27:48.645]                             invokeRestart(restart)
[01:27:48.645]                             muffled <- TRUE
[01:27:48.645]                             break
[01:27:48.645]                           }
[01:27:48.645]                         }
[01:27:48.645]                       }
[01:27:48.645]                       invisible(muffled)
[01:27:48.645]                     }
[01:27:48.645]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.645]                   }
[01:27:48.645]                 }
[01:27:48.645]             }
[01:27:48.645]         }))
[01:27:48.645]     }, error = function(ex) {
[01:27:48.645]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.645]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.645]                 ...future.rng), started = ...future.startTime, 
[01:27:48.645]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.645]             version = "1.8"), class = "FutureResult")
[01:27:48.645]     }, finally = {
[01:27:48.645]         if (!identical(...future.workdir, getwd())) 
[01:27:48.645]             setwd(...future.workdir)
[01:27:48.645]         {
[01:27:48.645]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.645]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.645]             }
[01:27:48.645]             base::options(...future.oldOptions)
[01:27:48.645]             if (.Platform$OS.type == "windows") {
[01:27:48.645]                 old_names <- names(...future.oldEnvVars)
[01:27:48.645]                 envs <- base::Sys.getenv()
[01:27:48.645]                 names <- names(envs)
[01:27:48.645]                 common <- intersect(names, old_names)
[01:27:48.645]                 added <- setdiff(names, old_names)
[01:27:48.645]                 removed <- setdiff(old_names, names)
[01:27:48.645]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.645]                   envs[common]]
[01:27:48.645]                 NAMES <- toupper(changed)
[01:27:48.645]                 args <- list()
[01:27:48.645]                 for (kk in seq_along(NAMES)) {
[01:27:48.645]                   name <- changed[[kk]]
[01:27:48.645]                   NAME <- NAMES[[kk]]
[01:27:48.645]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.645]                     next
[01:27:48.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.645]                 }
[01:27:48.645]                 NAMES <- toupper(added)
[01:27:48.645]                 for (kk in seq_along(NAMES)) {
[01:27:48.645]                   name <- added[[kk]]
[01:27:48.645]                   NAME <- NAMES[[kk]]
[01:27:48.645]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.645]                     next
[01:27:48.645]                   args[[name]] <- ""
[01:27:48.645]                 }
[01:27:48.645]                 NAMES <- toupper(removed)
[01:27:48.645]                 for (kk in seq_along(NAMES)) {
[01:27:48.645]                   name <- removed[[kk]]
[01:27:48.645]                   NAME <- NAMES[[kk]]
[01:27:48.645]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.645]                     next
[01:27:48.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.645]                 }
[01:27:48.645]                 if (length(args) > 0) 
[01:27:48.645]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.645]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.645]             }
[01:27:48.645]             else {
[01:27:48.645]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.645]             }
[01:27:48.645]             {
[01:27:48.645]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.645]                   0L) {
[01:27:48.645]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.645]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.645]                   base::options(opts)
[01:27:48.645]                 }
[01:27:48.645]                 {
[01:27:48.645]                   {
[01:27:48.645]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.645]                     NULL
[01:27:48.645]                   }
[01:27:48.645]                   options(future.plan = NULL)
[01:27:48.645]                   if (is.na(NA_character_)) 
[01:27:48.645]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.645]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.645]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.645]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.645]                     envir = parent.frame()) 
[01:27:48.645]                   {
[01:27:48.645]                     if (is.function(workers)) 
[01:27:48.645]                       workers <- workers()
[01:27:48.645]                     workers <- structure(as.integer(workers), 
[01:27:48.645]                       class = class(workers))
[01:27:48.645]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.645]                       workers >= 1)
[01:27:48.645]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.645]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.645]                     }
[01:27:48.645]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.645]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.645]                       envir = envir)
[01:27:48.645]                     if (!future$lazy) 
[01:27:48.645]                       future <- run(future)
[01:27:48.645]                     invisible(future)
[01:27:48.645]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.645]                 }
[01:27:48.645]             }
[01:27:48.645]         }
[01:27:48.645]     })
[01:27:48.645]     if (TRUE) {
[01:27:48.645]         base::sink(type = "output", split = FALSE)
[01:27:48.645]         if (TRUE) {
[01:27:48.645]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.645]         }
[01:27:48.645]         else {
[01:27:48.645]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.645]         }
[01:27:48.645]         base::close(...future.stdout)
[01:27:48.645]         ...future.stdout <- NULL
[01:27:48.645]     }
[01:27:48.645]     ...future.result$conditions <- ...future.conditions
[01:27:48.645]     ...future.result$finished <- base::Sys.time()
[01:27:48.645]     ...future.result
[01:27:48.645] }
[01:27:48.728] MultisessionFuture started
[01:27:48.728] result() for ClusterFuture ...
[01:27:48.729] receiveMessageFromWorker() for ClusterFuture ...
[01:27:48.729] - Validating connection of MultisessionFuture
[01:27:48.787] - received message: FutureResult
[01:27:48.787] - Received FutureResult
[01:27:48.787] - Erased future from FutureRegistry
[01:27:48.788] result() for ClusterFuture ...
[01:27:48.788] - result already collected: FutureResult
[01:27:48.788] result() for ClusterFuture ... done
[01:27:48.788] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:48.788] result() for ClusterFuture ... done
[01:27:48.789] result() for ClusterFuture ...
[01:27:48.789] - result already collected: FutureResult
[01:27:48.789] result() for ClusterFuture ... done
[01:27:48.792] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:27:48.795] plan(): nbrOfWorkers() = 2
Dimensions: NULL
[01:27:48.795] getGlobalsAndPackages() ...
[01:27:48.795] Searching for globals...
[01:27:48.796] 
[01:27:48.796] Searching for globals ... DONE
[01:27:48.796] - globals: [0] <none>
[01:27:48.796] getGlobalsAndPackages() ... DONE
[01:27:48.797] run() for 'Future' ...
[01:27:48.797] - state: 'created'
[01:27:48.797] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.811] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.812] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.812]   - Field: 'node'
[01:27:48.812]   - Field: 'label'
[01:27:48.812]   - Field: 'local'
[01:27:48.812]   - Field: 'owner'
[01:27:48.813]   - Field: 'envir'
[01:27:48.813]   - Field: 'workers'
[01:27:48.813]   - Field: 'packages'
[01:27:48.813]   - Field: 'gc'
[01:27:48.813]   - Field: 'conditions'
[01:27:48.814]   - Field: 'persistent'
[01:27:48.814]   - Field: 'expr'
[01:27:48.814]   - Field: 'uuid'
[01:27:48.814]   - Field: 'seed'
[01:27:48.814]   - Field: 'version'
[01:27:48.814]   - Field: 'result'
[01:27:48.815]   - Field: 'asynchronous'
[01:27:48.815]   - Field: 'calls'
[01:27:48.815]   - Field: 'globals'
[01:27:48.815]   - Field: 'stdout'
[01:27:48.815]   - Field: 'earlySignal'
[01:27:48.815]   - Field: 'lazy'
[01:27:48.816]   - Field: 'state'
[01:27:48.816] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.816] - Launch lazy future ...
[01:27:48.816] Packages needed by the future expression (n = 0): <none>
[01:27:48.817] Packages needed by future strategies (n = 0): <none>
[01:27:48.817] {
[01:27:48.817]     {
[01:27:48.817]         {
[01:27:48.817]             ...future.startTime <- base::Sys.time()
[01:27:48.817]             {
[01:27:48.817]                 {
[01:27:48.817]                   {
[01:27:48.817]                     {
[01:27:48.817]                       base::local({
[01:27:48.817]                         has_future <- base::requireNamespace("future", 
[01:27:48.817]                           quietly = TRUE)
[01:27:48.817]                         if (has_future) {
[01:27:48.817]                           ns <- base::getNamespace("future")
[01:27:48.817]                           version <- ns[[".package"]][["version"]]
[01:27:48.817]                           if (is.null(version)) 
[01:27:48.817]                             version <- utils::packageVersion("future")
[01:27:48.817]                         }
[01:27:48.817]                         else {
[01:27:48.817]                           version <- NULL
[01:27:48.817]                         }
[01:27:48.817]                         if (!has_future || version < "1.8.0") {
[01:27:48.817]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.817]                             "", base::R.version$version.string), 
[01:27:48.817]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.817]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.817]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.817]                               "release", "version")], collapse = " "), 
[01:27:48.817]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.817]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.817]                             info)
[01:27:48.817]                           info <- base::paste(info, collapse = "; ")
[01:27:48.817]                           if (!has_future) {
[01:27:48.817]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.817]                               info)
[01:27:48.817]                           }
[01:27:48.817]                           else {
[01:27:48.817]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.817]                               info, version)
[01:27:48.817]                           }
[01:27:48.817]                           base::stop(msg)
[01:27:48.817]                         }
[01:27:48.817]                       })
[01:27:48.817]                     }
[01:27:48.817]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.817]                     base::options(mc.cores = 1L)
[01:27:48.817]                   }
[01:27:48.817]                   options(future.plan = NULL)
[01:27:48.817]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.817]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.817]                 }
[01:27:48.817]                 ...future.workdir <- getwd()
[01:27:48.817]             }
[01:27:48.817]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.817]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.817]         }
[01:27:48.817]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.817]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.817]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.817]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.817]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.817]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.817]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.817]             base::names(...future.oldOptions))
[01:27:48.817]     }
[01:27:48.817]     if (FALSE) {
[01:27:48.817]     }
[01:27:48.817]     else {
[01:27:48.817]         if (TRUE) {
[01:27:48.817]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.817]                 open = "w")
[01:27:48.817]         }
[01:27:48.817]         else {
[01:27:48.817]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.817]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.817]         }
[01:27:48.817]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.817]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.817]             base::sink(type = "output", split = FALSE)
[01:27:48.817]             base::close(...future.stdout)
[01:27:48.817]         }, add = TRUE)
[01:27:48.817]     }
[01:27:48.817]     ...future.frame <- base::sys.nframe()
[01:27:48.817]     ...future.conditions <- base::list()
[01:27:48.817]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.817]     if (FALSE) {
[01:27:48.817]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.817]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.817]     }
[01:27:48.817]     ...future.result <- base::tryCatch({
[01:27:48.817]         base::withCallingHandlers({
[01:27:48.817]             ...future.value <- base::withVisible(base::local({
[01:27:48.817]                 ...future.makeSendCondition <- base::local({
[01:27:48.817]                   sendCondition <- NULL
[01:27:48.817]                   function(frame = 1L) {
[01:27:48.817]                     if (is.function(sendCondition)) 
[01:27:48.817]                       return(sendCondition)
[01:27:48.817]                     ns <- getNamespace("parallel")
[01:27:48.817]                     if (exists("sendData", mode = "function", 
[01:27:48.817]                       envir = ns)) {
[01:27:48.817]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.817]                         envir = ns)
[01:27:48.817]                       envir <- sys.frame(frame)
[01:27:48.817]                       master <- NULL
[01:27:48.817]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.817]                         !identical(envir, emptyenv())) {
[01:27:48.817]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.817]                           inherits = FALSE)) {
[01:27:48.817]                           master <- get("master", mode = "list", 
[01:27:48.817]                             envir = envir, inherits = FALSE)
[01:27:48.817]                           if (inherits(master, c("SOCKnode", 
[01:27:48.817]                             "SOCK0node"))) {
[01:27:48.817]                             sendCondition <<- function(cond) {
[01:27:48.817]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.817]                                 success = TRUE)
[01:27:48.817]                               parallel_sendData(master, data)
[01:27:48.817]                             }
[01:27:48.817]                             return(sendCondition)
[01:27:48.817]                           }
[01:27:48.817]                         }
[01:27:48.817]                         frame <- frame + 1L
[01:27:48.817]                         envir <- sys.frame(frame)
[01:27:48.817]                       }
[01:27:48.817]                     }
[01:27:48.817]                     sendCondition <<- function(cond) NULL
[01:27:48.817]                   }
[01:27:48.817]                 })
[01:27:48.817]                 withCallingHandlers({
[01:27:48.817]                   2
[01:27:48.817]                 }, immediateCondition = function(cond) {
[01:27:48.817]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.817]                   sendCondition(cond)
[01:27:48.817]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.817]                   {
[01:27:48.817]                     inherits <- base::inherits
[01:27:48.817]                     invokeRestart <- base::invokeRestart
[01:27:48.817]                     is.null <- base::is.null
[01:27:48.817]                     muffled <- FALSE
[01:27:48.817]                     if (inherits(cond, "message")) {
[01:27:48.817]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.817]                       if (muffled) 
[01:27:48.817]                         invokeRestart("muffleMessage")
[01:27:48.817]                     }
[01:27:48.817]                     else if (inherits(cond, "warning")) {
[01:27:48.817]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.817]                       if (muffled) 
[01:27:48.817]                         invokeRestart("muffleWarning")
[01:27:48.817]                     }
[01:27:48.817]                     else if (inherits(cond, "condition")) {
[01:27:48.817]                       if (!is.null(pattern)) {
[01:27:48.817]                         computeRestarts <- base::computeRestarts
[01:27:48.817]                         grepl <- base::grepl
[01:27:48.817]                         restarts <- computeRestarts(cond)
[01:27:48.817]                         for (restart in restarts) {
[01:27:48.817]                           name <- restart$name
[01:27:48.817]                           if (is.null(name)) 
[01:27:48.817]                             next
[01:27:48.817]                           if (!grepl(pattern, name)) 
[01:27:48.817]                             next
[01:27:48.817]                           invokeRestart(restart)
[01:27:48.817]                           muffled <- TRUE
[01:27:48.817]                           break
[01:27:48.817]                         }
[01:27:48.817]                       }
[01:27:48.817]                     }
[01:27:48.817]                     invisible(muffled)
[01:27:48.817]                   }
[01:27:48.817]                   muffleCondition(cond)
[01:27:48.817]                 })
[01:27:48.817]             }))
[01:27:48.817]             future::FutureResult(value = ...future.value$value, 
[01:27:48.817]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.817]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.817]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.817]                     ...future.globalenv.names))
[01:27:48.817]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.817]         }, condition = base::local({
[01:27:48.817]             c <- base::c
[01:27:48.817]             inherits <- base::inherits
[01:27:48.817]             invokeRestart <- base::invokeRestart
[01:27:48.817]             length <- base::length
[01:27:48.817]             list <- base::list
[01:27:48.817]             seq.int <- base::seq.int
[01:27:48.817]             signalCondition <- base::signalCondition
[01:27:48.817]             sys.calls <- base::sys.calls
[01:27:48.817]             `[[` <- base::`[[`
[01:27:48.817]             `+` <- base::`+`
[01:27:48.817]             `<<-` <- base::`<<-`
[01:27:48.817]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.817]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.817]                   3L)]
[01:27:48.817]             }
[01:27:48.817]             function(cond) {
[01:27:48.817]                 is_error <- inherits(cond, "error")
[01:27:48.817]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.817]                   NULL)
[01:27:48.817]                 if (is_error) {
[01:27:48.817]                   sessionInformation <- function() {
[01:27:48.817]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.817]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.817]                       search = base::search(), system = base::Sys.info())
[01:27:48.817]                   }
[01:27:48.817]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.817]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.817]                     cond$call), session = sessionInformation(), 
[01:27:48.817]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.817]                   signalCondition(cond)
[01:27:48.817]                 }
[01:27:48.817]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.817]                 "immediateCondition"))) {
[01:27:48.817]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.817]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.817]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.817]                   if (TRUE && !signal) {
[01:27:48.817]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.817]                     {
[01:27:48.817]                       inherits <- base::inherits
[01:27:48.817]                       invokeRestart <- base::invokeRestart
[01:27:48.817]                       is.null <- base::is.null
[01:27:48.817]                       muffled <- FALSE
[01:27:48.817]                       if (inherits(cond, "message")) {
[01:27:48.817]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.817]                         if (muffled) 
[01:27:48.817]                           invokeRestart("muffleMessage")
[01:27:48.817]                       }
[01:27:48.817]                       else if (inherits(cond, "warning")) {
[01:27:48.817]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.817]                         if (muffled) 
[01:27:48.817]                           invokeRestart("muffleWarning")
[01:27:48.817]                       }
[01:27:48.817]                       else if (inherits(cond, "condition")) {
[01:27:48.817]                         if (!is.null(pattern)) {
[01:27:48.817]                           computeRestarts <- base::computeRestarts
[01:27:48.817]                           grepl <- base::grepl
[01:27:48.817]                           restarts <- computeRestarts(cond)
[01:27:48.817]                           for (restart in restarts) {
[01:27:48.817]                             name <- restart$name
[01:27:48.817]                             if (is.null(name)) 
[01:27:48.817]                               next
[01:27:48.817]                             if (!grepl(pattern, name)) 
[01:27:48.817]                               next
[01:27:48.817]                             invokeRestart(restart)
[01:27:48.817]                             muffled <- TRUE
[01:27:48.817]                             break
[01:27:48.817]                           }
[01:27:48.817]                         }
[01:27:48.817]                       }
[01:27:48.817]                       invisible(muffled)
[01:27:48.817]                     }
[01:27:48.817]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.817]                   }
[01:27:48.817]                 }
[01:27:48.817]                 else {
[01:27:48.817]                   if (TRUE) {
[01:27:48.817]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.817]                     {
[01:27:48.817]                       inherits <- base::inherits
[01:27:48.817]                       invokeRestart <- base::invokeRestart
[01:27:48.817]                       is.null <- base::is.null
[01:27:48.817]                       muffled <- FALSE
[01:27:48.817]                       if (inherits(cond, "message")) {
[01:27:48.817]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.817]                         if (muffled) 
[01:27:48.817]                           invokeRestart("muffleMessage")
[01:27:48.817]                       }
[01:27:48.817]                       else if (inherits(cond, "warning")) {
[01:27:48.817]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.817]                         if (muffled) 
[01:27:48.817]                           invokeRestart("muffleWarning")
[01:27:48.817]                       }
[01:27:48.817]                       else if (inherits(cond, "condition")) {
[01:27:48.817]                         if (!is.null(pattern)) {
[01:27:48.817]                           computeRestarts <- base::computeRestarts
[01:27:48.817]                           grepl <- base::grepl
[01:27:48.817]                           restarts <- computeRestarts(cond)
[01:27:48.817]                           for (restart in restarts) {
[01:27:48.817]                             name <- restart$name
[01:27:48.817]                             if (is.null(name)) 
[01:27:48.817]                               next
[01:27:48.817]                             if (!grepl(pattern, name)) 
[01:27:48.817]                               next
[01:27:48.817]                             invokeRestart(restart)
[01:27:48.817]                             muffled <- TRUE
[01:27:48.817]                             break
[01:27:48.817]                           }
[01:27:48.817]                         }
[01:27:48.817]                       }
[01:27:48.817]                       invisible(muffled)
[01:27:48.817]                     }
[01:27:48.817]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.817]                   }
[01:27:48.817]                 }
[01:27:48.817]             }
[01:27:48.817]         }))
[01:27:48.817]     }, error = function(ex) {
[01:27:48.817]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.817]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.817]                 ...future.rng), started = ...future.startTime, 
[01:27:48.817]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.817]             version = "1.8"), class = "FutureResult")
[01:27:48.817]     }, finally = {
[01:27:48.817]         if (!identical(...future.workdir, getwd())) 
[01:27:48.817]             setwd(...future.workdir)
[01:27:48.817]         {
[01:27:48.817]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.817]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.817]             }
[01:27:48.817]             base::options(...future.oldOptions)
[01:27:48.817]             if (.Platform$OS.type == "windows") {
[01:27:48.817]                 old_names <- names(...future.oldEnvVars)
[01:27:48.817]                 envs <- base::Sys.getenv()
[01:27:48.817]                 names <- names(envs)
[01:27:48.817]                 common <- intersect(names, old_names)
[01:27:48.817]                 added <- setdiff(names, old_names)
[01:27:48.817]                 removed <- setdiff(old_names, names)
[01:27:48.817]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.817]                   envs[common]]
[01:27:48.817]                 NAMES <- toupper(changed)
[01:27:48.817]                 args <- list()
[01:27:48.817]                 for (kk in seq_along(NAMES)) {
[01:27:48.817]                   name <- changed[[kk]]
[01:27:48.817]                   NAME <- NAMES[[kk]]
[01:27:48.817]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.817]                     next
[01:27:48.817]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.817]                 }
[01:27:48.817]                 NAMES <- toupper(added)
[01:27:48.817]                 for (kk in seq_along(NAMES)) {
[01:27:48.817]                   name <- added[[kk]]
[01:27:48.817]                   NAME <- NAMES[[kk]]
[01:27:48.817]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.817]                     next
[01:27:48.817]                   args[[name]] <- ""
[01:27:48.817]                 }
[01:27:48.817]                 NAMES <- toupper(removed)
[01:27:48.817]                 for (kk in seq_along(NAMES)) {
[01:27:48.817]                   name <- removed[[kk]]
[01:27:48.817]                   NAME <- NAMES[[kk]]
[01:27:48.817]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.817]                     next
[01:27:48.817]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.817]                 }
[01:27:48.817]                 if (length(args) > 0) 
[01:27:48.817]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.817]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.817]             }
[01:27:48.817]             else {
[01:27:48.817]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.817]             }
[01:27:48.817]             {
[01:27:48.817]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.817]                   0L) {
[01:27:48.817]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.817]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.817]                   base::options(opts)
[01:27:48.817]                 }
[01:27:48.817]                 {
[01:27:48.817]                   {
[01:27:48.817]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.817]                     NULL
[01:27:48.817]                   }
[01:27:48.817]                   options(future.plan = NULL)
[01:27:48.817]                   if (is.na(NA_character_)) 
[01:27:48.817]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.817]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.817]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.817]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.817]                     envir = parent.frame()) 
[01:27:48.817]                   {
[01:27:48.817]                     if (is.function(workers)) 
[01:27:48.817]                       workers <- workers()
[01:27:48.817]                     workers <- structure(as.integer(workers), 
[01:27:48.817]                       class = class(workers))
[01:27:48.817]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.817]                       workers >= 1)
[01:27:48.817]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.817]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.817]                     }
[01:27:48.817]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.817]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.817]                       envir = envir)
[01:27:48.817]                     if (!future$lazy) 
[01:27:48.817]                       future <- run(future)
[01:27:48.817]                     invisible(future)
[01:27:48.817]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.817]                 }
[01:27:48.817]             }
[01:27:48.817]         }
[01:27:48.817]     })
[01:27:48.817]     if (TRUE) {
[01:27:48.817]         base::sink(type = "output", split = FALSE)
[01:27:48.817]         if (TRUE) {
[01:27:48.817]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.817]         }
[01:27:48.817]         else {
[01:27:48.817]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.817]         }
[01:27:48.817]         base::close(...future.stdout)
[01:27:48.817]         ...future.stdout <- NULL
[01:27:48.817]     }
[01:27:48.817]     ...future.result$conditions <- ...future.conditions
[01:27:48.817]     ...future.result$finished <- base::Sys.time()
[01:27:48.817]     ...future.result
[01:27:48.817] }
[01:27:48.823] MultisessionFuture started
[01:27:48.823] - Launch lazy future ... done
[01:27:48.823] run() for 'MultisessionFuture' ... done
[01:27:48.824] getGlobalsAndPackages() ...
[01:27:48.824] Searching for globals...
[01:27:48.824] 
[01:27:48.824] Searching for globals ... DONE
[01:27:48.825] - globals: [0] <none>
[01:27:48.825] getGlobalsAndPackages() ... DONE
[01:27:48.825] run() for 'Future' ...
[01:27:48.825] - state: 'created'
[01:27:48.826] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.839] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.840] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.840]   - Field: 'node'
[01:27:48.840]   - Field: 'label'
[01:27:48.840]   - Field: 'local'
[01:27:48.840]   - Field: 'owner'
[01:27:48.841]   - Field: 'envir'
[01:27:48.841]   - Field: 'workers'
[01:27:48.841]   - Field: 'packages'
[01:27:48.841]   - Field: 'gc'
[01:27:48.841]   - Field: 'conditions'
[01:27:48.841]   - Field: 'persistent'
[01:27:48.842]   - Field: 'expr'
[01:27:48.842]   - Field: 'uuid'
[01:27:48.842]   - Field: 'seed'
[01:27:48.842]   - Field: 'version'
[01:27:48.842]   - Field: 'result'
[01:27:48.843]   - Field: 'asynchronous'
[01:27:48.843]   - Field: 'calls'
[01:27:48.843]   - Field: 'globals'
[01:27:48.843]   - Field: 'stdout'
[01:27:48.843]   - Field: 'earlySignal'
[01:27:48.843]   - Field: 'lazy'
[01:27:48.844]   - Field: 'state'
[01:27:48.844] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.844] - Launch lazy future ...
[01:27:48.844] Packages needed by the future expression (n = 0): <none>
[01:27:48.844] Packages needed by future strategies (n = 0): <none>
[01:27:48.845] {
[01:27:48.845]     {
[01:27:48.845]         {
[01:27:48.845]             ...future.startTime <- base::Sys.time()
[01:27:48.845]             {
[01:27:48.845]                 {
[01:27:48.845]                   {
[01:27:48.845]                     {
[01:27:48.845]                       base::local({
[01:27:48.845]                         has_future <- base::requireNamespace("future", 
[01:27:48.845]                           quietly = TRUE)
[01:27:48.845]                         if (has_future) {
[01:27:48.845]                           ns <- base::getNamespace("future")
[01:27:48.845]                           version <- ns[[".package"]][["version"]]
[01:27:48.845]                           if (is.null(version)) 
[01:27:48.845]                             version <- utils::packageVersion("future")
[01:27:48.845]                         }
[01:27:48.845]                         else {
[01:27:48.845]                           version <- NULL
[01:27:48.845]                         }
[01:27:48.845]                         if (!has_future || version < "1.8.0") {
[01:27:48.845]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.845]                             "", base::R.version$version.string), 
[01:27:48.845]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.845]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.845]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.845]                               "release", "version")], collapse = " "), 
[01:27:48.845]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.845]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.845]                             info)
[01:27:48.845]                           info <- base::paste(info, collapse = "; ")
[01:27:48.845]                           if (!has_future) {
[01:27:48.845]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.845]                               info)
[01:27:48.845]                           }
[01:27:48.845]                           else {
[01:27:48.845]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.845]                               info, version)
[01:27:48.845]                           }
[01:27:48.845]                           base::stop(msg)
[01:27:48.845]                         }
[01:27:48.845]                       })
[01:27:48.845]                     }
[01:27:48.845]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.845]                     base::options(mc.cores = 1L)
[01:27:48.845]                   }
[01:27:48.845]                   options(future.plan = NULL)
[01:27:48.845]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.845]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.845]                 }
[01:27:48.845]                 ...future.workdir <- getwd()
[01:27:48.845]             }
[01:27:48.845]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.845]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.845]         }
[01:27:48.845]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.845]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.845]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.845]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.845]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.845]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.845]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.845]             base::names(...future.oldOptions))
[01:27:48.845]     }
[01:27:48.845]     if (FALSE) {
[01:27:48.845]     }
[01:27:48.845]     else {
[01:27:48.845]         if (TRUE) {
[01:27:48.845]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.845]                 open = "w")
[01:27:48.845]         }
[01:27:48.845]         else {
[01:27:48.845]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.845]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.845]         }
[01:27:48.845]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.845]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.845]             base::sink(type = "output", split = FALSE)
[01:27:48.845]             base::close(...future.stdout)
[01:27:48.845]         }, add = TRUE)
[01:27:48.845]     }
[01:27:48.845]     ...future.frame <- base::sys.nframe()
[01:27:48.845]     ...future.conditions <- base::list()
[01:27:48.845]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.845]     if (FALSE) {
[01:27:48.845]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.845]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.845]     }
[01:27:48.845]     ...future.result <- base::tryCatch({
[01:27:48.845]         base::withCallingHandlers({
[01:27:48.845]             ...future.value <- base::withVisible(base::local({
[01:27:48.845]                 ...future.makeSendCondition <- base::local({
[01:27:48.845]                   sendCondition <- NULL
[01:27:48.845]                   function(frame = 1L) {
[01:27:48.845]                     if (is.function(sendCondition)) 
[01:27:48.845]                       return(sendCondition)
[01:27:48.845]                     ns <- getNamespace("parallel")
[01:27:48.845]                     if (exists("sendData", mode = "function", 
[01:27:48.845]                       envir = ns)) {
[01:27:48.845]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.845]                         envir = ns)
[01:27:48.845]                       envir <- sys.frame(frame)
[01:27:48.845]                       master <- NULL
[01:27:48.845]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.845]                         !identical(envir, emptyenv())) {
[01:27:48.845]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.845]                           inherits = FALSE)) {
[01:27:48.845]                           master <- get("master", mode = "list", 
[01:27:48.845]                             envir = envir, inherits = FALSE)
[01:27:48.845]                           if (inherits(master, c("SOCKnode", 
[01:27:48.845]                             "SOCK0node"))) {
[01:27:48.845]                             sendCondition <<- function(cond) {
[01:27:48.845]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.845]                                 success = TRUE)
[01:27:48.845]                               parallel_sendData(master, data)
[01:27:48.845]                             }
[01:27:48.845]                             return(sendCondition)
[01:27:48.845]                           }
[01:27:48.845]                         }
[01:27:48.845]                         frame <- frame + 1L
[01:27:48.845]                         envir <- sys.frame(frame)
[01:27:48.845]                       }
[01:27:48.845]                     }
[01:27:48.845]                     sendCondition <<- function(cond) NULL
[01:27:48.845]                   }
[01:27:48.845]                 })
[01:27:48.845]                 withCallingHandlers({
[01:27:48.845]                   NULL
[01:27:48.845]                 }, immediateCondition = function(cond) {
[01:27:48.845]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.845]                   sendCondition(cond)
[01:27:48.845]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.845]                   {
[01:27:48.845]                     inherits <- base::inherits
[01:27:48.845]                     invokeRestart <- base::invokeRestart
[01:27:48.845]                     is.null <- base::is.null
[01:27:48.845]                     muffled <- FALSE
[01:27:48.845]                     if (inherits(cond, "message")) {
[01:27:48.845]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.845]                       if (muffled) 
[01:27:48.845]                         invokeRestart("muffleMessage")
[01:27:48.845]                     }
[01:27:48.845]                     else if (inherits(cond, "warning")) {
[01:27:48.845]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.845]                       if (muffled) 
[01:27:48.845]                         invokeRestart("muffleWarning")
[01:27:48.845]                     }
[01:27:48.845]                     else if (inherits(cond, "condition")) {
[01:27:48.845]                       if (!is.null(pattern)) {
[01:27:48.845]                         computeRestarts <- base::computeRestarts
[01:27:48.845]                         grepl <- base::grepl
[01:27:48.845]                         restarts <- computeRestarts(cond)
[01:27:48.845]                         for (restart in restarts) {
[01:27:48.845]                           name <- restart$name
[01:27:48.845]                           if (is.null(name)) 
[01:27:48.845]                             next
[01:27:48.845]                           if (!grepl(pattern, name)) 
[01:27:48.845]                             next
[01:27:48.845]                           invokeRestart(restart)
[01:27:48.845]                           muffled <- TRUE
[01:27:48.845]                           break
[01:27:48.845]                         }
[01:27:48.845]                       }
[01:27:48.845]                     }
[01:27:48.845]                     invisible(muffled)
[01:27:48.845]                   }
[01:27:48.845]                   muffleCondition(cond)
[01:27:48.845]                 })
[01:27:48.845]             }))
[01:27:48.845]             future::FutureResult(value = ...future.value$value, 
[01:27:48.845]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.845]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.845]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.845]                     ...future.globalenv.names))
[01:27:48.845]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.845]         }, condition = base::local({
[01:27:48.845]             c <- base::c
[01:27:48.845]             inherits <- base::inherits
[01:27:48.845]             invokeRestart <- base::invokeRestart
[01:27:48.845]             length <- base::length
[01:27:48.845]             list <- base::list
[01:27:48.845]             seq.int <- base::seq.int
[01:27:48.845]             signalCondition <- base::signalCondition
[01:27:48.845]             sys.calls <- base::sys.calls
[01:27:48.845]             `[[` <- base::`[[`
[01:27:48.845]             `+` <- base::`+`
[01:27:48.845]             `<<-` <- base::`<<-`
[01:27:48.845]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.845]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.845]                   3L)]
[01:27:48.845]             }
[01:27:48.845]             function(cond) {
[01:27:48.845]                 is_error <- inherits(cond, "error")
[01:27:48.845]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.845]                   NULL)
[01:27:48.845]                 if (is_error) {
[01:27:48.845]                   sessionInformation <- function() {
[01:27:48.845]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.845]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.845]                       search = base::search(), system = base::Sys.info())
[01:27:48.845]                   }
[01:27:48.845]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.845]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.845]                     cond$call), session = sessionInformation(), 
[01:27:48.845]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.845]                   signalCondition(cond)
[01:27:48.845]                 }
[01:27:48.845]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.845]                 "immediateCondition"))) {
[01:27:48.845]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.845]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.845]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.845]                   if (TRUE && !signal) {
[01:27:48.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.845]                     {
[01:27:48.845]                       inherits <- base::inherits
[01:27:48.845]                       invokeRestart <- base::invokeRestart
[01:27:48.845]                       is.null <- base::is.null
[01:27:48.845]                       muffled <- FALSE
[01:27:48.845]                       if (inherits(cond, "message")) {
[01:27:48.845]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.845]                         if (muffled) 
[01:27:48.845]                           invokeRestart("muffleMessage")
[01:27:48.845]                       }
[01:27:48.845]                       else if (inherits(cond, "warning")) {
[01:27:48.845]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.845]                         if (muffled) 
[01:27:48.845]                           invokeRestart("muffleWarning")
[01:27:48.845]                       }
[01:27:48.845]                       else if (inherits(cond, "condition")) {
[01:27:48.845]                         if (!is.null(pattern)) {
[01:27:48.845]                           computeRestarts <- base::computeRestarts
[01:27:48.845]                           grepl <- base::grepl
[01:27:48.845]                           restarts <- computeRestarts(cond)
[01:27:48.845]                           for (restart in restarts) {
[01:27:48.845]                             name <- restart$name
[01:27:48.845]                             if (is.null(name)) 
[01:27:48.845]                               next
[01:27:48.845]                             if (!grepl(pattern, name)) 
[01:27:48.845]                               next
[01:27:48.845]                             invokeRestart(restart)
[01:27:48.845]                             muffled <- TRUE
[01:27:48.845]                             break
[01:27:48.845]                           }
[01:27:48.845]                         }
[01:27:48.845]                       }
[01:27:48.845]                       invisible(muffled)
[01:27:48.845]                     }
[01:27:48.845]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.845]                   }
[01:27:48.845]                 }
[01:27:48.845]                 else {
[01:27:48.845]                   if (TRUE) {
[01:27:48.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.845]                     {
[01:27:48.845]                       inherits <- base::inherits
[01:27:48.845]                       invokeRestart <- base::invokeRestart
[01:27:48.845]                       is.null <- base::is.null
[01:27:48.845]                       muffled <- FALSE
[01:27:48.845]                       if (inherits(cond, "message")) {
[01:27:48.845]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.845]                         if (muffled) 
[01:27:48.845]                           invokeRestart("muffleMessage")
[01:27:48.845]                       }
[01:27:48.845]                       else if (inherits(cond, "warning")) {
[01:27:48.845]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.845]                         if (muffled) 
[01:27:48.845]                           invokeRestart("muffleWarning")
[01:27:48.845]                       }
[01:27:48.845]                       else if (inherits(cond, "condition")) {
[01:27:48.845]                         if (!is.null(pattern)) {
[01:27:48.845]                           computeRestarts <- base::computeRestarts
[01:27:48.845]                           grepl <- base::grepl
[01:27:48.845]                           restarts <- computeRestarts(cond)
[01:27:48.845]                           for (restart in restarts) {
[01:27:48.845]                             name <- restart$name
[01:27:48.845]                             if (is.null(name)) 
[01:27:48.845]                               next
[01:27:48.845]                             if (!grepl(pattern, name)) 
[01:27:48.845]                               next
[01:27:48.845]                             invokeRestart(restart)
[01:27:48.845]                             muffled <- TRUE
[01:27:48.845]                             break
[01:27:48.845]                           }
[01:27:48.845]                         }
[01:27:48.845]                       }
[01:27:48.845]                       invisible(muffled)
[01:27:48.845]                     }
[01:27:48.845]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.845]                   }
[01:27:48.845]                 }
[01:27:48.845]             }
[01:27:48.845]         }))
[01:27:48.845]     }, error = function(ex) {
[01:27:48.845]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.845]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.845]                 ...future.rng), started = ...future.startTime, 
[01:27:48.845]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.845]             version = "1.8"), class = "FutureResult")
[01:27:48.845]     }, finally = {
[01:27:48.845]         if (!identical(...future.workdir, getwd())) 
[01:27:48.845]             setwd(...future.workdir)
[01:27:48.845]         {
[01:27:48.845]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.845]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.845]             }
[01:27:48.845]             base::options(...future.oldOptions)
[01:27:48.845]             if (.Platform$OS.type == "windows") {
[01:27:48.845]                 old_names <- names(...future.oldEnvVars)
[01:27:48.845]                 envs <- base::Sys.getenv()
[01:27:48.845]                 names <- names(envs)
[01:27:48.845]                 common <- intersect(names, old_names)
[01:27:48.845]                 added <- setdiff(names, old_names)
[01:27:48.845]                 removed <- setdiff(old_names, names)
[01:27:48.845]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.845]                   envs[common]]
[01:27:48.845]                 NAMES <- toupper(changed)
[01:27:48.845]                 args <- list()
[01:27:48.845]                 for (kk in seq_along(NAMES)) {
[01:27:48.845]                   name <- changed[[kk]]
[01:27:48.845]                   NAME <- NAMES[[kk]]
[01:27:48.845]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.845]                     next
[01:27:48.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.845]                 }
[01:27:48.845]                 NAMES <- toupper(added)
[01:27:48.845]                 for (kk in seq_along(NAMES)) {
[01:27:48.845]                   name <- added[[kk]]
[01:27:48.845]                   NAME <- NAMES[[kk]]
[01:27:48.845]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.845]                     next
[01:27:48.845]                   args[[name]] <- ""
[01:27:48.845]                 }
[01:27:48.845]                 NAMES <- toupper(removed)
[01:27:48.845]                 for (kk in seq_along(NAMES)) {
[01:27:48.845]                   name <- removed[[kk]]
[01:27:48.845]                   NAME <- NAMES[[kk]]
[01:27:48.845]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.845]                     next
[01:27:48.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.845]                 }
[01:27:48.845]                 if (length(args) > 0) 
[01:27:48.845]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.845]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.845]             }
[01:27:48.845]             else {
[01:27:48.845]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.845]             }
[01:27:48.845]             {
[01:27:48.845]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.845]                   0L) {
[01:27:48.845]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.845]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.845]                   base::options(opts)
[01:27:48.845]                 }
[01:27:48.845]                 {
[01:27:48.845]                   {
[01:27:48.845]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.845]                     NULL
[01:27:48.845]                   }
[01:27:48.845]                   options(future.plan = NULL)
[01:27:48.845]                   if (is.na(NA_character_)) 
[01:27:48.845]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.845]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.845]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.845]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.845]                     envir = parent.frame()) 
[01:27:48.845]                   {
[01:27:48.845]                     if (is.function(workers)) 
[01:27:48.845]                       workers <- workers()
[01:27:48.845]                     workers <- structure(as.integer(workers), 
[01:27:48.845]                       class = class(workers))
[01:27:48.845]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.845]                       workers >= 1)
[01:27:48.845]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.845]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.845]                     }
[01:27:48.845]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.845]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.845]                       envir = envir)
[01:27:48.845]                     if (!future$lazy) 
[01:27:48.845]                       future <- run(future)
[01:27:48.845]                     invisible(future)
[01:27:48.845]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.845]                 }
[01:27:48.845]             }
[01:27:48.845]         }
[01:27:48.845]     })
[01:27:48.845]     if (TRUE) {
[01:27:48.845]         base::sink(type = "output", split = FALSE)
[01:27:48.845]         if (TRUE) {
[01:27:48.845]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.845]         }
[01:27:48.845]         else {
[01:27:48.845]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.845]         }
[01:27:48.845]         base::close(...future.stdout)
[01:27:48.845]         ...future.stdout <- NULL
[01:27:48.845]     }
[01:27:48.845]     ...future.result$conditions <- ...future.conditions
[01:27:48.845]     ...future.result$finished <- base::Sys.time()
[01:27:48.845]     ...future.result
[01:27:48.845] }
[01:27:48.949] MultisessionFuture started
[01:27:48.949] - Launch lazy future ... done
[01:27:48.949] run() for 'MultisessionFuture' ... done
[01:27:48.950] getGlobalsAndPackages() ...
[01:27:48.950] Searching for globals...
[01:27:48.951] - globals found: [1] '{'
[01:27:48.951] Searching for globals ... DONE
[01:27:48.951] Resolving globals: FALSE
[01:27:48.952] 
[01:27:48.952] 
[01:27:48.952] getGlobalsAndPackages() ... DONE
[01:27:48.953] run() for 'Future' ...
[01:27:48.953] - state: 'created'
[01:27:48.953] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:48.972] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:48.973] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:48.973]   - Field: 'node'
[01:27:48.974]   - Field: 'label'
[01:27:48.974]   - Field: 'local'
[01:27:48.974]   - Field: 'owner'
[01:27:48.975]   - Field: 'envir'
[01:27:48.975]   - Field: 'workers'
[01:27:48.975]   - Field: 'packages'
[01:27:48.975]   - Field: 'gc'
[01:27:48.976]   - Field: 'conditions'
[01:27:48.976]   - Field: 'persistent'
[01:27:48.976]   - Field: 'expr'
[01:27:48.976]   - Field: 'uuid'
[01:27:48.977]   - Field: 'seed'
[01:27:48.977]   - Field: 'version'
[01:27:48.977]   - Field: 'result'
[01:27:48.977]   - Field: 'asynchronous'
[01:27:48.977]   - Field: 'calls'
[01:27:48.978]   - Field: 'globals'
[01:27:48.978]   - Field: 'stdout'
[01:27:48.978]   - Field: 'earlySignal'
[01:27:48.978]   - Field: 'lazy'
[01:27:48.979]   - Field: 'state'
[01:27:48.979] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:48.979] - Launch lazy future ...
[01:27:48.980] Packages needed by the future expression (n = 0): <none>
[01:27:48.980] Packages needed by future strategies (n = 0): <none>
[01:27:48.981] {
[01:27:48.981]     {
[01:27:48.981]         {
[01:27:48.981]             ...future.startTime <- base::Sys.time()
[01:27:48.981]             {
[01:27:48.981]                 {
[01:27:48.981]                   {
[01:27:48.981]                     {
[01:27:48.981]                       base::local({
[01:27:48.981]                         has_future <- base::requireNamespace("future", 
[01:27:48.981]                           quietly = TRUE)
[01:27:48.981]                         if (has_future) {
[01:27:48.981]                           ns <- base::getNamespace("future")
[01:27:48.981]                           version <- ns[[".package"]][["version"]]
[01:27:48.981]                           if (is.null(version)) 
[01:27:48.981]                             version <- utils::packageVersion("future")
[01:27:48.981]                         }
[01:27:48.981]                         else {
[01:27:48.981]                           version <- NULL
[01:27:48.981]                         }
[01:27:48.981]                         if (!has_future || version < "1.8.0") {
[01:27:48.981]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:48.981]                             "", base::R.version$version.string), 
[01:27:48.981]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:48.981]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:48.981]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:48.981]                               "release", "version")], collapse = " "), 
[01:27:48.981]                             hostname = base::Sys.info()[["nodename"]])
[01:27:48.981]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:48.981]                             info)
[01:27:48.981]                           info <- base::paste(info, collapse = "; ")
[01:27:48.981]                           if (!has_future) {
[01:27:48.981]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:48.981]                               info)
[01:27:48.981]                           }
[01:27:48.981]                           else {
[01:27:48.981]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:48.981]                               info, version)
[01:27:48.981]                           }
[01:27:48.981]                           base::stop(msg)
[01:27:48.981]                         }
[01:27:48.981]                       })
[01:27:48.981]                     }
[01:27:48.981]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:48.981]                     base::options(mc.cores = 1L)
[01:27:48.981]                   }
[01:27:48.981]                   options(future.plan = NULL)
[01:27:48.981]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.981]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:48.981]                 }
[01:27:48.981]                 ...future.workdir <- getwd()
[01:27:48.981]             }
[01:27:48.981]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:48.981]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:48.981]         }
[01:27:48.981]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:48.981]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:48.981]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:48.981]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:48.981]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:48.981]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:48.981]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:48.981]             base::names(...future.oldOptions))
[01:27:48.981]     }
[01:27:48.981]     if (FALSE) {
[01:27:48.981]     }
[01:27:48.981]     else {
[01:27:48.981]         if (TRUE) {
[01:27:48.981]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:48.981]                 open = "w")
[01:27:48.981]         }
[01:27:48.981]         else {
[01:27:48.981]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:48.981]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:48.981]         }
[01:27:48.981]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:48.981]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:48.981]             base::sink(type = "output", split = FALSE)
[01:27:48.981]             base::close(...future.stdout)
[01:27:48.981]         }, add = TRUE)
[01:27:48.981]     }
[01:27:48.981]     ...future.frame <- base::sys.nframe()
[01:27:48.981]     ...future.conditions <- base::list()
[01:27:48.981]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:48.981]     if (FALSE) {
[01:27:48.981]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:48.981]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:48.981]     }
[01:27:48.981]     ...future.result <- base::tryCatch({
[01:27:48.981]         base::withCallingHandlers({
[01:27:48.981]             ...future.value <- base::withVisible(base::local({
[01:27:48.981]                 ...future.makeSendCondition <- base::local({
[01:27:48.981]                   sendCondition <- NULL
[01:27:48.981]                   function(frame = 1L) {
[01:27:48.981]                     if (is.function(sendCondition)) 
[01:27:48.981]                       return(sendCondition)
[01:27:48.981]                     ns <- getNamespace("parallel")
[01:27:48.981]                     if (exists("sendData", mode = "function", 
[01:27:48.981]                       envir = ns)) {
[01:27:48.981]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:48.981]                         envir = ns)
[01:27:48.981]                       envir <- sys.frame(frame)
[01:27:48.981]                       master <- NULL
[01:27:48.981]                       while (!identical(envir, .GlobalEnv) && 
[01:27:48.981]                         !identical(envir, emptyenv())) {
[01:27:48.981]                         if (exists("master", mode = "list", envir = envir, 
[01:27:48.981]                           inherits = FALSE)) {
[01:27:48.981]                           master <- get("master", mode = "list", 
[01:27:48.981]                             envir = envir, inherits = FALSE)
[01:27:48.981]                           if (inherits(master, c("SOCKnode", 
[01:27:48.981]                             "SOCK0node"))) {
[01:27:48.981]                             sendCondition <<- function(cond) {
[01:27:48.981]                               data <- list(type = "VALUE", value = cond, 
[01:27:48.981]                                 success = TRUE)
[01:27:48.981]                               parallel_sendData(master, data)
[01:27:48.981]                             }
[01:27:48.981]                             return(sendCondition)
[01:27:48.981]                           }
[01:27:48.981]                         }
[01:27:48.981]                         frame <- frame + 1L
[01:27:48.981]                         envir <- sys.frame(frame)
[01:27:48.981]                       }
[01:27:48.981]                     }
[01:27:48.981]                     sendCondition <<- function(cond) NULL
[01:27:48.981]                   }
[01:27:48.981]                 })
[01:27:48.981]                 withCallingHandlers({
[01:27:48.981]                   {
[01:27:48.981]                     4
[01:27:48.981]                   }
[01:27:48.981]                 }, immediateCondition = function(cond) {
[01:27:48.981]                   sendCondition <- ...future.makeSendCondition()
[01:27:48.981]                   sendCondition(cond)
[01:27:48.981]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.981]                   {
[01:27:48.981]                     inherits <- base::inherits
[01:27:48.981]                     invokeRestart <- base::invokeRestart
[01:27:48.981]                     is.null <- base::is.null
[01:27:48.981]                     muffled <- FALSE
[01:27:48.981]                     if (inherits(cond, "message")) {
[01:27:48.981]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:48.981]                       if (muffled) 
[01:27:48.981]                         invokeRestart("muffleMessage")
[01:27:48.981]                     }
[01:27:48.981]                     else if (inherits(cond, "warning")) {
[01:27:48.981]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:48.981]                       if (muffled) 
[01:27:48.981]                         invokeRestart("muffleWarning")
[01:27:48.981]                     }
[01:27:48.981]                     else if (inherits(cond, "condition")) {
[01:27:48.981]                       if (!is.null(pattern)) {
[01:27:48.981]                         computeRestarts <- base::computeRestarts
[01:27:48.981]                         grepl <- base::grepl
[01:27:48.981]                         restarts <- computeRestarts(cond)
[01:27:48.981]                         for (restart in restarts) {
[01:27:48.981]                           name <- restart$name
[01:27:48.981]                           if (is.null(name)) 
[01:27:48.981]                             next
[01:27:48.981]                           if (!grepl(pattern, name)) 
[01:27:48.981]                             next
[01:27:48.981]                           invokeRestart(restart)
[01:27:48.981]                           muffled <- TRUE
[01:27:48.981]                           break
[01:27:48.981]                         }
[01:27:48.981]                       }
[01:27:48.981]                     }
[01:27:48.981]                     invisible(muffled)
[01:27:48.981]                   }
[01:27:48.981]                   muffleCondition(cond)
[01:27:48.981]                 })
[01:27:48.981]             }))
[01:27:48.981]             future::FutureResult(value = ...future.value$value, 
[01:27:48.981]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.981]                   ...future.rng), globalenv = if (FALSE) 
[01:27:48.981]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:48.981]                     ...future.globalenv.names))
[01:27:48.981]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:48.981]         }, condition = base::local({
[01:27:48.981]             c <- base::c
[01:27:48.981]             inherits <- base::inherits
[01:27:48.981]             invokeRestart <- base::invokeRestart
[01:27:48.981]             length <- base::length
[01:27:48.981]             list <- base::list
[01:27:48.981]             seq.int <- base::seq.int
[01:27:48.981]             signalCondition <- base::signalCondition
[01:27:48.981]             sys.calls <- base::sys.calls
[01:27:48.981]             `[[` <- base::`[[`
[01:27:48.981]             `+` <- base::`+`
[01:27:48.981]             `<<-` <- base::`<<-`
[01:27:48.981]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:48.981]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:48.981]                   3L)]
[01:27:48.981]             }
[01:27:48.981]             function(cond) {
[01:27:48.981]                 is_error <- inherits(cond, "error")
[01:27:48.981]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:48.981]                   NULL)
[01:27:48.981]                 if (is_error) {
[01:27:48.981]                   sessionInformation <- function() {
[01:27:48.981]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:48.981]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:48.981]                       search = base::search(), system = base::Sys.info())
[01:27:48.981]                   }
[01:27:48.981]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.981]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:48.981]                     cond$call), session = sessionInformation(), 
[01:27:48.981]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:48.981]                   signalCondition(cond)
[01:27:48.981]                 }
[01:27:48.981]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:48.981]                 "immediateCondition"))) {
[01:27:48.981]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:48.981]                   ...future.conditions[[length(...future.conditions) + 
[01:27:48.981]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:48.981]                   if (TRUE && !signal) {
[01:27:48.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.981]                     {
[01:27:48.981]                       inherits <- base::inherits
[01:27:48.981]                       invokeRestart <- base::invokeRestart
[01:27:48.981]                       is.null <- base::is.null
[01:27:48.981]                       muffled <- FALSE
[01:27:48.981]                       if (inherits(cond, "message")) {
[01:27:48.981]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.981]                         if (muffled) 
[01:27:48.981]                           invokeRestart("muffleMessage")
[01:27:48.981]                       }
[01:27:48.981]                       else if (inherits(cond, "warning")) {
[01:27:48.981]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.981]                         if (muffled) 
[01:27:48.981]                           invokeRestart("muffleWarning")
[01:27:48.981]                       }
[01:27:48.981]                       else if (inherits(cond, "condition")) {
[01:27:48.981]                         if (!is.null(pattern)) {
[01:27:48.981]                           computeRestarts <- base::computeRestarts
[01:27:48.981]                           grepl <- base::grepl
[01:27:48.981]                           restarts <- computeRestarts(cond)
[01:27:48.981]                           for (restart in restarts) {
[01:27:48.981]                             name <- restart$name
[01:27:48.981]                             if (is.null(name)) 
[01:27:48.981]                               next
[01:27:48.981]                             if (!grepl(pattern, name)) 
[01:27:48.981]                               next
[01:27:48.981]                             invokeRestart(restart)
[01:27:48.981]                             muffled <- TRUE
[01:27:48.981]                             break
[01:27:48.981]                           }
[01:27:48.981]                         }
[01:27:48.981]                       }
[01:27:48.981]                       invisible(muffled)
[01:27:48.981]                     }
[01:27:48.981]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.981]                   }
[01:27:48.981]                 }
[01:27:48.981]                 else {
[01:27:48.981]                   if (TRUE) {
[01:27:48.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:48.981]                     {
[01:27:48.981]                       inherits <- base::inherits
[01:27:48.981]                       invokeRestart <- base::invokeRestart
[01:27:48.981]                       is.null <- base::is.null
[01:27:48.981]                       muffled <- FALSE
[01:27:48.981]                       if (inherits(cond, "message")) {
[01:27:48.981]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:48.981]                         if (muffled) 
[01:27:48.981]                           invokeRestart("muffleMessage")
[01:27:48.981]                       }
[01:27:48.981]                       else if (inherits(cond, "warning")) {
[01:27:48.981]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:48.981]                         if (muffled) 
[01:27:48.981]                           invokeRestart("muffleWarning")
[01:27:48.981]                       }
[01:27:48.981]                       else if (inherits(cond, "condition")) {
[01:27:48.981]                         if (!is.null(pattern)) {
[01:27:48.981]                           computeRestarts <- base::computeRestarts
[01:27:48.981]                           grepl <- base::grepl
[01:27:48.981]                           restarts <- computeRestarts(cond)
[01:27:48.981]                           for (restart in restarts) {
[01:27:48.981]                             name <- restart$name
[01:27:48.981]                             if (is.null(name)) 
[01:27:48.981]                               next
[01:27:48.981]                             if (!grepl(pattern, name)) 
[01:27:48.981]                               next
[01:27:48.981]                             invokeRestart(restart)
[01:27:48.981]                             muffled <- TRUE
[01:27:48.981]                             break
[01:27:48.981]                           }
[01:27:48.981]                         }
[01:27:48.981]                       }
[01:27:48.981]                       invisible(muffled)
[01:27:48.981]                     }
[01:27:48.981]                     muffleCondition(cond, pattern = "^muffle")
[01:27:48.981]                   }
[01:27:48.981]                 }
[01:27:48.981]             }
[01:27:48.981]         }))
[01:27:48.981]     }, error = function(ex) {
[01:27:48.981]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:48.981]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:48.981]                 ...future.rng), started = ...future.startTime, 
[01:27:48.981]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:48.981]             version = "1.8"), class = "FutureResult")
[01:27:48.981]     }, finally = {
[01:27:48.981]         if (!identical(...future.workdir, getwd())) 
[01:27:48.981]             setwd(...future.workdir)
[01:27:48.981]         {
[01:27:48.981]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:48.981]                 ...future.oldOptions$nwarnings <- NULL
[01:27:48.981]             }
[01:27:48.981]             base::options(...future.oldOptions)
[01:27:48.981]             if (.Platform$OS.type == "windows") {
[01:27:48.981]                 old_names <- names(...future.oldEnvVars)
[01:27:48.981]                 envs <- base::Sys.getenv()
[01:27:48.981]                 names <- names(envs)
[01:27:48.981]                 common <- intersect(names, old_names)
[01:27:48.981]                 added <- setdiff(names, old_names)
[01:27:48.981]                 removed <- setdiff(old_names, names)
[01:27:48.981]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:48.981]                   envs[common]]
[01:27:48.981]                 NAMES <- toupper(changed)
[01:27:48.981]                 args <- list()
[01:27:48.981]                 for (kk in seq_along(NAMES)) {
[01:27:48.981]                   name <- changed[[kk]]
[01:27:48.981]                   NAME <- NAMES[[kk]]
[01:27:48.981]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.981]                     next
[01:27:48.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.981]                 }
[01:27:48.981]                 NAMES <- toupper(added)
[01:27:48.981]                 for (kk in seq_along(NAMES)) {
[01:27:48.981]                   name <- added[[kk]]
[01:27:48.981]                   NAME <- NAMES[[kk]]
[01:27:48.981]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.981]                     next
[01:27:48.981]                   args[[name]] <- ""
[01:27:48.981]                 }
[01:27:48.981]                 NAMES <- toupper(removed)
[01:27:48.981]                 for (kk in seq_along(NAMES)) {
[01:27:48.981]                   name <- removed[[kk]]
[01:27:48.981]                   NAME <- NAMES[[kk]]
[01:27:48.981]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:48.981]                     next
[01:27:48.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:48.981]                 }
[01:27:48.981]                 if (length(args) > 0) 
[01:27:48.981]                   base::do.call(base::Sys.setenv, args = args)
[01:27:48.981]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:48.981]             }
[01:27:48.981]             else {
[01:27:48.981]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:48.981]             }
[01:27:48.981]             {
[01:27:48.981]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:48.981]                   0L) {
[01:27:48.981]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:48.981]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:48.981]                   base::options(opts)
[01:27:48.981]                 }
[01:27:48.981]                 {
[01:27:48.981]                   {
[01:27:48.981]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:48.981]                     NULL
[01:27:48.981]                   }
[01:27:48.981]                   options(future.plan = NULL)
[01:27:48.981]                   if (is.na(NA_character_)) 
[01:27:48.981]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:48.981]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:48.981]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:48.981]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:48.981]                     envir = parent.frame()) 
[01:27:48.981]                   {
[01:27:48.981]                     if (is.function(workers)) 
[01:27:48.981]                       workers <- workers()
[01:27:48.981]                     workers <- structure(as.integer(workers), 
[01:27:48.981]                       class = class(workers))
[01:27:48.981]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:48.981]                       workers >= 1)
[01:27:48.981]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:48.981]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:48.981]                     }
[01:27:48.981]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:48.981]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:48.981]                       envir = envir)
[01:27:48.981]                     if (!future$lazy) 
[01:27:48.981]                       future <- run(future)
[01:27:48.981]                     invisible(future)
[01:27:48.981]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:48.981]                 }
[01:27:48.981]             }
[01:27:48.981]         }
[01:27:48.981]     })
[01:27:48.981]     if (TRUE) {
[01:27:48.981]         base::sink(type = "output", split = FALSE)
[01:27:48.981]         if (TRUE) {
[01:27:48.981]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:48.981]         }
[01:27:48.981]         else {
[01:27:48.981]             ...future.result["stdout"] <- base::list(NULL)
[01:27:48.981]         }
[01:27:48.981]         base::close(...future.stdout)
[01:27:48.981]         ...future.stdout <- NULL
[01:27:48.981]     }
[01:27:48.981]     ...future.result$conditions <- ...future.conditions
[01:27:48.981]     ...future.result$finished <- base::Sys.time()
[01:27:48.981]     ...future.result
[01:27:48.981] }
[01:27:48.987] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:49.009] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.009] - Validating connection of MultisessionFuture
[01:27:49.010] - received message: FutureResult
[01:27:49.010] - Received FutureResult
[01:27:49.010] - Erased future from FutureRegistry
[01:27:49.010] result() for ClusterFuture ...
[01:27:49.010] - result already collected: FutureResult
[01:27:49.011] result() for ClusterFuture ... done
[01:27:49.011] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.011] result() for ClusterFuture ...
[01:27:49.011] - result already collected: FutureResult
[01:27:49.011] result() for ClusterFuture ... done
[01:27:49.012] result() for ClusterFuture ...
[01:27:49.012] - result already collected: FutureResult
[01:27:49.012] result() for ClusterFuture ... done
[01:27:49.014] MultisessionFuture started
[01:27:49.014] - Launch lazy future ... done
[01:27:49.014] run() for 'MultisessionFuture' ... done
<environment: 0x0000025b086b4bc8> 
<environment: 0x0000025b0a080178> 
[01:27:49.030] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.030] - Validating connection of MultisessionFuture
[01:27:49.030] - received message: FutureResult
[01:27:49.031] - Received FutureResult
[01:27:49.031] - Erased future from FutureRegistry
[01:27:49.031] result() for ClusterFuture ...
[01:27:49.031] - result already collected: FutureResult
[01:27:49.031] result() for ClusterFuture ... done
[01:27:49.032] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.032] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.032] - Validating connection of MultisessionFuture
[01:27:49.033] - received message: FutureResult
[01:27:49.033] - Received FutureResult
[01:27:49.033] - Erased future from FutureRegistry
[01:27:49.033] result() for ClusterFuture ...
[01:27:49.033] - result already collected: FutureResult
[01:27:49.033] result() for ClusterFuture ... done
[01:27:49.034] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:49.035] resolve() on environment ...
[01:27:49.035]  recursive: 0
[01:27:49.036]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:49.036] signalConditionsASAP(numeric, pos=1) ...
[01:27:49.036] - nx: 4
[01:27:49.037] - relay: TRUE
[01:27:49.037] - stdout: TRUE
[01:27:49.037] - signal: TRUE
[01:27:49.037] - resignal: FALSE
[01:27:49.037] - force: TRUE
[01:27:49.037] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.038] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.038]  - until=2
[01:27:49.038]  - relaying element #2
[01:27:49.038] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.038] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.038] signalConditionsASAP(NULL, pos=1) ... done
[01:27:49.039]  length: 3 (resolved future 1)
[01:27:49.039] Future #2
[01:27:49.039] result() for ClusterFuture ...
[01:27:49.039] - result already collected: FutureResult
[01:27:49.039] result() for ClusterFuture ... done
[01:27:49.039] result() for ClusterFuture ...
[01:27:49.040] - result already collected: FutureResult
[01:27:49.040] result() for ClusterFuture ... done
[01:27:49.040] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:49.040] - nx: 4
[01:27:49.040] - relay: TRUE
[01:27:49.040] - stdout: TRUE
[01:27:49.041] - signal: TRUE
[01:27:49.041] - resignal: FALSE
[01:27:49.041] - force: TRUE
[01:27:49.041] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.041] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.041]  - until=2
[01:27:49.041]  - relaying element #2
[01:27:49.042] result() for ClusterFuture ...
[01:27:49.042] - result already collected: FutureResult
[01:27:49.042] result() for ClusterFuture ... done
[01:27:49.042] result() for ClusterFuture ...
[01:27:49.042] - result already collected: FutureResult
[01:27:49.042] result() for ClusterFuture ... done
[01:27:49.043] result() for ClusterFuture ...
[01:27:49.043] - result already collected: FutureResult
[01:27:49.043] result() for ClusterFuture ... done
[01:27:49.043] result() for ClusterFuture ...
[01:27:49.043] - result already collected: FutureResult
[01:27:49.043] result() for ClusterFuture ... done
[01:27:49.044] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.044] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.044] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:49.044]  length: 2 (resolved future 2)
[01:27:49.044] Future #3
[01:27:49.045] result() for ClusterFuture ...
[01:27:49.045] - result already collected: FutureResult
[01:27:49.045] result() for ClusterFuture ... done
[01:27:49.045] result() for ClusterFuture ...
[01:27:49.045] - result already collected: FutureResult
[01:27:49.045] result() for ClusterFuture ... done
[01:27:49.046] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:49.046] - nx: 4
[01:27:49.046] - relay: TRUE
[01:27:49.046] - stdout: TRUE
[01:27:49.046] - signal: TRUE
[01:27:49.046] - resignal: FALSE
[01:27:49.046] - force: TRUE
[01:27:49.047] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.047] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.047]  - until=3
[01:27:49.047]  - relaying element #3
[01:27:49.047] result() for ClusterFuture ...
[01:27:49.047] - result already collected: FutureResult
[01:27:49.048] result() for ClusterFuture ... done
[01:27:49.048] result() for ClusterFuture ...
[01:27:49.048] - result already collected: FutureResult
[01:27:49.048] result() for ClusterFuture ... done
[01:27:49.048] result() for ClusterFuture ...
[01:27:49.048] - result already collected: FutureResult
[01:27:49.049] result() for ClusterFuture ... done
[01:27:49.049] result() for ClusterFuture ...
[01:27:49.049] - result already collected: FutureResult
[01:27:49.049] result() for ClusterFuture ... done
[01:27:49.049] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.049] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.050] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:49.050]  length: 1 (resolved future 3)
[01:27:49.050] Future #4
[01:27:49.050] result() for ClusterFuture ...
[01:27:49.050] - result already collected: FutureResult
[01:27:49.050] result() for ClusterFuture ... done
[01:27:49.051] result() for ClusterFuture ...
[01:27:49.051] - result already collected: FutureResult
[01:27:49.051] result() for ClusterFuture ... done
[01:27:49.051] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:49.051] - nx: 4
[01:27:49.051] - relay: TRUE
[01:27:49.052] - stdout: TRUE
[01:27:49.052] - signal: TRUE
[01:27:49.052] - resignal: FALSE
[01:27:49.052] - force: TRUE
[01:27:49.052] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.052] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.053]  - until=4
[01:27:49.053]  - relaying element #4
[01:27:49.053] result() for ClusterFuture ...
[01:27:49.053] - result already collected: FutureResult
[01:27:49.053] result() for ClusterFuture ... done
[01:27:49.053] result() for ClusterFuture ...
[01:27:49.054] - result already collected: FutureResult
[01:27:49.054] result() for ClusterFuture ... done
[01:27:49.054] result() for ClusterFuture ...
[01:27:49.054] - result already collected: FutureResult
[01:27:49.054] result() for ClusterFuture ... done
[01:27:49.054] result() for ClusterFuture ...
[01:27:49.055] - result already collected: FutureResult
[01:27:49.055] result() for ClusterFuture ... done
[01:27:49.055] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.055] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.055] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:49.055]  length: 0 (resolved future 4)
[01:27:49.056] Relaying remaining futures
[01:27:49.056] signalConditionsASAP(NULL, pos=0) ...
[01:27:49.056] - nx: 4
[01:27:49.056] - relay: TRUE
[01:27:49.056] - stdout: TRUE
[01:27:49.056] - signal: TRUE
[01:27:49.057] - resignal: FALSE
[01:27:49.057] - force: TRUE
[01:27:49.057] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.057] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:49.057] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.058] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.058] signalConditionsASAP(NULL, pos=0) ... done
[01:27:49.058] resolve() on environment ... DONE
[01:27:49.058] result() for ClusterFuture ...
[01:27:49.058] - result already collected: FutureResult
[01:27:49.058] result() for ClusterFuture ... done
[01:27:49.059] result() for ClusterFuture ...
[01:27:49.059] - result already collected: FutureResult
[01:27:49.059] result() for ClusterFuture ... done
[01:27:49.059] result() for ClusterFuture ...
[01:27:49.059] - result already collected: FutureResult
[01:27:49.059] result() for ClusterFuture ... done
[01:27:49.060] result() for ClusterFuture ...
[01:27:49.060] - result already collected: FutureResult
[01:27:49.060] result() for ClusterFuture ... done
[01:27:49.060] result() for ClusterFuture ...
[01:27:49.060] - result already collected: FutureResult
[01:27:49.060] result() for ClusterFuture ... done
[01:27:49.061] result() for ClusterFuture ...
[01:27:49.061] - result already collected: FutureResult
[01:27:49.061] result() for ClusterFuture ... done
<environment: 0x0000025b0a396c00> 
Dimensions: c(1, 6)
[01:27:49.061] getGlobalsAndPackages() ...
[01:27:49.062] Searching for globals...
[01:27:49.062] 
[01:27:49.062] Searching for globals ... DONE
[01:27:49.062] - globals: [0] <none>
[01:27:49.063] getGlobalsAndPackages() ... DONE
[01:27:49.063] run() for 'Future' ...
[01:27:49.063] - state: 'created'
[01:27:49.063] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.079] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.079] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.080]   - Field: 'node'
[01:27:49.080]   - Field: 'label'
[01:27:49.080]   - Field: 'local'
[01:27:49.080]   - Field: 'owner'
[01:27:49.080]   - Field: 'envir'
[01:27:49.081]   - Field: 'workers'
[01:27:49.081]   - Field: 'packages'
[01:27:49.081]   - Field: 'gc'
[01:27:49.081]   - Field: 'conditions'
[01:27:49.081]   - Field: 'persistent'
[01:27:49.081]   - Field: 'expr'
[01:27:49.082]   - Field: 'uuid'
[01:27:49.082]   - Field: 'seed'
[01:27:49.082]   - Field: 'version'
[01:27:49.082]   - Field: 'result'
[01:27:49.082]   - Field: 'asynchronous'
[01:27:49.083]   - Field: 'calls'
[01:27:49.083]   - Field: 'globals'
[01:27:49.083]   - Field: 'stdout'
[01:27:49.083]   - Field: 'earlySignal'
[01:27:49.083]   - Field: 'lazy'
[01:27:49.083]   - Field: 'state'
[01:27:49.084] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.084] - Launch lazy future ...
[01:27:49.084] Packages needed by the future expression (n = 0): <none>
[01:27:49.084] Packages needed by future strategies (n = 0): <none>
[01:27:49.085] {
[01:27:49.085]     {
[01:27:49.085]         {
[01:27:49.085]             ...future.startTime <- base::Sys.time()
[01:27:49.085]             {
[01:27:49.085]                 {
[01:27:49.085]                   {
[01:27:49.085]                     {
[01:27:49.085]                       base::local({
[01:27:49.085]                         has_future <- base::requireNamespace("future", 
[01:27:49.085]                           quietly = TRUE)
[01:27:49.085]                         if (has_future) {
[01:27:49.085]                           ns <- base::getNamespace("future")
[01:27:49.085]                           version <- ns[[".package"]][["version"]]
[01:27:49.085]                           if (is.null(version)) 
[01:27:49.085]                             version <- utils::packageVersion("future")
[01:27:49.085]                         }
[01:27:49.085]                         else {
[01:27:49.085]                           version <- NULL
[01:27:49.085]                         }
[01:27:49.085]                         if (!has_future || version < "1.8.0") {
[01:27:49.085]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.085]                             "", base::R.version$version.string), 
[01:27:49.085]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.085]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.085]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.085]                               "release", "version")], collapse = " "), 
[01:27:49.085]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.085]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.085]                             info)
[01:27:49.085]                           info <- base::paste(info, collapse = "; ")
[01:27:49.085]                           if (!has_future) {
[01:27:49.085]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.085]                               info)
[01:27:49.085]                           }
[01:27:49.085]                           else {
[01:27:49.085]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.085]                               info, version)
[01:27:49.085]                           }
[01:27:49.085]                           base::stop(msg)
[01:27:49.085]                         }
[01:27:49.085]                       })
[01:27:49.085]                     }
[01:27:49.085]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.085]                     base::options(mc.cores = 1L)
[01:27:49.085]                   }
[01:27:49.085]                   options(future.plan = NULL)
[01:27:49.085]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.085]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.085]                 }
[01:27:49.085]                 ...future.workdir <- getwd()
[01:27:49.085]             }
[01:27:49.085]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.085]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.085]         }
[01:27:49.085]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.085]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.085]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.085]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.085]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.085]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.085]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.085]             base::names(...future.oldOptions))
[01:27:49.085]     }
[01:27:49.085]     if (FALSE) {
[01:27:49.085]     }
[01:27:49.085]     else {
[01:27:49.085]         if (TRUE) {
[01:27:49.085]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.085]                 open = "w")
[01:27:49.085]         }
[01:27:49.085]         else {
[01:27:49.085]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.085]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.085]         }
[01:27:49.085]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.085]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.085]             base::sink(type = "output", split = FALSE)
[01:27:49.085]             base::close(...future.stdout)
[01:27:49.085]         }, add = TRUE)
[01:27:49.085]     }
[01:27:49.085]     ...future.frame <- base::sys.nframe()
[01:27:49.085]     ...future.conditions <- base::list()
[01:27:49.085]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.085]     if (FALSE) {
[01:27:49.085]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.085]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.085]     }
[01:27:49.085]     ...future.result <- base::tryCatch({
[01:27:49.085]         base::withCallingHandlers({
[01:27:49.085]             ...future.value <- base::withVisible(base::local({
[01:27:49.085]                 ...future.makeSendCondition <- base::local({
[01:27:49.085]                   sendCondition <- NULL
[01:27:49.085]                   function(frame = 1L) {
[01:27:49.085]                     if (is.function(sendCondition)) 
[01:27:49.085]                       return(sendCondition)
[01:27:49.085]                     ns <- getNamespace("parallel")
[01:27:49.085]                     if (exists("sendData", mode = "function", 
[01:27:49.085]                       envir = ns)) {
[01:27:49.085]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.085]                         envir = ns)
[01:27:49.085]                       envir <- sys.frame(frame)
[01:27:49.085]                       master <- NULL
[01:27:49.085]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.085]                         !identical(envir, emptyenv())) {
[01:27:49.085]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.085]                           inherits = FALSE)) {
[01:27:49.085]                           master <- get("master", mode = "list", 
[01:27:49.085]                             envir = envir, inherits = FALSE)
[01:27:49.085]                           if (inherits(master, c("SOCKnode", 
[01:27:49.085]                             "SOCK0node"))) {
[01:27:49.085]                             sendCondition <<- function(cond) {
[01:27:49.085]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.085]                                 success = TRUE)
[01:27:49.085]                               parallel_sendData(master, data)
[01:27:49.085]                             }
[01:27:49.085]                             return(sendCondition)
[01:27:49.085]                           }
[01:27:49.085]                         }
[01:27:49.085]                         frame <- frame + 1L
[01:27:49.085]                         envir <- sys.frame(frame)
[01:27:49.085]                       }
[01:27:49.085]                     }
[01:27:49.085]                     sendCondition <<- function(cond) NULL
[01:27:49.085]                   }
[01:27:49.085]                 })
[01:27:49.085]                 withCallingHandlers({
[01:27:49.085]                   2
[01:27:49.085]                 }, immediateCondition = function(cond) {
[01:27:49.085]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.085]                   sendCondition(cond)
[01:27:49.085]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.085]                   {
[01:27:49.085]                     inherits <- base::inherits
[01:27:49.085]                     invokeRestart <- base::invokeRestart
[01:27:49.085]                     is.null <- base::is.null
[01:27:49.085]                     muffled <- FALSE
[01:27:49.085]                     if (inherits(cond, "message")) {
[01:27:49.085]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.085]                       if (muffled) 
[01:27:49.085]                         invokeRestart("muffleMessage")
[01:27:49.085]                     }
[01:27:49.085]                     else if (inherits(cond, "warning")) {
[01:27:49.085]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.085]                       if (muffled) 
[01:27:49.085]                         invokeRestart("muffleWarning")
[01:27:49.085]                     }
[01:27:49.085]                     else if (inherits(cond, "condition")) {
[01:27:49.085]                       if (!is.null(pattern)) {
[01:27:49.085]                         computeRestarts <- base::computeRestarts
[01:27:49.085]                         grepl <- base::grepl
[01:27:49.085]                         restarts <- computeRestarts(cond)
[01:27:49.085]                         for (restart in restarts) {
[01:27:49.085]                           name <- restart$name
[01:27:49.085]                           if (is.null(name)) 
[01:27:49.085]                             next
[01:27:49.085]                           if (!grepl(pattern, name)) 
[01:27:49.085]                             next
[01:27:49.085]                           invokeRestart(restart)
[01:27:49.085]                           muffled <- TRUE
[01:27:49.085]                           break
[01:27:49.085]                         }
[01:27:49.085]                       }
[01:27:49.085]                     }
[01:27:49.085]                     invisible(muffled)
[01:27:49.085]                   }
[01:27:49.085]                   muffleCondition(cond)
[01:27:49.085]                 })
[01:27:49.085]             }))
[01:27:49.085]             future::FutureResult(value = ...future.value$value, 
[01:27:49.085]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.085]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.085]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.085]                     ...future.globalenv.names))
[01:27:49.085]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.085]         }, condition = base::local({
[01:27:49.085]             c <- base::c
[01:27:49.085]             inherits <- base::inherits
[01:27:49.085]             invokeRestart <- base::invokeRestart
[01:27:49.085]             length <- base::length
[01:27:49.085]             list <- base::list
[01:27:49.085]             seq.int <- base::seq.int
[01:27:49.085]             signalCondition <- base::signalCondition
[01:27:49.085]             sys.calls <- base::sys.calls
[01:27:49.085]             `[[` <- base::`[[`
[01:27:49.085]             `+` <- base::`+`
[01:27:49.085]             `<<-` <- base::`<<-`
[01:27:49.085]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.085]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.085]                   3L)]
[01:27:49.085]             }
[01:27:49.085]             function(cond) {
[01:27:49.085]                 is_error <- inherits(cond, "error")
[01:27:49.085]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.085]                   NULL)
[01:27:49.085]                 if (is_error) {
[01:27:49.085]                   sessionInformation <- function() {
[01:27:49.085]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.085]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.085]                       search = base::search(), system = base::Sys.info())
[01:27:49.085]                   }
[01:27:49.085]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.085]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.085]                     cond$call), session = sessionInformation(), 
[01:27:49.085]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.085]                   signalCondition(cond)
[01:27:49.085]                 }
[01:27:49.085]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.085]                 "immediateCondition"))) {
[01:27:49.085]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.085]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.085]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.085]                   if (TRUE && !signal) {
[01:27:49.085]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.085]                     {
[01:27:49.085]                       inherits <- base::inherits
[01:27:49.085]                       invokeRestart <- base::invokeRestart
[01:27:49.085]                       is.null <- base::is.null
[01:27:49.085]                       muffled <- FALSE
[01:27:49.085]                       if (inherits(cond, "message")) {
[01:27:49.085]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.085]                         if (muffled) 
[01:27:49.085]                           invokeRestart("muffleMessage")
[01:27:49.085]                       }
[01:27:49.085]                       else if (inherits(cond, "warning")) {
[01:27:49.085]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.085]                         if (muffled) 
[01:27:49.085]                           invokeRestart("muffleWarning")
[01:27:49.085]                       }
[01:27:49.085]                       else if (inherits(cond, "condition")) {
[01:27:49.085]                         if (!is.null(pattern)) {
[01:27:49.085]                           computeRestarts <- base::computeRestarts
[01:27:49.085]                           grepl <- base::grepl
[01:27:49.085]                           restarts <- computeRestarts(cond)
[01:27:49.085]                           for (restart in restarts) {
[01:27:49.085]                             name <- restart$name
[01:27:49.085]                             if (is.null(name)) 
[01:27:49.085]                               next
[01:27:49.085]                             if (!grepl(pattern, name)) 
[01:27:49.085]                               next
[01:27:49.085]                             invokeRestart(restart)
[01:27:49.085]                             muffled <- TRUE
[01:27:49.085]                             break
[01:27:49.085]                           }
[01:27:49.085]                         }
[01:27:49.085]                       }
[01:27:49.085]                       invisible(muffled)
[01:27:49.085]                     }
[01:27:49.085]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.085]                   }
[01:27:49.085]                 }
[01:27:49.085]                 else {
[01:27:49.085]                   if (TRUE) {
[01:27:49.085]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.085]                     {
[01:27:49.085]                       inherits <- base::inherits
[01:27:49.085]                       invokeRestart <- base::invokeRestart
[01:27:49.085]                       is.null <- base::is.null
[01:27:49.085]                       muffled <- FALSE
[01:27:49.085]                       if (inherits(cond, "message")) {
[01:27:49.085]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.085]                         if (muffled) 
[01:27:49.085]                           invokeRestart("muffleMessage")
[01:27:49.085]                       }
[01:27:49.085]                       else if (inherits(cond, "warning")) {
[01:27:49.085]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.085]                         if (muffled) 
[01:27:49.085]                           invokeRestart("muffleWarning")
[01:27:49.085]                       }
[01:27:49.085]                       else if (inherits(cond, "condition")) {
[01:27:49.085]                         if (!is.null(pattern)) {
[01:27:49.085]                           computeRestarts <- base::computeRestarts
[01:27:49.085]                           grepl <- base::grepl
[01:27:49.085]                           restarts <- computeRestarts(cond)
[01:27:49.085]                           for (restart in restarts) {
[01:27:49.085]                             name <- restart$name
[01:27:49.085]                             if (is.null(name)) 
[01:27:49.085]                               next
[01:27:49.085]                             if (!grepl(pattern, name)) 
[01:27:49.085]                               next
[01:27:49.085]                             invokeRestart(restart)
[01:27:49.085]                             muffled <- TRUE
[01:27:49.085]                             break
[01:27:49.085]                           }
[01:27:49.085]                         }
[01:27:49.085]                       }
[01:27:49.085]                       invisible(muffled)
[01:27:49.085]                     }
[01:27:49.085]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.085]                   }
[01:27:49.085]                 }
[01:27:49.085]             }
[01:27:49.085]         }))
[01:27:49.085]     }, error = function(ex) {
[01:27:49.085]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.085]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.085]                 ...future.rng), started = ...future.startTime, 
[01:27:49.085]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.085]             version = "1.8"), class = "FutureResult")
[01:27:49.085]     }, finally = {
[01:27:49.085]         if (!identical(...future.workdir, getwd())) 
[01:27:49.085]             setwd(...future.workdir)
[01:27:49.085]         {
[01:27:49.085]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.085]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.085]             }
[01:27:49.085]             base::options(...future.oldOptions)
[01:27:49.085]             if (.Platform$OS.type == "windows") {
[01:27:49.085]                 old_names <- names(...future.oldEnvVars)
[01:27:49.085]                 envs <- base::Sys.getenv()
[01:27:49.085]                 names <- names(envs)
[01:27:49.085]                 common <- intersect(names, old_names)
[01:27:49.085]                 added <- setdiff(names, old_names)
[01:27:49.085]                 removed <- setdiff(old_names, names)
[01:27:49.085]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.085]                   envs[common]]
[01:27:49.085]                 NAMES <- toupper(changed)
[01:27:49.085]                 args <- list()
[01:27:49.085]                 for (kk in seq_along(NAMES)) {
[01:27:49.085]                   name <- changed[[kk]]
[01:27:49.085]                   NAME <- NAMES[[kk]]
[01:27:49.085]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.085]                     next
[01:27:49.085]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.085]                 }
[01:27:49.085]                 NAMES <- toupper(added)
[01:27:49.085]                 for (kk in seq_along(NAMES)) {
[01:27:49.085]                   name <- added[[kk]]
[01:27:49.085]                   NAME <- NAMES[[kk]]
[01:27:49.085]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.085]                     next
[01:27:49.085]                   args[[name]] <- ""
[01:27:49.085]                 }
[01:27:49.085]                 NAMES <- toupper(removed)
[01:27:49.085]                 for (kk in seq_along(NAMES)) {
[01:27:49.085]                   name <- removed[[kk]]
[01:27:49.085]                   NAME <- NAMES[[kk]]
[01:27:49.085]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.085]                     next
[01:27:49.085]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.085]                 }
[01:27:49.085]                 if (length(args) > 0) 
[01:27:49.085]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.085]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.085]             }
[01:27:49.085]             else {
[01:27:49.085]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.085]             }
[01:27:49.085]             {
[01:27:49.085]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.085]                   0L) {
[01:27:49.085]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.085]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.085]                   base::options(opts)
[01:27:49.085]                 }
[01:27:49.085]                 {
[01:27:49.085]                   {
[01:27:49.085]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.085]                     NULL
[01:27:49.085]                   }
[01:27:49.085]                   options(future.plan = NULL)
[01:27:49.085]                   if (is.na(NA_character_)) 
[01:27:49.085]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.085]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.085]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.085]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.085]                     envir = parent.frame()) 
[01:27:49.085]                   {
[01:27:49.085]                     if (is.function(workers)) 
[01:27:49.085]                       workers <- workers()
[01:27:49.085]                     workers <- structure(as.integer(workers), 
[01:27:49.085]                       class = class(workers))
[01:27:49.085]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.085]                       workers >= 1)
[01:27:49.085]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.085]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.085]                     }
[01:27:49.085]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.085]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.085]                       envir = envir)
[01:27:49.085]                     if (!future$lazy) 
[01:27:49.085]                       future <- run(future)
[01:27:49.085]                     invisible(future)
[01:27:49.085]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.085]                 }
[01:27:49.085]             }
[01:27:49.085]         }
[01:27:49.085]     })
[01:27:49.085]     if (TRUE) {
[01:27:49.085]         base::sink(type = "output", split = FALSE)
[01:27:49.085]         if (TRUE) {
[01:27:49.085]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.085]         }
[01:27:49.085]         else {
[01:27:49.085]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.085]         }
[01:27:49.085]         base::close(...future.stdout)
[01:27:49.085]         ...future.stdout <- NULL
[01:27:49.085]     }
[01:27:49.085]     ...future.result$conditions <- ...future.conditions
[01:27:49.085]     ...future.result$finished <- base::Sys.time()
[01:27:49.085]     ...future.result
[01:27:49.085] }
[01:27:49.091] MultisessionFuture started
[01:27:49.092] - Launch lazy future ... done
[01:27:49.092] run() for 'MultisessionFuture' ... done
[01:27:49.092] getGlobalsAndPackages() ...
[01:27:49.092] Searching for globals...
[01:27:49.093] 
[01:27:49.093] Searching for globals ... DONE
[01:27:49.093] - globals: [0] <none>
[01:27:49.093] getGlobalsAndPackages() ... DONE
[01:27:49.094] run() for 'Future' ...
[01:27:49.094] - state: 'created'
[01:27:49.094] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.109] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.109] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.109]   - Field: 'node'
[01:27:49.109]   - Field: 'label'
[01:27:49.109]   - Field: 'local'
[01:27:49.110]   - Field: 'owner'
[01:27:49.110]   - Field: 'envir'
[01:27:49.110]   - Field: 'workers'
[01:27:49.110]   - Field: 'packages'
[01:27:49.110]   - Field: 'gc'
[01:27:49.111]   - Field: 'conditions'
[01:27:49.111]   - Field: 'persistent'
[01:27:49.111]   - Field: 'expr'
[01:27:49.111]   - Field: 'uuid'
[01:27:49.111]   - Field: 'seed'
[01:27:49.111]   - Field: 'version'
[01:27:49.112]   - Field: 'result'
[01:27:49.112]   - Field: 'asynchronous'
[01:27:49.112]   - Field: 'calls'
[01:27:49.112]   - Field: 'globals'
[01:27:49.112]   - Field: 'stdout'
[01:27:49.112]   - Field: 'earlySignal'
[01:27:49.113]   - Field: 'lazy'
[01:27:49.113]   - Field: 'state'
[01:27:49.113] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.113] - Launch lazy future ...
[01:27:49.114] Packages needed by the future expression (n = 0): <none>
[01:27:49.114] Packages needed by future strategies (n = 0): <none>
[01:27:49.114] {
[01:27:49.114]     {
[01:27:49.114]         {
[01:27:49.114]             ...future.startTime <- base::Sys.time()
[01:27:49.114]             {
[01:27:49.114]                 {
[01:27:49.114]                   {
[01:27:49.114]                     {
[01:27:49.114]                       base::local({
[01:27:49.114]                         has_future <- base::requireNamespace("future", 
[01:27:49.114]                           quietly = TRUE)
[01:27:49.114]                         if (has_future) {
[01:27:49.114]                           ns <- base::getNamespace("future")
[01:27:49.114]                           version <- ns[[".package"]][["version"]]
[01:27:49.114]                           if (is.null(version)) 
[01:27:49.114]                             version <- utils::packageVersion("future")
[01:27:49.114]                         }
[01:27:49.114]                         else {
[01:27:49.114]                           version <- NULL
[01:27:49.114]                         }
[01:27:49.114]                         if (!has_future || version < "1.8.0") {
[01:27:49.114]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.114]                             "", base::R.version$version.string), 
[01:27:49.114]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.114]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.114]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.114]                               "release", "version")], collapse = " "), 
[01:27:49.114]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.114]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.114]                             info)
[01:27:49.114]                           info <- base::paste(info, collapse = "; ")
[01:27:49.114]                           if (!has_future) {
[01:27:49.114]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.114]                               info)
[01:27:49.114]                           }
[01:27:49.114]                           else {
[01:27:49.114]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.114]                               info, version)
[01:27:49.114]                           }
[01:27:49.114]                           base::stop(msg)
[01:27:49.114]                         }
[01:27:49.114]                       })
[01:27:49.114]                     }
[01:27:49.114]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.114]                     base::options(mc.cores = 1L)
[01:27:49.114]                   }
[01:27:49.114]                   options(future.plan = NULL)
[01:27:49.114]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.114]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.114]                 }
[01:27:49.114]                 ...future.workdir <- getwd()
[01:27:49.114]             }
[01:27:49.114]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.114]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.114]         }
[01:27:49.114]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.114]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.114]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.114]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.114]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.114]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.114]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.114]             base::names(...future.oldOptions))
[01:27:49.114]     }
[01:27:49.114]     if (FALSE) {
[01:27:49.114]     }
[01:27:49.114]     else {
[01:27:49.114]         if (TRUE) {
[01:27:49.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.114]                 open = "w")
[01:27:49.114]         }
[01:27:49.114]         else {
[01:27:49.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.114]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.114]         }
[01:27:49.114]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.114]             base::sink(type = "output", split = FALSE)
[01:27:49.114]             base::close(...future.stdout)
[01:27:49.114]         }, add = TRUE)
[01:27:49.114]     }
[01:27:49.114]     ...future.frame <- base::sys.nframe()
[01:27:49.114]     ...future.conditions <- base::list()
[01:27:49.114]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.114]     if (FALSE) {
[01:27:49.114]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.114]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.114]     }
[01:27:49.114]     ...future.result <- base::tryCatch({
[01:27:49.114]         base::withCallingHandlers({
[01:27:49.114]             ...future.value <- base::withVisible(base::local({
[01:27:49.114]                 ...future.makeSendCondition <- base::local({
[01:27:49.114]                   sendCondition <- NULL
[01:27:49.114]                   function(frame = 1L) {
[01:27:49.114]                     if (is.function(sendCondition)) 
[01:27:49.114]                       return(sendCondition)
[01:27:49.114]                     ns <- getNamespace("parallel")
[01:27:49.114]                     if (exists("sendData", mode = "function", 
[01:27:49.114]                       envir = ns)) {
[01:27:49.114]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.114]                         envir = ns)
[01:27:49.114]                       envir <- sys.frame(frame)
[01:27:49.114]                       master <- NULL
[01:27:49.114]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.114]                         !identical(envir, emptyenv())) {
[01:27:49.114]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.114]                           inherits = FALSE)) {
[01:27:49.114]                           master <- get("master", mode = "list", 
[01:27:49.114]                             envir = envir, inherits = FALSE)
[01:27:49.114]                           if (inherits(master, c("SOCKnode", 
[01:27:49.114]                             "SOCK0node"))) {
[01:27:49.114]                             sendCondition <<- function(cond) {
[01:27:49.114]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.114]                                 success = TRUE)
[01:27:49.114]                               parallel_sendData(master, data)
[01:27:49.114]                             }
[01:27:49.114]                             return(sendCondition)
[01:27:49.114]                           }
[01:27:49.114]                         }
[01:27:49.114]                         frame <- frame + 1L
[01:27:49.114]                         envir <- sys.frame(frame)
[01:27:49.114]                       }
[01:27:49.114]                     }
[01:27:49.114]                     sendCondition <<- function(cond) NULL
[01:27:49.114]                   }
[01:27:49.114]                 })
[01:27:49.114]                 withCallingHandlers({
[01:27:49.114]                   NULL
[01:27:49.114]                 }, immediateCondition = function(cond) {
[01:27:49.114]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.114]                   sendCondition(cond)
[01:27:49.114]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.114]                   {
[01:27:49.114]                     inherits <- base::inherits
[01:27:49.114]                     invokeRestart <- base::invokeRestart
[01:27:49.114]                     is.null <- base::is.null
[01:27:49.114]                     muffled <- FALSE
[01:27:49.114]                     if (inherits(cond, "message")) {
[01:27:49.114]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.114]                       if (muffled) 
[01:27:49.114]                         invokeRestart("muffleMessage")
[01:27:49.114]                     }
[01:27:49.114]                     else if (inherits(cond, "warning")) {
[01:27:49.114]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.114]                       if (muffled) 
[01:27:49.114]                         invokeRestart("muffleWarning")
[01:27:49.114]                     }
[01:27:49.114]                     else if (inherits(cond, "condition")) {
[01:27:49.114]                       if (!is.null(pattern)) {
[01:27:49.114]                         computeRestarts <- base::computeRestarts
[01:27:49.114]                         grepl <- base::grepl
[01:27:49.114]                         restarts <- computeRestarts(cond)
[01:27:49.114]                         for (restart in restarts) {
[01:27:49.114]                           name <- restart$name
[01:27:49.114]                           if (is.null(name)) 
[01:27:49.114]                             next
[01:27:49.114]                           if (!grepl(pattern, name)) 
[01:27:49.114]                             next
[01:27:49.114]                           invokeRestart(restart)
[01:27:49.114]                           muffled <- TRUE
[01:27:49.114]                           break
[01:27:49.114]                         }
[01:27:49.114]                       }
[01:27:49.114]                     }
[01:27:49.114]                     invisible(muffled)
[01:27:49.114]                   }
[01:27:49.114]                   muffleCondition(cond)
[01:27:49.114]                 })
[01:27:49.114]             }))
[01:27:49.114]             future::FutureResult(value = ...future.value$value, 
[01:27:49.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.114]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.114]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.114]                     ...future.globalenv.names))
[01:27:49.114]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.114]         }, condition = base::local({
[01:27:49.114]             c <- base::c
[01:27:49.114]             inherits <- base::inherits
[01:27:49.114]             invokeRestart <- base::invokeRestart
[01:27:49.114]             length <- base::length
[01:27:49.114]             list <- base::list
[01:27:49.114]             seq.int <- base::seq.int
[01:27:49.114]             signalCondition <- base::signalCondition
[01:27:49.114]             sys.calls <- base::sys.calls
[01:27:49.114]             `[[` <- base::`[[`
[01:27:49.114]             `+` <- base::`+`
[01:27:49.114]             `<<-` <- base::`<<-`
[01:27:49.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.114]                   3L)]
[01:27:49.114]             }
[01:27:49.114]             function(cond) {
[01:27:49.114]                 is_error <- inherits(cond, "error")
[01:27:49.114]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.114]                   NULL)
[01:27:49.114]                 if (is_error) {
[01:27:49.114]                   sessionInformation <- function() {
[01:27:49.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.114]                       search = base::search(), system = base::Sys.info())
[01:27:49.114]                   }
[01:27:49.114]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.114]                     cond$call), session = sessionInformation(), 
[01:27:49.114]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.114]                   signalCondition(cond)
[01:27:49.114]                 }
[01:27:49.114]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.114]                 "immediateCondition"))) {
[01:27:49.114]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.114]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.114]                   if (TRUE && !signal) {
[01:27:49.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.114]                     {
[01:27:49.114]                       inherits <- base::inherits
[01:27:49.114]                       invokeRestart <- base::invokeRestart
[01:27:49.114]                       is.null <- base::is.null
[01:27:49.114]                       muffled <- FALSE
[01:27:49.114]                       if (inherits(cond, "message")) {
[01:27:49.114]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.114]                         if (muffled) 
[01:27:49.114]                           invokeRestart("muffleMessage")
[01:27:49.114]                       }
[01:27:49.114]                       else if (inherits(cond, "warning")) {
[01:27:49.114]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.114]                         if (muffled) 
[01:27:49.114]                           invokeRestart("muffleWarning")
[01:27:49.114]                       }
[01:27:49.114]                       else if (inherits(cond, "condition")) {
[01:27:49.114]                         if (!is.null(pattern)) {
[01:27:49.114]                           computeRestarts <- base::computeRestarts
[01:27:49.114]                           grepl <- base::grepl
[01:27:49.114]                           restarts <- computeRestarts(cond)
[01:27:49.114]                           for (restart in restarts) {
[01:27:49.114]                             name <- restart$name
[01:27:49.114]                             if (is.null(name)) 
[01:27:49.114]                               next
[01:27:49.114]                             if (!grepl(pattern, name)) 
[01:27:49.114]                               next
[01:27:49.114]                             invokeRestart(restart)
[01:27:49.114]                             muffled <- TRUE
[01:27:49.114]                             break
[01:27:49.114]                           }
[01:27:49.114]                         }
[01:27:49.114]                       }
[01:27:49.114]                       invisible(muffled)
[01:27:49.114]                     }
[01:27:49.114]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.114]                   }
[01:27:49.114]                 }
[01:27:49.114]                 else {
[01:27:49.114]                   if (TRUE) {
[01:27:49.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.114]                     {
[01:27:49.114]                       inherits <- base::inherits
[01:27:49.114]                       invokeRestart <- base::invokeRestart
[01:27:49.114]                       is.null <- base::is.null
[01:27:49.114]                       muffled <- FALSE
[01:27:49.114]                       if (inherits(cond, "message")) {
[01:27:49.114]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.114]                         if (muffled) 
[01:27:49.114]                           invokeRestart("muffleMessage")
[01:27:49.114]                       }
[01:27:49.114]                       else if (inherits(cond, "warning")) {
[01:27:49.114]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.114]                         if (muffled) 
[01:27:49.114]                           invokeRestart("muffleWarning")
[01:27:49.114]                       }
[01:27:49.114]                       else if (inherits(cond, "condition")) {
[01:27:49.114]                         if (!is.null(pattern)) {
[01:27:49.114]                           computeRestarts <- base::computeRestarts
[01:27:49.114]                           grepl <- base::grepl
[01:27:49.114]                           restarts <- computeRestarts(cond)
[01:27:49.114]                           for (restart in restarts) {
[01:27:49.114]                             name <- restart$name
[01:27:49.114]                             if (is.null(name)) 
[01:27:49.114]                               next
[01:27:49.114]                             if (!grepl(pattern, name)) 
[01:27:49.114]                               next
[01:27:49.114]                             invokeRestart(restart)
[01:27:49.114]                             muffled <- TRUE
[01:27:49.114]                             break
[01:27:49.114]                           }
[01:27:49.114]                         }
[01:27:49.114]                       }
[01:27:49.114]                       invisible(muffled)
[01:27:49.114]                     }
[01:27:49.114]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.114]                   }
[01:27:49.114]                 }
[01:27:49.114]             }
[01:27:49.114]         }))
[01:27:49.114]     }, error = function(ex) {
[01:27:49.114]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.114]                 ...future.rng), started = ...future.startTime, 
[01:27:49.114]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.114]             version = "1.8"), class = "FutureResult")
[01:27:49.114]     }, finally = {
[01:27:49.114]         if (!identical(...future.workdir, getwd())) 
[01:27:49.114]             setwd(...future.workdir)
[01:27:49.114]         {
[01:27:49.114]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.114]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.114]             }
[01:27:49.114]             base::options(...future.oldOptions)
[01:27:49.114]             if (.Platform$OS.type == "windows") {
[01:27:49.114]                 old_names <- names(...future.oldEnvVars)
[01:27:49.114]                 envs <- base::Sys.getenv()
[01:27:49.114]                 names <- names(envs)
[01:27:49.114]                 common <- intersect(names, old_names)
[01:27:49.114]                 added <- setdiff(names, old_names)
[01:27:49.114]                 removed <- setdiff(old_names, names)
[01:27:49.114]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.114]                   envs[common]]
[01:27:49.114]                 NAMES <- toupper(changed)
[01:27:49.114]                 args <- list()
[01:27:49.114]                 for (kk in seq_along(NAMES)) {
[01:27:49.114]                   name <- changed[[kk]]
[01:27:49.114]                   NAME <- NAMES[[kk]]
[01:27:49.114]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.114]                     next
[01:27:49.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.114]                 }
[01:27:49.114]                 NAMES <- toupper(added)
[01:27:49.114]                 for (kk in seq_along(NAMES)) {
[01:27:49.114]                   name <- added[[kk]]
[01:27:49.114]                   NAME <- NAMES[[kk]]
[01:27:49.114]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.114]                     next
[01:27:49.114]                   args[[name]] <- ""
[01:27:49.114]                 }
[01:27:49.114]                 NAMES <- toupper(removed)
[01:27:49.114]                 for (kk in seq_along(NAMES)) {
[01:27:49.114]                   name <- removed[[kk]]
[01:27:49.114]                   NAME <- NAMES[[kk]]
[01:27:49.114]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.114]                     next
[01:27:49.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.114]                 }
[01:27:49.114]                 if (length(args) > 0) 
[01:27:49.114]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.114]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.114]             }
[01:27:49.114]             else {
[01:27:49.114]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.114]             }
[01:27:49.114]             {
[01:27:49.114]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.114]                   0L) {
[01:27:49.114]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.114]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.114]                   base::options(opts)
[01:27:49.114]                 }
[01:27:49.114]                 {
[01:27:49.114]                   {
[01:27:49.114]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.114]                     NULL
[01:27:49.114]                   }
[01:27:49.114]                   options(future.plan = NULL)
[01:27:49.114]                   if (is.na(NA_character_)) 
[01:27:49.114]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.114]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.114]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.114]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.114]                     envir = parent.frame()) 
[01:27:49.114]                   {
[01:27:49.114]                     if (is.function(workers)) 
[01:27:49.114]                       workers <- workers()
[01:27:49.114]                     workers <- structure(as.integer(workers), 
[01:27:49.114]                       class = class(workers))
[01:27:49.114]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.114]                       workers >= 1)
[01:27:49.114]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.114]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.114]                     }
[01:27:49.114]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.114]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.114]                       envir = envir)
[01:27:49.114]                     if (!future$lazy) 
[01:27:49.114]                       future <- run(future)
[01:27:49.114]                     invisible(future)
[01:27:49.114]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.114]                 }
[01:27:49.114]             }
[01:27:49.114]         }
[01:27:49.114]     })
[01:27:49.114]     if (TRUE) {
[01:27:49.114]         base::sink(type = "output", split = FALSE)
[01:27:49.114]         if (TRUE) {
[01:27:49.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.114]         }
[01:27:49.114]         else {
[01:27:49.114]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.114]         }
[01:27:49.114]         base::close(...future.stdout)
[01:27:49.114]         ...future.stdout <- NULL
[01:27:49.114]     }
[01:27:49.114]     ...future.result$conditions <- ...future.conditions
[01:27:49.114]     ...future.result$finished <- base::Sys.time()
[01:27:49.114]     ...future.result
[01:27:49.114] }
[01:27:49.120] MultisessionFuture started
[01:27:49.121] - Launch lazy future ... done
[01:27:49.121] run() for 'MultisessionFuture' ... done
[01:27:49.121] getGlobalsAndPackages() ...
[01:27:49.122] Searching for globals...
[01:27:49.122] - globals found: [1] '{'
[01:27:49.123] Searching for globals ... DONE
[01:27:49.123] Resolving globals: FALSE
[01:27:49.123] 
[01:27:49.123] 
[01:27:49.124] getGlobalsAndPackages() ... DONE
[01:27:49.124] run() for 'Future' ...
[01:27:49.124] - state: 'created'
[01:27:49.124] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.140] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.141] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.142]   - Field: 'node'
[01:27:49.142]   - Field: 'label'
[01:27:49.142]   - Field: 'local'
[01:27:49.143]   - Field: 'owner'
[01:27:49.143]   - Field: 'envir'
[01:27:49.143]   - Field: 'workers'
[01:27:49.143]   - Field: 'packages'
[01:27:49.144]   - Field: 'gc'
[01:27:49.144]   - Field: 'conditions'
[01:27:49.144]   - Field: 'persistent'
[01:27:49.150]   - Field: 'expr'
[01:27:49.150]   - Field: 'uuid'
[01:27:49.150]   - Field: 'seed'
[01:27:49.150]   - Field: 'version'
[01:27:49.151]   - Field: 'result'
[01:27:49.151]   - Field: 'asynchronous'
[01:27:49.151]   - Field: 'calls'
[01:27:49.151]   - Field: 'globals'
[01:27:49.151]   - Field: 'stdout'
[01:27:49.152]   - Field: 'earlySignal'
[01:27:49.152]   - Field: 'lazy'
[01:27:49.152]   - Field: 'state'
[01:27:49.152] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.152] - Launch lazy future ...
[01:27:49.153] Packages needed by the future expression (n = 0): <none>
[01:27:49.153] Packages needed by future strategies (n = 0): <none>
[01:27:49.154] {
[01:27:49.154]     {
[01:27:49.154]         {
[01:27:49.154]             ...future.startTime <- base::Sys.time()
[01:27:49.154]             {
[01:27:49.154]                 {
[01:27:49.154]                   {
[01:27:49.154]                     {
[01:27:49.154]                       base::local({
[01:27:49.154]                         has_future <- base::requireNamespace("future", 
[01:27:49.154]                           quietly = TRUE)
[01:27:49.154]                         if (has_future) {
[01:27:49.154]                           ns <- base::getNamespace("future")
[01:27:49.154]                           version <- ns[[".package"]][["version"]]
[01:27:49.154]                           if (is.null(version)) 
[01:27:49.154]                             version <- utils::packageVersion("future")
[01:27:49.154]                         }
[01:27:49.154]                         else {
[01:27:49.154]                           version <- NULL
[01:27:49.154]                         }
[01:27:49.154]                         if (!has_future || version < "1.8.0") {
[01:27:49.154]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.154]                             "", base::R.version$version.string), 
[01:27:49.154]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.154]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.154]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.154]                               "release", "version")], collapse = " "), 
[01:27:49.154]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.154]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.154]                             info)
[01:27:49.154]                           info <- base::paste(info, collapse = "; ")
[01:27:49.154]                           if (!has_future) {
[01:27:49.154]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.154]                               info)
[01:27:49.154]                           }
[01:27:49.154]                           else {
[01:27:49.154]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.154]                               info, version)
[01:27:49.154]                           }
[01:27:49.154]                           base::stop(msg)
[01:27:49.154]                         }
[01:27:49.154]                       })
[01:27:49.154]                     }
[01:27:49.154]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.154]                     base::options(mc.cores = 1L)
[01:27:49.154]                   }
[01:27:49.154]                   options(future.plan = NULL)
[01:27:49.154]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.154]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.154]                 }
[01:27:49.154]                 ...future.workdir <- getwd()
[01:27:49.154]             }
[01:27:49.154]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.154]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.154]         }
[01:27:49.154]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.154]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.154]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.154]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.154]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.154]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.154]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.154]             base::names(...future.oldOptions))
[01:27:49.154]     }
[01:27:49.154]     if (FALSE) {
[01:27:49.154]     }
[01:27:49.154]     else {
[01:27:49.154]         if (TRUE) {
[01:27:49.154]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.154]                 open = "w")
[01:27:49.154]         }
[01:27:49.154]         else {
[01:27:49.154]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.154]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.154]         }
[01:27:49.154]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.154]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.154]             base::sink(type = "output", split = FALSE)
[01:27:49.154]             base::close(...future.stdout)
[01:27:49.154]         }, add = TRUE)
[01:27:49.154]     }
[01:27:49.154]     ...future.frame <- base::sys.nframe()
[01:27:49.154]     ...future.conditions <- base::list()
[01:27:49.154]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.154]     if (FALSE) {
[01:27:49.154]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.154]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.154]     }
[01:27:49.154]     ...future.result <- base::tryCatch({
[01:27:49.154]         base::withCallingHandlers({
[01:27:49.154]             ...future.value <- base::withVisible(base::local({
[01:27:49.154]                 ...future.makeSendCondition <- base::local({
[01:27:49.154]                   sendCondition <- NULL
[01:27:49.154]                   function(frame = 1L) {
[01:27:49.154]                     if (is.function(sendCondition)) 
[01:27:49.154]                       return(sendCondition)
[01:27:49.154]                     ns <- getNamespace("parallel")
[01:27:49.154]                     if (exists("sendData", mode = "function", 
[01:27:49.154]                       envir = ns)) {
[01:27:49.154]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.154]                         envir = ns)
[01:27:49.154]                       envir <- sys.frame(frame)
[01:27:49.154]                       master <- NULL
[01:27:49.154]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.154]                         !identical(envir, emptyenv())) {
[01:27:49.154]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.154]                           inherits = FALSE)) {
[01:27:49.154]                           master <- get("master", mode = "list", 
[01:27:49.154]                             envir = envir, inherits = FALSE)
[01:27:49.154]                           if (inherits(master, c("SOCKnode", 
[01:27:49.154]                             "SOCK0node"))) {
[01:27:49.154]                             sendCondition <<- function(cond) {
[01:27:49.154]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.154]                                 success = TRUE)
[01:27:49.154]                               parallel_sendData(master, data)
[01:27:49.154]                             }
[01:27:49.154]                             return(sendCondition)
[01:27:49.154]                           }
[01:27:49.154]                         }
[01:27:49.154]                         frame <- frame + 1L
[01:27:49.154]                         envir <- sys.frame(frame)
[01:27:49.154]                       }
[01:27:49.154]                     }
[01:27:49.154]                     sendCondition <<- function(cond) NULL
[01:27:49.154]                   }
[01:27:49.154]                 })
[01:27:49.154]                 withCallingHandlers({
[01:27:49.154]                   {
[01:27:49.154]                     4
[01:27:49.154]                   }
[01:27:49.154]                 }, immediateCondition = function(cond) {
[01:27:49.154]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.154]                   sendCondition(cond)
[01:27:49.154]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.154]                   {
[01:27:49.154]                     inherits <- base::inherits
[01:27:49.154]                     invokeRestart <- base::invokeRestart
[01:27:49.154]                     is.null <- base::is.null
[01:27:49.154]                     muffled <- FALSE
[01:27:49.154]                     if (inherits(cond, "message")) {
[01:27:49.154]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.154]                       if (muffled) 
[01:27:49.154]                         invokeRestart("muffleMessage")
[01:27:49.154]                     }
[01:27:49.154]                     else if (inherits(cond, "warning")) {
[01:27:49.154]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.154]                       if (muffled) 
[01:27:49.154]                         invokeRestart("muffleWarning")
[01:27:49.154]                     }
[01:27:49.154]                     else if (inherits(cond, "condition")) {
[01:27:49.154]                       if (!is.null(pattern)) {
[01:27:49.154]                         computeRestarts <- base::computeRestarts
[01:27:49.154]                         grepl <- base::grepl
[01:27:49.154]                         restarts <- computeRestarts(cond)
[01:27:49.154]                         for (restart in restarts) {
[01:27:49.154]                           name <- restart$name
[01:27:49.154]                           if (is.null(name)) 
[01:27:49.154]                             next
[01:27:49.154]                           if (!grepl(pattern, name)) 
[01:27:49.154]                             next
[01:27:49.154]                           invokeRestart(restart)
[01:27:49.154]                           muffled <- TRUE
[01:27:49.154]                           break
[01:27:49.154]                         }
[01:27:49.154]                       }
[01:27:49.154]                     }
[01:27:49.154]                     invisible(muffled)
[01:27:49.154]                   }
[01:27:49.154]                   muffleCondition(cond)
[01:27:49.154]                 })
[01:27:49.154]             }))
[01:27:49.154]             future::FutureResult(value = ...future.value$value, 
[01:27:49.154]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.154]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.154]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.154]                     ...future.globalenv.names))
[01:27:49.154]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.154]         }, condition = base::local({
[01:27:49.154]             c <- base::c
[01:27:49.154]             inherits <- base::inherits
[01:27:49.154]             invokeRestart <- base::invokeRestart
[01:27:49.154]             length <- base::length
[01:27:49.154]             list <- base::list
[01:27:49.154]             seq.int <- base::seq.int
[01:27:49.154]             signalCondition <- base::signalCondition
[01:27:49.154]             sys.calls <- base::sys.calls
[01:27:49.154]             `[[` <- base::`[[`
[01:27:49.154]             `+` <- base::`+`
[01:27:49.154]             `<<-` <- base::`<<-`
[01:27:49.154]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.154]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.154]                   3L)]
[01:27:49.154]             }
[01:27:49.154]             function(cond) {
[01:27:49.154]                 is_error <- inherits(cond, "error")
[01:27:49.154]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.154]                   NULL)
[01:27:49.154]                 if (is_error) {
[01:27:49.154]                   sessionInformation <- function() {
[01:27:49.154]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.154]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.154]                       search = base::search(), system = base::Sys.info())
[01:27:49.154]                   }
[01:27:49.154]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.154]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.154]                     cond$call), session = sessionInformation(), 
[01:27:49.154]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.154]                   signalCondition(cond)
[01:27:49.154]                 }
[01:27:49.154]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.154]                 "immediateCondition"))) {
[01:27:49.154]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.154]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.154]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.154]                   if (TRUE && !signal) {
[01:27:49.154]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.154]                     {
[01:27:49.154]                       inherits <- base::inherits
[01:27:49.154]                       invokeRestart <- base::invokeRestart
[01:27:49.154]                       is.null <- base::is.null
[01:27:49.154]                       muffled <- FALSE
[01:27:49.154]                       if (inherits(cond, "message")) {
[01:27:49.154]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.154]                         if (muffled) 
[01:27:49.154]                           invokeRestart("muffleMessage")
[01:27:49.154]                       }
[01:27:49.154]                       else if (inherits(cond, "warning")) {
[01:27:49.154]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.154]                         if (muffled) 
[01:27:49.154]                           invokeRestart("muffleWarning")
[01:27:49.154]                       }
[01:27:49.154]                       else if (inherits(cond, "condition")) {
[01:27:49.154]                         if (!is.null(pattern)) {
[01:27:49.154]                           computeRestarts <- base::computeRestarts
[01:27:49.154]                           grepl <- base::grepl
[01:27:49.154]                           restarts <- computeRestarts(cond)
[01:27:49.154]                           for (restart in restarts) {
[01:27:49.154]                             name <- restart$name
[01:27:49.154]                             if (is.null(name)) 
[01:27:49.154]                               next
[01:27:49.154]                             if (!grepl(pattern, name)) 
[01:27:49.154]                               next
[01:27:49.154]                             invokeRestart(restart)
[01:27:49.154]                             muffled <- TRUE
[01:27:49.154]                             break
[01:27:49.154]                           }
[01:27:49.154]                         }
[01:27:49.154]                       }
[01:27:49.154]                       invisible(muffled)
[01:27:49.154]                     }
[01:27:49.154]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.154]                   }
[01:27:49.154]                 }
[01:27:49.154]                 else {
[01:27:49.154]                   if (TRUE) {
[01:27:49.154]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.154]                     {
[01:27:49.154]                       inherits <- base::inherits
[01:27:49.154]                       invokeRestart <- base::invokeRestart
[01:27:49.154]                       is.null <- base::is.null
[01:27:49.154]                       muffled <- FALSE
[01:27:49.154]                       if (inherits(cond, "message")) {
[01:27:49.154]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.154]                         if (muffled) 
[01:27:49.154]                           invokeRestart("muffleMessage")
[01:27:49.154]                       }
[01:27:49.154]                       else if (inherits(cond, "warning")) {
[01:27:49.154]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.154]                         if (muffled) 
[01:27:49.154]                           invokeRestart("muffleWarning")
[01:27:49.154]                       }
[01:27:49.154]                       else if (inherits(cond, "condition")) {
[01:27:49.154]                         if (!is.null(pattern)) {
[01:27:49.154]                           computeRestarts <- base::computeRestarts
[01:27:49.154]                           grepl <- base::grepl
[01:27:49.154]                           restarts <- computeRestarts(cond)
[01:27:49.154]                           for (restart in restarts) {
[01:27:49.154]                             name <- restart$name
[01:27:49.154]                             if (is.null(name)) 
[01:27:49.154]                               next
[01:27:49.154]                             if (!grepl(pattern, name)) 
[01:27:49.154]                               next
[01:27:49.154]                             invokeRestart(restart)
[01:27:49.154]                             muffled <- TRUE
[01:27:49.154]                             break
[01:27:49.154]                           }
[01:27:49.154]                         }
[01:27:49.154]                       }
[01:27:49.154]                       invisible(muffled)
[01:27:49.154]                     }
[01:27:49.154]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.154]                   }
[01:27:49.154]                 }
[01:27:49.154]             }
[01:27:49.154]         }))
[01:27:49.154]     }, error = function(ex) {
[01:27:49.154]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.154]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.154]                 ...future.rng), started = ...future.startTime, 
[01:27:49.154]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.154]             version = "1.8"), class = "FutureResult")
[01:27:49.154]     }, finally = {
[01:27:49.154]         if (!identical(...future.workdir, getwd())) 
[01:27:49.154]             setwd(...future.workdir)
[01:27:49.154]         {
[01:27:49.154]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.154]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.154]             }
[01:27:49.154]             base::options(...future.oldOptions)
[01:27:49.154]             if (.Platform$OS.type == "windows") {
[01:27:49.154]                 old_names <- names(...future.oldEnvVars)
[01:27:49.154]                 envs <- base::Sys.getenv()
[01:27:49.154]                 names <- names(envs)
[01:27:49.154]                 common <- intersect(names, old_names)
[01:27:49.154]                 added <- setdiff(names, old_names)
[01:27:49.154]                 removed <- setdiff(old_names, names)
[01:27:49.154]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.154]                   envs[common]]
[01:27:49.154]                 NAMES <- toupper(changed)
[01:27:49.154]                 args <- list()
[01:27:49.154]                 for (kk in seq_along(NAMES)) {
[01:27:49.154]                   name <- changed[[kk]]
[01:27:49.154]                   NAME <- NAMES[[kk]]
[01:27:49.154]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.154]                     next
[01:27:49.154]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.154]                 }
[01:27:49.154]                 NAMES <- toupper(added)
[01:27:49.154]                 for (kk in seq_along(NAMES)) {
[01:27:49.154]                   name <- added[[kk]]
[01:27:49.154]                   NAME <- NAMES[[kk]]
[01:27:49.154]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.154]                     next
[01:27:49.154]                   args[[name]] <- ""
[01:27:49.154]                 }
[01:27:49.154]                 NAMES <- toupper(removed)
[01:27:49.154]                 for (kk in seq_along(NAMES)) {
[01:27:49.154]                   name <- removed[[kk]]
[01:27:49.154]                   NAME <- NAMES[[kk]]
[01:27:49.154]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.154]                     next
[01:27:49.154]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.154]                 }
[01:27:49.154]                 if (length(args) > 0) 
[01:27:49.154]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.154]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.154]             }
[01:27:49.154]             else {
[01:27:49.154]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.154]             }
[01:27:49.154]             {
[01:27:49.154]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.154]                   0L) {
[01:27:49.154]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.154]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.154]                   base::options(opts)
[01:27:49.154]                 }
[01:27:49.154]                 {
[01:27:49.154]                   {
[01:27:49.154]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.154]                     NULL
[01:27:49.154]                   }
[01:27:49.154]                   options(future.plan = NULL)
[01:27:49.154]                   if (is.na(NA_character_)) 
[01:27:49.154]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.154]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.154]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.154]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.154]                     envir = parent.frame()) 
[01:27:49.154]                   {
[01:27:49.154]                     if (is.function(workers)) 
[01:27:49.154]                       workers <- workers()
[01:27:49.154]                     workers <- structure(as.integer(workers), 
[01:27:49.154]                       class = class(workers))
[01:27:49.154]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.154]                       workers >= 1)
[01:27:49.154]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.154]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.154]                     }
[01:27:49.154]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.154]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.154]                       envir = envir)
[01:27:49.154]                     if (!future$lazy) 
[01:27:49.154]                       future <- run(future)
[01:27:49.154]                     invisible(future)
[01:27:49.154]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.154]                 }
[01:27:49.154]             }
[01:27:49.154]         }
[01:27:49.154]     })
[01:27:49.154]     if (TRUE) {
[01:27:49.154]         base::sink(type = "output", split = FALSE)
[01:27:49.154]         if (TRUE) {
[01:27:49.154]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.154]         }
[01:27:49.154]         else {
[01:27:49.154]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.154]         }
[01:27:49.154]         base::close(...future.stdout)
[01:27:49.154]         ...future.stdout <- NULL
[01:27:49.154]     }
[01:27:49.154]     ...future.result$conditions <- ...future.conditions
[01:27:49.154]     ...future.result$finished <- base::Sys.time()
[01:27:49.154]     ...future.result
[01:27:49.154] }
[01:27:49.160] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:49.191] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.191] - Validating connection of MultisessionFuture
[01:27:49.192] - received message: FutureResult
[01:27:49.192] - Received FutureResult
[01:27:49.192] - Erased future from FutureRegistry
[01:27:49.192] result() for ClusterFuture ...
[01:27:49.192] - result already collected: FutureResult
[01:27:49.193] result() for ClusterFuture ... done
[01:27:49.193] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.193] result() for ClusterFuture ...
[01:27:49.193] - result already collected: FutureResult
[01:27:49.193] result() for ClusterFuture ... done
[01:27:49.194] result() for ClusterFuture ...
[01:27:49.194] - result already collected: FutureResult
[01:27:49.194] result() for ClusterFuture ... done
[01:27:49.196] MultisessionFuture started
[01:27:49.196] - Launch lazy future ... done
[01:27:49.196] run() for 'MultisessionFuture' ... done
<environment: 0x0000025b0ad9fc68> 
<environment: 0x0000025b06361d48> 
[01:27:49.198] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.199] - Validating connection of MultisessionFuture
[01:27:49.199] - received message: FutureResult
[01:27:49.199] - Received FutureResult
[01:27:49.199] - Erased future from FutureRegistry
[01:27:49.200] result() for ClusterFuture ...
[01:27:49.200] - result already collected: FutureResult
[01:27:49.200] result() for ClusterFuture ... done
[01:27:49.200] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.214] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.215] - Validating connection of MultisessionFuture
[01:27:49.215] - received message: FutureResult
[01:27:49.215] - Received FutureResult
[01:27:49.215] - Erased future from FutureRegistry
[01:27:49.216] result() for ClusterFuture ...
[01:27:49.216] - result already collected: FutureResult
[01:27:49.216] result() for ClusterFuture ... done
[01:27:49.216] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:49.218] resolve() on environment ...
[01:27:49.218]  recursive: 0
[01:27:49.219]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:49.219] signalConditionsASAP(numeric, pos=1) ...
[01:27:49.220] - nx: 4
[01:27:49.220] - relay: TRUE
[01:27:49.220] - stdout: TRUE
[01:27:49.220] - signal: TRUE
[01:27:49.221] - resignal: FALSE
[01:27:49.221] - force: TRUE
[01:27:49.221] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.222] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.222]  - until=2
[01:27:49.222]  - relaying element #2
[01:27:49.222] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.223] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.223] signalConditionsASAP(NULL, pos=1) ... done
[01:27:49.223]  length: 3 (resolved future 1)
[01:27:49.224] Future #2
[01:27:49.224] result() for ClusterFuture ...
[01:27:49.224] - result already collected: FutureResult
[01:27:49.225] result() for ClusterFuture ... done
[01:27:49.225] result() for ClusterFuture ...
[01:27:49.225] - result already collected: FutureResult
[01:27:49.226] result() for ClusterFuture ... done
[01:27:49.226] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:49.226] - nx: 4
[01:27:49.227] - relay: TRUE
[01:27:49.227] - stdout: TRUE
[01:27:49.227] - signal: TRUE
[01:27:49.227] - resignal: FALSE
[01:27:49.228] - force: TRUE
[01:27:49.228] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.228] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.228]  - until=2
[01:27:49.229]  - relaying element #2
[01:27:49.229] result() for ClusterFuture ...
[01:27:49.229] - result already collected: FutureResult
[01:27:49.230] result() for ClusterFuture ... done
[01:27:49.230] result() for ClusterFuture ...
[01:27:49.230] - result already collected: FutureResult
[01:27:49.230] result() for ClusterFuture ... done
[01:27:49.231] result() for ClusterFuture ...
[01:27:49.231] - result already collected: FutureResult
[01:27:49.231] result() for ClusterFuture ... done
[01:27:49.231] result() for ClusterFuture ...
[01:27:49.232] - result already collected: FutureResult
[01:27:49.232] result() for ClusterFuture ... done
[01:27:49.232] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.232] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.232] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:49.232]  length: 2 (resolved future 2)
[01:27:49.233] Future #3
[01:27:49.233] result() for ClusterFuture ...
[01:27:49.233] - result already collected: FutureResult
[01:27:49.233] result() for ClusterFuture ... done
[01:27:49.233] result() for ClusterFuture ...
[01:27:49.234] - result already collected: FutureResult
[01:27:49.234] result() for ClusterFuture ... done
[01:27:49.234] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:49.234] - nx: 4
[01:27:49.234] - relay: TRUE
[01:27:49.234] - stdout: TRUE
[01:27:49.235] - signal: TRUE
[01:27:49.235] - resignal: FALSE
[01:27:49.235] - force: TRUE
[01:27:49.235] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.235] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.235]  - until=3
[01:27:49.236]  - relaying element #3
[01:27:49.236] result() for ClusterFuture ...
[01:27:49.236] - result already collected: FutureResult
[01:27:49.236] result() for ClusterFuture ... done
[01:27:49.236] result() for ClusterFuture ...
[01:27:49.236] - result already collected: FutureResult
[01:27:49.237] result() for ClusterFuture ... done
[01:27:49.237] result() for ClusterFuture ...
[01:27:49.237] - result already collected: FutureResult
[01:27:49.237] result() for ClusterFuture ... done
[01:27:49.237] result() for ClusterFuture ...
[01:27:49.237] - result already collected: FutureResult
[01:27:49.238] result() for ClusterFuture ... done
[01:27:49.238] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.238] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.238] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:49.238]  length: 1 (resolved future 3)
[01:27:49.239] Future #4
[01:27:49.239] result() for ClusterFuture ...
[01:27:49.239] - result already collected: FutureResult
[01:27:49.239] result() for ClusterFuture ... done
[01:27:49.239] result() for ClusterFuture ...
[01:27:49.239] - result already collected: FutureResult
[01:27:49.240] result() for ClusterFuture ... done
[01:27:49.240] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:49.240] - nx: 4
[01:27:49.240] - relay: TRUE
[01:27:49.240] - stdout: TRUE
[01:27:49.240] - signal: TRUE
[01:27:49.241] - resignal: FALSE
[01:27:49.241] - force: TRUE
[01:27:49.241] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.241] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.241]  - until=4
[01:27:49.241]  - relaying element #4
[01:27:49.242] result() for ClusterFuture ...
[01:27:49.242] - result already collected: FutureResult
[01:27:49.242] result() for ClusterFuture ... done
[01:27:49.242] result() for ClusterFuture ...
[01:27:49.242] - result already collected: FutureResult
[01:27:49.242] result() for ClusterFuture ... done
[01:27:49.243] result() for ClusterFuture ...
[01:27:49.243] - result already collected: FutureResult
[01:27:49.243] result() for ClusterFuture ... done
[01:27:49.243] result() for ClusterFuture ...
[01:27:49.243] - result already collected: FutureResult
[01:27:49.244] result() for ClusterFuture ... done
[01:27:49.244] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.244] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.244] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:49.245]  length: 0 (resolved future 4)
[01:27:49.245] Relaying remaining futures
[01:27:49.245] signalConditionsASAP(NULL, pos=0) ...
[01:27:49.245] - nx: 4
[01:27:49.245] - relay: TRUE
[01:27:49.245] - stdout: TRUE
[01:27:49.246] - signal: TRUE
[01:27:49.246] - resignal: FALSE
[01:27:49.246] - force: TRUE
[01:27:49.246] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.246] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:49.247] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.247] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.247] signalConditionsASAP(NULL, pos=0) ... done
[01:27:49.247] resolve() on environment ... DONE
[01:27:49.247] result() for ClusterFuture ...
[01:27:49.247] - result already collected: FutureResult
[01:27:49.248] result() for ClusterFuture ... done
[01:27:49.248] result() for ClusterFuture ...
[01:27:49.248] - result already collected: FutureResult
[01:27:49.248] result() for ClusterFuture ... done
[01:27:49.248] result() for ClusterFuture ...
[01:27:49.248] - result already collected: FutureResult
[01:27:49.249] result() for ClusterFuture ... done
[01:27:49.249] result() for ClusterFuture ...
[01:27:49.249] - result already collected: FutureResult
[01:27:49.249] result() for ClusterFuture ... done
[01:27:49.249] result() for ClusterFuture ...
[01:27:49.249] - result already collected: FutureResult
[01:27:49.249] result() for ClusterFuture ... done
[01:27:49.250] result() for ClusterFuture ...
[01:27:49.250] - result already collected: FutureResult
[01:27:49.250] result() for ClusterFuture ... done
<environment: 0x0000025b04c3f990> 
Dimensions: c(2, 3)
[01:27:49.251] getGlobalsAndPackages() ...
[01:27:49.251] Searching for globals...
[01:27:49.251] 
[01:27:49.251] Searching for globals ... DONE
[01:27:49.252] - globals: [0] <none>
[01:27:49.252] getGlobalsAndPackages() ... DONE
[01:27:49.252] run() for 'Future' ...
[01:27:49.252] - state: 'created'
[01:27:49.253] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.268] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.268] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.268]   - Field: 'node'
[01:27:49.268]   - Field: 'label'
[01:27:49.268]   - Field: 'local'
[01:27:49.269]   - Field: 'owner'
[01:27:49.269]   - Field: 'envir'
[01:27:49.269]   - Field: 'workers'
[01:27:49.269]   - Field: 'packages'
[01:27:49.269]   - Field: 'gc'
[01:27:49.270]   - Field: 'conditions'
[01:27:49.270]   - Field: 'persistent'
[01:27:49.270]   - Field: 'expr'
[01:27:49.270]   - Field: 'uuid'
[01:27:49.270]   - Field: 'seed'
[01:27:49.270]   - Field: 'version'
[01:27:49.271]   - Field: 'result'
[01:27:49.271]   - Field: 'asynchronous'
[01:27:49.271]   - Field: 'calls'
[01:27:49.271]   - Field: 'globals'
[01:27:49.271]   - Field: 'stdout'
[01:27:49.271]   - Field: 'earlySignal'
[01:27:49.272]   - Field: 'lazy'
[01:27:49.272]   - Field: 'state'
[01:27:49.272] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.272] - Launch lazy future ...
[01:27:49.273] Packages needed by the future expression (n = 0): <none>
[01:27:49.273] Packages needed by future strategies (n = 0): <none>
[01:27:49.273] {
[01:27:49.273]     {
[01:27:49.273]         {
[01:27:49.273]             ...future.startTime <- base::Sys.time()
[01:27:49.273]             {
[01:27:49.273]                 {
[01:27:49.273]                   {
[01:27:49.273]                     {
[01:27:49.273]                       base::local({
[01:27:49.273]                         has_future <- base::requireNamespace("future", 
[01:27:49.273]                           quietly = TRUE)
[01:27:49.273]                         if (has_future) {
[01:27:49.273]                           ns <- base::getNamespace("future")
[01:27:49.273]                           version <- ns[[".package"]][["version"]]
[01:27:49.273]                           if (is.null(version)) 
[01:27:49.273]                             version <- utils::packageVersion("future")
[01:27:49.273]                         }
[01:27:49.273]                         else {
[01:27:49.273]                           version <- NULL
[01:27:49.273]                         }
[01:27:49.273]                         if (!has_future || version < "1.8.0") {
[01:27:49.273]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.273]                             "", base::R.version$version.string), 
[01:27:49.273]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.273]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.273]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.273]                               "release", "version")], collapse = " "), 
[01:27:49.273]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.273]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.273]                             info)
[01:27:49.273]                           info <- base::paste(info, collapse = "; ")
[01:27:49.273]                           if (!has_future) {
[01:27:49.273]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.273]                               info)
[01:27:49.273]                           }
[01:27:49.273]                           else {
[01:27:49.273]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.273]                               info, version)
[01:27:49.273]                           }
[01:27:49.273]                           base::stop(msg)
[01:27:49.273]                         }
[01:27:49.273]                       })
[01:27:49.273]                     }
[01:27:49.273]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.273]                     base::options(mc.cores = 1L)
[01:27:49.273]                   }
[01:27:49.273]                   options(future.plan = NULL)
[01:27:49.273]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.273]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.273]                 }
[01:27:49.273]                 ...future.workdir <- getwd()
[01:27:49.273]             }
[01:27:49.273]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.273]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.273]         }
[01:27:49.273]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.273]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.273]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.273]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.273]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.273]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.273]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.273]             base::names(...future.oldOptions))
[01:27:49.273]     }
[01:27:49.273]     if (FALSE) {
[01:27:49.273]     }
[01:27:49.273]     else {
[01:27:49.273]         if (TRUE) {
[01:27:49.273]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.273]                 open = "w")
[01:27:49.273]         }
[01:27:49.273]         else {
[01:27:49.273]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.273]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.273]         }
[01:27:49.273]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.273]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.273]             base::sink(type = "output", split = FALSE)
[01:27:49.273]             base::close(...future.stdout)
[01:27:49.273]         }, add = TRUE)
[01:27:49.273]     }
[01:27:49.273]     ...future.frame <- base::sys.nframe()
[01:27:49.273]     ...future.conditions <- base::list()
[01:27:49.273]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.273]     if (FALSE) {
[01:27:49.273]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.273]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.273]     }
[01:27:49.273]     ...future.result <- base::tryCatch({
[01:27:49.273]         base::withCallingHandlers({
[01:27:49.273]             ...future.value <- base::withVisible(base::local({
[01:27:49.273]                 ...future.makeSendCondition <- base::local({
[01:27:49.273]                   sendCondition <- NULL
[01:27:49.273]                   function(frame = 1L) {
[01:27:49.273]                     if (is.function(sendCondition)) 
[01:27:49.273]                       return(sendCondition)
[01:27:49.273]                     ns <- getNamespace("parallel")
[01:27:49.273]                     if (exists("sendData", mode = "function", 
[01:27:49.273]                       envir = ns)) {
[01:27:49.273]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.273]                         envir = ns)
[01:27:49.273]                       envir <- sys.frame(frame)
[01:27:49.273]                       master <- NULL
[01:27:49.273]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.273]                         !identical(envir, emptyenv())) {
[01:27:49.273]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.273]                           inherits = FALSE)) {
[01:27:49.273]                           master <- get("master", mode = "list", 
[01:27:49.273]                             envir = envir, inherits = FALSE)
[01:27:49.273]                           if (inherits(master, c("SOCKnode", 
[01:27:49.273]                             "SOCK0node"))) {
[01:27:49.273]                             sendCondition <<- function(cond) {
[01:27:49.273]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.273]                                 success = TRUE)
[01:27:49.273]                               parallel_sendData(master, data)
[01:27:49.273]                             }
[01:27:49.273]                             return(sendCondition)
[01:27:49.273]                           }
[01:27:49.273]                         }
[01:27:49.273]                         frame <- frame + 1L
[01:27:49.273]                         envir <- sys.frame(frame)
[01:27:49.273]                       }
[01:27:49.273]                     }
[01:27:49.273]                     sendCondition <<- function(cond) NULL
[01:27:49.273]                   }
[01:27:49.273]                 })
[01:27:49.273]                 withCallingHandlers({
[01:27:49.273]                   2
[01:27:49.273]                 }, immediateCondition = function(cond) {
[01:27:49.273]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.273]                   sendCondition(cond)
[01:27:49.273]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.273]                   {
[01:27:49.273]                     inherits <- base::inherits
[01:27:49.273]                     invokeRestart <- base::invokeRestart
[01:27:49.273]                     is.null <- base::is.null
[01:27:49.273]                     muffled <- FALSE
[01:27:49.273]                     if (inherits(cond, "message")) {
[01:27:49.273]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.273]                       if (muffled) 
[01:27:49.273]                         invokeRestart("muffleMessage")
[01:27:49.273]                     }
[01:27:49.273]                     else if (inherits(cond, "warning")) {
[01:27:49.273]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.273]                       if (muffled) 
[01:27:49.273]                         invokeRestart("muffleWarning")
[01:27:49.273]                     }
[01:27:49.273]                     else if (inherits(cond, "condition")) {
[01:27:49.273]                       if (!is.null(pattern)) {
[01:27:49.273]                         computeRestarts <- base::computeRestarts
[01:27:49.273]                         grepl <- base::grepl
[01:27:49.273]                         restarts <- computeRestarts(cond)
[01:27:49.273]                         for (restart in restarts) {
[01:27:49.273]                           name <- restart$name
[01:27:49.273]                           if (is.null(name)) 
[01:27:49.273]                             next
[01:27:49.273]                           if (!grepl(pattern, name)) 
[01:27:49.273]                             next
[01:27:49.273]                           invokeRestart(restart)
[01:27:49.273]                           muffled <- TRUE
[01:27:49.273]                           break
[01:27:49.273]                         }
[01:27:49.273]                       }
[01:27:49.273]                     }
[01:27:49.273]                     invisible(muffled)
[01:27:49.273]                   }
[01:27:49.273]                   muffleCondition(cond)
[01:27:49.273]                 })
[01:27:49.273]             }))
[01:27:49.273]             future::FutureResult(value = ...future.value$value, 
[01:27:49.273]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.273]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.273]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.273]                     ...future.globalenv.names))
[01:27:49.273]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.273]         }, condition = base::local({
[01:27:49.273]             c <- base::c
[01:27:49.273]             inherits <- base::inherits
[01:27:49.273]             invokeRestart <- base::invokeRestart
[01:27:49.273]             length <- base::length
[01:27:49.273]             list <- base::list
[01:27:49.273]             seq.int <- base::seq.int
[01:27:49.273]             signalCondition <- base::signalCondition
[01:27:49.273]             sys.calls <- base::sys.calls
[01:27:49.273]             `[[` <- base::`[[`
[01:27:49.273]             `+` <- base::`+`
[01:27:49.273]             `<<-` <- base::`<<-`
[01:27:49.273]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.273]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.273]                   3L)]
[01:27:49.273]             }
[01:27:49.273]             function(cond) {
[01:27:49.273]                 is_error <- inherits(cond, "error")
[01:27:49.273]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.273]                   NULL)
[01:27:49.273]                 if (is_error) {
[01:27:49.273]                   sessionInformation <- function() {
[01:27:49.273]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.273]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.273]                       search = base::search(), system = base::Sys.info())
[01:27:49.273]                   }
[01:27:49.273]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.273]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.273]                     cond$call), session = sessionInformation(), 
[01:27:49.273]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.273]                   signalCondition(cond)
[01:27:49.273]                 }
[01:27:49.273]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.273]                 "immediateCondition"))) {
[01:27:49.273]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.273]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.273]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.273]                   if (TRUE && !signal) {
[01:27:49.273]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.273]                     {
[01:27:49.273]                       inherits <- base::inherits
[01:27:49.273]                       invokeRestart <- base::invokeRestart
[01:27:49.273]                       is.null <- base::is.null
[01:27:49.273]                       muffled <- FALSE
[01:27:49.273]                       if (inherits(cond, "message")) {
[01:27:49.273]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.273]                         if (muffled) 
[01:27:49.273]                           invokeRestart("muffleMessage")
[01:27:49.273]                       }
[01:27:49.273]                       else if (inherits(cond, "warning")) {
[01:27:49.273]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.273]                         if (muffled) 
[01:27:49.273]                           invokeRestart("muffleWarning")
[01:27:49.273]                       }
[01:27:49.273]                       else if (inherits(cond, "condition")) {
[01:27:49.273]                         if (!is.null(pattern)) {
[01:27:49.273]                           computeRestarts <- base::computeRestarts
[01:27:49.273]                           grepl <- base::grepl
[01:27:49.273]                           restarts <- computeRestarts(cond)
[01:27:49.273]                           for (restart in restarts) {
[01:27:49.273]                             name <- restart$name
[01:27:49.273]                             if (is.null(name)) 
[01:27:49.273]                               next
[01:27:49.273]                             if (!grepl(pattern, name)) 
[01:27:49.273]                               next
[01:27:49.273]                             invokeRestart(restart)
[01:27:49.273]                             muffled <- TRUE
[01:27:49.273]                             break
[01:27:49.273]                           }
[01:27:49.273]                         }
[01:27:49.273]                       }
[01:27:49.273]                       invisible(muffled)
[01:27:49.273]                     }
[01:27:49.273]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.273]                   }
[01:27:49.273]                 }
[01:27:49.273]                 else {
[01:27:49.273]                   if (TRUE) {
[01:27:49.273]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.273]                     {
[01:27:49.273]                       inherits <- base::inherits
[01:27:49.273]                       invokeRestart <- base::invokeRestart
[01:27:49.273]                       is.null <- base::is.null
[01:27:49.273]                       muffled <- FALSE
[01:27:49.273]                       if (inherits(cond, "message")) {
[01:27:49.273]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.273]                         if (muffled) 
[01:27:49.273]                           invokeRestart("muffleMessage")
[01:27:49.273]                       }
[01:27:49.273]                       else if (inherits(cond, "warning")) {
[01:27:49.273]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.273]                         if (muffled) 
[01:27:49.273]                           invokeRestart("muffleWarning")
[01:27:49.273]                       }
[01:27:49.273]                       else if (inherits(cond, "condition")) {
[01:27:49.273]                         if (!is.null(pattern)) {
[01:27:49.273]                           computeRestarts <- base::computeRestarts
[01:27:49.273]                           grepl <- base::grepl
[01:27:49.273]                           restarts <- computeRestarts(cond)
[01:27:49.273]                           for (restart in restarts) {
[01:27:49.273]                             name <- restart$name
[01:27:49.273]                             if (is.null(name)) 
[01:27:49.273]                               next
[01:27:49.273]                             if (!grepl(pattern, name)) 
[01:27:49.273]                               next
[01:27:49.273]                             invokeRestart(restart)
[01:27:49.273]                             muffled <- TRUE
[01:27:49.273]                             break
[01:27:49.273]                           }
[01:27:49.273]                         }
[01:27:49.273]                       }
[01:27:49.273]                       invisible(muffled)
[01:27:49.273]                     }
[01:27:49.273]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.273]                   }
[01:27:49.273]                 }
[01:27:49.273]             }
[01:27:49.273]         }))
[01:27:49.273]     }, error = function(ex) {
[01:27:49.273]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.273]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.273]                 ...future.rng), started = ...future.startTime, 
[01:27:49.273]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.273]             version = "1.8"), class = "FutureResult")
[01:27:49.273]     }, finally = {
[01:27:49.273]         if (!identical(...future.workdir, getwd())) 
[01:27:49.273]             setwd(...future.workdir)
[01:27:49.273]         {
[01:27:49.273]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.273]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.273]             }
[01:27:49.273]             base::options(...future.oldOptions)
[01:27:49.273]             if (.Platform$OS.type == "windows") {
[01:27:49.273]                 old_names <- names(...future.oldEnvVars)
[01:27:49.273]                 envs <- base::Sys.getenv()
[01:27:49.273]                 names <- names(envs)
[01:27:49.273]                 common <- intersect(names, old_names)
[01:27:49.273]                 added <- setdiff(names, old_names)
[01:27:49.273]                 removed <- setdiff(old_names, names)
[01:27:49.273]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.273]                   envs[common]]
[01:27:49.273]                 NAMES <- toupper(changed)
[01:27:49.273]                 args <- list()
[01:27:49.273]                 for (kk in seq_along(NAMES)) {
[01:27:49.273]                   name <- changed[[kk]]
[01:27:49.273]                   NAME <- NAMES[[kk]]
[01:27:49.273]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.273]                     next
[01:27:49.273]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.273]                 }
[01:27:49.273]                 NAMES <- toupper(added)
[01:27:49.273]                 for (kk in seq_along(NAMES)) {
[01:27:49.273]                   name <- added[[kk]]
[01:27:49.273]                   NAME <- NAMES[[kk]]
[01:27:49.273]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.273]                     next
[01:27:49.273]                   args[[name]] <- ""
[01:27:49.273]                 }
[01:27:49.273]                 NAMES <- toupper(removed)
[01:27:49.273]                 for (kk in seq_along(NAMES)) {
[01:27:49.273]                   name <- removed[[kk]]
[01:27:49.273]                   NAME <- NAMES[[kk]]
[01:27:49.273]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.273]                     next
[01:27:49.273]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.273]                 }
[01:27:49.273]                 if (length(args) > 0) 
[01:27:49.273]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.273]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.273]             }
[01:27:49.273]             else {
[01:27:49.273]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.273]             }
[01:27:49.273]             {
[01:27:49.273]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.273]                   0L) {
[01:27:49.273]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.273]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.273]                   base::options(opts)
[01:27:49.273]                 }
[01:27:49.273]                 {
[01:27:49.273]                   {
[01:27:49.273]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.273]                     NULL
[01:27:49.273]                   }
[01:27:49.273]                   options(future.plan = NULL)
[01:27:49.273]                   if (is.na(NA_character_)) 
[01:27:49.273]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.273]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.273]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.273]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.273]                     envir = parent.frame()) 
[01:27:49.273]                   {
[01:27:49.273]                     if (is.function(workers)) 
[01:27:49.273]                       workers <- workers()
[01:27:49.273]                     workers <- structure(as.integer(workers), 
[01:27:49.273]                       class = class(workers))
[01:27:49.273]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.273]                       workers >= 1)
[01:27:49.273]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.273]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.273]                     }
[01:27:49.273]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.273]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.273]                       envir = envir)
[01:27:49.273]                     if (!future$lazy) 
[01:27:49.273]                       future <- run(future)
[01:27:49.273]                     invisible(future)
[01:27:49.273]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.273]                 }
[01:27:49.273]             }
[01:27:49.273]         }
[01:27:49.273]     })
[01:27:49.273]     if (TRUE) {
[01:27:49.273]         base::sink(type = "output", split = FALSE)
[01:27:49.273]         if (TRUE) {
[01:27:49.273]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.273]         }
[01:27:49.273]         else {
[01:27:49.273]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.273]         }
[01:27:49.273]         base::close(...future.stdout)
[01:27:49.273]         ...future.stdout <- NULL
[01:27:49.273]     }
[01:27:49.273]     ...future.result$conditions <- ...future.conditions
[01:27:49.273]     ...future.result$finished <- base::Sys.time()
[01:27:49.273]     ...future.result
[01:27:49.273] }
[01:27:49.280] MultisessionFuture started
[01:27:49.280] - Launch lazy future ... done
[01:27:49.280] run() for 'MultisessionFuture' ... done
[01:27:49.280] getGlobalsAndPackages() ...
[01:27:49.281] Searching for globals...
[01:27:49.281] 
[01:27:49.281] Searching for globals ... DONE
[01:27:49.281] - globals: [0] <none>
[01:27:49.281] getGlobalsAndPackages() ... DONE
[01:27:49.282] run() for 'Future' ...
[01:27:49.282] - state: 'created'
[01:27:49.282] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.299] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.300] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.300]   - Field: 'node'
[01:27:49.300]   - Field: 'label'
[01:27:49.301]   - Field: 'local'
[01:27:49.301]   - Field: 'owner'
[01:27:49.301]   - Field: 'envir'
[01:27:49.301]   - Field: 'workers'
[01:27:49.302]   - Field: 'packages'
[01:27:49.302]   - Field: 'gc'
[01:27:49.302]   - Field: 'conditions'
[01:27:49.302]   - Field: 'persistent'
[01:27:49.303]   - Field: 'expr'
[01:27:49.303]   - Field: 'uuid'
[01:27:49.303]   - Field: 'seed'
[01:27:49.303]   - Field: 'version'
[01:27:49.304]   - Field: 'result'
[01:27:49.304]   - Field: 'asynchronous'
[01:27:49.304]   - Field: 'calls'
[01:27:49.304]   - Field: 'globals'
[01:27:49.305]   - Field: 'stdout'
[01:27:49.305]   - Field: 'earlySignal'
[01:27:49.305]   - Field: 'lazy'
[01:27:49.306]   - Field: 'state'
[01:27:49.306] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.306] - Launch lazy future ...
[01:27:49.307] Packages needed by the future expression (n = 0): <none>
[01:27:49.308] Packages needed by future strategies (n = 0): <none>
[01:27:49.309] {
[01:27:49.309]     {
[01:27:49.309]         {
[01:27:49.309]             ...future.startTime <- base::Sys.time()
[01:27:49.309]             {
[01:27:49.309]                 {
[01:27:49.309]                   {
[01:27:49.309]                     {
[01:27:49.309]                       base::local({
[01:27:49.309]                         has_future <- base::requireNamespace("future", 
[01:27:49.309]                           quietly = TRUE)
[01:27:49.309]                         if (has_future) {
[01:27:49.309]                           ns <- base::getNamespace("future")
[01:27:49.309]                           version <- ns[[".package"]][["version"]]
[01:27:49.309]                           if (is.null(version)) 
[01:27:49.309]                             version <- utils::packageVersion("future")
[01:27:49.309]                         }
[01:27:49.309]                         else {
[01:27:49.309]                           version <- NULL
[01:27:49.309]                         }
[01:27:49.309]                         if (!has_future || version < "1.8.0") {
[01:27:49.309]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.309]                             "", base::R.version$version.string), 
[01:27:49.309]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.309]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.309]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.309]                               "release", "version")], collapse = " "), 
[01:27:49.309]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.309]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.309]                             info)
[01:27:49.309]                           info <- base::paste(info, collapse = "; ")
[01:27:49.309]                           if (!has_future) {
[01:27:49.309]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.309]                               info)
[01:27:49.309]                           }
[01:27:49.309]                           else {
[01:27:49.309]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.309]                               info, version)
[01:27:49.309]                           }
[01:27:49.309]                           base::stop(msg)
[01:27:49.309]                         }
[01:27:49.309]                       })
[01:27:49.309]                     }
[01:27:49.309]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.309]                     base::options(mc.cores = 1L)
[01:27:49.309]                   }
[01:27:49.309]                   options(future.plan = NULL)
[01:27:49.309]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.309]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.309]                 }
[01:27:49.309]                 ...future.workdir <- getwd()
[01:27:49.309]             }
[01:27:49.309]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.309]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.309]         }
[01:27:49.309]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.309]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.309]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.309]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.309]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.309]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.309]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.309]             base::names(...future.oldOptions))
[01:27:49.309]     }
[01:27:49.309]     if (FALSE) {
[01:27:49.309]     }
[01:27:49.309]     else {
[01:27:49.309]         if (TRUE) {
[01:27:49.309]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.309]                 open = "w")
[01:27:49.309]         }
[01:27:49.309]         else {
[01:27:49.309]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.309]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.309]         }
[01:27:49.309]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.309]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.309]             base::sink(type = "output", split = FALSE)
[01:27:49.309]             base::close(...future.stdout)
[01:27:49.309]         }, add = TRUE)
[01:27:49.309]     }
[01:27:49.309]     ...future.frame <- base::sys.nframe()
[01:27:49.309]     ...future.conditions <- base::list()
[01:27:49.309]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.309]     if (FALSE) {
[01:27:49.309]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.309]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.309]     }
[01:27:49.309]     ...future.result <- base::tryCatch({
[01:27:49.309]         base::withCallingHandlers({
[01:27:49.309]             ...future.value <- base::withVisible(base::local({
[01:27:49.309]                 ...future.makeSendCondition <- base::local({
[01:27:49.309]                   sendCondition <- NULL
[01:27:49.309]                   function(frame = 1L) {
[01:27:49.309]                     if (is.function(sendCondition)) 
[01:27:49.309]                       return(sendCondition)
[01:27:49.309]                     ns <- getNamespace("parallel")
[01:27:49.309]                     if (exists("sendData", mode = "function", 
[01:27:49.309]                       envir = ns)) {
[01:27:49.309]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.309]                         envir = ns)
[01:27:49.309]                       envir <- sys.frame(frame)
[01:27:49.309]                       master <- NULL
[01:27:49.309]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.309]                         !identical(envir, emptyenv())) {
[01:27:49.309]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.309]                           inherits = FALSE)) {
[01:27:49.309]                           master <- get("master", mode = "list", 
[01:27:49.309]                             envir = envir, inherits = FALSE)
[01:27:49.309]                           if (inherits(master, c("SOCKnode", 
[01:27:49.309]                             "SOCK0node"))) {
[01:27:49.309]                             sendCondition <<- function(cond) {
[01:27:49.309]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.309]                                 success = TRUE)
[01:27:49.309]                               parallel_sendData(master, data)
[01:27:49.309]                             }
[01:27:49.309]                             return(sendCondition)
[01:27:49.309]                           }
[01:27:49.309]                         }
[01:27:49.309]                         frame <- frame + 1L
[01:27:49.309]                         envir <- sys.frame(frame)
[01:27:49.309]                       }
[01:27:49.309]                     }
[01:27:49.309]                     sendCondition <<- function(cond) NULL
[01:27:49.309]                   }
[01:27:49.309]                 })
[01:27:49.309]                 withCallingHandlers({
[01:27:49.309]                   NULL
[01:27:49.309]                 }, immediateCondition = function(cond) {
[01:27:49.309]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.309]                   sendCondition(cond)
[01:27:49.309]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.309]                   {
[01:27:49.309]                     inherits <- base::inherits
[01:27:49.309]                     invokeRestart <- base::invokeRestart
[01:27:49.309]                     is.null <- base::is.null
[01:27:49.309]                     muffled <- FALSE
[01:27:49.309]                     if (inherits(cond, "message")) {
[01:27:49.309]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.309]                       if (muffled) 
[01:27:49.309]                         invokeRestart("muffleMessage")
[01:27:49.309]                     }
[01:27:49.309]                     else if (inherits(cond, "warning")) {
[01:27:49.309]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.309]                       if (muffled) 
[01:27:49.309]                         invokeRestart("muffleWarning")
[01:27:49.309]                     }
[01:27:49.309]                     else if (inherits(cond, "condition")) {
[01:27:49.309]                       if (!is.null(pattern)) {
[01:27:49.309]                         computeRestarts <- base::computeRestarts
[01:27:49.309]                         grepl <- base::grepl
[01:27:49.309]                         restarts <- computeRestarts(cond)
[01:27:49.309]                         for (restart in restarts) {
[01:27:49.309]                           name <- restart$name
[01:27:49.309]                           if (is.null(name)) 
[01:27:49.309]                             next
[01:27:49.309]                           if (!grepl(pattern, name)) 
[01:27:49.309]                             next
[01:27:49.309]                           invokeRestart(restart)
[01:27:49.309]                           muffled <- TRUE
[01:27:49.309]                           break
[01:27:49.309]                         }
[01:27:49.309]                       }
[01:27:49.309]                     }
[01:27:49.309]                     invisible(muffled)
[01:27:49.309]                   }
[01:27:49.309]                   muffleCondition(cond)
[01:27:49.309]                 })
[01:27:49.309]             }))
[01:27:49.309]             future::FutureResult(value = ...future.value$value, 
[01:27:49.309]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.309]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.309]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.309]                     ...future.globalenv.names))
[01:27:49.309]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.309]         }, condition = base::local({
[01:27:49.309]             c <- base::c
[01:27:49.309]             inherits <- base::inherits
[01:27:49.309]             invokeRestart <- base::invokeRestart
[01:27:49.309]             length <- base::length
[01:27:49.309]             list <- base::list
[01:27:49.309]             seq.int <- base::seq.int
[01:27:49.309]             signalCondition <- base::signalCondition
[01:27:49.309]             sys.calls <- base::sys.calls
[01:27:49.309]             `[[` <- base::`[[`
[01:27:49.309]             `+` <- base::`+`
[01:27:49.309]             `<<-` <- base::`<<-`
[01:27:49.309]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.309]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.309]                   3L)]
[01:27:49.309]             }
[01:27:49.309]             function(cond) {
[01:27:49.309]                 is_error <- inherits(cond, "error")
[01:27:49.309]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.309]                   NULL)
[01:27:49.309]                 if (is_error) {
[01:27:49.309]                   sessionInformation <- function() {
[01:27:49.309]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.309]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.309]                       search = base::search(), system = base::Sys.info())
[01:27:49.309]                   }
[01:27:49.309]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.309]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.309]                     cond$call), session = sessionInformation(), 
[01:27:49.309]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.309]                   signalCondition(cond)
[01:27:49.309]                 }
[01:27:49.309]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.309]                 "immediateCondition"))) {
[01:27:49.309]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.309]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.309]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.309]                   if (TRUE && !signal) {
[01:27:49.309]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.309]                     {
[01:27:49.309]                       inherits <- base::inherits
[01:27:49.309]                       invokeRestart <- base::invokeRestart
[01:27:49.309]                       is.null <- base::is.null
[01:27:49.309]                       muffled <- FALSE
[01:27:49.309]                       if (inherits(cond, "message")) {
[01:27:49.309]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.309]                         if (muffled) 
[01:27:49.309]                           invokeRestart("muffleMessage")
[01:27:49.309]                       }
[01:27:49.309]                       else if (inherits(cond, "warning")) {
[01:27:49.309]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.309]                         if (muffled) 
[01:27:49.309]                           invokeRestart("muffleWarning")
[01:27:49.309]                       }
[01:27:49.309]                       else if (inherits(cond, "condition")) {
[01:27:49.309]                         if (!is.null(pattern)) {
[01:27:49.309]                           computeRestarts <- base::computeRestarts
[01:27:49.309]                           grepl <- base::grepl
[01:27:49.309]                           restarts <- computeRestarts(cond)
[01:27:49.309]                           for (restart in restarts) {
[01:27:49.309]                             name <- restart$name
[01:27:49.309]                             if (is.null(name)) 
[01:27:49.309]                               next
[01:27:49.309]                             if (!grepl(pattern, name)) 
[01:27:49.309]                               next
[01:27:49.309]                             invokeRestart(restart)
[01:27:49.309]                             muffled <- TRUE
[01:27:49.309]                             break
[01:27:49.309]                           }
[01:27:49.309]                         }
[01:27:49.309]                       }
[01:27:49.309]                       invisible(muffled)
[01:27:49.309]                     }
[01:27:49.309]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.309]                   }
[01:27:49.309]                 }
[01:27:49.309]                 else {
[01:27:49.309]                   if (TRUE) {
[01:27:49.309]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.309]                     {
[01:27:49.309]                       inherits <- base::inherits
[01:27:49.309]                       invokeRestart <- base::invokeRestart
[01:27:49.309]                       is.null <- base::is.null
[01:27:49.309]                       muffled <- FALSE
[01:27:49.309]                       if (inherits(cond, "message")) {
[01:27:49.309]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.309]                         if (muffled) 
[01:27:49.309]                           invokeRestart("muffleMessage")
[01:27:49.309]                       }
[01:27:49.309]                       else if (inherits(cond, "warning")) {
[01:27:49.309]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.309]                         if (muffled) 
[01:27:49.309]                           invokeRestart("muffleWarning")
[01:27:49.309]                       }
[01:27:49.309]                       else if (inherits(cond, "condition")) {
[01:27:49.309]                         if (!is.null(pattern)) {
[01:27:49.309]                           computeRestarts <- base::computeRestarts
[01:27:49.309]                           grepl <- base::grepl
[01:27:49.309]                           restarts <- computeRestarts(cond)
[01:27:49.309]                           for (restart in restarts) {
[01:27:49.309]                             name <- restart$name
[01:27:49.309]                             if (is.null(name)) 
[01:27:49.309]                               next
[01:27:49.309]                             if (!grepl(pattern, name)) 
[01:27:49.309]                               next
[01:27:49.309]                             invokeRestart(restart)
[01:27:49.309]                             muffled <- TRUE
[01:27:49.309]                             break
[01:27:49.309]                           }
[01:27:49.309]                         }
[01:27:49.309]                       }
[01:27:49.309]                       invisible(muffled)
[01:27:49.309]                     }
[01:27:49.309]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.309]                   }
[01:27:49.309]                 }
[01:27:49.309]             }
[01:27:49.309]         }))
[01:27:49.309]     }, error = function(ex) {
[01:27:49.309]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.309]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.309]                 ...future.rng), started = ...future.startTime, 
[01:27:49.309]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.309]             version = "1.8"), class = "FutureResult")
[01:27:49.309]     }, finally = {
[01:27:49.309]         if (!identical(...future.workdir, getwd())) 
[01:27:49.309]             setwd(...future.workdir)
[01:27:49.309]         {
[01:27:49.309]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.309]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.309]             }
[01:27:49.309]             base::options(...future.oldOptions)
[01:27:49.309]             if (.Platform$OS.type == "windows") {
[01:27:49.309]                 old_names <- names(...future.oldEnvVars)
[01:27:49.309]                 envs <- base::Sys.getenv()
[01:27:49.309]                 names <- names(envs)
[01:27:49.309]                 common <- intersect(names, old_names)
[01:27:49.309]                 added <- setdiff(names, old_names)
[01:27:49.309]                 removed <- setdiff(old_names, names)
[01:27:49.309]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.309]                   envs[common]]
[01:27:49.309]                 NAMES <- toupper(changed)
[01:27:49.309]                 args <- list()
[01:27:49.309]                 for (kk in seq_along(NAMES)) {
[01:27:49.309]                   name <- changed[[kk]]
[01:27:49.309]                   NAME <- NAMES[[kk]]
[01:27:49.309]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.309]                     next
[01:27:49.309]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.309]                 }
[01:27:49.309]                 NAMES <- toupper(added)
[01:27:49.309]                 for (kk in seq_along(NAMES)) {
[01:27:49.309]                   name <- added[[kk]]
[01:27:49.309]                   NAME <- NAMES[[kk]]
[01:27:49.309]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.309]                     next
[01:27:49.309]                   args[[name]] <- ""
[01:27:49.309]                 }
[01:27:49.309]                 NAMES <- toupper(removed)
[01:27:49.309]                 for (kk in seq_along(NAMES)) {
[01:27:49.309]                   name <- removed[[kk]]
[01:27:49.309]                   NAME <- NAMES[[kk]]
[01:27:49.309]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.309]                     next
[01:27:49.309]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.309]                 }
[01:27:49.309]                 if (length(args) > 0) 
[01:27:49.309]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.309]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.309]             }
[01:27:49.309]             else {
[01:27:49.309]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.309]             }
[01:27:49.309]             {
[01:27:49.309]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.309]                   0L) {
[01:27:49.309]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.309]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.309]                   base::options(opts)
[01:27:49.309]                 }
[01:27:49.309]                 {
[01:27:49.309]                   {
[01:27:49.309]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.309]                     NULL
[01:27:49.309]                   }
[01:27:49.309]                   options(future.plan = NULL)
[01:27:49.309]                   if (is.na(NA_character_)) 
[01:27:49.309]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.309]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.309]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.309]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.309]                     envir = parent.frame()) 
[01:27:49.309]                   {
[01:27:49.309]                     if (is.function(workers)) 
[01:27:49.309]                       workers <- workers()
[01:27:49.309]                     workers <- structure(as.integer(workers), 
[01:27:49.309]                       class = class(workers))
[01:27:49.309]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.309]                       workers >= 1)
[01:27:49.309]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.309]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.309]                     }
[01:27:49.309]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.309]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.309]                       envir = envir)
[01:27:49.309]                     if (!future$lazy) 
[01:27:49.309]                       future <- run(future)
[01:27:49.309]                     invisible(future)
[01:27:49.309]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.309]                 }
[01:27:49.309]             }
[01:27:49.309]         }
[01:27:49.309]     })
[01:27:49.309]     if (TRUE) {
[01:27:49.309]         base::sink(type = "output", split = FALSE)
[01:27:49.309]         if (TRUE) {
[01:27:49.309]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.309]         }
[01:27:49.309]         else {
[01:27:49.309]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.309]         }
[01:27:49.309]         base::close(...future.stdout)
[01:27:49.309]         ...future.stdout <- NULL
[01:27:49.309]     }
[01:27:49.309]     ...future.result$conditions <- ...future.conditions
[01:27:49.309]     ...future.result$finished <- base::Sys.time()
[01:27:49.309]     ...future.result
[01:27:49.309] }
[01:27:49.319] MultisessionFuture started
[01:27:49.320] - Launch lazy future ... done
[01:27:49.320] run() for 'MultisessionFuture' ... done
[01:27:49.321] getGlobalsAndPackages() ...
[01:27:49.321] Searching for globals...
[01:27:49.322] - globals found: [1] '{'
[01:27:49.323] Searching for globals ... DONE
[01:27:49.323] Resolving globals: FALSE
[01:27:49.323] 
[01:27:49.324] 
[01:27:49.324] getGlobalsAndPackages() ... DONE
[01:27:49.324] run() for 'Future' ...
[01:27:49.324] - state: 'created'
[01:27:49.325] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.340] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.340] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.341]   - Field: 'node'
[01:27:49.341]   - Field: 'label'
[01:27:49.341]   - Field: 'local'
[01:27:49.341]   - Field: 'owner'
[01:27:49.341]   - Field: 'envir'
[01:27:49.342]   - Field: 'workers'
[01:27:49.342]   - Field: 'packages'
[01:27:49.342]   - Field: 'gc'
[01:27:49.342]   - Field: 'conditions'
[01:27:49.342]   - Field: 'persistent'
[01:27:49.343]   - Field: 'expr'
[01:27:49.343]   - Field: 'uuid'
[01:27:49.343]   - Field: 'seed'
[01:27:49.343]   - Field: 'version'
[01:27:49.343]   - Field: 'result'
[01:27:49.344]   - Field: 'asynchronous'
[01:27:49.344]   - Field: 'calls'
[01:27:49.344]   - Field: 'globals'
[01:27:49.344]   - Field: 'stdout'
[01:27:49.345]   - Field: 'earlySignal'
[01:27:49.345]   - Field: 'lazy'
[01:27:49.345]   - Field: 'state'
[01:27:49.345] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.346] - Launch lazy future ...
[01:27:49.346] Packages needed by the future expression (n = 0): <none>
[01:27:49.346] Packages needed by future strategies (n = 0): <none>
[01:27:49.347] {
[01:27:49.347]     {
[01:27:49.347]         {
[01:27:49.347]             ...future.startTime <- base::Sys.time()
[01:27:49.347]             {
[01:27:49.347]                 {
[01:27:49.347]                   {
[01:27:49.347]                     {
[01:27:49.347]                       base::local({
[01:27:49.347]                         has_future <- base::requireNamespace("future", 
[01:27:49.347]                           quietly = TRUE)
[01:27:49.347]                         if (has_future) {
[01:27:49.347]                           ns <- base::getNamespace("future")
[01:27:49.347]                           version <- ns[[".package"]][["version"]]
[01:27:49.347]                           if (is.null(version)) 
[01:27:49.347]                             version <- utils::packageVersion("future")
[01:27:49.347]                         }
[01:27:49.347]                         else {
[01:27:49.347]                           version <- NULL
[01:27:49.347]                         }
[01:27:49.347]                         if (!has_future || version < "1.8.0") {
[01:27:49.347]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.347]                             "", base::R.version$version.string), 
[01:27:49.347]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.347]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.347]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.347]                               "release", "version")], collapse = " "), 
[01:27:49.347]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.347]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.347]                             info)
[01:27:49.347]                           info <- base::paste(info, collapse = "; ")
[01:27:49.347]                           if (!has_future) {
[01:27:49.347]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.347]                               info)
[01:27:49.347]                           }
[01:27:49.347]                           else {
[01:27:49.347]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.347]                               info, version)
[01:27:49.347]                           }
[01:27:49.347]                           base::stop(msg)
[01:27:49.347]                         }
[01:27:49.347]                       })
[01:27:49.347]                     }
[01:27:49.347]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.347]                     base::options(mc.cores = 1L)
[01:27:49.347]                   }
[01:27:49.347]                   options(future.plan = NULL)
[01:27:49.347]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.347]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.347]                 }
[01:27:49.347]                 ...future.workdir <- getwd()
[01:27:49.347]             }
[01:27:49.347]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.347]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.347]         }
[01:27:49.347]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.347]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.347]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.347]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.347]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.347]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.347]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.347]             base::names(...future.oldOptions))
[01:27:49.347]     }
[01:27:49.347]     if (FALSE) {
[01:27:49.347]     }
[01:27:49.347]     else {
[01:27:49.347]         if (TRUE) {
[01:27:49.347]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.347]                 open = "w")
[01:27:49.347]         }
[01:27:49.347]         else {
[01:27:49.347]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.347]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.347]         }
[01:27:49.347]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.347]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.347]             base::sink(type = "output", split = FALSE)
[01:27:49.347]             base::close(...future.stdout)
[01:27:49.347]         }, add = TRUE)
[01:27:49.347]     }
[01:27:49.347]     ...future.frame <- base::sys.nframe()
[01:27:49.347]     ...future.conditions <- base::list()
[01:27:49.347]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.347]     if (FALSE) {
[01:27:49.347]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.347]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.347]     }
[01:27:49.347]     ...future.result <- base::tryCatch({
[01:27:49.347]         base::withCallingHandlers({
[01:27:49.347]             ...future.value <- base::withVisible(base::local({
[01:27:49.347]                 ...future.makeSendCondition <- base::local({
[01:27:49.347]                   sendCondition <- NULL
[01:27:49.347]                   function(frame = 1L) {
[01:27:49.347]                     if (is.function(sendCondition)) 
[01:27:49.347]                       return(sendCondition)
[01:27:49.347]                     ns <- getNamespace("parallel")
[01:27:49.347]                     if (exists("sendData", mode = "function", 
[01:27:49.347]                       envir = ns)) {
[01:27:49.347]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.347]                         envir = ns)
[01:27:49.347]                       envir <- sys.frame(frame)
[01:27:49.347]                       master <- NULL
[01:27:49.347]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.347]                         !identical(envir, emptyenv())) {
[01:27:49.347]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.347]                           inherits = FALSE)) {
[01:27:49.347]                           master <- get("master", mode = "list", 
[01:27:49.347]                             envir = envir, inherits = FALSE)
[01:27:49.347]                           if (inherits(master, c("SOCKnode", 
[01:27:49.347]                             "SOCK0node"))) {
[01:27:49.347]                             sendCondition <<- function(cond) {
[01:27:49.347]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.347]                                 success = TRUE)
[01:27:49.347]                               parallel_sendData(master, data)
[01:27:49.347]                             }
[01:27:49.347]                             return(sendCondition)
[01:27:49.347]                           }
[01:27:49.347]                         }
[01:27:49.347]                         frame <- frame + 1L
[01:27:49.347]                         envir <- sys.frame(frame)
[01:27:49.347]                       }
[01:27:49.347]                     }
[01:27:49.347]                     sendCondition <<- function(cond) NULL
[01:27:49.347]                   }
[01:27:49.347]                 })
[01:27:49.347]                 withCallingHandlers({
[01:27:49.347]                   {
[01:27:49.347]                     4
[01:27:49.347]                   }
[01:27:49.347]                 }, immediateCondition = function(cond) {
[01:27:49.347]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.347]                   sendCondition(cond)
[01:27:49.347]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.347]                   {
[01:27:49.347]                     inherits <- base::inherits
[01:27:49.347]                     invokeRestart <- base::invokeRestart
[01:27:49.347]                     is.null <- base::is.null
[01:27:49.347]                     muffled <- FALSE
[01:27:49.347]                     if (inherits(cond, "message")) {
[01:27:49.347]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.347]                       if (muffled) 
[01:27:49.347]                         invokeRestart("muffleMessage")
[01:27:49.347]                     }
[01:27:49.347]                     else if (inherits(cond, "warning")) {
[01:27:49.347]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.347]                       if (muffled) 
[01:27:49.347]                         invokeRestart("muffleWarning")
[01:27:49.347]                     }
[01:27:49.347]                     else if (inherits(cond, "condition")) {
[01:27:49.347]                       if (!is.null(pattern)) {
[01:27:49.347]                         computeRestarts <- base::computeRestarts
[01:27:49.347]                         grepl <- base::grepl
[01:27:49.347]                         restarts <- computeRestarts(cond)
[01:27:49.347]                         for (restart in restarts) {
[01:27:49.347]                           name <- restart$name
[01:27:49.347]                           if (is.null(name)) 
[01:27:49.347]                             next
[01:27:49.347]                           if (!grepl(pattern, name)) 
[01:27:49.347]                             next
[01:27:49.347]                           invokeRestart(restart)
[01:27:49.347]                           muffled <- TRUE
[01:27:49.347]                           break
[01:27:49.347]                         }
[01:27:49.347]                       }
[01:27:49.347]                     }
[01:27:49.347]                     invisible(muffled)
[01:27:49.347]                   }
[01:27:49.347]                   muffleCondition(cond)
[01:27:49.347]                 })
[01:27:49.347]             }))
[01:27:49.347]             future::FutureResult(value = ...future.value$value, 
[01:27:49.347]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.347]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.347]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.347]                     ...future.globalenv.names))
[01:27:49.347]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.347]         }, condition = base::local({
[01:27:49.347]             c <- base::c
[01:27:49.347]             inherits <- base::inherits
[01:27:49.347]             invokeRestart <- base::invokeRestart
[01:27:49.347]             length <- base::length
[01:27:49.347]             list <- base::list
[01:27:49.347]             seq.int <- base::seq.int
[01:27:49.347]             signalCondition <- base::signalCondition
[01:27:49.347]             sys.calls <- base::sys.calls
[01:27:49.347]             `[[` <- base::`[[`
[01:27:49.347]             `+` <- base::`+`
[01:27:49.347]             `<<-` <- base::`<<-`
[01:27:49.347]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.347]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.347]                   3L)]
[01:27:49.347]             }
[01:27:49.347]             function(cond) {
[01:27:49.347]                 is_error <- inherits(cond, "error")
[01:27:49.347]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.347]                   NULL)
[01:27:49.347]                 if (is_error) {
[01:27:49.347]                   sessionInformation <- function() {
[01:27:49.347]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.347]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.347]                       search = base::search(), system = base::Sys.info())
[01:27:49.347]                   }
[01:27:49.347]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.347]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.347]                     cond$call), session = sessionInformation(), 
[01:27:49.347]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.347]                   signalCondition(cond)
[01:27:49.347]                 }
[01:27:49.347]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.347]                 "immediateCondition"))) {
[01:27:49.347]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.347]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.347]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.347]                   if (TRUE && !signal) {
[01:27:49.347]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.347]                     {
[01:27:49.347]                       inherits <- base::inherits
[01:27:49.347]                       invokeRestart <- base::invokeRestart
[01:27:49.347]                       is.null <- base::is.null
[01:27:49.347]                       muffled <- FALSE
[01:27:49.347]                       if (inherits(cond, "message")) {
[01:27:49.347]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.347]                         if (muffled) 
[01:27:49.347]                           invokeRestart("muffleMessage")
[01:27:49.347]                       }
[01:27:49.347]                       else if (inherits(cond, "warning")) {
[01:27:49.347]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.347]                         if (muffled) 
[01:27:49.347]                           invokeRestart("muffleWarning")
[01:27:49.347]                       }
[01:27:49.347]                       else if (inherits(cond, "condition")) {
[01:27:49.347]                         if (!is.null(pattern)) {
[01:27:49.347]                           computeRestarts <- base::computeRestarts
[01:27:49.347]                           grepl <- base::grepl
[01:27:49.347]                           restarts <- computeRestarts(cond)
[01:27:49.347]                           for (restart in restarts) {
[01:27:49.347]                             name <- restart$name
[01:27:49.347]                             if (is.null(name)) 
[01:27:49.347]                               next
[01:27:49.347]                             if (!grepl(pattern, name)) 
[01:27:49.347]                               next
[01:27:49.347]                             invokeRestart(restart)
[01:27:49.347]                             muffled <- TRUE
[01:27:49.347]                             break
[01:27:49.347]                           }
[01:27:49.347]                         }
[01:27:49.347]                       }
[01:27:49.347]                       invisible(muffled)
[01:27:49.347]                     }
[01:27:49.347]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.347]                   }
[01:27:49.347]                 }
[01:27:49.347]                 else {
[01:27:49.347]                   if (TRUE) {
[01:27:49.347]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.347]                     {
[01:27:49.347]                       inherits <- base::inherits
[01:27:49.347]                       invokeRestart <- base::invokeRestart
[01:27:49.347]                       is.null <- base::is.null
[01:27:49.347]                       muffled <- FALSE
[01:27:49.347]                       if (inherits(cond, "message")) {
[01:27:49.347]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.347]                         if (muffled) 
[01:27:49.347]                           invokeRestart("muffleMessage")
[01:27:49.347]                       }
[01:27:49.347]                       else if (inherits(cond, "warning")) {
[01:27:49.347]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.347]                         if (muffled) 
[01:27:49.347]                           invokeRestart("muffleWarning")
[01:27:49.347]                       }
[01:27:49.347]                       else if (inherits(cond, "condition")) {
[01:27:49.347]                         if (!is.null(pattern)) {
[01:27:49.347]                           computeRestarts <- base::computeRestarts
[01:27:49.347]                           grepl <- base::grepl
[01:27:49.347]                           restarts <- computeRestarts(cond)
[01:27:49.347]                           for (restart in restarts) {
[01:27:49.347]                             name <- restart$name
[01:27:49.347]                             if (is.null(name)) 
[01:27:49.347]                               next
[01:27:49.347]                             if (!grepl(pattern, name)) 
[01:27:49.347]                               next
[01:27:49.347]                             invokeRestart(restart)
[01:27:49.347]                             muffled <- TRUE
[01:27:49.347]                             break
[01:27:49.347]                           }
[01:27:49.347]                         }
[01:27:49.347]                       }
[01:27:49.347]                       invisible(muffled)
[01:27:49.347]                     }
[01:27:49.347]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.347]                   }
[01:27:49.347]                 }
[01:27:49.347]             }
[01:27:49.347]         }))
[01:27:49.347]     }, error = function(ex) {
[01:27:49.347]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.347]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.347]                 ...future.rng), started = ...future.startTime, 
[01:27:49.347]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.347]             version = "1.8"), class = "FutureResult")
[01:27:49.347]     }, finally = {
[01:27:49.347]         if (!identical(...future.workdir, getwd())) 
[01:27:49.347]             setwd(...future.workdir)
[01:27:49.347]         {
[01:27:49.347]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.347]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.347]             }
[01:27:49.347]             base::options(...future.oldOptions)
[01:27:49.347]             if (.Platform$OS.type == "windows") {
[01:27:49.347]                 old_names <- names(...future.oldEnvVars)
[01:27:49.347]                 envs <- base::Sys.getenv()
[01:27:49.347]                 names <- names(envs)
[01:27:49.347]                 common <- intersect(names, old_names)
[01:27:49.347]                 added <- setdiff(names, old_names)
[01:27:49.347]                 removed <- setdiff(old_names, names)
[01:27:49.347]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.347]                   envs[common]]
[01:27:49.347]                 NAMES <- toupper(changed)
[01:27:49.347]                 args <- list()
[01:27:49.347]                 for (kk in seq_along(NAMES)) {
[01:27:49.347]                   name <- changed[[kk]]
[01:27:49.347]                   NAME <- NAMES[[kk]]
[01:27:49.347]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.347]                     next
[01:27:49.347]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.347]                 }
[01:27:49.347]                 NAMES <- toupper(added)
[01:27:49.347]                 for (kk in seq_along(NAMES)) {
[01:27:49.347]                   name <- added[[kk]]
[01:27:49.347]                   NAME <- NAMES[[kk]]
[01:27:49.347]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.347]                     next
[01:27:49.347]                   args[[name]] <- ""
[01:27:49.347]                 }
[01:27:49.347]                 NAMES <- toupper(removed)
[01:27:49.347]                 for (kk in seq_along(NAMES)) {
[01:27:49.347]                   name <- removed[[kk]]
[01:27:49.347]                   NAME <- NAMES[[kk]]
[01:27:49.347]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.347]                     next
[01:27:49.347]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.347]                 }
[01:27:49.347]                 if (length(args) > 0) 
[01:27:49.347]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.347]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.347]             }
[01:27:49.347]             else {
[01:27:49.347]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.347]             }
[01:27:49.347]             {
[01:27:49.347]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.347]                   0L) {
[01:27:49.347]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.347]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.347]                   base::options(opts)
[01:27:49.347]                 }
[01:27:49.347]                 {
[01:27:49.347]                   {
[01:27:49.347]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.347]                     NULL
[01:27:49.347]                   }
[01:27:49.347]                   options(future.plan = NULL)
[01:27:49.347]                   if (is.na(NA_character_)) 
[01:27:49.347]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.347]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.347]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.347]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.347]                     envir = parent.frame()) 
[01:27:49.347]                   {
[01:27:49.347]                     if (is.function(workers)) 
[01:27:49.347]                       workers <- workers()
[01:27:49.347]                     workers <- structure(as.integer(workers), 
[01:27:49.347]                       class = class(workers))
[01:27:49.347]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.347]                       workers >= 1)
[01:27:49.347]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.347]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.347]                     }
[01:27:49.347]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.347]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.347]                       envir = envir)
[01:27:49.347]                     if (!future$lazy) 
[01:27:49.347]                       future <- run(future)
[01:27:49.347]                     invisible(future)
[01:27:49.347]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.347]                 }
[01:27:49.347]             }
[01:27:49.347]         }
[01:27:49.347]     })
[01:27:49.347]     if (TRUE) {
[01:27:49.347]         base::sink(type = "output", split = FALSE)
[01:27:49.347]         if (TRUE) {
[01:27:49.347]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.347]         }
[01:27:49.347]         else {
[01:27:49.347]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.347]         }
[01:27:49.347]         base::close(...future.stdout)
[01:27:49.347]         ...future.stdout <- NULL
[01:27:49.347]     }
[01:27:49.347]     ...future.result$conditions <- ...future.conditions
[01:27:49.347]     ...future.result$finished <- base::Sys.time()
[01:27:49.347]     ...future.result
[01:27:49.347] }
[01:27:49.352] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:49.368] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.368] - Validating connection of MultisessionFuture
[01:27:49.369] - received message: FutureResult
[01:27:49.369] - Received FutureResult
[01:27:49.369] - Erased future from FutureRegistry
[01:27:49.369] result() for ClusterFuture ...
[01:27:49.370] - result already collected: FutureResult
[01:27:49.370] result() for ClusterFuture ... done
[01:27:49.370] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.371] result() for ClusterFuture ...
[01:27:49.371] - result already collected: FutureResult
[01:27:49.371] result() for ClusterFuture ... done
[01:27:49.371] result() for ClusterFuture ...
[01:27:49.371] - result already collected: FutureResult
[01:27:49.372] result() for ClusterFuture ... done
[01:27:49.374] MultisessionFuture started
[01:27:49.374] - Launch lazy future ... done
[01:27:49.374] run() for 'MultisessionFuture' ... done
<environment: 0x0000025b0a5b3ca0> 
<environment: 0x0000025b0b760ba0> 
[01:27:49.377] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.377] - Validating connection of MultisessionFuture
[01:27:49.377] - received message: FutureResult
[01:27:49.377] - Received FutureResult
[01:27:49.377] - Erased future from FutureRegistry
[01:27:49.378] result() for ClusterFuture ...
[01:27:49.378] - result already collected: FutureResult
[01:27:49.378] result() for ClusterFuture ... done
[01:27:49.378] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.394] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.394] - Validating connection of MultisessionFuture
[01:27:49.394] - received message: FutureResult
[01:27:49.395] - Received FutureResult
[01:27:49.395] - Erased future from FutureRegistry
[01:27:49.395] result() for ClusterFuture ...
[01:27:49.395] - result already collected: FutureResult
[01:27:49.395] result() for ClusterFuture ... done
[01:27:49.395] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:49.397] resolve() on environment ...
[01:27:49.397]  recursive: 0
[01:27:49.398]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:49.398] signalConditionsASAP(numeric, pos=1) ...
[01:27:49.398] - nx: 4
[01:27:49.398] - relay: TRUE
[01:27:49.399] - stdout: TRUE
[01:27:49.399] - signal: TRUE
[01:27:49.399] - resignal: FALSE
[01:27:49.399] - force: TRUE
[01:27:49.399] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.399] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.400]  - until=2
[01:27:49.400]  - relaying element #2
[01:27:49.400] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.400] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.400] signalConditionsASAP(NULL, pos=1) ... done
[01:27:49.401]  length: 3 (resolved future 1)
[01:27:49.401] Future #2
[01:27:49.401] result() for ClusterFuture ...
[01:27:49.401] - result already collected: FutureResult
[01:27:49.401] result() for ClusterFuture ... done
[01:27:49.401] result() for ClusterFuture ...
[01:27:49.402] - result already collected: FutureResult
[01:27:49.405] result() for ClusterFuture ... done
[01:27:49.405] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:49.406] - nx: 4
[01:27:49.406] - relay: TRUE
[01:27:49.406] - stdout: TRUE
[01:27:49.406] - signal: TRUE
[01:27:49.406] - resignal: FALSE
[01:27:49.406] - force: TRUE
[01:27:49.407] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.407] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.407]  - until=2
[01:27:49.407]  - relaying element #2
[01:27:49.407] result() for ClusterFuture ...
[01:27:49.407] - result already collected: FutureResult
[01:27:49.407] result() for ClusterFuture ... done
[01:27:49.408] result() for ClusterFuture ...
[01:27:49.408] - result already collected: FutureResult
[01:27:49.408] result() for ClusterFuture ... done
[01:27:49.408] result() for ClusterFuture ...
[01:27:49.408] - result already collected: FutureResult
[01:27:49.408] result() for ClusterFuture ... done
[01:27:49.409] result() for ClusterFuture ...
[01:27:49.409] - result already collected: FutureResult
[01:27:49.409] result() for ClusterFuture ... done
[01:27:49.409] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.409] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.409] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:49.410]  length: 2 (resolved future 2)
[01:27:49.410] Future #3
[01:27:49.410] result() for ClusterFuture ...
[01:27:49.410] - result already collected: FutureResult
[01:27:49.410] result() for ClusterFuture ... done
[01:27:49.410] result() for ClusterFuture ...
[01:27:49.411] - result already collected: FutureResult
[01:27:49.411] result() for ClusterFuture ... done
[01:27:49.411] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:49.411] - nx: 4
[01:27:49.411] - relay: TRUE
[01:27:49.411] - stdout: TRUE
[01:27:49.412] - signal: TRUE
[01:27:49.412] - resignal: FALSE
[01:27:49.412] - force: TRUE
[01:27:49.412] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.412] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.412]  - until=3
[01:27:49.413]  - relaying element #3
[01:27:49.413] result() for ClusterFuture ...
[01:27:49.413] - result already collected: FutureResult
[01:27:49.413] result() for ClusterFuture ... done
[01:27:49.413] result() for ClusterFuture ...
[01:27:49.413] - result already collected: FutureResult
[01:27:49.413] result() for ClusterFuture ... done
[01:27:49.414] result() for ClusterFuture ...
[01:27:49.414] - result already collected: FutureResult
[01:27:49.414] result() for ClusterFuture ... done
[01:27:49.414] result() for ClusterFuture ...
[01:27:49.415] - result already collected: FutureResult
[01:27:49.415] result() for ClusterFuture ... done
[01:27:49.415] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.415] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.416] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:49.416]  length: 1 (resolved future 3)
[01:27:49.416] Future #4
[01:27:49.416] result() for ClusterFuture ...
[01:27:49.417] - result already collected: FutureResult
[01:27:49.417] result() for ClusterFuture ... done
[01:27:49.417] result() for ClusterFuture ...
[01:27:49.417] - result already collected: FutureResult
[01:27:49.417] result() for ClusterFuture ... done
[01:27:49.418] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:49.418] - nx: 4
[01:27:49.418] - relay: TRUE
[01:27:49.418] - stdout: TRUE
[01:27:49.418] - signal: TRUE
[01:27:49.418] - resignal: FALSE
[01:27:49.419] - force: TRUE
[01:27:49.419] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.419] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.419]  - until=4
[01:27:49.419]  - relaying element #4
[01:27:49.420] result() for ClusterFuture ...
[01:27:49.420] - result already collected: FutureResult
[01:27:49.420] result() for ClusterFuture ... done
[01:27:49.420] result() for ClusterFuture ...
[01:27:49.420] - result already collected: FutureResult
[01:27:49.420] result() for ClusterFuture ... done
[01:27:49.421] result() for ClusterFuture ...
[01:27:49.421] - result already collected: FutureResult
[01:27:49.421] result() for ClusterFuture ... done
[01:27:49.421] result() for ClusterFuture ...
[01:27:49.421] - result already collected: FutureResult
[01:27:49.421] result() for ClusterFuture ... done
[01:27:49.422] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.422] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.422] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:49.422]  length: 0 (resolved future 4)
[01:27:49.422] Relaying remaining futures
[01:27:49.423] signalConditionsASAP(NULL, pos=0) ...
[01:27:49.423] - nx: 4
[01:27:49.423] - relay: TRUE
[01:27:49.423] - stdout: TRUE
[01:27:49.423] - signal: TRUE
[01:27:49.424] - resignal: FALSE
[01:27:49.424] - force: TRUE
[01:27:49.424] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.424] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:49.424] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.425] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.425] signalConditionsASAP(NULL, pos=0) ... done
[01:27:49.425] resolve() on environment ... DONE
[01:27:49.425] result() for ClusterFuture ...
[01:27:49.425] - result already collected: FutureResult
[01:27:49.425] result() for ClusterFuture ... done
[01:27:49.426] result() for ClusterFuture ...
[01:27:49.426] - result already collected: FutureResult
[01:27:49.426] result() for ClusterFuture ... done
[01:27:49.426] result() for ClusterFuture ...
[01:27:49.426] - result already collected: FutureResult
[01:27:49.427] result() for ClusterFuture ... done
[01:27:49.427] result() for ClusterFuture ...
[01:27:49.427] - result already collected: FutureResult
[01:27:49.427] result() for ClusterFuture ... done
[01:27:49.427] result() for ClusterFuture ...
[01:27:49.428] - result already collected: FutureResult
[01:27:49.428] result() for ClusterFuture ... done
[01:27:49.428] result() for ClusterFuture ...
[01:27:49.428] - result already collected: FutureResult
[01:27:49.428] result() for ClusterFuture ... done
<environment: 0x0000025b0b9a5548> 
Dimensions: c(2, 3, 1)
[01:27:49.429] getGlobalsAndPackages() ...
[01:27:49.429] Searching for globals...
[01:27:49.430] 
[01:27:49.430] Searching for globals ... DONE
[01:27:49.430] - globals: [0] <none>
[01:27:49.431] getGlobalsAndPackages() ... DONE
[01:27:49.431] run() for 'Future' ...
[01:27:49.432] - state: 'created'
[01:27:49.432] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.449] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.450] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.450]   - Field: 'node'
[01:27:49.450]   - Field: 'label'
[01:27:49.450]   - Field: 'local'
[01:27:49.450]   - Field: 'owner'
[01:27:49.451]   - Field: 'envir'
[01:27:49.451]   - Field: 'workers'
[01:27:49.451]   - Field: 'packages'
[01:27:49.451]   - Field: 'gc'
[01:27:49.452]   - Field: 'conditions'
[01:27:49.452]   - Field: 'persistent'
[01:27:49.452]   - Field: 'expr'
[01:27:49.452]   - Field: 'uuid'
[01:27:49.452]   - Field: 'seed'
[01:27:49.453]   - Field: 'version'
[01:27:49.453]   - Field: 'result'
[01:27:49.453]   - Field: 'asynchronous'
[01:27:49.453]   - Field: 'calls'
[01:27:49.453]   - Field: 'globals'
[01:27:49.454]   - Field: 'stdout'
[01:27:49.454]   - Field: 'earlySignal'
[01:27:49.454]   - Field: 'lazy'
[01:27:49.454]   - Field: 'state'
[01:27:49.454] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.455] - Launch lazy future ...
[01:27:49.455] Packages needed by the future expression (n = 0): <none>
[01:27:49.455] Packages needed by future strategies (n = 0): <none>
[01:27:49.456] {
[01:27:49.456]     {
[01:27:49.456]         {
[01:27:49.456]             ...future.startTime <- base::Sys.time()
[01:27:49.456]             {
[01:27:49.456]                 {
[01:27:49.456]                   {
[01:27:49.456]                     {
[01:27:49.456]                       base::local({
[01:27:49.456]                         has_future <- base::requireNamespace("future", 
[01:27:49.456]                           quietly = TRUE)
[01:27:49.456]                         if (has_future) {
[01:27:49.456]                           ns <- base::getNamespace("future")
[01:27:49.456]                           version <- ns[[".package"]][["version"]]
[01:27:49.456]                           if (is.null(version)) 
[01:27:49.456]                             version <- utils::packageVersion("future")
[01:27:49.456]                         }
[01:27:49.456]                         else {
[01:27:49.456]                           version <- NULL
[01:27:49.456]                         }
[01:27:49.456]                         if (!has_future || version < "1.8.0") {
[01:27:49.456]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.456]                             "", base::R.version$version.string), 
[01:27:49.456]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.456]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.456]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.456]                               "release", "version")], collapse = " "), 
[01:27:49.456]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.456]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.456]                             info)
[01:27:49.456]                           info <- base::paste(info, collapse = "; ")
[01:27:49.456]                           if (!has_future) {
[01:27:49.456]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.456]                               info)
[01:27:49.456]                           }
[01:27:49.456]                           else {
[01:27:49.456]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.456]                               info, version)
[01:27:49.456]                           }
[01:27:49.456]                           base::stop(msg)
[01:27:49.456]                         }
[01:27:49.456]                       })
[01:27:49.456]                     }
[01:27:49.456]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.456]                     base::options(mc.cores = 1L)
[01:27:49.456]                   }
[01:27:49.456]                   options(future.plan = NULL)
[01:27:49.456]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.456]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.456]                 }
[01:27:49.456]                 ...future.workdir <- getwd()
[01:27:49.456]             }
[01:27:49.456]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.456]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.456]         }
[01:27:49.456]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.456]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.456]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.456]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.456]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.456]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.456]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.456]             base::names(...future.oldOptions))
[01:27:49.456]     }
[01:27:49.456]     if (FALSE) {
[01:27:49.456]     }
[01:27:49.456]     else {
[01:27:49.456]         if (TRUE) {
[01:27:49.456]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.456]                 open = "w")
[01:27:49.456]         }
[01:27:49.456]         else {
[01:27:49.456]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.456]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.456]         }
[01:27:49.456]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.456]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.456]             base::sink(type = "output", split = FALSE)
[01:27:49.456]             base::close(...future.stdout)
[01:27:49.456]         }, add = TRUE)
[01:27:49.456]     }
[01:27:49.456]     ...future.frame <- base::sys.nframe()
[01:27:49.456]     ...future.conditions <- base::list()
[01:27:49.456]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.456]     if (FALSE) {
[01:27:49.456]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.456]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.456]     }
[01:27:49.456]     ...future.result <- base::tryCatch({
[01:27:49.456]         base::withCallingHandlers({
[01:27:49.456]             ...future.value <- base::withVisible(base::local({
[01:27:49.456]                 ...future.makeSendCondition <- base::local({
[01:27:49.456]                   sendCondition <- NULL
[01:27:49.456]                   function(frame = 1L) {
[01:27:49.456]                     if (is.function(sendCondition)) 
[01:27:49.456]                       return(sendCondition)
[01:27:49.456]                     ns <- getNamespace("parallel")
[01:27:49.456]                     if (exists("sendData", mode = "function", 
[01:27:49.456]                       envir = ns)) {
[01:27:49.456]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.456]                         envir = ns)
[01:27:49.456]                       envir <- sys.frame(frame)
[01:27:49.456]                       master <- NULL
[01:27:49.456]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.456]                         !identical(envir, emptyenv())) {
[01:27:49.456]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.456]                           inherits = FALSE)) {
[01:27:49.456]                           master <- get("master", mode = "list", 
[01:27:49.456]                             envir = envir, inherits = FALSE)
[01:27:49.456]                           if (inherits(master, c("SOCKnode", 
[01:27:49.456]                             "SOCK0node"))) {
[01:27:49.456]                             sendCondition <<- function(cond) {
[01:27:49.456]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.456]                                 success = TRUE)
[01:27:49.456]                               parallel_sendData(master, data)
[01:27:49.456]                             }
[01:27:49.456]                             return(sendCondition)
[01:27:49.456]                           }
[01:27:49.456]                         }
[01:27:49.456]                         frame <- frame + 1L
[01:27:49.456]                         envir <- sys.frame(frame)
[01:27:49.456]                       }
[01:27:49.456]                     }
[01:27:49.456]                     sendCondition <<- function(cond) NULL
[01:27:49.456]                   }
[01:27:49.456]                 })
[01:27:49.456]                 withCallingHandlers({
[01:27:49.456]                   2
[01:27:49.456]                 }, immediateCondition = function(cond) {
[01:27:49.456]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.456]                   sendCondition(cond)
[01:27:49.456]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.456]                   {
[01:27:49.456]                     inherits <- base::inherits
[01:27:49.456]                     invokeRestart <- base::invokeRestart
[01:27:49.456]                     is.null <- base::is.null
[01:27:49.456]                     muffled <- FALSE
[01:27:49.456]                     if (inherits(cond, "message")) {
[01:27:49.456]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.456]                       if (muffled) 
[01:27:49.456]                         invokeRestart("muffleMessage")
[01:27:49.456]                     }
[01:27:49.456]                     else if (inherits(cond, "warning")) {
[01:27:49.456]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.456]                       if (muffled) 
[01:27:49.456]                         invokeRestart("muffleWarning")
[01:27:49.456]                     }
[01:27:49.456]                     else if (inherits(cond, "condition")) {
[01:27:49.456]                       if (!is.null(pattern)) {
[01:27:49.456]                         computeRestarts <- base::computeRestarts
[01:27:49.456]                         grepl <- base::grepl
[01:27:49.456]                         restarts <- computeRestarts(cond)
[01:27:49.456]                         for (restart in restarts) {
[01:27:49.456]                           name <- restart$name
[01:27:49.456]                           if (is.null(name)) 
[01:27:49.456]                             next
[01:27:49.456]                           if (!grepl(pattern, name)) 
[01:27:49.456]                             next
[01:27:49.456]                           invokeRestart(restart)
[01:27:49.456]                           muffled <- TRUE
[01:27:49.456]                           break
[01:27:49.456]                         }
[01:27:49.456]                       }
[01:27:49.456]                     }
[01:27:49.456]                     invisible(muffled)
[01:27:49.456]                   }
[01:27:49.456]                   muffleCondition(cond)
[01:27:49.456]                 })
[01:27:49.456]             }))
[01:27:49.456]             future::FutureResult(value = ...future.value$value, 
[01:27:49.456]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.456]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.456]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.456]                     ...future.globalenv.names))
[01:27:49.456]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.456]         }, condition = base::local({
[01:27:49.456]             c <- base::c
[01:27:49.456]             inherits <- base::inherits
[01:27:49.456]             invokeRestart <- base::invokeRestart
[01:27:49.456]             length <- base::length
[01:27:49.456]             list <- base::list
[01:27:49.456]             seq.int <- base::seq.int
[01:27:49.456]             signalCondition <- base::signalCondition
[01:27:49.456]             sys.calls <- base::sys.calls
[01:27:49.456]             `[[` <- base::`[[`
[01:27:49.456]             `+` <- base::`+`
[01:27:49.456]             `<<-` <- base::`<<-`
[01:27:49.456]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.456]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.456]                   3L)]
[01:27:49.456]             }
[01:27:49.456]             function(cond) {
[01:27:49.456]                 is_error <- inherits(cond, "error")
[01:27:49.456]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.456]                   NULL)
[01:27:49.456]                 if (is_error) {
[01:27:49.456]                   sessionInformation <- function() {
[01:27:49.456]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.456]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.456]                       search = base::search(), system = base::Sys.info())
[01:27:49.456]                   }
[01:27:49.456]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.456]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.456]                     cond$call), session = sessionInformation(), 
[01:27:49.456]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.456]                   signalCondition(cond)
[01:27:49.456]                 }
[01:27:49.456]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.456]                 "immediateCondition"))) {
[01:27:49.456]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.456]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.456]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.456]                   if (TRUE && !signal) {
[01:27:49.456]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.456]                     {
[01:27:49.456]                       inherits <- base::inherits
[01:27:49.456]                       invokeRestart <- base::invokeRestart
[01:27:49.456]                       is.null <- base::is.null
[01:27:49.456]                       muffled <- FALSE
[01:27:49.456]                       if (inherits(cond, "message")) {
[01:27:49.456]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.456]                         if (muffled) 
[01:27:49.456]                           invokeRestart("muffleMessage")
[01:27:49.456]                       }
[01:27:49.456]                       else if (inherits(cond, "warning")) {
[01:27:49.456]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.456]                         if (muffled) 
[01:27:49.456]                           invokeRestart("muffleWarning")
[01:27:49.456]                       }
[01:27:49.456]                       else if (inherits(cond, "condition")) {
[01:27:49.456]                         if (!is.null(pattern)) {
[01:27:49.456]                           computeRestarts <- base::computeRestarts
[01:27:49.456]                           grepl <- base::grepl
[01:27:49.456]                           restarts <- computeRestarts(cond)
[01:27:49.456]                           for (restart in restarts) {
[01:27:49.456]                             name <- restart$name
[01:27:49.456]                             if (is.null(name)) 
[01:27:49.456]                               next
[01:27:49.456]                             if (!grepl(pattern, name)) 
[01:27:49.456]                               next
[01:27:49.456]                             invokeRestart(restart)
[01:27:49.456]                             muffled <- TRUE
[01:27:49.456]                             break
[01:27:49.456]                           }
[01:27:49.456]                         }
[01:27:49.456]                       }
[01:27:49.456]                       invisible(muffled)
[01:27:49.456]                     }
[01:27:49.456]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.456]                   }
[01:27:49.456]                 }
[01:27:49.456]                 else {
[01:27:49.456]                   if (TRUE) {
[01:27:49.456]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.456]                     {
[01:27:49.456]                       inherits <- base::inherits
[01:27:49.456]                       invokeRestart <- base::invokeRestart
[01:27:49.456]                       is.null <- base::is.null
[01:27:49.456]                       muffled <- FALSE
[01:27:49.456]                       if (inherits(cond, "message")) {
[01:27:49.456]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.456]                         if (muffled) 
[01:27:49.456]                           invokeRestart("muffleMessage")
[01:27:49.456]                       }
[01:27:49.456]                       else if (inherits(cond, "warning")) {
[01:27:49.456]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.456]                         if (muffled) 
[01:27:49.456]                           invokeRestart("muffleWarning")
[01:27:49.456]                       }
[01:27:49.456]                       else if (inherits(cond, "condition")) {
[01:27:49.456]                         if (!is.null(pattern)) {
[01:27:49.456]                           computeRestarts <- base::computeRestarts
[01:27:49.456]                           grepl <- base::grepl
[01:27:49.456]                           restarts <- computeRestarts(cond)
[01:27:49.456]                           for (restart in restarts) {
[01:27:49.456]                             name <- restart$name
[01:27:49.456]                             if (is.null(name)) 
[01:27:49.456]                               next
[01:27:49.456]                             if (!grepl(pattern, name)) 
[01:27:49.456]                               next
[01:27:49.456]                             invokeRestart(restart)
[01:27:49.456]                             muffled <- TRUE
[01:27:49.456]                             break
[01:27:49.456]                           }
[01:27:49.456]                         }
[01:27:49.456]                       }
[01:27:49.456]                       invisible(muffled)
[01:27:49.456]                     }
[01:27:49.456]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.456]                   }
[01:27:49.456]                 }
[01:27:49.456]             }
[01:27:49.456]         }))
[01:27:49.456]     }, error = function(ex) {
[01:27:49.456]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.456]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.456]                 ...future.rng), started = ...future.startTime, 
[01:27:49.456]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.456]             version = "1.8"), class = "FutureResult")
[01:27:49.456]     }, finally = {
[01:27:49.456]         if (!identical(...future.workdir, getwd())) 
[01:27:49.456]             setwd(...future.workdir)
[01:27:49.456]         {
[01:27:49.456]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.456]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.456]             }
[01:27:49.456]             base::options(...future.oldOptions)
[01:27:49.456]             if (.Platform$OS.type == "windows") {
[01:27:49.456]                 old_names <- names(...future.oldEnvVars)
[01:27:49.456]                 envs <- base::Sys.getenv()
[01:27:49.456]                 names <- names(envs)
[01:27:49.456]                 common <- intersect(names, old_names)
[01:27:49.456]                 added <- setdiff(names, old_names)
[01:27:49.456]                 removed <- setdiff(old_names, names)
[01:27:49.456]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.456]                   envs[common]]
[01:27:49.456]                 NAMES <- toupper(changed)
[01:27:49.456]                 args <- list()
[01:27:49.456]                 for (kk in seq_along(NAMES)) {
[01:27:49.456]                   name <- changed[[kk]]
[01:27:49.456]                   NAME <- NAMES[[kk]]
[01:27:49.456]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.456]                     next
[01:27:49.456]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.456]                 }
[01:27:49.456]                 NAMES <- toupper(added)
[01:27:49.456]                 for (kk in seq_along(NAMES)) {
[01:27:49.456]                   name <- added[[kk]]
[01:27:49.456]                   NAME <- NAMES[[kk]]
[01:27:49.456]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.456]                     next
[01:27:49.456]                   args[[name]] <- ""
[01:27:49.456]                 }
[01:27:49.456]                 NAMES <- toupper(removed)
[01:27:49.456]                 for (kk in seq_along(NAMES)) {
[01:27:49.456]                   name <- removed[[kk]]
[01:27:49.456]                   NAME <- NAMES[[kk]]
[01:27:49.456]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.456]                     next
[01:27:49.456]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.456]                 }
[01:27:49.456]                 if (length(args) > 0) 
[01:27:49.456]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.456]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.456]             }
[01:27:49.456]             else {
[01:27:49.456]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.456]             }
[01:27:49.456]             {
[01:27:49.456]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.456]                   0L) {
[01:27:49.456]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.456]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.456]                   base::options(opts)
[01:27:49.456]                 }
[01:27:49.456]                 {
[01:27:49.456]                   {
[01:27:49.456]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.456]                     NULL
[01:27:49.456]                   }
[01:27:49.456]                   options(future.plan = NULL)
[01:27:49.456]                   if (is.na(NA_character_)) 
[01:27:49.456]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.456]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.456]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.456]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.456]                     envir = parent.frame()) 
[01:27:49.456]                   {
[01:27:49.456]                     if (is.function(workers)) 
[01:27:49.456]                       workers <- workers()
[01:27:49.456]                     workers <- structure(as.integer(workers), 
[01:27:49.456]                       class = class(workers))
[01:27:49.456]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.456]                       workers >= 1)
[01:27:49.456]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.456]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.456]                     }
[01:27:49.456]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.456]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.456]                       envir = envir)
[01:27:49.456]                     if (!future$lazy) 
[01:27:49.456]                       future <- run(future)
[01:27:49.456]                     invisible(future)
[01:27:49.456]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.456]                 }
[01:27:49.456]             }
[01:27:49.456]         }
[01:27:49.456]     })
[01:27:49.456]     if (TRUE) {
[01:27:49.456]         base::sink(type = "output", split = FALSE)
[01:27:49.456]         if (TRUE) {
[01:27:49.456]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.456]         }
[01:27:49.456]         else {
[01:27:49.456]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.456]         }
[01:27:49.456]         base::close(...future.stdout)
[01:27:49.456]         ...future.stdout <- NULL
[01:27:49.456]     }
[01:27:49.456]     ...future.result$conditions <- ...future.conditions
[01:27:49.456]     ...future.result$finished <- base::Sys.time()
[01:27:49.456]     ...future.result
[01:27:49.456] }
[01:27:49.464] MultisessionFuture started
[01:27:49.464] - Launch lazy future ... done
[01:27:49.464] run() for 'MultisessionFuture' ... done
[01:27:49.465] getGlobalsAndPackages() ...
[01:27:49.465] Searching for globals...
[01:27:49.465] 
[01:27:49.466] Searching for globals ... DONE
[01:27:49.466] - globals: [0] <none>
[01:27:49.466] getGlobalsAndPackages() ... DONE
[01:27:49.466] run() for 'Future' ...
[01:27:49.467] - state: 'created'
[01:27:49.467] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.483] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.483] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.483]   - Field: 'node'
[01:27:49.484]   - Field: 'label'
[01:27:49.484]   - Field: 'local'
[01:27:49.484]   - Field: 'owner'
[01:27:49.484]   - Field: 'envir'
[01:27:49.484]   - Field: 'workers'
[01:27:49.485]   - Field: 'packages'
[01:27:49.485]   - Field: 'gc'
[01:27:49.485]   - Field: 'conditions'
[01:27:49.485]   - Field: 'persistent'
[01:27:49.485]   - Field: 'expr'
[01:27:49.485]   - Field: 'uuid'
[01:27:49.486]   - Field: 'seed'
[01:27:49.486]   - Field: 'version'
[01:27:49.486]   - Field: 'result'
[01:27:49.486]   - Field: 'asynchronous'
[01:27:49.486]   - Field: 'calls'
[01:27:49.487]   - Field: 'globals'
[01:27:49.487]   - Field: 'stdout'
[01:27:49.487]   - Field: 'earlySignal'
[01:27:49.487]   - Field: 'lazy'
[01:27:49.487]   - Field: 'state'
[01:27:49.487] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.488] - Launch lazy future ...
[01:27:49.488] Packages needed by the future expression (n = 0): <none>
[01:27:49.488] Packages needed by future strategies (n = 0): <none>
[01:27:49.489] {
[01:27:49.489]     {
[01:27:49.489]         {
[01:27:49.489]             ...future.startTime <- base::Sys.time()
[01:27:49.489]             {
[01:27:49.489]                 {
[01:27:49.489]                   {
[01:27:49.489]                     {
[01:27:49.489]                       base::local({
[01:27:49.489]                         has_future <- base::requireNamespace("future", 
[01:27:49.489]                           quietly = TRUE)
[01:27:49.489]                         if (has_future) {
[01:27:49.489]                           ns <- base::getNamespace("future")
[01:27:49.489]                           version <- ns[[".package"]][["version"]]
[01:27:49.489]                           if (is.null(version)) 
[01:27:49.489]                             version <- utils::packageVersion("future")
[01:27:49.489]                         }
[01:27:49.489]                         else {
[01:27:49.489]                           version <- NULL
[01:27:49.489]                         }
[01:27:49.489]                         if (!has_future || version < "1.8.0") {
[01:27:49.489]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.489]                             "", base::R.version$version.string), 
[01:27:49.489]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.489]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.489]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.489]                               "release", "version")], collapse = " "), 
[01:27:49.489]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.489]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.489]                             info)
[01:27:49.489]                           info <- base::paste(info, collapse = "; ")
[01:27:49.489]                           if (!has_future) {
[01:27:49.489]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.489]                               info)
[01:27:49.489]                           }
[01:27:49.489]                           else {
[01:27:49.489]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.489]                               info, version)
[01:27:49.489]                           }
[01:27:49.489]                           base::stop(msg)
[01:27:49.489]                         }
[01:27:49.489]                       })
[01:27:49.489]                     }
[01:27:49.489]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.489]                     base::options(mc.cores = 1L)
[01:27:49.489]                   }
[01:27:49.489]                   options(future.plan = NULL)
[01:27:49.489]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.489]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.489]                 }
[01:27:49.489]                 ...future.workdir <- getwd()
[01:27:49.489]             }
[01:27:49.489]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.489]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.489]         }
[01:27:49.489]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.489]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.489]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.489]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.489]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.489]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.489]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.489]             base::names(...future.oldOptions))
[01:27:49.489]     }
[01:27:49.489]     if (FALSE) {
[01:27:49.489]     }
[01:27:49.489]     else {
[01:27:49.489]         if (TRUE) {
[01:27:49.489]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.489]                 open = "w")
[01:27:49.489]         }
[01:27:49.489]         else {
[01:27:49.489]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.489]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.489]         }
[01:27:49.489]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.489]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.489]             base::sink(type = "output", split = FALSE)
[01:27:49.489]             base::close(...future.stdout)
[01:27:49.489]         }, add = TRUE)
[01:27:49.489]     }
[01:27:49.489]     ...future.frame <- base::sys.nframe()
[01:27:49.489]     ...future.conditions <- base::list()
[01:27:49.489]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.489]     if (FALSE) {
[01:27:49.489]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.489]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.489]     }
[01:27:49.489]     ...future.result <- base::tryCatch({
[01:27:49.489]         base::withCallingHandlers({
[01:27:49.489]             ...future.value <- base::withVisible(base::local({
[01:27:49.489]                 ...future.makeSendCondition <- base::local({
[01:27:49.489]                   sendCondition <- NULL
[01:27:49.489]                   function(frame = 1L) {
[01:27:49.489]                     if (is.function(sendCondition)) 
[01:27:49.489]                       return(sendCondition)
[01:27:49.489]                     ns <- getNamespace("parallel")
[01:27:49.489]                     if (exists("sendData", mode = "function", 
[01:27:49.489]                       envir = ns)) {
[01:27:49.489]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.489]                         envir = ns)
[01:27:49.489]                       envir <- sys.frame(frame)
[01:27:49.489]                       master <- NULL
[01:27:49.489]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.489]                         !identical(envir, emptyenv())) {
[01:27:49.489]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.489]                           inherits = FALSE)) {
[01:27:49.489]                           master <- get("master", mode = "list", 
[01:27:49.489]                             envir = envir, inherits = FALSE)
[01:27:49.489]                           if (inherits(master, c("SOCKnode", 
[01:27:49.489]                             "SOCK0node"))) {
[01:27:49.489]                             sendCondition <<- function(cond) {
[01:27:49.489]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.489]                                 success = TRUE)
[01:27:49.489]                               parallel_sendData(master, data)
[01:27:49.489]                             }
[01:27:49.489]                             return(sendCondition)
[01:27:49.489]                           }
[01:27:49.489]                         }
[01:27:49.489]                         frame <- frame + 1L
[01:27:49.489]                         envir <- sys.frame(frame)
[01:27:49.489]                       }
[01:27:49.489]                     }
[01:27:49.489]                     sendCondition <<- function(cond) NULL
[01:27:49.489]                   }
[01:27:49.489]                 })
[01:27:49.489]                 withCallingHandlers({
[01:27:49.489]                   NULL
[01:27:49.489]                 }, immediateCondition = function(cond) {
[01:27:49.489]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.489]                   sendCondition(cond)
[01:27:49.489]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.489]                   {
[01:27:49.489]                     inherits <- base::inherits
[01:27:49.489]                     invokeRestart <- base::invokeRestart
[01:27:49.489]                     is.null <- base::is.null
[01:27:49.489]                     muffled <- FALSE
[01:27:49.489]                     if (inherits(cond, "message")) {
[01:27:49.489]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.489]                       if (muffled) 
[01:27:49.489]                         invokeRestart("muffleMessage")
[01:27:49.489]                     }
[01:27:49.489]                     else if (inherits(cond, "warning")) {
[01:27:49.489]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.489]                       if (muffled) 
[01:27:49.489]                         invokeRestart("muffleWarning")
[01:27:49.489]                     }
[01:27:49.489]                     else if (inherits(cond, "condition")) {
[01:27:49.489]                       if (!is.null(pattern)) {
[01:27:49.489]                         computeRestarts <- base::computeRestarts
[01:27:49.489]                         grepl <- base::grepl
[01:27:49.489]                         restarts <- computeRestarts(cond)
[01:27:49.489]                         for (restart in restarts) {
[01:27:49.489]                           name <- restart$name
[01:27:49.489]                           if (is.null(name)) 
[01:27:49.489]                             next
[01:27:49.489]                           if (!grepl(pattern, name)) 
[01:27:49.489]                             next
[01:27:49.489]                           invokeRestart(restart)
[01:27:49.489]                           muffled <- TRUE
[01:27:49.489]                           break
[01:27:49.489]                         }
[01:27:49.489]                       }
[01:27:49.489]                     }
[01:27:49.489]                     invisible(muffled)
[01:27:49.489]                   }
[01:27:49.489]                   muffleCondition(cond)
[01:27:49.489]                 })
[01:27:49.489]             }))
[01:27:49.489]             future::FutureResult(value = ...future.value$value, 
[01:27:49.489]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.489]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.489]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.489]                     ...future.globalenv.names))
[01:27:49.489]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.489]         }, condition = base::local({
[01:27:49.489]             c <- base::c
[01:27:49.489]             inherits <- base::inherits
[01:27:49.489]             invokeRestart <- base::invokeRestart
[01:27:49.489]             length <- base::length
[01:27:49.489]             list <- base::list
[01:27:49.489]             seq.int <- base::seq.int
[01:27:49.489]             signalCondition <- base::signalCondition
[01:27:49.489]             sys.calls <- base::sys.calls
[01:27:49.489]             `[[` <- base::`[[`
[01:27:49.489]             `+` <- base::`+`
[01:27:49.489]             `<<-` <- base::`<<-`
[01:27:49.489]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.489]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.489]                   3L)]
[01:27:49.489]             }
[01:27:49.489]             function(cond) {
[01:27:49.489]                 is_error <- inherits(cond, "error")
[01:27:49.489]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.489]                   NULL)
[01:27:49.489]                 if (is_error) {
[01:27:49.489]                   sessionInformation <- function() {
[01:27:49.489]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.489]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.489]                       search = base::search(), system = base::Sys.info())
[01:27:49.489]                   }
[01:27:49.489]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.489]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.489]                     cond$call), session = sessionInformation(), 
[01:27:49.489]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.489]                   signalCondition(cond)
[01:27:49.489]                 }
[01:27:49.489]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.489]                 "immediateCondition"))) {
[01:27:49.489]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.489]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.489]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.489]                   if (TRUE && !signal) {
[01:27:49.489]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.489]                     {
[01:27:49.489]                       inherits <- base::inherits
[01:27:49.489]                       invokeRestart <- base::invokeRestart
[01:27:49.489]                       is.null <- base::is.null
[01:27:49.489]                       muffled <- FALSE
[01:27:49.489]                       if (inherits(cond, "message")) {
[01:27:49.489]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.489]                         if (muffled) 
[01:27:49.489]                           invokeRestart("muffleMessage")
[01:27:49.489]                       }
[01:27:49.489]                       else if (inherits(cond, "warning")) {
[01:27:49.489]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.489]                         if (muffled) 
[01:27:49.489]                           invokeRestart("muffleWarning")
[01:27:49.489]                       }
[01:27:49.489]                       else if (inherits(cond, "condition")) {
[01:27:49.489]                         if (!is.null(pattern)) {
[01:27:49.489]                           computeRestarts <- base::computeRestarts
[01:27:49.489]                           grepl <- base::grepl
[01:27:49.489]                           restarts <- computeRestarts(cond)
[01:27:49.489]                           for (restart in restarts) {
[01:27:49.489]                             name <- restart$name
[01:27:49.489]                             if (is.null(name)) 
[01:27:49.489]                               next
[01:27:49.489]                             if (!grepl(pattern, name)) 
[01:27:49.489]                               next
[01:27:49.489]                             invokeRestart(restart)
[01:27:49.489]                             muffled <- TRUE
[01:27:49.489]                             break
[01:27:49.489]                           }
[01:27:49.489]                         }
[01:27:49.489]                       }
[01:27:49.489]                       invisible(muffled)
[01:27:49.489]                     }
[01:27:49.489]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.489]                   }
[01:27:49.489]                 }
[01:27:49.489]                 else {
[01:27:49.489]                   if (TRUE) {
[01:27:49.489]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.489]                     {
[01:27:49.489]                       inherits <- base::inherits
[01:27:49.489]                       invokeRestart <- base::invokeRestart
[01:27:49.489]                       is.null <- base::is.null
[01:27:49.489]                       muffled <- FALSE
[01:27:49.489]                       if (inherits(cond, "message")) {
[01:27:49.489]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.489]                         if (muffled) 
[01:27:49.489]                           invokeRestart("muffleMessage")
[01:27:49.489]                       }
[01:27:49.489]                       else if (inherits(cond, "warning")) {
[01:27:49.489]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.489]                         if (muffled) 
[01:27:49.489]                           invokeRestart("muffleWarning")
[01:27:49.489]                       }
[01:27:49.489]                       else if (inherits(cond, "condition")) {
[01:27:49.489]                         if (!is.null(pattern)) {
[01:27:49.489]                           computeRestarts <- base::computeRestarts
[01:27:49.489]                           grepl <- base::grepl
[01:27:49.489]                           restarts <- computeRestarts(cond)
[01:27:49.489]                           for (restart in restarts) {
[01:27:49.489]                             name <- restart$name
[01:27:49.489]                             if (is.null(name)) 
[01:27:49.489]                               next
[01:27:49.489]                             if (!grepl(pattern, name)) 
[01:27:49.489]                               next
[01:27:49.489]                             invokeRestart(restart)
[01:27:49.489]                             muffled <- TRUE
[01:27:49.489]                             break
[01:27:49.489]                           }
[01:27:49.489]                         }
[01:27:49.489]                       }
[01:27:49.489]                       invisible(muffled)
[01:27:49.489]                     }
[01:27:49.489]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.489]                   }
[01:27:49.489]                 }
[01:27:49.489]             }
[01:27:49.489]         }))
[01:27:49.489]     }, error = function(ex) {
[01:27:49.489]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.489]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.489]                 ...future.rng), started = ...future.startTime, 
[01:27:49.489]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.489]             version = "1.8"), class = "FutureResult")
[01:27:49.489]     }, finally = {
[01:27:49.489]         if (!identical(...future.workdir, getwd())) 
[01:27:49.489]             setwd(...future.workdir)
[01:27:49.489]         {
[01:27:49.489]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.489]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.489]             }
[01:27:49.489]             base::options(...future.oldOptions)
[01:27:49.489]             if (.Platform$OS.type == "windows") {
[01:27:49.489]                 old_names <- names(...future.oldEnvVars)
[01:27:49.489]                 envs <- base::Sys.getenv()
[01:27:49.489]                 names <- names(envs)
[01:27:49.489]                 common <- intersect(names, old_names)
[01:27:49.489]                 added <- setdiff(names, old_names)
[01:27:49.489]                 removed <- setdiff(old_names, names)
[01:27:49.489]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.489]                   envs[common]]
[01:27:49.489]                 NAMES <- toupper(changed)
[01:27:49.489]                 args <- list()
[01:27:49.489]                 for (kk in seq_along(NAMES)) {
[01:27:49.489]                   name <- changed[[kk]]
[01:27:49.489]                   NAME <- NAMES[[kk]]
[01:27:49.489]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.489]                     next
[01:27:49.489]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.489]                 }
[01:27:49.489]                 NAMES <- toupper(added)
[01:27:49.489]                 for (kk in seq_along(NAMES)) {
[01:27:49.489]                   name <- added[[kk]]
[01:27:49.489]                   NAME <- NAMES[[kk]]
[01:27:49.489]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.489]                     next
[01:27:49.489]                   args[[name]] <- ""
[01:27:49.489]                 }
[01:27:49.489]                 NAMES <- toupper(removed)
[01:27:49.489]                 for (kk in seq_along(NAMES)) {
[01:27:49.489]                   name <- removed[[kk]]
[01:27:49.489]                   NAME <- NAMES[[kk]]
[01:27:49.489]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.489]                     next
[01:27:49.489]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.489]                 }
[01:27:49.489]                 if (length(args) > 0) 
[01:27:49.489]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.489]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.489]             }
[01:27:49.489]             else {
[01:27:49.489]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.489]             }
[01:27:49.489]             {
[01:27:49.489]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.489]                   0L) {
[01:27:49.489]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.489]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.489]                   base::options(opts)
[01:27:49.489]                 }
[01:27:49.489]                 {
[01:27:49.489]                   {
[01:27:49.489]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.489]                     NULL
[01:27:49.489]                   }
[01:27:49.489]                   options(future.plan = NULL)
[01:27:49.489]                   if (is.na(NA_character_)) 
[01:27:49.489]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.489]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.489]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.489]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.489]                     envir = parent.frame()) 
[01:27:49.489]                   {
[01:27:49.489]                     if (is.function(workers)) 
[01:27:49.489]                       workers <- workers()
[01:27:49.489]                     workers <- structure(as.integer(workers), 
[01:27:49.489]                       class = class(workers))
[01:27:49.489]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.489]                       workers >= 1)
[01:27:49.489]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.489]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.489]                     }
[01:27:49.489]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.489]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.489]                       envir = envir)
[01:27:49.489]                     if (!future$lazy) 
[01:27:49.489]                       future <- run(future)
[01:27:49.489]                     invisible(future)
[01:27:49.489]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.489]                 }
[01:27:49.489]             }
[01:27:49.489]         }
[01:27:49.489]     })
[01:27:49.489]     if (TRUE) {
[01:27:49.489]         base::sink(type = "output", split = FALSE)
[01:27:49.489]         if (TRUE) {
[01:27:49.489]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.489]         }
[01:27:49.489]         else {
[01:27:49.489]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.489]         }
[01:27:49.489]         base::close(...future.stdout)
[01:27:49.489]         ...future.stdout <- NULL
[01:27:49.489]     }
[01:27:49.489]     ...future.result$conditions <- ...future.conditions
[01:27:49.489]     ...future.result$finished <- base::Sys.time()
[01:27:49.489]     ...future.result
[01:27:49.489] }
[01:27:49.495] MultisessionFuture started
[01:27:49.496] - Launch lazy future ... done
[01:27:49.496] run() for 'MultisessionFuture' ... done
[01:27:49.496] getGlobalsAndPackages() ...
[01:27:49.496] Searching for globals...
[01:27:49.497] - globals found: [1] '{'
[01:27:49.498] Searching for globals ... DONE
[01:27:49.498] Resolving globals: FALSE
[01:27:49.498] 
[01:27:49.498] 
[01:27:49.498] getGlobalsAndPackages() ... DONE
[01:27:49.499] run() for 'Future' ...
[01:27:49.499] - state: 'created'
[01:27:49.499] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.514] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.514] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.514]   - Field: 'node'
[01:27:49.514]   - Field: 'label'
[01:27:49.514]   - Field: 'local'
[01:27:49.515]   - Field: 'owner'
[01:27:49.515]   - Field: 'envir'
[01:27:49.515]   - Field: 'workers'
[01:27:49.515]   - Field: 'packages'
[01:27:49.515]   - Field: 'gc'
[01:27:49.516]   - Field: 'conditions'
[01:27:49.516]   - Field: 'persistent'
[01:27:49.516]   - Field: 'expr'
[01:27:49.516]   - Field: 'uuid'
[01:27:49.516]   - Field: 'seed'
[01:27:49.516]   - Field: 'version'
[01:27:49.517]   - Field: 'result'
[01:27:49.517]   - Field: 'asynchronous'
[01:27:49.517]   - Field: 'calls'
[01:27:49.517]   - Field: 'globals'
[01:27:49.517]   - Field: 'stdout'
[01:27:49.518]   - Field: 'earlySignal'
[01:27:49.518]   - Field: 'lazy'
[01:27:49.518]   - Field: 'state'
[01:27:49.518] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.518] - Launch lazy future ...
[01:27:49.519] Packages needed by the future expression (n = 0): <none>
[01:27:49.519] Packages needed by future strategies (n = 0): <none>
[01:27:49.519] {
[01:27:49.519]     {
[01:27:49.519]         {
[01:27:49.519]             ...future.startTime <- base::Sys.time()
[01:27:49.519]             {
[01:27:49.519]                 {
[01:27:49.519]                   {
[01:27:49.519]                     {
[01:27:49.519]                       base::local({
[01:27:49.519]                         has_future <- base::requireNamespace("future", 
[01:27:49.519]                           quietly = TRUE)
[01:27:49.519]                         if (has_future) {
[01:27:49.519]                           ns <- base::getNamespace("future")
[01:27:49.519]                           version <- ns[[".package"]][["version"]]
[01:27:49.519]                           if (is.null(version)) 
[01:27:49.519]                             version <- utils::packageVersion("future")
[01:27:49.519]                         }
[01:27:49.519]                         else {
[01:27:49.519]                           version <- NULL
[01:27:49.519]                         }
[01:27:49.519]                         if (!has_future || version < "1.8.0") {
[01:27:49.519]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.519]                             "", base::R.version$version.string), 
[01:27:49.519]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.519]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.519]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.519]                               "release", "version")], collapse = " "), 
[01:27:49.519]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.519]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.519]                             info)
[01:27:49.519]                           info <- base::paste(info, collapse = "; ")
[01:27:49.519]                           if (!has_future) {
[01:27:49.519]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.519]                               info)
[01:27:49.519]                           }
[01:27:49.519]                           else {
[01:27:49.519]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.519]                               info, version)
[01:27:49.519]                           }
[01:27:49.519]                           base::stop(msg)
[01:27:49.519]                         }
[01:27:49.519]                       })
[01:27:49.519]                     }
[01:27:49.519]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.519]                     base::options(mc.cores = 1L)
[01:27:49.519]                   }
[01:27:49.519]                   options(future.plan = NULL)
[01:27:49.519]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.519]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.519]                 }
[01:27:49.519]                 ...future.workdir <- getwd()
[01:27:49.519]             }
[01:27:49.519]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.519]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.519]         }
[01:27:49.519]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.519]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.519]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.519]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.519]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.519]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.519]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.519]             base::names(...future.oldOptions))
[01:27:49.519]     }
[01:27:49.519]     if (FALSE) {
[01:27:49.519]     }
[01:27:49.519]     else {
[01:27:49.519]         if (TRUE) {
[01:27:49.519]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.519]                 open = "w")
[01:27:49.519]         }
[01:27:49.519]         else {
[01:27:49.519]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.519]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.519]         }
[01:27:49.519]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.519]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.519]             base::sink(type = "output", split = FALSE)
[01:27:49.519]             base::close(...future.stdout)
[01:27:49.519]         }, add = TRUE)
[01:27:49.519]     }
[01:27:49.519]     ...future.frame <- base::sys.nframe()
[01:27:49.519]     ...future.conditions <- base::list()
[01:27:49.519]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.519]     if (FALSE) {
[01:27:49.519]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.519]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.519]     }
[01:27:49.519]     ...future.result <- base::tryCatch({
[01:27:49.519]         base::withCallingHandlers({
[01:27:49.519]             ...future.value <- base::withVisible(base::local({
[01:27:49.519]                 ...future.makeSendCondition <- base::local({
[01:27:49.519]                   sendCondition <- NULL
[01:27:49.519]                   function(frame = 1L) {
[01:27:49.519]                     if (is.function(sendCondition)) 
[01:27:49.519]                       return(sendCondition)
[01:27:49.519]                     ns <- getNamespace("parallel")
[01:27:49.519]                     if (exists("sendData", mode = "function", 
[01:27:49.519]                       envir = ns)) {
[01:27:49.519]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.519]                         envir = ns)
[01:27:49.519]                       envir <- sys.frame(frame)
[01:27:49.519]                       master <- NULL
[01:27:49.519]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.519]                         !identical(envir, emptyenv())) {
[01:27:49.519]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.519]                           inherits = FALSE)) {
[01:27:49.519]                           master <- get("master", mode = "list", 
[01:27:49.519]                             envir = envir, inherits = FALSE)
[01:27:49.519]                           if (inherits(master, c("SOCKnode", 
[01:27:49.519]                             "SOCK0node"))) {
[01:27:49.519]                             sendCondition <<- function(cond) {
[01:27:49.519]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.519]                                 success = TRUE)
[01:27:49.519]                               parallel_sendData(master, data)
[01:27:49.519]                             }
[01:27:49.519]                             return(sendCondition)
[01:27:49.519]                           }
[01:27:49.519]                         }
[01:27:49.519]                         frame <- frame + 1L
[01:27:49.519]                         envir <- sys.frame(frame)
[01:27:49.519]                       }
[01:27:49.519]                     }
[01:27:49.519]                     sendCondition <<- function(cond) NULL
[01:27:49.519]                   }
[01:27:49.519]                 })
[01:27:49.519]                 withCallingHandlers({
[01:27:49.519]                   {
[01:27:49.519]                     4
[01:27:49.519]                   }
[01:27:49.519]                 }, immediateCondition = function(cond) {
[01:27:49.519]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.519]                   sendCondition(cond)
[01:27:49.519]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.519]                   {
[01:27:49.519]                     inherits <- base::inherits
[01:27:49.519]                     invokeRestart <- base::invokeRestart
[01:27:49.519]                     is.null <- base::is.null
[01:27:49.519]                     muffled <- FALSE
[01:27:49.519]                     if (inherits(cond, "message")) {
[01:27:49.519]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.519]                       if (muffled) 
[01:27:49.519]                         invokeRestart("muffleMessage")
[01:27:49.519]                     }
[01:27:49.519]                     else if (inherits(cond, "warning")) {
[01:27:49.519]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.519]                       if (muffled) 
[01:27:49.519]                         invokeRestart("muffleWarning")
[01:27:49.519]                     }
[01:27:49.519]                     else if (inherits(cond, "condition")) {
[01:27:49.519]                       if (!is.null(pattern)) {
[01:27:49.519]                         computeRestarts <- base::computeRestarts
[01:27:49.519]                         grepl <- base::grepl
[01:27:49.519]                         restarts <- computeRestarts(cond)
[01:27:49.519]                         for (restart in restarts) {
[01:27:49.519]                           name <- restart$name
[01:27:49.519]                           if (is.null(name)) 
[01:27:49.519]                             next
[01:27:49.519]                           if (!grepl(pattern, name)) 
[01:27:49.519]                             next
[01:27:49.519]                           invokeRestart(restart)
[01:27:49.519]                           muffled <- TRUE
[01:27:49.519]                           break
[01:27:49.519]                         }
[01:27:49.519]                       }
[01:27:49.519]                     }
[01:27:49.519]                     invisible(muffled)
[01:27:49.519]                   }
[01:27:49.519]                   muffleCondition(cond)
[01:27:49.519]                 })
[01:27:49.519]             }))
[01:27:49.519]             future::FutureResult(value = ...future.value$value, 
[01:27:49.519]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.519]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.519]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.519]                     ...future.globalenv.names))
[01:27:49.519]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.519]         }, condition = base::local({
[01:27:49.519]             c <- base::c
[01:27:49.519]             inherits <- base::inherits
[01:27:49.519]             invokeRestart <- base::invokeRestart
[01:27:49.519]             length <- base::length
[01:27:49.519]             list <- base::list
[01:27:49.519]             seq.int <- base::seq.int
[01:27:49.519]             signalCondition <- base::signalCondition
[01:27:49.519]             sys.calls <- base::sys.calls
[01:27:49.519]             `[[` <- base::`[[`
[01:27:49.519]             `+` <- base::`+`
[01:27:49.519]             `<<-` <- base::`<<-`
[01:27:49.519]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.519]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.519]                   3L)]
[01:27:49.519]             }
[01:27:49.519]             function(cond) {
[01:27:49.519]                 is_error <- inherits(cond, "error")
[01:27:49.519]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.519]                   NULL)
[01:27:49.519]                 if (is_error) {
[01:27:49.519]                   sessionInformation <- function() {
[01:27:49.519]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.519]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.519]                       search = base::search(), system = base::Sys.info())
[01:27:49.519]                   }
[01:27:49.519]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.519]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.519]                     cond$call), session = sessionInformation(), 
[01:27:49.519]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.519]                   signalCondition(cond)
[01:27:49.519]                 }
[01:27:49.519]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.519]                 "immediateCondition"))) {
[01:27:49.519]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.519]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.519]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.519]                   if (TRUE && !signal) {
[01:27:49.519]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.519]                     {
[01:27:49.519]                       inherits <- base::inherits
[01:27:49.519]                       invokeRestart <- base::invokeRestart
[01:27:49.519]                       is.null <- base::is.null
[01:27:49.519]                       muffled <- FALSE
[01:27:49.519]                       if (inherits(cond, "message")) {
[01:27:49.519]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.519]                         if (muffled) 
[01:27:49.519]                           invokeRestart("muffleMessage")
[01:27:49.519]                       }
[01:27:49.519]                       else if (inherits(cond, "warning")) {
[01:27:49.519]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.519]                         if (muffled) 
[01:27:49.519]                           invokeRestart("muffleWarning")
[01:27:49.519]                       }
[01:27:49.519]                       else if (inherits(cond, "condition")) {
[01:27:49.519]                         if (!is.null(pattern)) {
[01:27:49.519]                           computeRestarts <- base::computeRestarts
[01:27:49.519]                           grepl <- base::grepl
[01:27:49.519]                           restarts <- computeRestarts(cond)
[01:27:49.519]                           for (restart in restarts) {
[01:27:49.519]                             name <- restart$name
[01:27:49.519]                             if (is.null(name)) 
[01:27:49.519]                               next
[01:27:49.519]                             if (!grepl(pattern, name)) 
[01:27:49.519]                               next
[01:27:49.519]                             invokeRestart(restart)
[01:27:49.519]                             muffled <- TRUE
[01:27:49.519]                             break
[01:27:49.519]                           }
[01:27:49.519]                         }
[01:27:49.519]                       }
[01:27:49.519]                       invisible(muffled)
[01:27:49.519]                     }
[01:27:49.519]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.519]                   }
[01:27:49.519]                 }
[01:27:49.519]                 else {
[01:27:49.519]                   if (TRUE) {
[01:27:49.519]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.519]                     {
[01:27:49.519]                       inherits <- base::inherits
[01:27:49.519]                       invokeRestart <- base::invokeRestart
[01:27:49.519]                       is.null <- base::is.null
[01:27:49.519]                       muffled <- FALSE
[01:27:49.519]                       if (inherits(cond, "message")) {
[01:27:49.519]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.519]                         if (muffled) 
[01:27:49.519]                           invokeRestart("muffleMessage")
[01:27:49.519]                       }
[01:27:49.519]                       else if (inherits(cond, "warning")) {
[01:27:49.519]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.519]                         if (muffled) 
[01:27:49.519]                           invokeRestart("muffleWarning")
[01:27:49.519]                       }
[01:27:49.519]                       else if (inherits(cond, "condition")) {
[01:27:49.519]                         if (!is.null(pattern)) {
[01:27:49.519]                           computeRestarts <- base::computeRestarts
[01:27:49.519]                           grepl <- base::grepl
[01:27:49.519]                           restarts <- computeRestarts(cond)
[01:27:49.519]                           for (restart in restarts) {
[01:27:49.519]                             name <- restart$name
[01:27:49.519]                             if (is.null(name)) 
[01:27:49.519]                               next
[01:27:49.519]                             if (!grepl(pattern, name)) 
[01:27:49.519]                               next
[01:27:49.519]                             invokeRestart(restart)
[01:27:49.519]                             muffled <- TRUE
[01:27:49.519]                             break
[01:27:49.519]                           }
[01:27:49.519]                         }
[01:27:49.519]                       }
[01:27:49.519]                       invisible(muffled)
[01:27:49.519]                     }
[01:27:49.519]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.519]                   }
[01:27:49.519]                 }
[01:27:49.519]             }
[01:27:49.519]         }))
[01:27:49.519]     }, error = function(ex) {
[01:27:49.519]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.519]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.519]                 ...future.rng), started = ...future.startTime, 
[01:27:49.519]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.519]             version = "1.8"), class = "FutureResult")
[01:27:49.519]     }, finally = {
[01:27:49.519]         if (!identical(...future.workdir, getwd())) 
[01:27:49.519]             setwd(...future.workdir)
[01:27:49.519]         {
[01:27:49.519]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.519]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.519]             }
[01:27:49.519]             base::options(...future.oldOptions)
[01:27:49.519]             if (.Platform$OS.type == "windows") {
[01:27:49.519]                 old_names <- names(...future.oldEnvVars)
[01:27:49.519]                 envs <- base::Sys.getenv()
[01:27:49.519]                 names <- names(envs)
[01:27:49.519]                 common <- intersect(names, old_names)
[01:27:49.519]                 added <- setdiff(names, old_names)
[01:27:49.519]                 removed <- setdiff(old_names, names)
[01:27:49.519]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.519]                   envs[common]]
[01:27:49.519]                 NAMES <- toupper(changed)
[01:27:49.519]                 args <- list()
[01:27:49.519]                 for (kk in seq_along(NAMES)) {
[01:27:49.519]                   name <- changed[[kk]]
[01:27:49.519]                   NAME <- NAMES[[kk]]
[01:27:49.519]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.519]                     next
[01:27:49.519]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.519]                 }
[01:27:49.519]                 NAMES <- toupper(added)
[01:27:49.519]                 for (kk in seq_along(NAMES)) {
[01:27:49.519]                   name <- added[[kk]]
[01:27:49.519]                   NAME <- NAMES[[kk]]
[01:27:49.519]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.519]                     next
[01:27:49.519]                   args[[name]] <- ""
[01:27:49.519]                 }
[01:27:49.519]                 NAMES <- toupper(removed)
[01:27:49.519]                 for (kk in seq_along(NAMES)) {
[01:27:49.519]                   name <- removed[[kk]]
[01:27:49.519]                   NAME <- NAMES[[kk]]
[01:27:49.519]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.519]                     next
[01:27:49.519]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.519]                 }
[01:27:49.519]                 if (length(args) > 0) 
[01:27:49.519]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.519]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.519]             }
[01:27:49.519]             else {
[01:27:49.519]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.519]             }
[01:27:49.519]             {
[01:27:49.519]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.519]                   0L) {
[01:27:49.519]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.519]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.519]                   base::options(opts)
[01:27:49.519]                 }
[01:27:49.519]                 {
[01:27:49.519]                   {
[01:27:49.519]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.519]                     NULL
[01:27:49.519]                   }
[01:27:49.519]                   options(future.plan = NULL)
[01:27:49.519]                   if (is.na(NA_character_)) 
[01:27:49.519]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.519]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.519]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.519]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.519]                     envir = parent.frame()) 
[01:27:49.519]                   {
[01:27:49.519]                     if (is.function(workers)) 
[01:27:49.519]                       workers <- workers()
[01:27:49.519]                     workers <- structure(as.integer(workers), 
[01:27:49.519]                       class = class(workers))
[01:27:49.519]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.519]                       workers >= 1)
[01:27:49.519]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.519]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.519]                     }
[01:27:49.519]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.519]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.519]                       envir = envir)
[01:27:49.519]                     if (!future$lazy) 
[01:27:49.519]                       future <- run(future)
[01:27:49.519]                     invisible(future)
[01:27:49.519]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.519]                 }
[01:27:49.519]             }
[01:27:49.519]         }
[01:27:49.519]     })
[01:27:49.519]     if (TRUE) {
[01:27:49.519]         base::sink(type = "output", split = FALSE)
[01:27:49.519]         if (TRUE) {
[01:27:49.519]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.519]         }
[01:27:49.519]         else {
[01:27:49.519]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.519]         }
[01:27:49.519]         base::close(...future.stdout)
[01:27:49.519]         ...future.stdout <- NULL
[01:27:49.519]     }
[01:27:49.519]     ...future.result$conditions <- ...future.conditions
[01:27:49.519]     ...future.result$finished <- base::Sys.time()
[01:27:49.519]     ...future.result
[01:27:49.519] }
[01:27:49.525] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:49.540] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.540] - Validating connection of MultisessionFuture
[01:27:49.540] - received message: FutureResult
[01:27:49.540] - Received FutureResult
[01:27:49.541] - Erased future from FutureRegistry
[01:27:49.541] result() for ClusterFuture ...
[01:27:49.541] - result already collected: FutureResult
[01:27:49.541] result() for ClusterFuture ... done
[01:27:49.541] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.542] result() for ClusterFuture ...
[01:27:49.542] - result already collected: FutureResult
[01:27:49.542] result() for ClusterFuture ... done
[01:27:49.542] result() for ClusterFuture ...
[01:27:49.542] - result already collected: FutureResult
[01:27:49.542] result() for ClusterFuture ... done
[01:27:49.544] MultisessionFuture started
[01:27:49.544] - Launch lazy future ... done
[01:27:49.544] run() for 'MultisessionFuture' ... done
<environment: 0x0000025b07c568e8> 
<environment: 0x0000025b0a85b668> 
[01:27:49.546] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.547] - Validating connection of MultisessionFuture
[01:27:49.547] - received message: FutureResult
[01:27:49.547] - Received FutureResult
[01:27:49.547] - Erased future from FutureRegistry
[01:27:49.547] result() for ClusterFuture ...
[01:27:49.548] - result already collected: FutureResult
[01:27:49.548] result() for ClusterFuture ... done
[01:27:49.548] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.561] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.562] - Validating connection of MultisessionFuture
[01:27:49.562] - received message: FutureResult
[01:27:49.562] - Received FutureResult
[01:27:49.562] - Erased future from FutureRegistry
[01:27:49.562] result() for ClusterFuture ...
[01:27:49.563] - result already collected: FutureResult
[01:27:49.563] result() for ClusterFuture ... done
[01:27:49.563] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:49.565] resolve() on environment ...
[01:27:49.565]  recursive: 0
[01:27:49.566]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:49.566] signalConditionsASAP(numeric, pos=1) ...
[01:27:49.566] - nx: 4
[01:27:49.566] - relay: TRUE
[01:27:49.566] - stdout: TRUE
[01:27:49.566] - signal: TRUE
[01:27:49.567] - resignal: FALSE
[01:27:49.567] - force: TRUE
[01:27:49.567] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.567] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.567]  - until=2
[01:27:49.567]  - relaying element #2
[01:27:49.568] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.568] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.568] signalConditionsASAP(NULL, pos=1) ... done
[01:27:49.568]  length: 3 (resolved future 1)
[01:27:49.568] Future #2
[01:27:49.569] result() for ClusterFuture ...
[01:27:49.569] - result already collected: FutureResult
[01:27:49.569] result() for ClusterFuture ... done
[01:27:49.569] result() for ClusterFuture ...
[01:27:49.569] - result already collected: FutureResult
[01:27:49.569] result() for ClusterFuture ... done
[01:27:49.570] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:49.570] - nx: 4
[01:27:49.570] - relay: TRUE
[01:27:49.570] - stdout: TRUE
[01:27:49.570] - signal: TRUE
[01:27:49.570] - resignal: FALSE
[01:27:49.571] - force: TRUE
[01:27:49.571] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.571] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.572]  - until=2
[01:27:49.572]  - relaying element #2
[01:27:49.572] result() for ClusterFuture ...
[01:27:49.573] - result already collected: FutureResult
[01:27:49.573] result() for ClusterFuture ... done
[01:27:49.573] result() for ClusterFuture ...
[01:27:49.573] - result already collected: FutureResult
[01:27:49.574] result() for ClusterFuture ... done
[01:27:49.574] result() for ClusterFuture ...
[01:27:49.574] - result already collected: FutureResult
[01:27:49.575] result() for ClusterFuture ... done
[01:27:49.575] result() for ClusterFuture ...
[01:27:49.575] - result already collected: FutureResult
[01:27:49.575] result() for ClusterFuture ... done
[01:27:49.575] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.576] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.576] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:49.576]  length: 2 (resolved future 2)
[01:27:49.576] Future #3
[01:27:49.577] result() for ClusterFuture ...
[01:27:49.577] - result already collected: FutureResult
[01:27:49.577] result() for ClusterFuture ... done
[01:27:49.578] result() for ClusterFuture ...
[01:27:49.578] - result already collected: FutureResult
[01:27:49.578] result() for ClusterFuture ... done
[01:27:49.578] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:49.579] - nx: 4
[01:27:49.579] - relay: TRUE
[01:27:49.579] - stdout: TRUE
[01:27:49.579] - signal: TRUE
[01:27:49.579] - resignal: FALSE
[01:27:49.580] - force: TRUE
[01:27:49.580] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.580] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.580]  - until=3
[01:27:49.581]  - relaying element #3
[01:27:49.581] result() for ClusterFuture ...
[01:27:49.581] - result already collected: FutureResult
[01:27:49.581] result() for ClusterFuture ... done
[01:27:49.581] result() for ClusterFuture ...
[01:27:49.582] - result already collected: FutureResult
[01:27:49.582] result() for ClusterFuture ... done
[01:27:49.582] result() for ClusterFuture ...
[01:27:49.582] - result already collected: FutureResult
[01:27:49.582] result() for ClusterFuture ... done
[01:27:49.583] result() for ClusterFuture ...
[01:27:49.583] - result already collected: FutureResult
[01:27:49.583] result() for ClusterFuture ... done
[01:27:49.583] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.583] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.584] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:49.584]  length: 1 (resolved future 3)
[01:27:49.584] Future #4
[01:27:49.584] result() for ClusterFuture ...
[01:27:49.584] - result already collected: FutureResult
[01:27:49.585] result() for ClusterFuture ... done
[01:27:49.585] result() for ClusterFuture ...
[01:27:49.585] - result already collected: FutureResult
[01:27:49.585] result() for ClusterFuture ... done
[01:27:49.585] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:49.586] - nx: 4
[01:27:49.586] - relay: TRUE
[01:27:49.586] - stdout: TRUE
[01:27:49.586] - signal: TRUE
[01:27:49.586] - resignal: FALSE
[01:27:49.587] - force: TRUE
[01:27:49.587] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.587] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.587]  - until=4
[01:27:49.587]  - relaying element #4
[01:27:49.588] result() for ClusterFuture ...
[01:27:49.588] - result already collected: FutureResult
[01:27:49.588] result() for ClusterFuture ... done
[01:27:49.588] result() for ClusterFuture ...
[01:27:49.588] - result already collected: FutureResult
[01:27:49.589] result() for ClusterFuture ... done
[01:27:49.589] result() for ClusterFuture ...
[01:27:49.589] - result already collected: FutureResult
[01:27:49.589] result() for ClusterFuture ... done
[01:27:49.589] result() for ClusterFuture ...
[01:27:49.589] - result already collected: FutureResult
[01:27:49.590] result() for ClusterFuture ... done
[01:27:49.590] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.590] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.590] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:49.590]  length: 0 (resolved future 4)
[01:27:49.591] Relaying remaining futures
[01:27:49.591] signalConditionsASAP(NULL, pos=0) ...
[01:27:49.591] - nx: 4
[01:27:49.591] - relay: TRUE
[01:27:49.591] - stdout: TRUE
[01:27:49.591] - signal: TRUE
[01:27:49.591] - resignal: FALSE
[01:27:49.592] - force: TRUE
[01:27:49.592] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.592] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:49.592] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.592] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.593] signalConditionsASAP(NULL, pos=0) ... done
[01:27:49.593] resolve() on environment ... DONE
[01:27:49.593] result() for ClusterFuture ...
[01:27:49.593] - result already collected: FutureResult
[01:27:49.593] result() for ClusterFuture ... done
[01:27:49.593] result() for ClusterFuture ...
[01:27:49.594] - result already collected: FutureResult
[01:27:49.594] result() for ClusterFuture ... done
[01:27:49.594] result() for ClusterFuture ...
[01:27:49.594] - result already collected: FutureResult
[01:27:49.594] result() for ClusterFuture ... done
[01:27:49.594] result() for ClusterFuture ...
[01:27:49.595] - result already collected: FutureResult
[01:27:49.595] result() for ClusterFuture ... done
[01:27:49.595] result() for ClusterFuture ...
[01:27:49.595] - result already collected: FutureResult
[01:27:49.595] result() for ClusterFuture ... done
[01:27:49.595] result() for ClusterFuture ...
[01:27:49.596] - result already collected: FutureResult
[01:27:49.596] result() for ClusterFuture ... done
<environment: 0x0000025b0ab15628> 
Dimensions: c(2, 1, 3, 1)
[01:27:49.596] getGlobalsAndPackages() ...
[01:27:49.596] Searching for globals...
[01:27:49.597] 
[01:27:49.597] Searching for globals ... DONE
[01:27:49.597] - globals: [0] <none>
[01:27:49.597] getGlobalsAndPackages() ... DONE
[01:27:49.598] run() for 'Future' ...
[01:27:49.598] - state: 'created'
[01:27:49.598] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.613] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.613] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.613]   - Field: 'node'
[01:27:49.613]   - Field: 'label'
[01:27:49.613]   - Field: 'local'
[01:27:49.614]   - Field: 'owner'
[01:27:49.614]   - Field: 'envir'
[01:27:49.614]   - Field: 'workers'
[01:27:49.614]   - Field: 'packages'
[01:27:49.614]   - Field: 'gc'
[01:27:49.615]   - Field: 'conditions'
[01:27:49.615]   - Field: 'persistent'
[01:27:49.615]   - Field: 'expr'
[01:27:49.615]   - Field: 'uuid'
[01:27:49.615]   - Field: 'seed'
[01:27:49.616]   - Field: 'version'
[01:27:49.616]   - Field: 'result'
[01:27:49.616]   - Field: 'asynchronous'
[01:27:49.616]   - Field: 'calls'
[01:27:49.616]   - Field: 'globals'
[01:27:49.616]   - Field: 'stdout'
[01:27:49.617]   - Field: 'earlySignal'
[01:27:49.617]   - Field: 'lazy'
[01:27:49.617]   - Field: 'state'
[01:27:49.617] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.617] - Launch lazy future ...
[01:27:49.618] Packages needed by the future expression (n = 0): <none>
[01:27:49.618] Packages needed by future strategies (n = 0): <none>
[01:27:49.619] {
[01:27:49.619]     {
[01:27:49.619]         {
[01:27:49.619]             ...future.startTime <- base::Sys.time()
[01:27:49.619]             {
[01:27:49.619]                 {
[01:27:49.619]                   {
[01:27:49.619]                     {
[01:27:49.619]                       base::local({
[01:27:49.619]                         has_future <- base::requireNamespace("future", 
[01:27:49.619]                           quietly = TRUE)
[01:27:49.619]                         if (has_future) {
[01:27:49.619]                           ns <- base::getNamespace("future")
[01:27:49.619]                           version <- ns[[".package"]][["version"]]
[01:27:49.619]                           if (is.null(version)) 
[01:27:49.619]                             version <- utils::packageVersion("future")
[01:27:49.619]                         }
[01:27:49.619]                         else {
[01:27:49.619]                           version <- NULL
[01:27:49.619]                         }
[01:27:49.619]                         if (!has_future || version < "1.8.0") {
[01:27:49.619]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.619]                             "", base::R.version$version.string), 
[01:27:49.619]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.619]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.619]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.619]                               "release", "version")], collapse = " "), 
[01:27:49.619]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.619]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.619]                             info)
[01:27:49.619]                           info <- base::paste(info, collapse = "; ")
[01:27:49.619]                           if (!has_future) {
[01:27:49.619]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.619]                               info)
[01:27:49.619]                           }
[01:27:49.619]                           else {
[01:27:49.619]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.619]                               info, version)
[01:27:49.619]                           }
[01:27:49.619]                           base::stop(msg)
[01:27:49.619]                         }
[01:27:49.619]                       })
[01:27:49.619]                     }
[01:27:49.619]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.619]                     base::options(mc.cores = 1L)
[01:27:49.619]                   }
[01:27:49.619]                   options(future.plan = NULL)
[01:27:49.619]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.619]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.619]                 }
[01:27:49.619]                 ...future.workdir <- getwd()
[01:27:49.619]             }
[01:27:49.619]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.619]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.619]         }
[01:27:49.619]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.619]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.619]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.619]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.619]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.619]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.619]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.619]             base::names(...future.oldOptions))
[01:27:49.619]     }
[01:27:49.619]     if (FALSE) {
[01:27:49.619]     }
[01:27:49.619]     else {
[01:27:49.619]         if (TRUE) {
[01:27:49.619]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.619]                 open = "w")
[01:27:49.619]         }
[01:27:49.619]         else {
[01:27:49.619]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.619]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.619]         }
[01:27:49.619]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.619]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.619]             base::sink(type = "output", split = FALSE)
[01:27:49.619]             base::close(...future.stdout)
[01:27:49.619]         }, add = TRUE)
[01:27:49.619]     }
[01:27:49.619]     ...future.frame <- base::sys.nframe()
[01:27:49.619]     ...future.conditions <- base::list()
[01:27:49.619]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.619]     if (FALSE) {
[01:27:49.619]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.619]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.619]     }
[01:27:49.619]     ...future.result <- base::tryCatch({
[01:27:49.619]         base::withCallingHandlers({
[01:27:49.619]             ...future.value <- base::withVisible(base::local({
[01:27:49.619]                 ...future.makeSendCondition <- base::local({
[01:27:49.619]                   sendCondition <- NULL
[01:27:49.619]                   function(frame = 1L) {
[01:27:49.619]                     if (is.function(sendCondition)) 
[01:27:49.619]                       return(sendCondition)
[01:27:49.619]                     ns <- getNamespace("parallel")
[01:27:49.619]                     if (exists("sendData", mode = "function", 
[01:27:49.619]                       envir = ns)) {
[01:27:49.619]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.619]                         envir = ns)
[01:27:49.619]                       envir <- sys.frame(frame)
[01:27:49.619]                       master <- NULL
[01:27:49.619]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.619]                         !identical(envir, emptyenv())) {
[01:27:49.619]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.619]                           inherits = FALSE)) {
[01:27:49.619]                           master <- get("master", mode = "list", 
[01:27:49.619]                             envir = envir, inherits = FALSE)
[01:27:49.619]                           if (inherits(master, c("SOCKnode", 
[01:27:49.619]                             "SOCK0node"))) {
[01:27:49.619]                             sendCondition <<- function(cond) {
[01:27:49.619]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.619]                                 success = TRUE)
[01:27:49.619]                               parallel_sendData(master, data)
[01:27:49.619]                             }
[01:27:49.619]                             return(sendCondition)
[01:27:49.619]                           }
[01:27:49.619]                         }
[01:27:49.619]                         frame <- frame + 1L
[01:27:49.619]                         envir <- sys.frame(frame)
[01:27:49.619]                       }
[01:27:49.619]                     }
[01:27:49.619]                     sendCondition <<- function(cond) NULL
[01:27:49.619]                   }
[01:27:49.619]                 })
[01:27:49.619]                 withCallingHandlers({
[01:27:49.619]                   2
[01:27:49.619]                 }, immediateCondition = function(cond) {
[01:27:49.619]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.619]                   sendCondition(cond)
[01:27:49.619]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.619]                   {
[01:27:49.619]                     inherits <- base::inherits
[01:27:49.619]                     invokeRestart <- base::invokeRestart
[01:27:49.619]                     is.null <- base::is.null
[01:27:49.619]                     muffled <- FALSE
[01:27:49.619]                     if (inherits(cond, "message")) {
[01:27:49.619]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.619]                       if (muffled) 
[01:27:49.619]                         invokeRestart("muffleMessage")
[01:27:49.619]                     }
[01:27:49.619]                     else if (inherits(cond, "warning")) {
[01:27:49.619]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.619]                       if (muffled) 
[01:27:49.619]                         invokeRestart("muffleWarning")
[01:27:49.619]                     }
[01:27:49.619]                     else if (inherits(cond, "condition")) {
[01:27:49.619]                       if (!is.null(pattern)) {
[01:27:49.619]                         computeRestarts <- base::computeRestarts
[01:27:49.619]                         grepl <- base::grepl
[01:27:49.619]                         restarts <- computeRestarts(cond)
[01:27:49.619]                         for (restart in restarts) {
[01:27:49.619]                           name <- restart$name
[01:27:49.619]                           if (is.null(name)) 
[01:27:49.619]                             next
[01:27:49.619]                           if (!grepl(pattern, name)) 
[01:27:49.619]                             next
[01:27:49.619]                           invokeRestart(restart)
[01:27:49.619]                           muffled <- TRUE
[01:27:49.619]                           break
[01:27:49.619]                         }
[01:27:49.619]                       }
[01:27:49.619]                     }
[01:27:49.619]                     invisible(muffled)
[01:27:49.619]                   }
[01:27:49.619]                   muffleCondition(cond)
[01:27:49.619]                 })
[01:27:49.619]             }))
[01:27:49.619]             future::FutureResult(value = ...future.value$value, 
[01:27:49.619]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.619]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.619]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.619]                     ...future.globalenv.names))
[01:27:49.619]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.619]         }, condition = base::local({
[01:27:49.619]             c <- base::c
[01:27:49.619]             inherits <- base::inherits
[01:27:49.619]             invokeRestart <- base::invokeRestart
[01:27:49.619]             length <- base::length
[01:27:49.619]             list <- base::list
[01:27:49.619]             seq.int <- base::seq.int
[01:27:49.619]             signalCondition <- base::signalCondition
[01:27:49.619]             sys.calls <- base::sys.calls
[01:27:49.619]             `[[` <- base::`[[`
[01:27:49.619]             `+` <- base::`+`
[01:27:49.619]             `<<-` <- base::`<<-`
[01:27:49.619]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.619]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.619]                   3L)]
[01:27:49.619]             }
[01:27:49.619]             function(cond) {
[01:27:49.619]                 is_error <- inherits(cond, "error")
[01:27:49.619]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.619]                   NULL)
[01:27:49.619]                 if (is_error) {
[01:27:49.619]                   sessionInformation <- function() {
[01:27:49.619]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.619]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.619]                       search = base::search(), system = base::Sys.info())
[01:27:49.619]                   }
[01:27:49.619]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.619]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.619]                     cond$call), session = sessionInformation(), 
[01:27:49.619]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.619]                   signalCondition(cond)
[01:27:49.619]                 }
[01:27:49.619]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.619]                 "immediateCondition"))) {
[01:27:49.619]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.619]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.619]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.619]                   if (TRUE && !signal) {
[01:27:49.619]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.619]                     {
[01:27:49.619]                       inherits <- base::inherits
[01:27:49.619]                       invokeRestart <- base::invokeRestart
[01:27:49.619]                       is.null <- base::is.null
[01:27:49.619]                       muffled <- FALSE
[01:27:49.619]                       if (inherits(cond, "message")) {
[01:27:49.619]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.619]                         if (muffled) 
[01:27:49.619]                           invokeRestart("muffleMessage")
[01:27:49.619]                       }
[01:27:49.619]                       else if (inherits(cond, "warning")) {
[01:27:49.619]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.619]                         if (muffled) 
[01:27:49.619]                           invokeRestart("muffleWarning")
[01:27:49.619]                       }
[01:27:49.619]                       else if (inherits(cond, "condition")) {
[01:27:49.619]                         if (!is.null(pattern)) {
[01:27:49.619]                           computeRestarts <- base::computeRestarts
[01:27:49.619]                           grepl <- base::grepl
[01:27:49.619]                           restarts <- computeRestarts(cond)
[01:27:49.619]                           for (restart in restarts) {
[01:27:49.619]                             name <- restart$name
[01:27:49.619]                             if (is.null(name)) 
[01:27:49.619]                               next
[01:27:49.619]                             if (!grepl(pattern, name)) 
[01:27:49.619]                               next
[01:27:49.619]                             invokeRestart(restart)
[01:27:49.619]                             muffled <- TRUE
[01:27:49.619]                             break
[01:27:49.619]                           }
[01:27:49.619]                         }
[01:27:49.619]                       }
[01:27:49.619]                       invisible(muffled)
[01:27:49.619]                     }
[01:27:49.619]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.619]                   }
[01:27:49.619]                 }
[01:27:49.619]                 else {
[01:27:49.619]                   if (TRUE) {
[01:27:49.619]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.619]                     {
[01:27:49.619]                       inherits <- base::inherits
[01:27:49.619]                       invokeRestart <- base::invokeRestart
[01:27:49.619]                       is.null <- base::is.null
[01:27:49.619]                       muffled <- FALSE
[01:27:49.619]                       if (inherits(cond, "message")) {
[01:27:49.619]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.619]                         if (muffled) 
[01:27:49.619]                           invokeRestart("muffleMessage")
[01:27:49.619]                       }
[01:27:49.619]                       else if (inherits(cond, "warning")) {
[01:27:49.619]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.619]                         if (muffled) 
[01:27:49.619]                           invokeRestart("muffleWarning")
[01:27:49.619]                       }
[01:27:49.619]                       else if (inherits(cond, "condition")) {
[01:27:49.619]                         if (!is.null(pattern)) {
[01:27:49.619]                           computeRestarts <- base::computeRestarts
[01:27:49.619]                           grepl <- base::grepl
[01:27:49.619]                           restarts <- computeRestarts(cond)
[01:27:49.619]                           for (restart in restarts) {
[01:27:49.619]                             name <- restart$name
[01:27:49.619]                             if (is.null(name)) 
[01:27:49.619]                               next
[01:27:49.619]                             if (!grepl(pattern, name)) 
[01:27:49.619]                               next
[01:27:49.619]                             invokeRestart(restart)
[01:27:49.619]                             muffled <- TRUE
[01:27:49.619]                             break
[01:27:49.619]                           }
[01:27:49.619]                         }
[01:27:49.619]                       }
[01:27:49.619]                       invisible(muffled)
[01:27:49.619]                     }
[01:27:49.619]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.619]                   }
[01:27:49.619]                 }
[01:27:49.619]             }
[01:27:49.619]         }))
[01:27:49.619]     }, error = function(ex) {
[01:27:49.619]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.619]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.619]                 ...future.rng), started = ...future.startTime, 
[01:27:49.619]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.619]             version = "1.8"), class = "FutureResult")
[01:27:49.619]     }, finally = {
[01:27:49.619]         if (!identical(...future.workdir, getwd())) 
[01:27:49.619]             setwd(...future.workdir)
[01:27:49.619]         {
[01:27:49.619]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.619]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.619]             }
[01:27:49.619]             base::options(...future.oldOptions)
[01:27:49.619]             if (.Platform$OS.type == "windows") {
[01:27:49.619]                 old_names <- names(...future.oldEnvVars)
[01:27:49.619]                 envs <- base::Sys.getenv()
[01:27:49.619]                 names <- names(envs)
[01:27:49.619]                 common <- intersect(names, old_names)
[01:27:49.619]                 added <- setdiff(names, old_names)
[01:27:49.619]                 removed <- setdiff(old_names, names)
[01:27:49.619]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.619]                   envs[common]]
[01:27:49.619]                 NAMES <- toupper(changed)
[01:27:49.619]                 args <- list()
[01:27:49.619]                 for (kk in seq_along(NAMES)) {
[01:27:49.619]                   name <- changed[[kk]]
[01:27:49.619]                   NAME <- NAMES[[kk]]
[01:27:49.619]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.619]                     next
[01:27:49.619]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.619]                 }
[01:27:49.619]                 NAMES <- toupper(added)
[01:27:49.619]                 for (kk in seq_along(NAMES)) {
[01:27:49.619]                   name <- added[[kk]]
[01:27:49.619]                   NAME <- NAMES[[kk]]
[01:27:49.619]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.619]                     next
[01:27:49.619]                   args[[name]] <- ""
[01:27:49.619]                 }
[01:27:49.619]                 NAMES <- toupper(removed)
[01:27:49.619]                 for (kk in seq_along(NAMES)) {
[01:27:49.619]                   name <- removed[[kk]]
[01:27:49.619]                   NAME <- NAMES[[kk]]
[01:27:49.619]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.619]                     next
[01:27:49.619]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.619]                 }
[01:27:49.619]                 if (length(args) > 0) 
[01:27:49.619]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.619]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.619]             }
[01:27:49.619]             else {
[01:27:49.619]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.619]             }
[01:27:49.619]             {
[01:27:49.619]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.619]                   0L) {
[01:27:49.619]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.619]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.619]                   base::options(opts)
[01:27:49.619]                 }
[01:27:49.619]                 {
[01:27:49.619]                   {
[01:27:49.619]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.619]                     NULL
[01:27:49.619]                   }
[01:27:49.619]                   options(future.plan = NULL)
[01:27:49.619]                   if (is.na(NA_character_)) 
[01:27:49.619]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.619]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.619]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.619]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.619]                     envir = parent.frame()) 
[01:27:49.619]                   {
[01:27:49.619]                     if (is.function(workers)) 
[01:27:49.619]                       workers <- workers()
[01:27:49.619]                     workers <- structure(as.integer(workers), 
[01:27:49.619]                       class = class(workers))
[01:27:49.619]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.619]                       workers >= 1)
[01:27:49.619]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.619]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.619]                     }
[01:27:49.619]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.619]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.619]                       envir = envir)
[01:27:49.619]                     if (!future$lazy) 
[01:27:49.619]                       future <- run(future)
[01:27:49.619]                     invisible(future)
[01:27:49.619]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.619]                 }
[01:27:49.619]             }
[01:27:49.619]         }
[01:27:49.619]     })
[01:27:49.619]     if (TRUE) {
[01:27:49.619]         base::sink(type = "output", split = FALSE)
[01:27:49.619]         if (TRUE) {
[01:27:49.619]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.619]         }
[01:27:49.619]         else {
[01:27:49.619]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.619]         }
[01:27:49.619]         base::close(...future.stdout)
[01:27:49.619]         ...future.stdout <- NULL
[01:27:49.619]     }
[01:27:49.619]     ...future.result$conditions <- ...future.conditions
[01:27:49.619]     ...future.result$finished <- base::Sys.time()
[01:27:49.619]     ...future.result
[01:27:49.619] }
[01:27:49.625] MultisessionFuture started
[01:27:49.625] - Launch lazy future ... done
[01:27:49.625] run() for 'MultisessionFuture' ... done
[01:27:49.625] getGlobalsAndPackages() ...
[01:27:49.625] Searching for globals...
[01:27:49.626] 
[01:27:49.626] Searching for globals ... DONE
[01:27:49.626] - globals: [0] <none>
[01:27:49.626] getGlobalsAndPackages() ... DONE
[01:27:49.627] run() for 'Future' ...
[01:27:49.627] - state: 'created'
[01:27:49.627] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.648] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.648] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.648]   - Field: 'node'
[01:27:49.648]   - Field: 'label'
[01:27:49.649]   - Field: 'local'
[01:27:49.649]   - Field: 'owner'
[01:27:49.649]   - Field: 'envir'
[01:27:49.649]   - Field: 'workers'
[01:27:49.650]   - Field: 'packages'
[01:27:49.650]   - Field: 'gc'
[01:27:49.650]   - Field: 'conditions'
[01:27:49.650]   - Field: 'persistent'
[01:27:49.650]   - Field: 'expr'
[01:27:49.651]   - Field: 'uuid'
[01:27:49.651]   - Field: 'seed'
[01:27:49.651]   - Field: 'version'
[01:27:49.651]   - Field: 'result'
[01:27:49.651]   - Field: 'asynchronous'
[01:27:49.652]   - Field: 'calls'
[01:27:49.652]   - Field: 'globals'
[01:27:49.652]   - Field: 'stdout'
[01:27:49.652]   - Field: 'earlySignal'
[01:27:49.652]   - Field: 'lazy'
[01:27:49.653]   - Field: 'state'
[01:27:49.653] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.653] - Launch lazy future ...
[01:27:49.654] Packages needed by the future expression (n = 0): <none>
[01:27:49.654] Packages needed by future strategies (n = 0): <none>
[01:27:49.655] {
[01:27:49.655]     {
[01:27:49.655]         {
[01:27:49.655]             ...future.startTime <- base::Sys.time()
[01:27:49.655]             {
[01:27:49.655]                 {
[01:27:49.655]                   {
[01:27:49.655]                     {
[01:27:49.655]                       base::local({
[01:27:49.655]                         has_future <- base::requireNamespace("future", 
[01:27:49.655]                           quietly = TRUE)
[01:27:49.655]                         if (has_future) {
[01:27:49.655]                           ns <- base::getNamespace("future")
[01:27:49.655]                           version <- ns[[".package"]][["version"]]
[01:27:49.655]                           if (is.null(version)) 
[01:27:49.655]                             version <- utils::packageVersion("future")
[01:27:49.655]                         }
[01:27:49.655]                         else {
[01:27:49.655]                           version <- NULL
[01:27:49.655]                         }
[01:27:49.655]                         if (!has_future || version < "1.8.0") {
[01:27:49.655]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.655]                             "", base::R.version$version.string), 
[01:27:49.655]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.655]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.655]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.655]                               "release", "version")], collapse = " "), 
[01:27:49.655]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.655]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.655]                             info)
[01:27:49.655]                           info <- base::paste(info, collapse = "; ")
[01:27:49.655]                           if (!has_future) {
[01:27:49.655]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.655]                               info)
[01:27:49.655]                           }
[01:27:49.655]                           else {
[01:27:49.655]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.655]                               info, version)
[01:27:49.655]                           }
[01:27:49.655]                           base::stop(msg)
[01:27:49.655]                         }
[01:27:49.655]                       })
[01:27:49.655]                     }
[01:27:49.655]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.655]                     base::options(mc.cores = 1L)
[01:27:49.655]                   }
[01:27:49.655]                   options(future.plan = NULL)
[01:27:49.655]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.655]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.655]                 }
[01:27:49.655]                 ...future.workdir <- getwd()
[01:27:49.655]             }
[01:27:49.655]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.655]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.655]         }
[01:27:49.655]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.655]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.655]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.655]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.655]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.655]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.655]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.655]             base::names(...future.oldOptions))
[01:27:49.655]     }
[01:27:49.655]     if (FALSE) {
[01:27:49.655]     }
[01:27:49.655]     else {
[01:27:49.655]         if (TRUE) {
[01:27:49.655]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.655]                 open = "w")
[01:27:49.655]         }
[01:27:49.655]         else {
[01:27:49.655]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.655]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.655]         }
[01:27:49.655]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.655]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.655]             base::sink(type = "output", split = FALSE)
[01:27:49.655]             base::close(...future.stdout)
[01:27:49.655]         }, add = TRUE)
[01:27:49.655]     }
[01:27:49.655]     ...future.frame <- base::sys.nframe()
[01:27:49.655]     ...future.conditions <- base::list()
[01:27:49.655]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.655]     if (FALSE) {
[01:27:49.655]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.655]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.655]     }
[01:27:49.655]     ...future.result <- base::tryCatch({
[01:27:49.655]         base::withCallingHandlers({
[01:27:49.655]             ...future.value <- base::withVisible(base::local({
[01:27:49.655]                 ...future.makeSendCondition <- base::local({
[01:27:49.655]                   sendCondition <- NULL
[01:27:49.655]                   function(frame = 1L) {
[01:27:49.655]                     if (is.function(sendCondition)) 
[01:27:49.655]                       return(sendCondition)
[01:27:49.655]                     ns <- getNamespace("parallel")
[01:27:49.655]                     if (exists("sendData", mode = "function", 
[01:27:49.655]                       envir = ns)) {
[01:27:49.655]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.655]                         envir = ns)
[01:27:49.655]                       envir <- sys.frame(frame)
[01:27:49.655]                       master <- NULL
[01:27:49.655]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.655]                         !identical(envir, emptyenv())) {
[01:27:49.655]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.655]                           inherits = FALSE)) {
[01:27:49.655]                           master <- get("master", mode = "list", 
[01:27:49.655]                             envir = envir, inherits = FALSE)
[01:27:49.655]                           if (inherits(master, c("SOCKnode", 
[01:27:49.655]                             "SOCK0node"))) {
[01:27:49.655]                             sendCondition <<- function(cond) {
[01:27:49.655]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.655]                                 success = TRUE)
[01:27:49.655]                               parallel_sendData(master, data)
[01:27:49.655]                             }
[01:27:49.655]                             return(sendCondition)
[01:27:49.655]                           }
[01:27:49.655]                         }
[01:27:49.655]                         frame <- frame + 1L
[01:27:49.655]                         envir <- sys.frame(frame)
[01:27:49.655]                       }
[01:27:49.655]                     }
[01:27:49.655]                     sendCondition <<- function(cond) NULL
[01:27:49.655]                   }
[01:27:49.655]                 })
[01:27:49.655]                 withCallingHandlers({
[01:27:49.655]                   NULL
[01:27:49.655]                 }, immediateCondition = function(cond) {
[01:27:49.655]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.655]                   sendCondition(cond)
[01:27:49.655]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.655]                   {
[01:27:49.655]                     inherits <- base::inherits
[01:27:49.655]                     invokeRestart <- base::invokeRestart
[01:27:49.655]                     is.null <- base::is.null
[01:27:49.655]                     muffled <- FALSE
[01:27:49.655]                     if (inherits(cond, "message")) {
[01:27:49.655]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.655]                       if (muffled) 
[01:27:49.655]                         invokeRestart("muffleMessage")
[01:27:49.655]                     }
[01:27:49.655]                     else if (inherits(cond, "warning")) {
[01:27:49.655]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.655]                       if (muffled) 
[01:27:49.655]                         invokeRestart("muffleWarning")
[01:27:49.655]                     }
[01:27:49.655]                     else if (inherits(cond, "condition")) {
[01:27:49.655]                       if (!is.null(pattern)) {
[01:27:49.655]                         computeRestarts <- base::computeRestarts
[01:27:49.655]                         grepl <- base::grepl
[01:27:49.655]                         restarts <- computeRestarts(cond)
[01:27:49.655]                         for (restart in restarts) {
[01:27:49.655]                           name <- restart$name
[01:27:49.655]                           if (is.null(name)) 
[01:27:49.655]                             next
[01:27:49.655]                           if (!grepl(pattern, name)) 
[01:27:49.655]                             next
[01:27:49.655]                           invokeRestart(restart)
[01:27:49.655]                           muffled <- TRUE
[01:27:49.655]                           break
[01:27:49.655]                         }
[01:27:49.655]                       }
[01:27:49.655]                     }
[01:27:49.655]                     invisible(muffled)
[01:27:49.655]                   }
[01:27:49.655]                   muffleCondition(cond)
[01:27:49.655]                 })
[01:27:49.655]             }))
[01:27:49.655]             future::FutureResult(value = ...future.value$value, 
[01:27:49.655]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.655]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.655]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.655]                     ...future.globalenv.names))
[01:27:49.655]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.655]         }, condition = base::local({
[01:27:49.655]             c <- base::c
[01:27:49.655]             inherits <- base::inherits
[01:27:49.655]             invokeRestart <- base::invokeRestart
[01:27:49.655]             length <- base::length
[01:27:49.655]             list <- base::list
[01:27:49.655]             seq.int <- base::seq.int
[01:27:49.655]             signalCondition <- base::signalCondition
[01:27:49.655]             sys.calls <- base::sys.calls
[01:27:49.655]             `[[` <- base::`[[`
[01:27:49.655]             `+` <- base::`+`
[01:27:49.655]             `<<-` <- base::`<<-`
[01:27:49.655]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.655]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.655]                   3L)]
[01:27:49.655]             }
[01:27:49.655]             function(cond) {
[01:27:49.655]                 is_error <- inherits(cond, "error")
[01:27:49.655]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.655]                   NULL)
[01:27:49.655]                 if (is_error) {
[01:27:49.655]                   sessionInformation <- function() {
[01:27:49.655]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.655]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.655]                       search = base::search(), system = base::Sys.info())
[01:27:49.655]                   }
[01:27:49.655]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.655]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.655]                     cond$call), session = sessionInformation(), 
[01:27:49.655]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.655]                   signalCondition(cond)
[01:27:49.655]                 }
[01:27:49.655]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.655]                 "immediateCondition"))) {
[01:27:49.655]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.655]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.655]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.655]                   if (TRUE && !signal) {
[01:27:49.655]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.655]                     {
[01:27:49.655]                       inherits <- base::inherits
[01:27:49.655]                       invokeRestart <- base::invokeRestart
[01:27:49.655]                       is.null <- base::is.null
[01:27:49.655]                       muffled <- FALSE
[01:27:49.655]                       if (inherits(cond, "message")) {
[01:27:49.655]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.655]                         if (muffled) 
[01:27:49.655]                           invokeRestart("muffleMessage")
[01:27:49.655]                       }
[01:27:49.655]                       else if (inherits(cond, "warning")) {
[01:27:49.655]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.655]                         if (muffled) 
[01:27:49.655]                           invokeRestart("muffleWarning")
[01:27:49.655]                       }
[01:27:49.655]                       else if (inherits(cond, "condition")) {
[01:27:49.655]                         if (!is.null(pattern)) {
[01:27:49.655]                           computeRestarts <- base::computeRestarts
[01:27:49.655]                           grepl <- base::grepl
[01:27:49.655]                           restarts <- computeRestarts(cond)
[01:27:49.655]                           for (restart in restarts) {
[01:27:49.655]                             name <- restart$name
[01:27:49.655]                             if (is.null(name)) 
[01:27:49.655]                               next
[01:27:49.655]                             if (!grepl(pattern, name)) 
[01:27:49.655]                               next
[01:27:49.655]                             invokeRestart(restart)
[01:27:49.655]                             muffled <- TRUE
[01:27:49.655]                             break
[01:27:49.655]                           }
[01:27:49.655]                         }
[01:27:49.655]                       }
[01:27:49.655]                       invisible(muffled)
[01:27:49.655]                     }
[01:27:49.655]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.655]                   }
[01:27:49.655]                 }
[01:27:49.655]                 else {
[01:27:49.655]                   if (TRUE) {
[01:27:49.655]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.655]                     {
[01:27:49.655]                       inherits <- base::inherits
[01:27:49.655]                       invokeRestart <- base::invokeRestart
[01:27:49.655]                       is.null <- base::is.null
[01:27:49.655]                       muffled <- FALSE
[01:27:49.655]                       if (inherits(cond, "message")) {
[01:27:49.655]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.655]                         if (muffled) 
[01:27:49.655]                           invokeRestart("muffleMessage")
[01:27:49.655]                       }
[01:27:49.655]                       else if (inherits(cond, "warning")) {
[01:27:49.655]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.655]                         if (muffled) 
[01:27:49.655]                           invokeRestart("muffleWarning")
[01:27:49.655]                       }
[01:27:49.655]                       else if (inherits(cond, "condition")) {
[01:27:49.655]                         if (!is.null(pattern)) {
[01:27:49.655]                           computeRestarts <- base::computeRestarts
[01:27:49.655]                           grepl <- base::grepl
[01:27:49.655]                           restarts <- computeRestarts(cond)
[01:27:49.655]                           for (restart in restarts) {
[01:27:49.655]                             name <- restart$name
[01:27:49.655]                             if (is.null(name)) 
[01:27:49.655]                               next
[01:27:49.655]                             if (!grepl(pattern, name)) 
[01:27:49.655]                               next
[01:27:49.655]                             invokeRestart(restart)
[01:27:49.655]                             muffled <- TRUE
[01:27:49.655]                             break
[01:27:49.655]                           }
[01:27:49.655]                         }
[01:27:49.655]                       }
[01:27:49.655]                       invisible(muffled)
[01:27:49.655]                     }
[01:27:49.655]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.655]                   }
[01:27:49.655]                 }
[01:27:49.655]             }
[01:27:49.655]         }))
[01:27:49.655]     }, error = function(ex) {
[01:27:49.655]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.655]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.655]                 ...future.rng), started = ...future.startTime, 
[01:27:49.655]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.655]             version = "1.8"), class = "FutureResult")
[01:27:49.655]     }, finally = {
[01:27:49.655]         if (!identical(...future.workdir, getwd())) 
[01:27:49.655]             setwd(...future.workdir)
[01:27:49.655]         {
[01:27:49.655]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.655]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.655]             }
[01:27:49.655]             base::options(...future.oldOptions)
[01:27:49.655]             if (.Platform$OS.type == "windows") {
[01:27:49.655]                 old_names <- names(...future.oldEnvVars)
[01:27:49.655]                 envs <- base::Sys.getenv()
[01:27:49.655]                 names <- names(envs)
[01:27:49.655]                 common <- intersect(names, old_names)
[01:27:49.655]                 added <- setdiff(names, old_names)
[01:27:49.655]                 removed <- setdiff(old_names, names)
[01:27:49.655]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.655]                   envs[common]]
[01:27:49.655]                 NAMES <- toupper(changed)
[01:27:49.655]                 args <- list()
[01:27:49.655]                 for (kk in seq_along(NAMES)) {
[01:27:49.655]                   name <- changed[[kk]]
[01:27:49.655]                   NAME <- NAMES[[kk]]
[01:27:49.655]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.655]                     next
[01:27:49.655]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.655]                 }
[01:27:49.655]                 NAMES <- toupper(added)
[01:27:49.655]                 for (kk in seq_along(NAMES)) {
[01:27:49.655]                   name <- added[[kk]]
[01:27:49.655]                   NAME <- NAMES[[kk]]
[01:27:49.655]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.655]                     next
[01:27:49.655]                   args[[name]] <- ""
[01:27:49.655]                 }
[01:27:49.655]                 NAMES <- toupper(removed)
[01:27:49.655]                 for (kk in seq_along(NAMES)) {
[01:27:49.655]                   name <- removed[[kk]]
[01:27:49.655]                   NAME <- NAMES[[kk]]
[01:27:49.655]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.655]                     next
[01:27:49.655]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.655]                 }
[01:27:49.655]                 if (length(args) > 0) 
[01:27:49.655]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.655]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.655]             }
[01:27:49.655]             else {
[01:27:49.655]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.655]             }
[01:27:49.655]             {
[01:27:49.655]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.655]                   0L) {
[01:27:49.655]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.655]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.655]                   base::options(opts)
[01:27:49.655]                 }
[01:27:49.655]                 {
[01:27:49.655]                   {
[01:27:49.655]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.655]                     NULL
[01:27:49.655]                   }
[01:27:49.655]                   options(future.plan = NULL)
[01:27:49.655]                   if (is.na(NA_character_)) 
[01:27:49.655]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.655]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.655]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.655]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.655]                     envir = parent.frame()) 
[01:27:49.655]                   {
[01:27:49.655]                     if (is.function(workers)) 
[01:27:49.655]                       workers <- workers()
[01:27:49.655]                     workers <- structure(as.integer(workers), 
[01:27:49.655]                       class = class(workers))
[01:27:49.655]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.655]                       workers >= 1)
[01:27:49.655]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.655]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.655]                     }
[01:27:49.655]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.655]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.655]                       envir = envir)
[01:27:49.655]                     if (!future$lazy) 
[01:27:49.655]                       future <- run(future)
[01:27:49.655]                     invisible(future)
[01:27:49.655]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.655]                 }
[01:27:49.655]             }
[01:27:49.655]         }
[01:27:49.655]     })
[01:27:49.655]     if (TRUE) {
[01:27:49.655]         base::sink(type = "output", split = FALSE)
[01:27:49.655]         if (TRUE) {
[01:27:49.655]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.655]         }
[01:27:49.655]         else {
[01:27:49.655]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.655]         }
[01:27:49.655]         base::close(...future.stdout)
[01:27:49.655]         ...future.stdout <- NULL
[01:27:49.655]     }
[01:27:49.655]     ...future.result$conditions <- ...future.conditions
[01:27:49.655]     ...future.result$finished <- base::Sys.time()
[01:27:49.655]     ...future.result
[01:27:49.655] }
[01:27:49.662] MultisessionFuture started
[01:27:49.663] - Launch lazy future ... done
[01:27:49.663] run() for 'MultisessionFuture' ... done
[01:27:49.663] getGlobalsAndPackages() ...
[01:27:49.664] Searching for globals...
[01:27:49.665] - globals found: [1] '{'
[01:27:49.665] Searching for globals ... DONE
[01:27:49.665] Resolving globals: FALSE
[01:27:49.666] 
[01:27:49.666] 
[01:27:49.666] getGlobalsAndPackages() ... DONE
[01:27:49.666] run() for 'Future' ...
[01:27:49.667] - state: 'created'
[01:27:49.667] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:49.683] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:49.684] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:49.684]   - Field: 'node'
[01:27:49.684]   - Field: 'label'
[01:27:49.684]   - Field: 'local'
[01:27:49.684]   - Field: 'owner'
[01:27:49.685]   - Field: 'envir'
[01:27:49.685]   - Field: 'workers'
[01:27:49.685]   - Field: 'packages'
[01:27:49.685]   - Field: 'gc'
[01:27:49.685]   - Field: 'conditions'
[01:27:49.686]   - Field: 'persistent'
[01:27:49.686]   - Field: 'expr'
[01:27:49.686]   - Field: 'uuid'
[01:27:49.686]   - Field: 'seed'
[01:27:49.686]   - Field: 'version'
[01:27:49.687]   - Field: 'result'
[01:27:49.687]   - Field: 'asynchronous'
[01:27:49.687]   - Field: 'calls'
[01:27:49.687]   - Field: 'globals'
[01:27:49.688]   - Field: 'stdout'
[01:27:49.688]   - Field: 'earlySignal'
[01:27:49.688]   - Field: 'lazy'
[01:27:49.688]   - Field: 'state'
[01:27:49.688] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:49.689] - Launch lazy future ...
[01:27:49.689] Packages needed by the future expression (n = 0): <none>
[01:27:49.689] Packages needed by future strategies (n = 0): <none>
[01:27:49.690] {
[01:27:49.690]     {
[01:27:49.690]         {
[01:27:49.690]             ...future.startTime <- base::Sys.time()
[01:27:49.690]             {
[01:27:49.690]                 {
[01:27:49.690]                   {
[01:27:49.690]                     {
[01:27:49.690]                       base::local({
[01:27:49.690]                         has_future <- base::requireNamespace("future", 
[01:27:49.690]                           quietly = TRUE)
[01:27:49.690]                         if (has_future) {
[01:27:49.690]                           ns <- base::getNamespace("future")
[01:27:49.690]                           version <- ns[[".package"]][["version"]]
[01:27:49.690]                           if (is.null(version)) 
[01:27:49.690]                             version <- utils::packageVersion("future")
[01:27:49.690]                         }
[01:27:49.690]                         else {
[01:27:49.690]                           version <- NULL
[01:27:49.690]                         }
[01:27:49.690]                         if (!has_future || version < "1.8.0") {
[01:27:49.690]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:49.690]                             "", base::R.version$version.string), 
[01:27:49.690]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:49.690]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:49.690]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:49.690]                               "release", "version")], collapse = " "), 
[01:27:49.690]                             hostname = base::Sys.info()[["nodename"]])
[01:27:49.690]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:49.690]                             info)
[01:27:49.690]                           info <- base::paste(info, collapse = "; ")
[01:27:49.690]                           if (!has_future) {
[01:27:49.690]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:49.690]                               info)
[01:27:49.690]                           }
[01:27:49.690]                           else {
[01:27:49.690]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:49.690]                               info, version)
[01:27:49.690]                           }
[01:27:49.690]                           base::stop(msg)
[01:27:49.690]                         }
[01:27:49.690]                       })
[01:27:49.690]                     }
[01:27:49.690]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:49.690]                     base::options(mc.cores = 1L)
[01:27:49.690]                   }
[01:27:49.690]                   options(future.plan = NULL)
[01:27:49.690]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.690]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:49.690]                 }
[01:27:49.690]                 ...future.workdir <- getwd()
[01:27:49.690]             }
[01:27:49.690]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:49.690]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:49.690]         }
[01:27:49.690]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:49.690]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:49.690]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:49.690]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:49.690]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:49.690]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:49.690]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:49.690]             base::names(...future.oldOptions))
[01:27:49.690]     }
[01:27:49.690]     if (FALSE) {
[01:27:49.690]     }
[01:27:49.690]     else {
[01:27:49.690]         if (TRUE) {
[01:27:49.690]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:49.690]                 open = "w")
[01:27:49.690]         }
[01:27:49.690]         else {
[01:27:49.690]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:49.690]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:49.690]         }
[01:27:49.690]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:49.690]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:49.690]             base::sink(type = "output", split = FALSE)
[01:27:49.690]             base::close(...future.stdout)
[01:27:49.690]         }, add = TRUE)
[01:27:49.690]     }
[01:27:49.690]     ...future.frame <- base::sys.nframe()
[01:27:49.690]     ...future.conditions <- base::list()
[01:27:49.690]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:49.690]     if (FALSE) {
[01:27:49.690]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:49.690]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:49.690]     }
[01:27:49.690]     ...future.result <- base::tryCatch({
[01:27:49.690]         base::withCallingHandlers({
[01:27:49.690]             ...future.value <- base::withVisible(base::local({
[01:27:49.690]                 ...future.makeSendCondition <- base::local({
[01:27:49.690]                   sendCondition <- NULL
[01:27:49.690]                   function(frame = 1L) {
[01:27:49.690]                     if (is.function(sendCondition)) 
[01:27:49.690]                       return(sendCondition)
[01:27:49.690]                     ns <- getNamespace("parallel")
[01:27:49.690]                     if (exists("sendData", mode = "function", 
[01:27:49.690]                       envir = ns)) {
[01:27:49.690]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:49.690]                         envir = ns)
[01:27:49.690]                       envir <- sys.frame(frame)
[01:27:49.690]                       master <- NULL
[01:27:49.690]                       while (!identical(envir, .GlobalEnv) && 
[01:27:49.690]                         !identical(envir, emptyenv())) {
[01:27:49.690]                         if (exists("master", mode = "list", envir = envir, 
[01:27:49.690]                           inherits = FALSE)) {
[01:27:49.690]                           master <- get("master", mode = "list", 
[01:27:49.690]                             envir = envir, inherits = FALSE)
[01:27:49.690]                           if (inherits(master, c("SOCKnode", 
[01:27:49.690]                             "SOCK0node"))) {
[01:27:49.690]                             sendCondition <<- function(cond) {
[01:27:49.690]                               data <- list(type = "VALUE", value = cond, 
[01:27:49.690]                                 success = TRUE)
[01:27:49.690]                               parallel_sendData(master, data)
[01:27:49.690]                             }
[01:27:49.690]                             return(sendCondition)
[01:27:49.690]                           }
[01:27:49.690]                         }
[01:27:49.690]                         frame <- frame + 1L
[01:27:49.690]                         envir <- sys.frame(frame)
[01:27:49.690]                       }
[01:27:49.690]                     }
[01:27:49.690]                     sendCondition <<- function(cond) NULL
[01:27:49.690]                   }
[01:27:49.690]                 })
[01:27:49.690]                 withCallingHandlers({
[01:27:49.690]                   {
[01:27:49.690]                     4
[01:27:49.690]                   }
[01:27:49.690]                 }, immediateCondition = function(cond) {
[01:27:49.690]                   sendCondition <- ...future.makeSendCondition()
[01:27:49.690]                   sendCondition(cond)
[01:27:49.690]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.690]                   {
[01:27:49.690]                     inherits <- base::inherits
[01:27:49.690]                     invokeRestart <- base::invokeRestart
[01:27:49.690]                     is.null <- base::is.null
[01:27:49.690]                     muffled <- FALSE
[01:27:49.690]                     if (inherits(cond, "message")) {
[01:27:49.690]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:49.690]                       if (muffled) 
[01:27:49.690]                         invokeRestart("muffleMessage")
[01:27:49.690]                     }
[01:27:49.690]                     else if (inherits(cond, "warning")) {
[01:27:49.690]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:49.690]                       if (muffled) 
[01:27:49.690]                         invokeRestart("muffleWarning")
[01:27:49.690]                     }
[01:27:49.690]                     else if (inherits(cond, "condition")) {
[01:27:49.690]                       if (!is.null(pattern)) {
[01:27:49.690]                         computeRestarts <- base::computeRestarts
[01:27:49.690]                         grepl <- base::grepl
[01:27:49.690]                         restarts <- computeRestarts(cond)
[01:27:49.690]                         for (restart in restarts) {
[01:27:49.690]                           name <- restart$name
[01:27:49.690]                           if (is.null(name)) 
[01:27:49.690]                             next
[01:27:49.690]                           if (!grepl(pattern, name)) 
[01:27:49.690]                             next
[01:27:49.690]                           invokeRestart(restart)
[01:27:49.690]                           muffled <- TRUE
[01:27:49.690]                           break
[01:27:49.690]                         }
[01:27:49.690]                       }
[01:27:49.690]                     }
[01:27:49.690]                     invisible(muffled)
[01:27:49.690]                   }
[01:27:49.690]                   muffleCondition(cond)
[01:27:49.690]                 })
[01:27:49.690]             }))
[01:27:49.690]             future::FutureResult(value = ...future.value$value, 
[01:27:49.690]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.690]                   ...future.rng), globalenv = if (FALSE) 
[01:27:49.690]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:49.690]                     ...future.globalenv.names))
[01:27:49.690]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:49.690]         }, condition = base::local({
[01:27:49.690]             c <- base::c
[01:27:49.690]             inherits <- base::inherits
[01:27:49.690]             invokeRestart <- base::invokeRestart
[01:27:49.690]             length <- base::length
[01:27:49.690]             list <- base::list
[01:27:49.690]             seq.int <- base::seq.int
[01:27:49.690]             signalCondition <- base::signalCondition
[01:27:49.690]             sys.calls <- base::sys.calls
[01:27:49.690]             `[[` <- base::`[[`
[01:27:49.690]             `+` <- base::`+`
[01:27:49.690]             `<<-` <- base::`<<-`
[01:27:49.690]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:49.690]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:49.690]                   3L)]
[01:27:49.690]             }
[01:27:49.690]             function(cond) {
[01:27:49.690]                 is_error <- inherits(cond, "error")
[01:27:49.690]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:49.690]                   NULL)
[01:27:49.690]                 if (is_error) {
[01:27:49.690]                   sessionInformation <- function() {
[01:27:49.690]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:49.690]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:49.690]                       search = base::search(), system = base::Sys.info())
[01:27:49.690]                   }
[01:27:49.690]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.690]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:49.690]                     cond$call), session = sessionInformation(), 
[01:27:49.690]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:49.690]                   signalCondition(cond)
[01:27:49.690]                 }
[01:27:49.690]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:49.690]                 "immediateCondition"))) {
[01:27:49.690]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:49.690]                   ...future.conditions[[length(...future.conditions) + 
[01:27:49.690]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:49.690]                   if (TRUE && !signal) {
[01:27:49.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.690]                     {
[01:27:49.690]                       inherits <- base::inherits
[01:27:49.690]                       invokeRestart <- base::invokeRestart
[01:27:49.690]                       is.null <- base::is.null
[01:27:49.690]                       muffled <- FALSE
[01:27:49.690]                       if (inherits(cond, "message")) {
[01:27:49.690]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.690]                         if (muffled) 
[01:27:49.690]                           invokeRestart("muffleMessage")
[01:27:49.690]                       }
[01:27:49.690]                       else if (inherits(cond, "warning")) {
[01:27:49.690]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.690]                         if (muffled) 
[01:27:49.690]                           invokeRestart("muffleWarning")
[01:27:49.690]                       }
[01:27:49.690]                       else if (inherits(cond, "condition")) {
[01:27:49.690]                         if (!is.null(pattern)) {
[01:27:49.690]                           computeRestarts <- base::computeRestarts
[01:27:49.690]                           grepl <- base::grepl
[01:27:49.690]                           restarts <- computeRestarts(cond)
[01:27:49.690]                           for (restart in restarts) {
[01:27:49.690]                             name <- restart$name
[01:27:49.690]                             if (is.null(name)) 
[01:27:49.690]                               next
[01:27:49.690]                             if (!grepl(pattern, name)) 
[01:27:49.690]                               next
[01:27:49.690]                             invokeRestart(restart)
[01:27:49.690]                             muffled <- TRUE
[01:27:49.690]                             break
[01:27:49.690]                           }
[01:27:49.690]                         }
[01:27:49.690]                       }
[01:27:49.690]                       invisible(muffled)
[01:27:49.690]                     }
[01:27:49.690]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.690]                   }
[01:27:49.690]                 }
[01:27:49.690]                 else {
[01:27:49.690]                   if (TRUE) {
[01:27:49.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:49.690]                     {
[01:27:49.690]                       inherits <- base::inherits
[01:27:49.690]                       invokeRestart <- base::invokeRestart
[01:27:49.690]                       is.null <- base::is.null
[01:27:49.690]                       muffled <- FALSE
[01:27:49.690]                       if (inherits(cond, "message")) {
[01:27:49.690]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:49.690]                         if (muffled) 
[01:27:49.690]                           invokeRestart("muffleMessage")
[01:27:49.690]                       }
[01:27:49.690]                       else if (inherits(cond, "warning")) {
[01:27:49.690]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:49.690]                         if (muffled) 
[01:27:49.690]                           invokeRestart("muffleWarning")
[01:27:49.690]                       }
[01:27:49.690]                       else if (inherits(cond, "condition")) {
[01:27:49.690]                         if (!is.null(pattern)) {
[01:27:49.690]                           computeRestarts <- base::computeRestarts
[01:27:49.690]                           grepl <- base::grepl
[01:27:49.690]                           restarts <- computeRestarts(cond)
[01:27:49.690]                           for (restart in restarts) {
[01:27:49.690]                             name <- restart$name
[01:27:49.690]                             if (is.null(name)) 
[01:27:49.690]                               next
[01:27:49.690]                             if (!grepl(pattern, name)) 
[01:27:49.690]                               next
[01:27:49.690]                             invokeRestart(restart)
[01:27:49.690]                             muffled <- TRUE
[01:27:49.690]                             break
[01:27:49.690]                           }
[01:27:49.690]                         }
[01:27:49.690]                       }
[01:27:49.690]                       invisible(muffled)
[01:27:49.690]                     }
[01:27:49.690]                     muffleCondition(cond, pattern = "^muffle")
[01:27:49.690]                   }
[01:27:49.690]                 }
[01:27:49.690]             }
[01:27:49.690]         }))
[01:27:49.690]     }, error = function(ex) {
[01:27:49.690]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:49.690]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:49.690]                 ...future.rng), started = ...future.startTime, 
[01:27:49.690]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:49.690]             version = "1.8"), class = "FutureResult")
[01:27:49.690]     }, finally = {
[01:27:49.690]         if (!identical(...future.workdir, getwd())) 
[01:27:49.690]             setwd(...future.workdir)
[01:27:49.690]         {
[01:27:49.690]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:49.690]                 ...future.oldOptions$nwarnings <- NULL
[01:27:49.690]             }
[01:27:49.690]             base::options(...future.oldOptions)
[01:27:49.690]             if (.Platform$OS.type == "windows") {
[01:27:49.690]                 old_names <- names(...future.oldEnvVars)
[01:27:49.690]                 envs <- base::Sys.getenv()
[01:27:49.690]                 names <- names(envs)
[01:27:49.690]                 common <- intersect(names, old_names)
[01:27:49.690]                 added <- setdiff(names, old_names)
[01:27:49.690]                 removed <- setdiff(old_names, names)
[01:27:49.690]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:49.690]                   envs[common]]
[01:27:49.690]                 NAMES <- toupper(changed)
[01:27:49.690]                 args <- list()
[01:27:49.690]                 for (kk in seq_along(NAMES)) {
[01:27:49.690]                   name <- changed[[kk]]
[01:27:49.690]                   NAME <- NAMES[[kk]]
[01:27:49.690]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.690]                     next
[01:27:49.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.690]                 }
[01:27:49.690]                 NAMES <- toupper(added)
[01:27:49.690]                 for (kk in seq_along(NAMES)) {
[01:27:49.690]                   name <- added[[kk]]
[01:27:49.690]                   NAME <- NAMES[[kk]]
[01:27:49.690]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.690]                     next
[01:27:49.690]                   args[[name]] <- ""
[01:27:49.690]                 }
[01:27:49.690]                 NAMES <- toupper(removed)
[01:27:49.690]                 for (kk in seq_along(NAMES)) {
[01:27:49.690]                   name <- removed[[kk]]
[01:27:49.690]                   NAME <- NAMES[[kk]]
[01:27:49.690]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:49.690]                     next
[01:27:49.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:49.690]                 }
[01:27:49.690]                 if (length(args) > 0) 
[01:27:49.690]                   base::do.call(base::Sys.setenv, args = args)
[01:27:49.690]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:49.690]             }
[01:27:49.690]             else {
[01:27:49.690]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:49.690]             }
[01:27:49.690]             {
[01:27:49.690]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:49.690]                   0L) {
[01:27:49.690]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:49.690]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:49.690]                   base::options(opts)
[01:27:49.690]                 }
[01:27:49.690]                 {
[01:27:49.690]                   {
[01:27:49.690]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:49.690]                     NULL
[01:27:49.690]                   }
[01:27:49.690]                   options(future.plan = NULL)
[01:27:49.690]                   if (is.na(NA_character_)) 
[01:27:49.690]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:49.690]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:49.690]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:49.690]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:49.690]                     envir = parent.frame()) 
[01:27:49.690]                   {
[01:27:49.690]                     if (is.function(workers)) 
[01:27:49.690]                       workers <- workers()
[01:27:49.690]                     workers <- structure(as.integer(workers), 
[01:27:49.690]                       class = class(workers))
[01:27:49.690]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:49.690]                       workers >= 1)
[01:27:49.690]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:49.690]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:49.690]                     }
[01:27:49.690]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:49.690]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:49.690]                       envir = envir)
[01:27:49.690]                     if (!future$lazy) 
[01:27:49.690]                       future <- run(future)
[01:27:49.690]                     invisible(future)
[01:27:49.690]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:49.690]                 }
[01:27:49.690]             }
[01:27:49.690]         }
[01:27:49.690]     })
[01:27:49.690]     if (TRUE) {
[01:27:49.690]         base::sink(type = "output", split = FALSE)
[01:27:49.690]         if (TRUE) {
[01:27:49.690]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:49.690]         }
[01:27:49.690]         else {
[01:27:49.690]             ...future.result["stdout"] <- base::list(NULL)
[01:27:49.690]         }
[01:27:49.690]         base::close(...future.stdout)
[01:27:49.690]         ...future.stdout <- NULL
[01:27:49.690]     }
[01:27:49.690]     ...future.result$conditions <- ...future.conditions
[01:27:49.690]     ...future.result$finished <- base::Sys.time()
[01:27:49.690]     ...future.result
[01:27:49.690] }
[01:27:49.696] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:49.712] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.712] - Validating connection of MultisessionFuture
[01:27:49.712] - received message: FutureResult
[01:27:49.713] - Received FutureResult
[01:27:49.713] - Erased future from FutureRegistry
[01:27:49.713] result() for ClusterFuture ...
[01:27:49.713] - result already collected: FutureResult
[01:27:49.714] result() for ClusterFuture ... done
[01:27:49.714] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.714] result() for ClusterFuture ...
[01:27:49.714] - result already collected: FutureResult
[01:27:49.715] result() for ClusterFuture ... done
[01:27:49.715] result() for ClusterFuture ...
[01:27:49.715] - result already collected: FutureResult
[01:27:49.715] result() for ClusterFuture ... done
[01:27:49.717] MultisessionFuture started
[01:27:49.717] - Launch lazy future ... done
[01:27:49.717] run() for 'MultisessionFuture' ... done
<environment: 0x0000025b0b56fc38> 
<environment: 0x0000025b0669a848> 
[01:27:49.720] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.720] - Validating connection of MultisessionFuture
[01:27:49.720] - received message: FutureResult
[01:27:49.720] - Received FutureResult
[01:27:49.721] - Erased future from FutureRegistry
[01:27:49.721] result() for ClusterFuture ...
[01:27:49.721] - result already collected: FutureResult
[01:27:49.721] result() for ClusterFuture ... done
[01:27:49.722] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:49.735] receiveMessageFromWorker() for ClusterFuture ...
[01:27:49.736] - Validating connection of MultisessionFuture
[01:27:49.736] - received message: FutureResult
[01:27:49.736] - Received FutureResult
[01:27:49.736] - Erased future from FutureRegistry
[01:27:49.737] result() for ClusterFuture ...
[01:27:49.737] - result already collected: FutureResult
[01:27:49.737] result() for ClusterFuture ... done
[01:27:49.737] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:4] TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
[01:27:49.739] resolve() on environment ...
[01:27:49.739]  recursive: 0
[01:27:49.740]  elements: [4] 'a', 'b', 'c', 'd'
[01:27:49.740] signalConditionsASAP(numeric, pos=1) ...
[01:27:49.740] - nx: 4
[01:27:49.740] - relay: TRUE
[01:27:49.741] - stdout: TRUE
[01:27:49.741] - signal: TRUE
[01:27:49.741] - resignal: FALSE
[01:27:49.741] - force: TRUE
[01:27:49.741] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.741] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.742]  - until=2
[01:27:49.742]  - relaying element #2
[01:27:49.742] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.742] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.742] signalConditionsASAP(NULL, pos=1) ... done
[01:27:49.743]  length: 3 (resolved future 1)
[01:27:49.743] Future #2
[01:27:49.743] result() for ClusterFuture ...
[01:27:49.743] - result already collected: FutureResult
[01:27:49.743] result() for ClusterFuture ... done
[01:27:49.743] result() for ClusterFuture ...
[01:27:49.744] - result already collected: FutureResult
[01:27:49.744] result() for ClusterFuture ... done
[01:27:49.744] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:49.744] - nx: 4
[01:27:49.744] - relay: TRUE
[01:27:49.745] - stdout: TRUE
[01:27:49.745] - signal: TRUE
[01:27:49.745] - resignal: FALSE
[01:27:49.745] - force: TRUE
[01:27:49.745] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:27:49.745] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:27:49.746]  - until=2
[01:27:49.746]  - relaying element #2
[01:27:49.746] result() for ClusterFuture ...
[01:27:49.746] - result already collected: FutureResult
[01:27:49.746] result() for ClusterFuture ... done
[01:27:49.746] result() for ClusterFuture ...
[01:27:49.746] - result already collected: FutureResult
[01:27:49.747] result() for ClusterFuture ... done
[01:27:49.747] result() for ClusterFuture ...
[01:27:49.747] - result already collected: FutureResult
[01:27:49.747] result() for ClusterFuture ... done
[01:27:49.747] result() for ClusterFuture ...
[01:27:49.748] - result already collected: FutureResult
[01:27:49.748] result() for ClusterFuture ... done
[01:27:49.748] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.748] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.748] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:49.748]  length: 2 (resolved future 2)
[01:27:49.749] Future #3
[01:27:49.749] result() for ClusterFuture ...
[01:27:49.749] - result already collected: FutureResult
[01:27:49.749] result() for ClusterFuture ... done
[01:27:49.749] result() for ClusterFuture ...
[01:27:49.749] - result already collected: FutureResult
[01:27:49.750] result() for ClusterFuture ... done
[01:27:49.750] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:49.750] - nx: 4
[01:27:49.750] - relay: TRUE
[01:27:49.750] - stdout: TRUE
[01:27:49.750] - signal: TRUE
[01:27:49.751] - resignal: FALSE
[01:27:49.751] - force: TRUE
[01:27:49.751] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:27:49.751] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
[01:27:49.751]  - until=3
[01:27:49.751]  - relaying element #3
[01:27:49.752] result() for ClusterFuture ...
[01:27:49.752] - result already collected: FutureResult
[01:27:49.752] result() for ClusterFuture ... done
[01:27:49.752] result() for ClusterFuture ...
[01:27:49.752] - result already collected: FutureResult
[01:27:49.752] result() for ClusterFuture ... done
[01:27:49.753] result() for ClusterFuture ...
[01:27:49.753] - result already collected: FutureResult
[01:27:49.753] result() for ClusterFuture ... done
[01:27:49.753] result() for ClusterFuture ...
[01:27:49.753] - result already collected: FutureResult
[01:27:49.753] result() for ClusterFuture ... done
[01:27:49.753] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.754] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.754] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:49.754]  length: 1 (resolved future 3)
[01:27:49.754] Future #4
[01:27:49.754] result() for ClusterFuture ...
[01:27:49.755] - result already collected: FutureResult
[01:27:49.755] result() for ClusterFuture ... done
[01:27:49.755] result() for ClusterFuture ...
[01:27:49.755] - result already collected: FutureResult
[01:27:49.755] result() for ClusterFuture ... done
[01:27:49.755] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:49.756] - nx: 4
[01:27:49.756] - relay: TRUE
[01:27:49.756] - stdout: TRUE
[01:27:49.756] - signal: TRUE
[01:27:49.756] - resignal: FALSE
[01:27:49.756] - force: TRUE
[01:27:49.756] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:27:49.757] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
[01:27:49.757]  - until=4
[01:27:49.757]  - relaying element #4
[01:27:49.757] result() for ClusterFuture ...
[01:27:49.757] - result already collected: FutureResult
[01:27:49.757] result() for ClusterFuture ... done
[01:27:49.758] result() for ClusterFuture ...
[01:27:49.758] - result already collected: FutureResult
[01:27:49.758] result() for ClusterFuture ... done
[01:27:49.758] result() for ClusterFuture ...
[01:27:49.758] - result already collected: FutureResult
[01:27:49.759] result() for ClusterFuture ... done
[01:27:49.759] result() for ClusterFuture ...
[01:27:49.759] - result already collected: FutureResult
[01:27:49.759] result() for ClusterFuture ... done
[01:27:49.759] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.759] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.760] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:49.760]  length: 0 (resolved future 4)
[01:27:49.760] Relaying remaining futures
[01:27:49.760] signalConditionsASAP(NULL, pos=0) ...
[01:27:49.760] - nx: 4
[01:27:49.760] - relay: TRUE
[01:27:49.761] - stdout: TRUE
[01:27:49.761] - signal: TRUE
[01:27:49.761] - resignal: FALSE
[01:27:49.761] - force: TRUE
[01:27:49.761] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.761] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
 - flush all
[01:27:49.762] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:27:49.762] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
[01:27:49.762] signalConditionsASAP(NULL, pos=0) ... done
[01:27:49.762] resolve() on environment ... DONE
[01:27:49.762] result() for ClusterFuture ...
[01:27:49.762] - result already collected: FutureResult
[01:27:49.763] result() for ClusterFuture ... done
[01:27:49.763] result() for ClusterFuture ...
[01:27:49.763] - result already collected: FutureResult
[01:27:49.763] result() for ClusterFuture ... done
[01:27:49.763] result() for ClusterFuture ...
[01:27:49.763] - result already collected: FutureResult
[01:27:49.764] result() for ClusterFuture ... done
[01:27:49.764] result() for ClusterFuture ...
[01:27:49.764] - result already collected: FutureResult
[01:27:49.764] result() for ClusterFuture ... done
[01:27:49.764] result() for ClusterFuture ...
[01:27:49.764] - result already collected: FutureResult
[01:27:49.765] result() for ClusterFuture ... done
[01:27:49.765] result() for ClusterFuture ...
[01:27:49.765] - result already collected: FutureResult
[01:27:49.765] result() for ClusterFuture ... done
<environment: 0x0000025b04a98458> 
*** futures() - environment ... DONE
Type of object: listenv
Type of future: multisession
[01:27:49.766] plan(): Setting new future strategy stack:
[01:27:49.766] List of future strategies:
[01:27:49.766] 1. multisession:
[01:27:49.766]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:27:49.766]    - tweaked: FALSE
[01:27:49.766]    - call: plan(strategy)
[01:27:49.767] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:27:49.767] multisession:
[01:27:49.767] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:27:49.767] - tweaked: FALSE
[01:27:49.767] - call: plan(strategy)
[01:27:49.770] getGlobalsAndPackages() ...
[01:27:49.770] Not searching for globals
[01:27:49.770] - globals: [0] <none>
[01:27:49.770] getGlobalsAndPackages() ... DONE
[01:27:49.771] [local output] makeClusterPSOCK() ...
[01:27:49.771] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:27:49.774] [local output] Base port: 29737
[01:27:49.775] [local output] Getting setup options for 2 cluster nodes ...
[01:27:49.775] [local output]  - Node 1 of 2 ...
[01:27:49.775] [local output] localMachine=TRUE => revtunnel=FALSE

[01:27:49.777] [local output] Rscript port: 29737

[01:27:49.777] [local output]  - Node 2 of 2 ...
[01:27:49.778] [local output] localMachine=TRUE => revtunnel=FALSE

[01:27:49.779] [local output] Rscript port: 29737

[01:27:49.780] [local output] Getting setup options for 2 cluster nodes ... done
[01:27:49.780] [local output]  - Parallel setup requested for some PSOCK nodes
[01:27:49.780] [local output] Setting up PSOCK nodes in parallel
[01:27:49.780] List of 36
[01:27:49.780]  $ worker          : chr "localhost"
[01:27:49.780]   ..- attr(*, "localhost")= logi TRUE
[01:27:49.780]  $ master          : chr "localhost"
[01:27:49.780]  $ port            : int 29737
[01:27:49.780]  $ connectTimeout  : num 120
[01:27:49.780]  $ timeout         : num 120
[01:27:49.780]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:27:49.780]  $ homogeneous     : logi TRUE
[01:27:49.780]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futures.R:3492:CRANWIN3:CRAN\" -"| __truncated__
[01:27:49.780]  $ rscript_envs    : NULL
[01:27:49.780]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:27:49.780]  $ rscript_startup : NULL
[01:27:49.780]  $ rscript_sh      : chr "cmd"
[01:27:49.780]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:27:49.780]  $ methods         : logi TRUE
[01:27:49.780]  $ socketOptions   : chr "no-delay"
[01:27:49.780]  $ useXDR          : logi FALSE
[01:27:49.780]  $ outfile         : chr "/dev/null"
[01:27:49.780]  $ renice          : int NA
[01:27:49.780]  $ rshcmd          : NULL
[01:27:49.780]  $ user            : chr(0) 
[01:27:49.780]  $ revtunnel       : logi FALSE
[01:27:49.780]  $ rshlogfile      : NULL
[01:27:49.780]  $ rshopts         : chr(0) 
[01:27:49.780]  $ rank            : int 1
[01:27:49.780]  $ manual          : logi FALSE
[01:27:49.780]  $ dryrun          : logi FALSE
[01:27:49.780]  $ quiet           : logi FALSE
[01:27:49.780]  $ setup_strategy  : chr "parallel"
[01:27:49.780]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:27:49.780]  $ pidfile         : chr "D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da4662d40cf.pid"
[01:27:49.780]  $ rshcmd_label    : NULL
[01:27:49.780]  $ rsh_call        : NULL
[01:27:49.780]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:27:49.780]  $ localMachine    : logi TRUE
[01:27:49.780]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:27:49.780]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:27:49.780]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:27:49.780]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:27:49.780]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:27:49.780]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:27:49.780]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:27:49.780]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:27:49.780]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:27:49.780]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:27:49.780]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:27:49.780]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:27:49.780]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:27:49.780]  $ arguments       :List of 28
[01:27:49.780]   ..$ worker          : chr "localhost"
[01:27:49.780]   ..$ master          : NULL
[01:27:49.780]   ..$ port            : int 29737
[01:27:49.780]   ..$ connectTimeout  : num 120
[01:27:49.780]   ..$ timeout         : num 120
[01:27:49.780]   ..$ rscript         : NULL
[01:27:49.780]   ..$ homogeneous     : NULL
[01:27:49.780]   ..$ rscript_args    : NULL
[01:27:49.780]   ..$ rscript_envs    : NULL
[01:27:49.780]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:27:49.780]   ..$ rscript_startup : NULL
[01:27:49.780]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:27:49.780]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:27:49.780]   ..$ methods         : logi TRUE
[01:27:49.780]   ..$ socketOptions   : chr "no-delay"
[01:27:49.780]   ..$ useXDR          : logi FALSE
[01:27:49.780]   ..$ outfile         : chr "/dev/null"
[01:27:49.780]   ..$ renice          : int NA
[01:27:49.780]   ..$ rshcmd          : NULL
[01:27:49.780]   ..$ user            : NULL
[01:27:49.780]   ..$ revtunnel       : logi NA
[01:27:49.780]   ..$ rshlogfile      : NULL
[01:27:49.780]   ..$ rshopts         : NULL
[01:27:49.780]   ..$ rank            : int 1
[01:27:49.780]   ..$ manual          : logi FALSE
[01:27:49.780]   ..$ dryrun          : logi FALSE
[01:27:49.780]   ..$ quiet           : logi FALSE
[01:27:49.780]   ..$ setup_strategy  : chr "parallel"
[01:27:49.780]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:27:49.803] [local output] System call to launch all workers:
[01:27:49.803] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futures.R:3492:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpULKOlw/worker.rank=1.parallelly.parent=3492.da4662d40cf.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=29737 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:27:49.803] [local output] Starting PSOCK main server
[01:27:49.809] [local output] Workers launched
[01:27:49.809] [local output] Waiting for workers to connect back
[01:27:49.809]  - [local output] 0 workers out of 2 ready
[01:27:49.989]  - [local output] 0 workers out of 2 ready
[01:27:49.989]  - [local output] 1 workers out of 2 ready
[01:27:49.999]  - [local output] 1 workers out of 2 ready
[01:27:50.000]  - [local output] 2 workers out of 2 ready
[01:27:50.000] [local output] Launching of workers completed
[01:27:50.000] [local output] Collecting session information from workers
[01:27:50.001] [local output]  - Worker #1 of 2
[01:27:50.001] [local output]  - Worker #2 of 2
[01:27:50.002] [local output] makeClusterPSOCK() ... done
[01:27:50.016] Packages needed by the future expression (n = 0): <none>
[01:27:50.016] Packages needed by future strategies (n = 0): <none>
[01:27:50.017] {
[01:27:50.017]     {
[01:27:50.017]         {
[01:27:50.017]             ...future.startTime <- base::Sys.time()
[01:27:50.017]             {
[01:27:50.017]                 {
[01:27:50.017]                   {
[01:27:50.017]                     {
[01:27:50.017]                       base::local({
[01:27:50.017]                         has_future <- base::requireNamespace("future", 
[01:27:50.017]                           quietly = TRUE)
[01:27:50.017]                         if (has_future) {
[01:27:50.017]                           ns <- base::getNamespace("future")
[01:27:50.017]                           version <- ns[[".package"]][["version"]]
[01:27:50.017]                           if (is.null(version)) 
[01:27:50.017]                             version <- utils::packageVersion("future")
[01:27:50.017]                         }
[01:27:50.017]                         else {
[01:27:50.017]                           version <- NULL
[01:27:50.017]                         }
[01:27:50.017]                         if (!has_future || version < "1.8.0") {
[01:27:50.017]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.017]                             "", base::R.version$version.string), 
[01:27:50.017]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.017]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.017]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.017]                               "release", "version")], collapse = " "), 
[01:27:50.017]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.017]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.017]                             info)
[01:27:50.017]                           info <- base::paste(info, collapse = "; ")
[01:27:50.017]                           if (!has_future) {
[01:27:50.017]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.017]                               info)
[01:27:50.017]                           }
[01:27:50.017]                           else {
[01:27:50.017]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.017]                               info, version)
[01:27:50.017]                           }
[01:27:50.017]                           base::stop(msg)
[01:27:50.017]                         }
[01:27:50.017]                       })
[01:27:50.017]                     }
[01:27:50.017]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.017]                     base::options(mc.cores = 1L)
[01:27:50.017]                   }
[01:27:50.017]                   options(future.plan = NULL)
[01:27:50.017]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.017]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.017]                 }
[01:27:50.017]                 ...future.workdir <- getwd()
[01:27:50.017]             }
[01:27:50.017]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.017]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.017]         }
[01:27:50.017]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.017]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.017]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.017]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.017]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.017]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.017]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.017]             base::names(...future.oldOptions))
[01:27:50.017]     }
[01:27:50.017]     if (FALSE) {
[01:27:50.017]     }
[01:27:50.017]     else {
[01:27:50.017]         if (TRUE) {
[01:27:50.017]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.017]                 open = "w")
[01:27:50.017]         }
[01:27:50.017]         else {
[01:27:50.017]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.017]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.017]         }
[01:27:50.017]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.017]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.017]             base::sink(type = "output", split = FALSE)
[01:27:50.017]             base::close(...future.stdout)
[01:27:50.017]         }, add = TRUE)
[01:27:50.017]     }
[01:27:50.017]     ...future.frame <- base::sys.nframe()
[01:27:50.017]     ...future.conditions <- base::list()
[01:27:50.017]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.017]     if (FALSE) {
[01:27:50.017]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.017]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.017]     }
[01:27:50.017]     ...future.result <- base::tryCatch({
[01:27:50.017]         base::withCallingHandlers({
[01:27:50.017]             ...future.value <- base::withVisible(base::local({
[01:27:50.017]                 ...future.makeSendCondition <- base::local({
[01:27:50.017]                   sendCondition <- NULL
[01:27:50.017]                   function(frame = 1L) {
[01:27:50.017]                     if (is.function(sendCondition)) 
[01:27:50.017]                       return(sendCondition)
[01:27:50.017]                     ns <- getNamespace("parallel")
[01:27:50.017]                     if (exists("sendData", mode = "function", 
[01:27:50.017]                       envir = ns)) {
[01:27:50.017]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.017]                         envir = ns)
[01:27:50.017]                       envir <- sys.frame(frame)
[01:27:50.017]                       master <- NULL
[01:27:50.017]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.017]                         !identical(envir, emptyenv())) {
[01:27:50.017]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.017]                           inherits = FALSE)) {
[01:27:50.017]                           master <- get("master", mode = "list", 
[01:27:50.017]                             envir = envir, inherits = FALSE)
[01:27:50.017]                           if (inherits(master, c("SOCKnode", 
[01:27:50.017]                             "SOCK0node"))) {
[01:27:50.017]                             sendCondition <<- function(cond) {
[01:27:50.017]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.017]                                 success = TRUE)
[01:27:50.017]                               parallel_sendData(master, data)
[01:27:50.017]                             }
[01:27:50.017]                             return(sendCondition)
[01:27:50.017]                           }
[01:27:50.017]                         }
[01:27:50.017]                         frame <- frame + 1L
[01:27:50.017]                         envir <- sys.frame(frame)
[01:27:50.017]                       }
[01:27:50.017]                     }
[01:27:50.017]                     sendCondition <<- function(cond) NULL
[01:27:50.017]                   }
[01:27:50.017]                 })
[01:27:50.017]                 withCallingHandlers({
[01:27:50.017]                   NA
[01:27:50.017]                 }, immediateCondition = function(cond) {
[01:27:50.017]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.017]                   sendCondition(cond)
[01:27:50.017]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.017]                   {
[01:27:50.017]                     inherits <- base::inherits
[01:27:50.017]                     invokeRestart <- base::invokeRestart
[01:27:50.017]                     is.null <- base::is.null
[01:27:50.017]                     muffled <- FALSE
[01:27:50.017]                     if (inherits(cond, "message")) {
[01:27:50.017]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.017]                       if (muffled) 
[01:27:50.017]                         invokeRestart("muffleMessage")
[01:27:50.017]                     }
[01:27:50.017]                     else if (inherits(cond, "warning")) {
[01:27:50.017]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.017]                       if (muffled) 
[01:27:50.017]                         invokeRestart("muffleWarning")
[01:27:50.017]                     }
[01:27:50.017]                     else if (inherits(cond, "condition")) {
[01:27:50.017]                       if (!is.null(pattern)) {
[01:27:50.017]                         computeRestarts <- base::computeRestarts
[01:27:50.017]                         grepl <- base::grepl
[01:27:50.017]                         restarts <- computeRestarts(cond)
[01:27:50.017]                         for (restart in restarts) {
[01:27:50.017]                           name <- restart$name
[01:27:50.017]                           if (is.null(name)) 
[01:27:50.017]                             next
[01:27:50.017]                           if (!grepl(pattern, name)) 
[01:27:50.017]                             next
[01:27:50.017]                           invokeRestart(restart)
[01:27:50.017]                           muffled <- TRUE
[01:27:50.017]                           break
[01:27:50.017]                         }
[01:27:50.017]                       }
[01:27:50.017]                     }
[01:27:50.017]                     invisible(muffled)
[01:27:50.017]                   }
[01:27:50.017]                   muffleCondition(cond)
[01:27:50.017]                 })
[01:27:50.017]             }))
[01:27:50.017]             future::FutureResult(value = ...future.value$value, 
[01:27:50.017]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.017]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.017]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.017]                     ...future.globalenv.names))
[01:27:50.017]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.017]         }, condition = base::local({
[01:27:50.017]             c <- base::c
[01:27:50.017]             inherits <- base::inherits
[01:27:50.017]             invokeRestart <- base::invokeRestart
[01:27:50.017]             length <- base::length
[01:27:50.017]             list <- base::list
[01:27:50.017]             seq.int <- base::seq.int
[01:27:50.017]             signalCondition <- base::signalCondition
[01:27:50.017]             sys.calls <- base::sys.calls
[01:27:50.017]             `[[` <- base::`[[`
[01:27:50.017]             `+` <- base::`+`
[01:27:50.017]             `<<-` <- base::`<<-`
[01:27:50.017]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.017]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.017]                   3L)]
[01:27:50.017]             }
[01:27:50.017]             function(cond) {
[01:27:50.017]                 is_error <- inherits(cond, "error")
[01:27:50.017]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.017]                   NULL)
[01:27:50.017]                 if (is_error) {
[01:27:50.017]                   sessionInformation <- function() {
[01:27:50.017]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.017]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.017]                       search = base::search(), system = base::Sys.info())
[01:27:50.017]                   }
[01:27:50.017]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.017]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.017]                     cond$call), session = sessionInformation(), 
[01:27:50.017]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.017]                   signalCondition(cond)
[01:27:50.017]                 }
[01:27:50.017]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.017]                 "immediateCondition"))) {
[01:27:50.017]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.017]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.017]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.017]                   if (TRUE && !signal) {
[01:27:50.017]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.017]                     {
[01:27:50.017]                       inherits <- base::inherits
[01:27:50.017]                       invokeRestart <- base::invokeRestart
[01:27:50.017]                       is.null <- base::is.null
[01:27:50.017]                       muffled <- FALSE
[01:27:50.017]                       if (inherits(cond, "message")) {
[01:27:50.017]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.017]                         if (muffled) 
[01:27:50.017]                           invokeRestart("muffleMessage")
[01:27:50.017]                       }
[01:27:50.017]                       else if (inherits(cond, "warning")) {
[01:27:50.017]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.017]                         if (muffled) 
[01:27:50.017]                           invokeRestart("muffleWarning")
[01:27:50.017]                       }
[01:27:50.017]                       else if (inherits(cond, "condition")) {
[01:27:50.017]                         if (!is.null(pattern)) {
[01:27:50.017]                           computeRestarts <- base::computeRestarts
[01:27:50.017]                           grepl <- base::grepl
[01:27:50.017]                           restarts <- computeRestarts(cond)
[01:27:50.017]                           for (restart in restarts) {
[01:27:50.017]                             name <- restart$name
[01:27:50.017]                             if (is.null(name)) 
[01:27:50.017]                               next
[01:27:50.017]                             if (!grepl(pattern, name)) 
[01:27:50.017]                               next
[01:27:50.017]                             invokeRestart(restart)
[01:27:50.017]                             muffled <- TRUE
[01:27:50.017]                             break
[01:27:50.017]                           }
[01:27:50.017]                         }
[01:27:50.017]                       }
[01:27:50.017]                       invisible(muffled)
[01:27:50.017]                     }
[01:27:50.017]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.017]                   }
[01:27:50.017]                 }
[01:27:50.017]                 else {
[01:27:50.017]                   if (TRUE) {
[01:27:50.017]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.017]                     {
[01:27:50.017]                       inherits <- base::inherits
[01:27:50.017]                       invokeRestart <- base::invokeRestart
[01:27:50.017]                       is.null <- base::is.null
[01:27:50.017]                       muffled <- FALSE
[01:27:50.017]                       if (inherits(cond, "message")) {
[01:27:50.017]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.017]                         if (muffled) 
[01:27:50.017]                           invokeRestart("muffleMessage")
[01:27:50.017]                       }
[01:27:50.017]                       else if (inherits(cond, "warning")) {
[01:27:50.017]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.017]                         if (muffled) 
[01:27:50.017]                           invokeRestart("muffleWarning")
[01:27:50.017]                       }
[01:27:50.017]                       else if (inherits(cond, "condition")) {
[01:27:50.017]                         if (!is.null(pattern)) {
[01:27:50.017]                           computeRestarts <- base::computeRestarts
[01:27:50.017]                           grepl <- base::grepl
[01:27:50.017]                           restarts <- computeRestarts(cond)
[01:27:50.017]                           for (restart in restarts) {
[01:27:50.017]                             name <- restart$name
[01:27:50.017]                             if (is.null(name)) 
[01:27:50.017]                               next
[01:27:50.017]                             if (!grepl(pattern, name)) 
[01:27:50.017]                               next
[01:27:50.017]                             invokeRestart(restart)
[01:27:50.017]                             muffled <- TRUE
[01:27:50.017]                             break
[01:27:50.017]                           }
[01:27:50.017]                         }
[01:27:50.017]                       }
[01:27:50.017]                       invisible(muffled)
[01:27:50.017]                     }
[01:27:50.017]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.017]                   }
[01:27:50.017]                 }
[01:27:50.017]             }
[01:27:50.017]         }))
[01:27:50.017]     }, error = function(ex) {
[01:27:50.017]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.017]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.017]                 ...future.rng), started = ...future.startTime, 
[01:27:50.017]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.017]             version = "1.8"), class = "FutureResult")
[01:27:50.017]     }, finally = {
[01:27:50.017]         if (!identical(...future.workdir, getwd())) 
[01:27:50.017]             setwd(...future.workdir)
[01:27:50.017]         {
[01:27:50.017]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.017]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.017]             }
[01:27:50.017]             base::options(...future.oldOptions)
[01:27:50.017]             if (.Platform$OS.type == "windows") {
[01:27:50.017]                 old_names <- names(...future.oldEnvVars)
[01:27:50.017]                 envs <- base::Sys.getenv()
[01:27:50.017]                 names <- names(envs)
[01:27:50.017]                 common <- intersect(names, old_names)
[01:27:50.017]                 added <- setdiff(names, old_names)
[01:27:50.017]                 removed <- setdiff(old_names, names)
[01:27:50.017]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.017]                   envs[common]]
[01:27:50.017]                 NAMES <- toupper(changed)
[01:27:50.017]                 args <- list()
[01:27:50.017]                 for (kk in seq_along(NAMES)) {
[01:27:50.017]                   name <- changed[[kk]]
[01:27:50.017]                   NAME <- NAMES[[kk]]
[01:27:50.017]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.017]                     next
[01:27:50.017]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.017]                 }
[01:27:50.017]                 NAMES <- toupper(added)
[01:27:50.017]                 for (kk in seq_along(NAMES)) {
[01:27:50.017]                   name <- added[[kk]]
[01:27:50.017]                   NAME <- NAMES[[kk]]
[01:27:50.017]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.017]                     next
[01:27:50.017]                   args[[name]] <- ""
[01:27:50.017]                 }
[01:27:50.017]                 NAMES <- toupper(removed)
[01:27:50.017]                 for (kk in seq_along(NAMES)) {
[01:27:50.017]                   name <- removed[[kk]]
[01:27:50.017]                   NAME <- NAMES[[kk]]
[01:27:50.017]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.017]                     next
[01:27:50.017]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.017]                 }
[01:27:50.017]                 if (length(args) > 0) 
[01:27:50.017]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.017]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.017]             }
[01:27:50.017]             else {
[01:27:50.017]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.017]             }
[01:27:50.017]             {
[01:27:50.017]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.017]                   0L) {
[01:27:50.017]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.017]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.017]                   base::options(opts)
[01:27:50.017]                 }
[01:27:50.017]                 {
[01:27:50.017]                   {
[01:27:50.017]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.017]                     NULL
[01:27:50.017]                   }
[01:27:50.017]                   options(future.plan = NULL)
[01:27:50.017]                   if (is.na(NA_character_)) 
[01:27:50.017]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.017]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.017]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.017]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.017]                     envir = parent.frame()) 
[01:27:50.017]                   {
[01:27:50.017]                     if (is.function(workers)) 
[01:27:50.017]                       workers <- workers()
[01:27:50.017]                     workers <- structure(as.integer(workers), 
[01:27:50.017]                       class = class(workers))
[01:27:50.017]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.017]                       workers >= 1)
[01:27:50.017]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.017]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.017]                     }
[01:27:50.017]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.017]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.017]                       envir = envir)
[01:27:50.017]                     if (!future$lazy) 
[01:27:50.017]                       future <- run(future)
[01:27:50.017]                     invisible(future)
[01:27:50.017]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.017]                 }
[01:27:50.017]             }
[01:27:50.017]         }
[01:27:50.017]     })
[01:27:50.017]     if (TRUE) {
[01:27:50.017]         base::sink(type = "output", split = FALSE)
[01:27:50.017]         if (TRUE) {
[01:27:50.017]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.017]         }
[01:27:50.017]         else {
[01:27:50.017]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.017]         }
[01:27:50.017]         base::close(...future.stdout)
[01:27:50.017]         ...future.stdout <- NULL
[01:27:50.017]     }
[01:27:50.017]     ...future.result$conditions <- ...future.conditions
[01:27:50.017]     ...future.result$finished <- base::Sys.time()
[01:27:50.017]     ...future.result
[01:27:50.017] }
[01:27:50.097] MultisessionFuture started
[01:27:50.097] result() for ClusterFuture ...
[01:27:50.097] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.097] - Validating connection of MultisessionFuture
[01:27:50.155] - received message: FutureResult
[01:27:50.155] - Received FutureResult
[01:27:50.155] - Erased future from FutureRegistry
[01:27:50.156] result() for ClusterFuture ...
[01:27:50.156] - result already collected: FutureResult
[01:27:50.162] result() for ClusterFuture ... done
[01:27:50.162] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.162] result() for ClusterFuture ... done
[01:27:50.162] result() for ClusterFuture ...
[01:27:50.162] - result already collected: FutureResult
[01:27:50.163] result() for ClusterFuture ... done
[01:27:50.163] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:27:50.165] plan(): nbrOfWorkers() = 2
Dimensions: NULL
[01:27:50.166] getGlobalsAndPackages() ...
[01:27:50.166] Searching for globals...
[01:27:50.166] 
[01:27:50.166] Searching for globals ... DONE
[01:27:50.167] - globals: [0] <none>
[01:27:50.167] getGlobalsAndPackages() ... DONE
[01:27:50.167] run() for 'Future' ...
[01:27:50.167] - state: 'created'
[01:27:50.168] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.182] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.182] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.182]   - Field: 'node'
[01:27:50.182]   - Field: 'label'
[01:27:50.182]   - Field: 'local'
[01:27:50.183]   - Field: 'owner'
[01:27:50.183]   - Field: 'envir'
[01:27:50.183]   - Field: 'workers'
[01:27:50.183]   - Field: 'packages'
[01:27:50.183]   - Field: 'gc'
[01:27:50.183]   - Field: 'conditions'
[01:27:50.184]   - Field: 'persistent'
[01:27:50.184]   - Field: 'expr'
[01:27:50.184]   - Field: 'uuid'
[01:27:50.184]   - Field: 'seed'
[01:27:50.184]   - Field: 'version'
[01:27:50.184]   - Field: 'result'
[01:27:50.185]   - Field: 'asynchronous'
[01:27:50.185]   - Field: 'calls'
[01:27:50.185]   - Field: 'globals'
[01:27:50.185]   - Field: 'stdout'
[01:27:50.185]   - Field: 'earlySignal'
[01:27:50.186]   - Field: 'lazy'
[01:27:50.186]   - Field: 'state'
[01:27:50.186] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.186] - Launch lazy future ...
[01:27:50.186] Packages needed by the future expression (n = 0): <none>
[01:27:50.187] Packages needed by future strategies (n = 0): <none>
[01:27:50.187] {
[01:27:50.187]     {
[01:27:50.187]         {
[01:27:50.187]             ...future.startTime <- base::Sys.time()
[01:27:50.187]             {
[01:27:50.187]                 {
[01:27:50.187]                   {
[01:27:50.187]                     {
[01:27:50.187]                       base::local({
[01:27:50.187]                         has_future <- base::requireNamespace("future", 
[01:27:50.187]                           quietly = TRUE)
[01:27:50.187]                         if (has_future) {
[01:27:50.187]                           ns <- base::getNamespace("future")
[01:27:50.187]                           version <- ns[[".package"]][["version"]]
[01:27:50.187]                           if (is.null(version)) 
[01:27:50.187]                             version <- utils::packageVersion("future")
[01:27:50.187]                         }
[01:27:50.187]                         else {
[01:27:50.187]                           version <- NULL
[01:27:50.187]                         }
[01:27:50.187]                         if (!has_future || version < "1.8.0") {
[01:27:50.187]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.187]                             "", base::R.version$version.string), 
[01:27:50.187]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.187]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.187]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.187]                               "release", "version")], collapse = " "), 
[01:27:50.187]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.187]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.187]                             info)
[01:27:50.187]                           info <- base::paste(info, collapse = "; ")
[01:27:50.187]                           if (!has_future) {
[01:27:50.187]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.187]                               info)
[01:27:50.187]                           }
[01:27:50.187]                           else {
[01:27:50.187]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.187]                               info, version)
[01:27:50.187]                           }
[01:27:50.187]                           base::stop(msg)
[01:27:50.187]                         }
[01:27:50.187]                       })
[01:27:50.187]                     }
[01:27:50.187]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.187]                     base::options(mc.cores = 1L)
[01:27:50.187]                   }
[01:27:50.187]                   options(future.plan = NULL)
[01:27:50.187]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.187]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.187]                 }
[01:27:50.187]                 ...future.workdir <- getwd()
[01:27:50.187]             }
[01:27:50.187]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.187]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.187]         }
[01:27:50.187]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.187]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.187]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.187]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.187]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.187]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.187]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.187]             base::names(...future.oldOptions))
[01:27:50.187]     }
[01:27:50.187]     if (FALSE) {
[01:27:50.187]     }
[01:27:50.187]     else {
[01:27:50.187]         if (TRUE) {
[01:27:50.187]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.187]                 open = "w")
[01:27:50.187]         }
[01:27:50.187]         else {
[01:27:50.187]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.187]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.187]         }
[01:27:50.187]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.187]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.187]             base::sink(type = "output", split = FALSE)
[01:27:50.187]             base::close(...future.stdout)
[01:27:50.187]         }, add = TRUE)
[01:27:50.187]     }
[01:27:50.187]     ...future.frame <- base::sys.nframe()
[01:27:50.187]     ...future.conditions <- base::list()
[01:27:50.187]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.187]     if (FALSE) {
[01:27:50.187]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.187]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.187]     }
[01:27:50.187]     ...future.result <- base::tryCatch({
[01:27:50.187]         base::withCallingHandlers({
[01:27:50.187]             ...future.value <- base::withVisible(base::local({
[01:27:50.187]                 ...future.makeSendCondition <- base::local({
[01:27:50.187]                   sendCondition <- NULL
[01:27:50.187]                   function(frame = 1L) {
[01:27:50.187]                     if (is.function(sendCondition)) 
[01:27:50.187]                       return(sendCondition)
[01:27:50.187]                     ns <- getNamespace("parallel")
[01:27:50.187]                     if (exists("sendData", mode = "function", 
[01:27:50.187]                       envir = ns)) {
[01:27:50.187]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.187]                         envir = ns)
[01:27:50.187]                       envir <- sys.frame(frame)
[01:27:50.187]                       master <- NULL
[01:27:50.187]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.187]                         !identical(envir, emptyenv())) {
[01:27:50.187]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.187]                           inherits = FALSE)) {
[01:27:50.187]                           master <- get("master", mode = "list", 
[01:27:50.187]                             envir = envir, inherits = FALSE)
[01:27:50.187]                           if (inherits(master, c("SOCKnode", 
[01:27:50.187]                             "SOCK0node"))) {
[01:27:50.187]                             sendCondition <<- function(cond) {
[01:27:50.187]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.187]                                 success = TRUE)
[01:27:50.187]                               parallel_sendData(master, data)
[01:27:50.187]                             }
[01:27:50.187]                             return(sendCondition)
[01:27:50.187]                           }
[01:27:50.187]                         }
[01:27:50.187]                         frame <- frame + 1L
[01:27:50.187]                         envir <- sys.frame(frame)
[01:27:50.187]                       }
[01:27:50.187]                     }
[01:27:50.187]                     sendCondition <<- function(cond) NULL
[01:27:50.187]                   }
[01:27:50.187]                 })
[01:27:50.187]                 withCallingHandlers({
[01:27:50.187]                   2
[01:27:50.187]                 }, immediateCondition = function(cond) {
[01:27:50.187]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.187]                   sendCondition(cond)
[01:27:50.187]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.187]                   {
[01:27:50.187]                     inherits <- base::inherits
[01:27:50.187]                     invokeRestart <- base::invokeRestart
[01:27:50.187]                     is.null <- base::is.null
[01:27:50.187]                     muffled <- FALSE
[01:27:50.187]                     if (inherits(cond, "message")) {
[01:27:50.187]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.187]                       if (muffled) 
[01:27:50.187]                         invokeRestart("muffleMessage")
[01:27:50.187]                     }
[01:27:50.187]                     else if (inherits(cond, "warning")) {
[01:27:50.187]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.187]                       if (muffled) 
[01:27:50.187]                         invokeRestart("muffleWarning")
[01:27:50.187]                     }
[01:27:50.187]                     else if (inherits(cond, "condition")) {
[01:27:50.187]                       if (!is.null(pattern)) {
[01:27:50.187]                         computeRestarts <- base::computeRestarts
[01:27:50.187]                         grepl <- base::grepl
[01:27:50.187]                         restarts <- computeRestarts(cond)
[01:27:50.187]                         for (restart in restarts) {
[01:27:50.187]                           name <- restart$name
[01:27:50.187]                           if (is.null(name)) 
[01:27:50.187]                             next
[01:27:50.187]                           if (!grepl(pattern, name)) 
[01:27:50.187]                             next
[01:27:50.187]                           invokeRestart(restart)
[01:27:50.187]                           muffled <- TRUE
[01:27:50.187]                           break
[01:27:50.187]                         }
[01:27:50.187]                       }
[01:27:50.187]                     }
[01:27:50.187]                     invisible(muffled)
[01:27:50.187]                   }
[01:27:50.187]                   muffleCondition(cond)
[01:27:50.187]                 })
[01:27:50.187]             }))
[01:27:50.187]             future::FutureResult(value = ...future.value$value, 
[01:27:50.187]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.187]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.187]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.187]                     ...future.globalenv.names))
[01:27:50.187]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.187]         }, condition = base::local({
[01:27:50.187]             c <- base::c
[01:27:50.187]             inherits <- base::inherits
[01:27:50.187]             invokeRestart <- base::invokeRestart
[01:27:50.187]             length <- base::length
[01:27:50.187]             list <- base::list
[01:27:50.187]             seq.int <- base::seq.int
[01:27:50.187]             signalCondition <- base::signalCondition
[01:27:50.187]             sys.calls <- base::sys.calls
[01:27:50.187]             `[[` <- base::`[[`
[01:27:50.187]             `+` <- base::`+`
[01:27:50.187]             `<<-` <- base::`<<-`
[01:27:50.187]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.187]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.187]                   3L)]
[01:27:50.187]             }
[01:27:50.187]             function(cond) {
[01:27:50.187]                 is_error <- inherits(cond, "error")
[01:27:50.187]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.187]                   NULL)
[01:27:50.187]                 if (is_error) {
[01:27:50.187]                   sessionInformation <- function() {
[01:27:50.187]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.187]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.187]                       search = base::search(), system = base::Sys.info())
[01:27:50.187]                   }
[01:27:50.187]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.187]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.187]                     cond$call), session = sessionInformation(), 
[01:27:50.187]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.187]                   signalCondition(cond)
[01:27:50.187]                 }
[01:27:50.187]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.187]                 "immediateCondition"))) {
[01:27:50.187]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.187]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.187]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.187]                   if (TRUE && !signal) {
[01:27:50.187]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.187]                     {
[01:27:50.187]                       inherits <- base::inherits
[01:27:50.187]                       invokeRestart <- base::invokeRestart
[01:27:50.187]                       is.null <- base::is.null
[01:27:50.187]                       muffled <- FALSE
[01:27:50.187]                       if (inherits(cond, "message")) {
[01:27:50.187]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.187]                         if (muffled) 
[01:27:50.187]                           invokeRestart("muffleMessage")
[01:27:50.187]                       }
[01:27:50.187]                       else if (inherits(cond, "warning")) {
[01:27:50.187]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.187]                         if (muffled) 
[01:27:50.187]                           invokeRestart("muffleWarning")
[01:27:50.187]                       }
[01:27:50.187]                       else if (inherits(cond, "condition")) {
[01:27:50.187]                         if (!is.null(pattern)) {
[01:27:50.187]                           computeRestarts <- base::computeRestarts
[01:27:50.187]                           grepl <- base::grepl
[01:27:50.187]                           restarts <- computeRestarts(cond)
[01:27:50.187]                           for (restart in restarts) {
[01:27:50.187]                             name <- restart$name
[01:27:50.187]                             if (is.null(name)) 
[01:27:50.187]                               next
[01:27:50.187]                             if (!grepl(pattern, name)) 
[01:27:50.187]                               next
[01:27:50.187]                             invokeRestart(restart)
[01:27:50.187]                             muffled <- TRUE
[01:27:50.187]                             break
[01:27:50.187]                           }
[01:27:50.187]                         }
[01:27:50.187]                       }
[01:27:50.187]                       invisible(muffled)
[01:27:50.187]                     }
[01:27:50.187]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.187]                   }
[01:27:50.187]                 }
[01:27:50.187]                 else {
[01:27:50.187]                   if (TRUE) {
[01:27:50.187]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.187]                     {
[01:27:50.187]                       inherits <- base::inherits
[01:27:50.187]                       invokeRestart <- base::invokeRestart
[01:27:50.187]                       is.null <- base::is.null
[01:27:50.187]                       muffled <- FALSE
[01:27:50.187]                       if (inherits(cond, "message")) {
[01:27:50.187]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.187]                         if (muffled) 
[01:27:50.187]                           invokeRestart("muffleMessage")
[01:27:50.187]                       }
[01:27:50.187]                       else if (inherits(cond, "warning")) {
[01:27:50.187]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.187]                         if (muffled) 
[01:27:50.187]                           invokeRestart("muffleWarning")
[01:27:50.187]                       }
[01:27:50.187]                       else if (inherits(cond, "condition")) {
[01:27:50.187]                         if (!is.null(pattern)) {
[01:27:50.187]                           computeRestarts <- base::computeRestarts
[01:27:50.187]                           grepl <- base::grepl
[01:27:50.187]                           restarts <- computeRestarts(cond)
[01:27:50.187]                           for (restart in restarts) {
[01:27:50.187]                             name <- restart$name
[01:27:50.187]                             if (is.null(name)) 
[01:27:50.187]                               next
[01:27:50.187]                             if (!grepl(pattern, name)) 
[01:27:50.187]                               next
[01:27:50.187]                             invokeRestart(restart)
[01:27:50.187]                             muffled <- TRUE
[01:27:50.187]                             break
[01:27:50.187]                           }
[01:27:50.187]                         }
[01:27:50.187]                       }
[01:27:50.187]                       invisible(muffled)
[01:27:50.187]                     }
[01:27:50.187]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.187]                   }
[01:27:50.187]                 }
[01:27:50.187]             }
[01:27:50.187]         }))
[01:27:50.187]     }, error = function(ex) {
[01:27:50.187]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.187]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.187]                 ...future.rng), started = ...future.startTime, 
[01:27:50.187]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.187]             version = "1.8"), class = "FutureResult")
[01:27:50.187]     }, finally = {
[01:27:50.187]         if (!identical(...future.workdir, getwd())) 
[01:27:50.187]             setwd(...future.workdir)
[01:27:50.187]         {
[01:27:50.187]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.187]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.187]             }
[01:27:50.187]             base::options(...future.oldOptions)
[01:27:50.187]             if (.Platform$OS.type == "windows") {
[01:27:50.187]                 old_names <- names(...future.oldEnvVars)
[01:27:50.187]                 envs <- base::Sys.getenv()
[01:27:50.187]                 names <- names(envs)
[01:27:50.187]                 common <- intersect(names, old_names)
[01:27:50.187]                 added <- setdiff(names, old_names)
[01:27:50.187]                 removed <- setdiff(old_names, names)
[01:27:50.187]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.187]                   envs[common]]
[01:27:50.187]                 NAMES <- toupper(changed)
[01:27:50.187]                 args <- list()
[01:27:50.187]                 for (kk in seq_along(NAMES)) {
[01:27:50.187]                   name <- changed[[kk]]
[01:27:50.187]                   NAME <- NAMES[[kk]]
[01:27:50.187]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.187]                     next
[01:27:50.187]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.187]                 }
[01:27:50.187]                 NAMES <- toupper(added)
[01:27:50.187]                 for (kk in seq_along(NAMES)) {
[01:27:50.187]                   name <- added[[kk]]
[01:27:50.187]                   NAME <- NAMES[[kk]]
[01:27:50.187]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.187]                     next
[01:27:50.187]                   args[[name]] <- ""
[01:27:50.187]                 }
[01:27:50.187]                 NAMES <- toupper(removed)
[01:27:50.187]                 for (kk in seq_along(NAMES)) {
[01:27:50.187]                   name <- removed[[kk]]
[01:27:50.187]                   NAME <- NAMES[[kk]]
[01:27:50.187]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.187]                     next
[01:27:50.187]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.187]                 }
[01:27:50.187]                 if (length(args) > 0) 
[01:27:50.187]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.187]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.187]             }
[01:27:50.187]             else {
[01:27:50.187]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.187]             }
[01:27:50.187]             {
[01:27:50.187]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.187]                   0L) {
[01:27:50.187]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.187]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.187]                   base::options(opts)
[01:27:50.187]                 }
[01:27:50.187]                 {
[01:27:50.187]                   {
[01:27:50.187]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.187]                     NULL
[01:27:50.187]                   }
[01:27:50.187]                   options(future.plan = NULL)
[01:27:50.187]                   if (is.na(NA_character_)) 
[01:27:50.187]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.187]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.187]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.187]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.187]                     envir = parent.frame()) 
[01:27:50.187]                   {
[01:27:50.187]                     if (is.function(workers)) 
[01:27:50.187]                       workers <- workers()
[01:27:50.187]                     workers <- structure(as.integer(workers), 
[01:27:50.187]                       class = class(workers))
[01:27:50.187]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.187]                       workers >= 1)
[01:27:50.187]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.187]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.187]                     }
[01:27:50.187]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.187]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.187]                       envir = envir)
[01:27:50.187]                     if (!future$lazy) 
[01:27:50.187]                       future <- run(future)
[01:27:50.187]                     invisible(future)
[01:27:50.187]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.187]                 }
[01:27:50.187]             }
[01:27:50.187]         }
[01:27:50.187]     })
[01:27:50.187]     if (TRUE) {
[01:27:50.187]         base::sink(type = "output", split = FALSE)
[01:27:50.187]         if (TRUE) {
[01:27:50.187]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.187]         }
[01:27:50.187]         else {
[01:27:50.187]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.187]         }
[01:27:50.187]         base::close(...future.stdout)
[01:27:50.187]         ...future.stdout <- NULL
[01:27:50.187]     }
[01:27:50.187]     ...future.result$conditions <- ...future.conditions
[01:27:50.187]     ...future.result$finished <- base::Sys.time()
[01:27:50.187]     ...future.result
[01:27:50.187] }
[01:27:50.193] MultisessionFuture started
[01:27:50.193] - Launch lazy future ... done
[01:27:50.194] run() for 'MultisessionFuture' ... done
[01:27:50.194] getGlobalsAndPackages() ...
[01:27:50.194] Searching for globals...
[01:27:50.194] 
[01:27:50.195] Searching for globals ... DONE
[01:27:50.195] - globals: [0] <none>
[01:27:50.195] getGlobalsAndPackages() ... DONE
[01:27:50.195] run() for 'Future' ...
[01:27:50.195] - state: 'created'
[01:27:50.196] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.209] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.210] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.210]   - Field: 'node'
[01:27:50.210]   - Field: 'label'
[01:27:50.210]   - Field: 'local'
[01:27:50.210]   - Field: 'owner'
[01:27:50.210]   - Field: 'envir'
[01:27:50.211]   - Field: 'workers'
[01:27:50.211]   - Field: 'packages'
[01:27:50.211]   - Field: 'gc'
[01:27:50.211]   - Field: 'conditions'
[01:27:50.211]   - Field: 'persistent'
[01:27:50.212]   - Field: 'expr'
[01:27:50.212]   - Field: 'uuid'
[01:27:50.212]   - Field: 'seed'
[01:27:50.212]   - Field: 'version'
[01:27:50.212]   - Field: 'result'
[01:27:50.213]   - Field: 'asynchronous'
[01:27:50.213]   - Field: 'calls'
[01:27:50.213]   - Field: 'globals'
[01:27:50.213]   - Field: 'stdout'
[01:27:50.213]   - Field: 'earlySignal'
[01:27:50.213]   - Field: 'lazy'
[01:27:50.214]   - Field: 'state'
[01:27:50.214] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.214] - Launch lazy future ...
[01:27:50.214] Packages needed by the future expression (n = 0): <none>
[01:27:50.215] Packages needed by future strategies (n = 0): <none>
[01:27:50.215] {
[01:27:50.215]     {
[01:27:50.215]         {
[01:27:50.215]             ...future.startTime <- base::Sys.time()
[01:27:50.215]             {
[01:27:50.215]                 {
[01:27:50.215]                   {
[01:27:50.215]                     {
[01:27:50.215]                       base::local({
[01:27:50.215]                         has_future <- base::requireNamespace("future", 
[01:27:50.215]                           quietly = TRUE)
[01:27:50.215]                         if (has_future) {
[01:27:50.215]                           ns <- base::getNamespace("future")
[01:27:50.215]                           version <- ns[[".package"]][["version"]]
[01:27:50.215]                           if (is.null(version)) 
[01:27:50.215]                             version <- utils::packageVersion("future")
[01:27:50.215]                         }
[01:27:50.215]                         else {
[01:27:50.215]                           version <- NULL
[01:27:50.215]                         }
[01:27:50.215]                         if (!has_future || version < "1.8.0") {
[01:27:50.215]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.215]                             "", base::R.version$version.string), 
[01:27:50.215]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.215]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.215]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.215]                               "release", "version")], collapse = " "), 
[01:27:50.215]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.215]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.215]                             info)
[01:27:50.215]                           info <- base::paste(info, collapse = "; ")
[01:27:50.215]                           if (!has_future) {
[01:27:50.215]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.215]                               info)
[01:27:50.215]                           }
[01:27:50.215]                           else {
[01:27:50.215]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.215]                               info, version)
[01:27:50.215]                           }
[01:27:50.215]                           base::stop(msg)
[01:27:50.215]                         }
[01:27:50.215]                       })
[01:27:50.215]                     }
[01:27:50.215]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.215]                     base::options(mc.cores = 1L)
[01:27:50.215]                   }
[01:27:50.215]                   options(future.plan = NULL)
[01:27:50.215]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.215]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.215]                 }
[01:27:50.215]                 ...future.workdir <- getwd()
[01:27:50.215]             }
[01:27:50.215]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.215]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.215]         }
[01:27:50.215]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.215]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.215]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.215]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.215]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.215]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.215]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.215]             base::names(...future.oldOptions))
[01:27:50.215]     }
[01:27:50.215]     if (FALSE) {
[01:27:50.215]     }
[01:27:50.215]     else {
[01:27:50.215]         if (TRUE) {
[01:27:50.215]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.215]                 open = "w")
[01:27:50.215]         }
[01:27:50.215]         else {
[01:27:50.215]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.215]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.215]         }
[01:27:50.215]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.215]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.215]             base::sink(type = "output", split = FALSE)
[01:27:50.215]             base::close(...future.stdout)
[01:27:50.215]         }, add = TRUE)
[01:27:50.215]     }
[01:27:50.215]     ...future.frame <- base::sys.nframe()
[01:27:50.215]     ...future.conditions <- base::list()
[01:27:50.215]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.215]     if (FALSE) {
[01:27:50.215]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.215]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.215]     }
[01:27:50.215]     ...future.result <- base::tryCatch({
[01:27:50.215]         base::withCallingHandlers({
[01:27:50.215]             ...future.value <- base::withVisible(base::local({
[01:27:50.215]                 ...future.makeSendCondition <- base::local({
[01:27:50.215]                   sendCondition <- NULL
[01:27:50.215]                   function(frame = 1L) {
[01:27:50.215]                     if (is.function(sendCondition)) 
[01:27:50.215]                       return(sendCondition)
[01:27:50.215]                     ns <- getNamespace("parallel")
[01:27:50.215]                     if (exists("sendData", mode = "function", 
[01:27:50.215]                       envir = ns)) {
[01:27:50.215]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.215]                         envir = ns)
[01:27:50.215]                       envir <- sys.frame(frame)
[01:27:50.215]                       master <- NULL
[01:27:50.215]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.215]                         !identical(envir, emptyenv())) {
[01:27:50.215]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.215]                           inherits = FALSE)) {
[01:27:50.215]                           master <- get("master", mode = "list", 
[01:27:50.215]                             envir = envir, inherits = FALSE)
[01:27:50.215]                           if (inherits(master, c("SOCKnode", 
[01:27:50.215]                             "SOCK0node"))) {
[01:27:50.215]                             sendCondition <<- function(cond) {
[01:27:50.215]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.215]                                 success = TRUE)
[01:27:50.215]                               parallel_sendData(master, data)
[01:27:50.215]                             }
[01:27:50.215]                             return(sendCondition)
[01:27:50.215]                           }
[01:27:50.215]                         }
[01:27:50.215]                         frame <- frame + 1L
[01:27:50.215]                         envir <- sys.frame(frame)
[01:27:50.215]                       }
[01:27:50.215]                     }
[01:27:50.215]                     sendCondition <<- function(cond) NULL
[01:27:50.215]                   }
[01:27:50.215]                 })
[01:27:50.215]                 withCallingHandlers({
[01:27:50.215]                   NULL
[01:27:50.215]                 }, immediateCondition = function(cond) {
[01:27:50.215]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.215]                   sendCondition(cond)
[01:27:50.215]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.215]                   {
[01:27:50.215]                     inherits <- base::inherits
[01:27:50.215]                     invokeRestart <- base::invokeRestart
[01:27:50.215]                     is.null <- base::is.null
[01:27:50.215]                     muffled <- FALSE
[01:27:50.215]                     if (inherits(cond, "message")) {
[01:27:50.215]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.215]                       if (muffled) 
[01:27:50.215]                         invokeRestart("muffleMessage")
[01:27:50.215]                     }
[01:27:50.215]                     else if (inherits(cond, "warning")) {
[01:27:50.215]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.215]                       if (muffled) 
[01:27:50.215]                         invokeRestart("muffleWarning")
[01:27:50.215]                     }
[01:27:50.215]                     else if (inherits(cond, "condition")) {
[01:27:50.215]                       if (!is.null(pattern)) {
[01:27:50.215]                         computeRestarts <- base::computeRestarts
[01:27:50.215]                         grepl <- base::grepl
[01:27:50.215]                         restarts <- computeRestarts(cond)
[01:27:50.215]                         for (restart in restarts) {
[01:27:50.215]                           name <- restart$name
[01:27:50.215]                           if (is.null(name)) 
[01:27:50.215]                             next
[01:27:50.215]                           if (!grepl(pattern, name)) 
[01:27:50.215]                             next
[01:27:50.215]                           invokeRestart(restart)
[01:27:50.215]                           muffled <- TRUE
[01:27:50.215]                           break
[01:27:50.215]                         }
[01:27:50.215]                       }
[01:27:50.215]                     }
[01:27:50.215]                     invisible(muffled)
[01:27:50.215]                   }
[01:27:50.215]                   muffleCondition(cond)
[01:27:50.215]                 })
[01:27:50.215]             }))
[01:27:50.215]             future::FutureResult(value = ...future.value$value, 
[01:27:50.215]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.215]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.215]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.215]                     ...future.globalenv.names))
[01:27:50.215]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.215]         }, condition = base::local({
[01:27:50.215]             c <- base::c
[01:27:50.215]             inherits <- base::inherits
[01:27:50.215]             invokeRestart <- base::invokeRestart
[01:27:50.215]             length <- base::length
[01:27:50.215]             list <- base::list
[01:27:50.215]             seq.int <- base::seq.int
[01:27:50.215]             signalCondition <- base::signalCondition
[01:27:50.215]             sys.calls <- base::sys.calls
[01:27:50.215]             `[[` <- base::`[[`
[01:27:50.215]             `+` <- base::`+`
[01:27:50.215]             `<<-` <- base::`<<-`
[01:27:50.215]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.215]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.215]                   3L)]
[01:27:50.215]             }
[01:27:50.215]             function(cond) {
[01:27:50.215]                 is_error <- inherits(cond, "error")
[01:27:50.215]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.215]                   NULL)
[01:27:50.215]                 if (is_error) {
[01:27:50.215]                   sessionInformation <- function() {
[01:27:50.215]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.215]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.215]                       search = base::search(), system = base::Sys.info())
[01:27:50.215]                   }
[01:27:50.215]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.215]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.215]                     cond$call), session = sessionInformation(), 
[01:27:50.215]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.215]                   signalCondition(cond)
[01:27:50.215]                 }
[01:27:50.215]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.215]                 "immediateCondition"))) {
[01:27:50.215]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.215]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.215]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.215]                   if (TRUE && !signal) {
[01:27:50.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.215]                     {
[01:27:50.215]                       inherits <- base::inherits
[01:27:50.215]                       invokeRestart <- base::invokeRestart
[01:27:50.215]                       is.null <- base::is.null
[01:27:50.215]                       muffled <- FALSE
[01:27:50.215]                       if (inherits(cond, "message")) {
[01:27:50.215]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.215]                         if (muffled) 
[01:27:50.215]                           invokeRestart("muffleMessage")
[01:27:50.215]                       }
[01:27:50.215]                       else if (inherits(cond, "warning")) {
[01:27:50.215]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.215]                         if (muffled) 
[01:27:50.215]                           invokeRestart("muffleWarning")
[01:27:50.215]                       }
[01:27:50.215]                       else if (inherits(cond, "condition")) {
[01:27:50.215]                         if (!is.null(pattern)) {
[01:27:50.215]                           computeRestarts <- base::computeRestarts
[01:27:50.215]                           grepl <- base::grepl
[01:27:50.215]                           restarts <- computeRestarts(cond)
[01:27:50.215]                           for (restart in restarts) {
[01:27:50.215]                             name <- restart$name
[01:27:50.215]                             if (is.null(name)) 
[01:27:50.215]                               next
[01:27:50.215]                             if (!grepl(pattern, name)) 
[01:27:50.215]                               next
[01:27:50.215]                             invokeRestart(restart)
[01:27:50.215]                             muffled <- TRUE
[01:27:50.215]                             break
[01:27:50.215]                           }
[01:27:50.215]                         }
[01:27:50.215]                       }
[01:27:50.215]                       invisible(muffled)
[01:27:50.215]                     }
[01:27:50.215]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.215]                   }
[01:27:50.215]                 }
[01:27:50.215]                 else {
[01:27:50.215]                   if (TRUE) {
[01:27:50.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.215]                     {
[01:27:50.215]                       inherits <- base::inherits
[01:27:50.215]                       invokeRestart <- base::invokeRestart
[01:27:50.215]                       is.null <- base::is.null
[01:27:50.215]                       muffled <- FALSE
[01:27:50.215]                       if (inherits(cond, "message")) {
[01:27:50.215]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.215]                         if (muffled) 
[01:27:50.215]                           invokeRestart("muffleMessage")
[01:27:50.215]                       }
[01:27:50.215]                       else if (inherits(cond, "warning")) {
[01:27:50.215]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.215]                         if (muffled) 
[01:27:50.215]                           invokeRestart("muffleWarning")
[01:27:50.215]                       }
[01:27:50.215]                       else if (inherits(cond, "condition")) {
[01:27:50.215]                         if (!is.null(pattern)) {
[01:27:50.215]                           computeRestarts <- base::computeRestarts
[01:27:50.215]                           grepl <- base::grepl
[01:27:50.215]                           restarts <- computeRestarts(cond)
[01:27:50.215]                           for (restart in restarts) {
[01:27:50.215]                             name <- restart$name
[01:27:50.215]                             if (is.null(name)) 
[01:27:50.215]                               next
[01:27:50.215]                             if (!grepl(pattern, name)) 
[01:27:50.215]                               next
[01:27:50.215]                             invokeRestart(restart)
[01:27:50.215]                             muffled <- TRUE
[01:27:50.215]                             break
[01:27:50.215]                           }
[01:27:50.215]                         }
[01:27:50.215]                       }
[01:27:50.215]                       invisible(muffled)
[01:27:50.215]                     }
[01:27:50.215]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.215]                   }
[01:27:50.215]                 }
[01:27:50.215]             }
[01:27:50.215]         }))
[01:27:50.215]     }, error = function(ex) {
[01:27:50.215]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.215]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.215]                 ...future.rng), started = ...future.startTime, 
[01:27:50.215]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.215]             version = "1.8"), class = "FutureResult")
[01:27:50.215]     }, finally = {
[01:27:50.215]         if (!identical(...future.workdir, getwd())) 
[01:27:50.215]             setwd(...future.workdir)
[01:27:50.215]         {
[01:27:50.215]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.215]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.215]             }
[01:27:50.215]             base::options(...future.oldOptions)
[01:27:50.215]             if (.Platform$OS.type == "windows") {
[01:27:50.215]                 old_names <- names(...future.oldEnvVars)
[01:27:50.215]                 envs <- base::Sys.getenv()
[01:27:50.215]                 names <- names(envs)
[01:27:50.215]                 common <- intersect(names, old_names)
[01:27:50.215]                 added <- setdiff(names, old_names)
[01:27:50.215]                 removed <- setdiff(old_names, names)
[01:27:50.215]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.215]                   envs[common]]
[01:27:50.215]                 NAMES <- toupper(changed)
[01:27:50.215]                 args <- list()
[01:27:50.215]                 for (kk in seq_along(NAMES)) {
[01:27:50.215]                   name <- changed[[kk]]
[01:27:50.215]                   NAME <- NAMES[[kk]]
[01:27:50.215]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.215]                     next
[01:27:50.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.215]                 }
[01:27:50.215]                 NAMES <- toupper(added)
[01:27:50.215]                 for (kk in seq_along(NAMES)) {
[01:27:50.215]                   name <- added[[kk]]
[01:27:50.215]                   NAME <- NAMES[[kk]]
[01:27:50.215]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.215]                     next
[01:27:50.215]                   args[[name]] <- ""
[01:27:50.215]                 }
[01:27:50.215]                 NAMES <- toupper(removed)
[01:27:50.215]                 for (kk in seq_along(NAMES)) {
[01:27:50.215]                   name <- removed[[kk]]
[01:27:50.215]                   NAME <- NAMES[[kk]]
[01:27:50.215]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.215]                     next
[01:27:50.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.215]                 }
[01:27:50.215]                 if (length(args) > 0) 
[01:27:50.215]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.215]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.215]             }
[01:27:50.215]             else {
[01:27:50.215]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.215]             }
[01:27:50.215]             {
[01:27:50.215]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.215]                   0L) {
[01:27:50.215]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.215]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.215]                   base::options(opts)
[01:27:50.215]                 }
[01:27:50.215]                 {
[01:27:50.215]                   {
[01:27:50.215]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.215]                     NULL
[01:27:50.215]                   }
[01:27:50.215]                   options(future.plan = NULL)
[01:27:50.215]                   if (is.na(NA_character_)) 
[01:27:50.215]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.215]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.215]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.215]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.215]                     envir = parent.frame()) 
[01:27:50.215]                   {
[01:27:50.215]                     if (is.function(workers)) 
[01:27:50.215]                       workers <- workers()
[01:27:50.215]                     workers <- structure(as.integer(workers), 
[01:27:50.215]                       class = class(workers))
[01:27:50.215]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.215]                       workers >= 1)
[01:27:50.215]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.215]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.215]                     }
[01:27:50.215]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.215]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.215]                       envir = envir)
[01:27:50.215]                     if (!future$lazy) 
[01:27:50.215]                       future <- run(future)
[01:27:50.215]                     invisible(future)
[01:27:50.215]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.215]                 }
[01:27:50.215]             }
[01:27:50.215]         }
[01:27:50.215]     })
[01:27:50.215]     if (TRUE) {
[01:27:50.215]         base::sink(type = "output", split = FALSE)
[01:27:50.215]         if (TRUE) {
[01:27:50.215]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.215]         }
[01:27:50.215]         else {
[01:27:50.215]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.215]         }
[01:27:50.215]         base::close(...future.stdout)
[01:27:50.215]         ...future.stdout <- NULL
[01:27:50.215]     }
[01:27:50.215]     ...future.result$conditions <- ...future.conditions
[01:27:50.215]     ...future.result$finished <- base::Sys.time()
[01:27:50.215]     ...future.result
[01:27:50.215] }
[01:27:50.294] MultisessionFuture started
[01:27:50.294] - Launch lazy future ... done
[01:27:50.295] run() for 'MultisessionFuture' ... done
[01:27:50.295] getGlobalsAndPackages() ...
[01:27:50.295] Searching for globals...
[01:27:50.296] - globals found: [1] '{'
[01:27:50.297] Searching for globals ... DONE
[01:27:50.297] Resolving globals: FALSE
[01:27:50.297] 
[01:27:50.297] 
[01:27:50.297] getGlobalsAndPackages() ... DONE
[01:27:50.298] run() for 'Future' ...
[01:27:50.298] - state: 'created'
[01:27:50.298] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.313] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.313] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.314]   - Field: 'node'
[01:27:50.314]   - Field: 'label'
[01:27:50.314]   - Field: 'local'
[01:27:50.314]   - Field: 'owner'
[01:27:50.314]   - Field: 'envir'
[01:27:50.315]   - Field: 'workers'
[01:27:50.315]   - Field: 'packages'
[01:27:50.315]   - Field: 'gc'
[01:27:50.315]   - Field: 'conditions'
[01:27:50.315]   - Field: 'persistent'
[01:27:50.315]   - Field: 'expr'
[01:27:50.316]   - Field: 'uuid'
[01:27:50.316]   - Field: 'seed'
[01:27:50.316]   - Field: 'version'
[01:27:50.316]   - Field: 'result'
[01:27:50.316]   - Field: 'asynchronous'
[01:27:50.317]   - Field: 'calls'
[01:27:50.317]   - Field: 'globals'
[01:27:50.317]   - Field: 'stdout'
[01:27:50.317]   - Field: 'earlySignal'
[01:27:50.317]   - Field: 'lazy'
[01:27:50.317]   - Field: 'state'
[01:27:50.318] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.318] - Launch lazy future ...
[01:27:50.318] Packages needed by the future expression (n = 0): <none>
[01:27:50.318] Packages needed by future strategies (n = 0): <none>
[01:27:50.319] {
[01:27:50.319]     {
[01:27:50.319]         {
[01:27:50.319]             ...future.startTime <- base::Sys.time()
[01:27:50.319]             {
[01:27:50.319]                 {
[01:27:50.319]                   {
[01:27:50.319]                     {
[01:27:50.319]                       base::local({
[01:27:50.319]                         has_future <- base::requireNamespace("future", 
[01:27:50.319]                           quietly = TRUE)
[01:27:50.319]                         if (has_future) {
[01:27:50.319]                           ns <- base::getNamespace("future")
[01:27:50.319]                           version <- ns[[".package"]][["version"]]
[01:27:50.319]                           if (is.null(version)) 
[01:27:50.319]                             version <- utils::packageVersion("future")
[01:27:50.319]                         }
[01:27:50.319]                         else {
[01:27:50.319]                           version <- NULL
[01:27:50.319]                         }
[01:27:50.319]                         if (!has_future || version < "1.8.0") {
[01:27:50.319]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.319]                             "", base::R.version$version.string), 
[01:27:50.319]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.319]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.319]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.319]                               "release", "version")], collapse = " "), 
[01:27:50.319]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.319]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.319]                             info)
[01:27:50.319]                           info <- base::paste(info, collapse = "; ")
[01:27:50.319]                           if (!has_future) {
[01:27:50.319]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.319]                               info)
[01:27:50.319]                           }
[01:27:50.319]                           else {
[01:27:50.319]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.319]                               info, version)
[01:27:50.319]                           }
[01:27:50.319]                           base::stop(msg)
[01:27:50.319]                         }
[01:27:50.319]                       })
[01:27:50.319]                     }
[01:27:50.319]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.319]                     base::options(mc.cores = 1L)
[01:27:50.319]                   }
[01:27:50.319]                   options(future.plan = NULL)
[01:27:50.319]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.319]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.319]                 }
[01:27:50.319]                 ...future.workdir <- getwd()
[01:27:50.319]             }
[01:27:50.319]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.319]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.319]         }
[01:27:50.319]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.319]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.319]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.319]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.319]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.319]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.319]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.319]             base::names(...future.oldOptions))
[01:27:50.319]     }
[01:27:50.319]     if (FALSE) {
[01:27:50.319]     }
[01:27:50.319]     else {
[01:27:50.319]         if (TRUE) {
[01:27:50.319]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.319]                 open = "w")
[01:27:50.319]         }
[01:27:50.319]         else {
[01:27:50.319]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.319]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.319]         }
[01:27:50.319]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.319]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.319]             base::sink(type = "output", split = FALSE)
[01:27:50.319]             base::close(...future.stdout)
[01:27:50.319]         }, add = TRUE)
[01:27:50.319]     }
[01:27:50.319]     ...future.frame <- base::sys.nframe()
[01:27:50.319]     ...future.conditions <- base::list()
[01:27:50.319]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.319]     if (FALSE) {
[01:27:50.319]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.319]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.319]     }
[01:27:50.319]     ...future.result <- base::tryCatch({
[01:27:50.319]         base::withCallingHandlers({
[01:27:50.319]             ...future.value <- base::withVisible(base::local({
[01:27:50.319]                 ...future.makeSendCondition <- base::local({
[01:27:50.319]                   sendCondition <- NULL
[01:27:50.319]                   function(frame = 1L) {
[01:27:50.319]                     if (is.function(sendCondition)) 
[01:27:50.319]                       return(sendCondition)
[01:27:50.319]                     ns <- getNamespace("parallel")
[01:27:50.319]                     if (exists("sendData", mode = "function", 
[01:27:50.319]                       envir = ns)) {
[01:27:50.319]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.319]                         envir = ns)
[01:27:50.319]                       envir <- sys.frame(frame)
[01:27:50.319]                       master <- NULL
[01:27:50.319]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.319]                         !identical(envir, emptyenv())) {
[01:27:50.319]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.319]                           inherits = FALSE)) {
[01:27:50.319]                           master <- get("master", mode = "list", 
[01:27:50.319]                             envir = envir, inherits = FALSE)
[01:27:50.319]                           if (inherits(master, c("SOCKnode", 
[01:27:50.319]                             "SOCK0node"))) {
[01:27:50.319]                             sendCondition <<- function(cond) {
[01:27:50.319]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.319]                                 success = TRUE)
[01:27:50.319]                               parallel_sendData(master, data)
[01:27:50.319]                             }
[01:27:50.319]                             return(sendCondition)
[01:27:50.319]                           }
[01:27:50.319]                         }
[01:27:50.319]                         frame <- frame + 1L
[01:27:50.319]                         envir <- sys.frame(frame)
[01:27:50.319]                       }
[01:27:50.319]                     }
[01:27:50.319]                     sendCondition <<- function(cond) NULL
[01:27:50.319]                   }
[01:27:50.319]                 })
[01:27:50.319]                 withCallingHandlers({
[01:27:50.319]                   {
[01:27:50.319]                     4
[01:27:50.319]                   }
[01:27:50.319]                 }, immediateCondition = function(cond) {
[01:27:50.319]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.319]                   sendCondition(cond)
[01:27:50.319]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.319]                   {
[01:27:50.319]                     inherits <- base::inherits
[01:27:50.319]                     invokeRestart <- base::invokeRestart
[01:27:50.319]                     is.null <- base::is.null
[01:27:50.319]                     muffled <- FALSE
[01:27:50.319]                     if (inherits(cond, "message")) {
[01:27:50.319]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.319]                       if (muffled) 
[01:27:50.319]                         invokeRestart("muffleMessage")
[01:27:50.319]                     }
[01:27:50.319]                     else if (inherits(cond, "warning")) {
[01:27:50.319]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.319]                       if (muffled) 
[01:27:50.319]                         invokeRestart("muffleWarning")
[01:27:50.319]                     }
[01:27:50.319]                     else if (inherits(cond, "condition")) {
[01:27:50.319]                       if (!is.null(pattern)) {
[01:27:50.319]                         computeRestarts <- base::computeRestarts
[01:27:50.319]                         grepl <- base::grepl
[01:27:50.319]                         restarts <- computeRestarts(cond)
[01:27:50.319]                         for (restart in restarts) {
[01:27:50.319]                           name <- restart$name
[01:27:50.319]                           if (is.null(name)) 
[01:27:50.319]                             next
[01:27:50.319]                           if (!grepl(pattern, name)) 
[01:27:50.319]                             next
[01:27:50.319]                           invokeRestart(restart)
[01:27:50.319]                           muffled <- TRUE
[01:27:50.319]                           break
[01:27:50.319]                         }
[01:27:50.319]                       }
[01:27:50.319]                     }
[01:27:50.319]                     invisible(muffled)
[01:27:50.319]                   }
[01:27:50.319]                   muffleCondition(cond)
[01:27:50.319]                 })
[01:27:50.319]             }))
[01:27:50.319]             future::FutureResult(value = ...future.value$value, 
[01:27:50.319]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.319]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.319]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.319]                     ...future.globalenv.names))
[01:27:50.319]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.319]         }, condition = base::local({
[01:27:50.319]             c <- base::c
[01:27:50.319]             inherits <- base::inherits
[01:27:50.319]             invokeRestart <- base::invokeRestart
[01:27:50.319]             length <- base::length
[01:27:50.319]             list <- base::list
[01:27:50.319]             seq.int <- base::seq.int
[01:27:50.319]             signalCondition <- base::signalCondition
[01:27:50.319]             sys.calls <- base::sys.calls
[01:27:50.319]             `[[` <- base::`[[`
[01:27:50.319]             `+` <- base::`+`
[01:27:50.319]             `<<-` <- base::`<<-`
[01:27:50.319]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.319]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.319]                   3L)]
[01:27:50.319]             }
[01:27:50.319]             function(cond) {
[01:27:50.319]                 is_error <- inherits(cond, "error")
[01:27:50.319]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.319]                   NULL)
[01:27:50.319]                 if (is_error) {
[01:27:50.319]                   sessionInformation <- function() {
[01:27:50.319]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.319]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.319]                       search = base::search(), system = base::Sys.info())
[01:27:50.319]                   }
[01:27:50.319]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.319]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.319]                     cond$call), session = sessionInformation(), 
[01:27:50.319]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.319]                   signalCondition(cond)
[01:27:50.319]                 }
[01:27:50.319]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.319]                 "immediateCondition"))) {
[01:27:50.319]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.319]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.319]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.319]                   if (TRUE && !signal) {
[01:27:50.319]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.319]                     {
[01:27:50.319]                       inherits <- base::inherits
[01:27:50.319]                       invokeRestart <- base::invokeRestart
[01:27:50.319]                       is.null <- base::is.null
[01:27:50.319]                       muffled <- FALSE
[01:27:50.319]                       if (inherits(cond, "message")) {
[01:27:50.319]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.319]                         if (muffled) 
[01:27:50.319]                           invokeRestart("muffleMessage")
[01:27:50.319]                       }
[01:27:50.319]                       else if (inherits(cond, "warning")) {
[01:27:50.319]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.319]                         if (muffled) 
[01:27:50.319]                           invokeRestart("muffleWarning")
[01:27:50.319]                       }
[01:27:50.319]                       else if (inherits(cond, "condition")) {
[01:27:50.319]                         if (!is.null(pattern)) {
[01:27:50.319]                           computeRestarts <- base::computeRestarts
[01:27:50.319]                           grepl <- base::grepl
[01:27:50.319]                           restarts <- computeRestarts(cond)
[01:27:50.319]                           for (restart in restarts) {
[01:27:50.319]                             name <- restart$name
[01:27:50.319]                             if (is.null(name)) 
[01:27:50.319]                               next
[01:27:50.319]                             if (!grepl(pattern, name)) 
[01:27:50.319]                               next
[01:27:50.319]                             invokeRestart(restart)
[01:27:50.319]                             muffled <- TRUE
[01:27:50.319]                             break
[01:27:50.319]                           }
[01:27:50.319]                         }
[01:27:50.319]                       }
[01:27:50.319]                       invisible(muffled)
[01:27:50.319]                     }
[01:27:50.319]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.319]                   }
[01:27:50.319]                 }
[01:27:50.319]                 else {
[01:27:50.319]                   if (TRUE) {
[01:27:50.319]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.319]                     {
[01:27:50.319]                       inherits <- base::inherits
[01:27:50.319]                       invokeRestart <- base::invokeRestart
[01:27:50.319]                       is.null <- base::is.null
[01:27:50.319]                       muffled <- FALSE
[01:27:50.319]                       if (inherits(cond, "message")) {
[01:27:50.319]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.319]                         if (muffled) 
[01:27:50.319]                           invokeRestart("muffleMessage")
[01:27:50.319]                       }
[01:27:50.319]                       else if (inherits(cond, "warning")) {
[01:27:50.319]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.319]                         if (muffled) 
[01:27:50.319]                           invokeRestart("muffleWarning")
[01:27:50.319]                       }
[01:27:50.319]                       else if (inherits(cond, "condition")) {
[01:27:50.319]                         if (!is.null(pattern)) {
[01:27:50.319]                           computeRestarts <- base::computeRestarts
[01:27:50.319]                           grepl <- base::grepl
[01:27:50.319]                           restarts <- computeRestarts(cond)
[01:27:50.319]                           for (restart in restarts) {
[01:27:50.319]                             name <- restart$name
[01:27:50.319]                             if (is.null(name)) 
[01:27:50.319]                               next
[01:27:50.319]                             if (!grepl(pattern, name)) 
[01:27:50.319]                               next
[01:27:50.319]                             invokeRestart(restart)
[01:27:50.319]                             muffled <- TRUE
[01:27:50.319]                             break
[01:27:50.319]                           }
[01:27:50.319]                         }
[01:27:50.319]                       }
[01:27:50.319]                       invisible(muffled)
[01:27:50.319]                     }
[01:27:50.319]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.319]                   }
[01:27:50.319]                 }
[01:27:50.319]             }
[01:27:50.319]         }))
[01:27:50.319]     }, error = function(ex) {
[01:27:50.319]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.319]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.319]                 ...future.rng), started = ...future.startTime, 
[01:27:50.319]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.319]             version = "1.8"), class = "FutureResult")
[01:27:50.319]     }, finally = {
[01:27:50.319]         if (!identical(...future.workdir, getwd())) 
[01:27:50.319]             setwd(...future.workdir)
[01:27:50.319]         {
[01:27:50.319]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.319]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.319]             }
[01:27:50.319]             base::options(...future.oldOptions)
[01:27:50.319]             if (.Platform$OS.type == "windows") {
[01:27:50.319]                 old_names <- names(...future.oldEnvVars)
[01:27:50.319]                 envs <- base::Sys.getenv()
[01:27:50.319]                 names <- names(envs)
[01:27:50.319]                 common <- intersect(names, old_names)
[01:27:50.319]                 added <- setdiff(names, old_names)
[01:27:50.319]                 removed <- setdiff(old_names, names)
[01:27:50.319]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.319]                   envs[common]]
[01:27:50.319]                 NAMES <- toupper(changed)
[01:27:50.319]                 args <- list()
[01:27:50.319]                 for (kk in seq_along(NAMES)) {
[01:27:50.319]                   name <- changed[[kk]]
[01:27:50.319]                   NAME <- NAMES[[kk]]
[01:27:50.319]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.319]                     next
[01:27:50.319]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.319]                 }
[01:27:50.319]                 NAMES <- toupper(added)
[01:27:50.319]                 for (kk in seq_along(NAMES)) {
[01:27:50.319]                   name <- added[[kk]]
[01:27:50.319]                   NAME <- NAMES[[kk]]
[01:27:50.319]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.319]                     next
[01:27:50.319]                   args[[name]] <- ""
[01:27:50.319]                 }
[01:27:50.319]                 NAMES <- toupper(removed)
[01:27:50.319]                 for (kk in seq_along(NAMES)) {
[01:27:50.319]                   name <- removed[[kk]]
[01:27:50.319]                   NAME <- NAMES[[kk]]
[01:27:50.319]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.319]                     next
[01:27:50.319]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.319]                 }
[01:27:50.319]                 if (length(args) > 0) 
[01:27:50.319]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.319]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.319]             }
[01:27:50.319]             else {
[01:27:50.319]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.319]             }
[01:27:50.319]             {
[01:27:50.319]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.319]                   0L) {
[01:27:50.319]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.319]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.319]                   base::options(opts)
[01:27:50.319]                 }
[01:27:50.319]                 {
[01:27:50.319]                   {
[01:27:50.319]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.319]                     NULL
[01:27:50.319]                   }
[01:27:50.319]                   options(future.plan = NULL)
[01:27:50.319]                   if (is.na(NA_character_)) 
[01:27:50.319]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.319]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.319]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.319]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.319]                     envir = parent.frame()) 
[01:27:50.319]                   {
[01:27:50.319]                     if (is.function(workers)) 
[01:27:50.319]                       workers <- workers()
[01:27:50.319]                     workers <- structure(as.integer(workers), 
[01:27:50.319]                       class = class(workers))
[01:27:50.319]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.319]                       workers >= 1)
[01:27:50.319]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.319]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.319]                     }
[01:27:50.319]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.319]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.319]                       envir = envir)
[01:27:50.319]                     if (!future$lazy) 
[01:27:50.319]                       future <- run(future)
[01:27:50.319]                     invisible(future)
[01:27:50.319]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.319]                 }
[01:27:50.319]             }
[01:27:50.319]         }
[01:27:50.319]     })
[01:27:50.319]     if (TRUE) {
[01:27:50.319]         base::sink(type = "output", split = FALSE)
[01:27:50.319]         if (TRUE) {
[01:27:50.319]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.319]         }
[01:27:50.319]         else {
[01:27:50.319]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.319]         }
[01:27:50.319]         base::close(...future.stdout)
[01:27:50.319]         ...future.stdout <- NULL
[01:27:50.319]     }
[01:27:50.319]     ...future.result$conditions <- ...future.conditions
[01:27:50.319]     ...future.result$finished <- base::Sys.time()
[01:27:50.319]     ...future.result
[01:27:50.319] }
[01:27:50.326] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:50.352] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.353] - Validating connection of MultisessionFuture
[01:27:50.353] - received message: FutureResult
[01:27:50.353] - Received FutureResult
[01:27:50.353] - Erased future from FutureRegistry
[01:27:50.354] result() for ClusterFuture ...
[01:27:50.354] - result already collected: FutureResult
[01:27:50.354] result() for ClusterFuture ... done
[01:27:50.354] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.354] result() for ClusterFuture ...
[01:27:50.354] - result already collected: FutureResult
[01:27:50.355] result() for ClusterFuture ... done
[01:27:50.355] result() for ClusterFuture ...
[01:27:50.355] - result already collected: FutureResult
[01:27:50.355] result() for ClusterFuture ... done
[01:27:50.356] MultisessionFuture started
[01:27:50.357] - Launch lazy future ... done
[01:27:50.357] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b08703530> 
Classes 'listenv', 'environment' <environment: 0x0000025b0a0addb8> 
[01:27:50.370] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.371] - Validating connection of MultisessionFuture
[01:27:50.371] - received message: FutureResult
[01:27:50.371] - Received FutureResult
[01:27:50.371] - Erased future from FutureRegistry
[01:27:50.372] result() for ClusterFuture ...
[01:27:50.372] - result already collected: FutureResult
[01:27:50.372] result() for ClusterFuture ... done
[01:27:50.372] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.375] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.375] - Validating connection of MultisessionFuture
[01:27:50.375] - received message: FutureResult
[01:27:50.376] - Received FutureResult
[01:27:50.376] - Erased future from FutureRegistry
[01:27:50.376] result() for ClusterFuture ...
[01:27:50.376] - result already collected: FutureResult
[01:27:50.376] result() for ClusterFuture ... done
[01:27:50.376] receiveMessageFromWorker() for ClusterFuture ... done
 Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
 - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
[01:27:50.378] resolve() on list environment ...
[01:27:50.379]  recursive: 0
[01:27:50.380]  length: 6
[01:27:50.380]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:50.380] signalConditionsASAP(numeric, pos=1) ...
[01:27:50.380] - nx: 6
[01:27:50.380] - relay: TRUE
[01:27:50.380] - stdout: TRUE
[01:27:50.381] - signal: TRUE
[01:27:50.381] - resignal: FALSE
[01:27:50.381] - force: TRUE
[01:27:50.381] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.381] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.381]  - until=2
[01:27:50.382]  - relaying element #2
[01:27:50.382] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.382] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.382] signalConditionsASAP(NULL, pos=1) ... done
[01:27:50.382]  length: 5 (resolved future 1)
[01:27:50.382] Future #2
[01:27:50.383] result() for ClusterFuture ...
[01:27:50.383] - result already collected: FutureResult
[01:27:50.383] result() for ClusterFuture ... done
[01:27:50.383] result() for ClusterFuture ...
[01:27:50.383] - result already collected: FutureResult
[01:27:50.384] result() for ClusterFuture ... done
[01:27:50.384] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:50.384] - nx: 6
[01:27:50.384] - relay: TRUE
[01:27:50.384] - stdout: TRUE
[01:27:50.384] - signal: TRUE
[01:27:50.384] - resignal: FALSE
[01:27:50.385] - force: TRUE
[01:27:50.385] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.385] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.385]  - until=2
[01:27:50.385]  - relaying element #2
[01:27:50.385] result() for ClusterFuture ...
[01:27:50.386] - result already collected: FutureResult
[01:27:50.386] result() for ClusterFuture ... done
[01:27:50.386] result() for ClusterFuture ...
[01:27:50.386] - result already collected: FutureResult
[01:27:50.386] result() for ClusterFuture ... done
[01:27:50.386] result() for ClusterFuture ...
[01:27:50.387] - result already collected: FutureResult
[01:27:50.387] result() for ClusterFuture ... done
[01:27:50.387] result() for ClusterFuture ...
[01:27:50.387] - result already collected: FutureResult
[01:27:50.387] result() for ClusterFuture ... done
[01:27:50.387] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.388] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.388] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:50.388]  length: 4 (resolved future 2)
[01:27:50.388] Future #3
[01:27:50.388] result() for ClusterFuture ...
[01:27:50.389] - result already collected: FutureResult
[01:27:50.389] result() for ClusterFuture ... done
[01:27:50.389] result() for ClusterFuture ...
[01:27:50.389] - result already collected: FutureResult
[01:27:50.389] result() for ClusterFuture ... done
[01:27:50.389] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:50.390] - nx: 6
[01:27:50.390] - relay: TRUE
[01:27:50.390] - stdout: TRUE
[01:27:50.390] - signal: TRUE
[01:27:50.390] - resignal: FALSE
[01:27:50.390] - force: TRUE
[01:27:50.390] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.391] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.391]  - until=3
[01:27:50.391]  - relaying element #3
[01:27:50.391] result() for ClusterFuture ...
[01:27:50.391] - result already collected: FutureResult
[01:27:50.391] result() for ClusterFuture ... done
[01:27:50.392] result() for ClusterFuture ...
[01:27:50.392] - result already collected: FutureResult
[01:27:50.392] result() for ClusterFuture ... done
[01:27:50.392] result() for ClusterFuture ...
[01:27:50.392] - result already collected: FutureResult
[01:27:50.392] result() for ClusterFuture ... done
[01:27:50.393] result() for ClusterFuture ...
[01:27:50.393] - result already collected: FutureResult
[01:27:50.393] result() for ClusterFuture ... done
[01:27:50.393] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.393] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.393] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:50.394]  length: 3 (resolved future 3)
[01:27:50.394] Future #4
[01:27:50.394] result() for ClusterFuture ...
[01:27:50.394] - result already collected: FutureResult
[01:27:50.394] result() for ClusterFuture ... done
[01:27:50.395] result() for ClusterFuture ...
[01:27:50.395] - result already collected: FutureResult
[01:27:50.395] result() for ClusterFuture ... done
[01:27:50.395] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:50.395] - nx: 6
[01:27:50.395] - relay: TRUE
[01:27:50.395] - stdout: TRUE
[01:27:50.396] - signal: TRUE
[01:27:50.396] - resignal: FALSE
[01:27:50.396] - force: TRUE
[01:27:50.396] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.396] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.396]  - until=4
[01:27:50.397]  - relaying element #4
[01:27:50.397] result() for ClusterFuture ...
[01:27:50.397] - result already collected: FutureResult
[01:27:50.397] result() for ClusterFuture ... done
[01:27:50.397] result() for ClusterFuture ...
[01:27:50.397] - result already collected: FutureResult
[01:27:50.398] result() for ClusterFuture ... done
[01:27:50.398] result() for ClusterFuture ...
[01:27:50.398] - result already collected: FutureResult
[01:27:50.398] result() for ClusterFuture ... done
[01:27:50.398] result() for ClusterFuture ...
[01:27:50.398] - result already collected: FutureResult
[01:27:50.399] result() for ClusterFuture ... done
[01:27:50.399] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.399] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.399] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:50.399]  length: 2 (resolved future 4)
[01:27:50.399] signalConditionsASAP(NULL, pos=5) ...
[01:27:50.400] - nx: 6
[01:27:50.400] - relay: TRUE
[01:27:50.400] - stdout: TRUE
[01:27:50.400] - signal: TRUE
[01:27:50.400] - resignal: FALSE
[01:27:50.400] - force: TRUE
[01:27:50.401] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.401] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.401]  - until=6
[01:27:50.401]  - relaying element #6
[01:27:50.401] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.401] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.402] signalConditionsASAP(NULL, pos=5) ... done
[01:27:50.402]  length: 1 (resolved future 5)
[01:27:50.402] signalConditionsASAP(numeric, pos=6) ...
[01:27:50.402] - nx: 6
[01:27:50.402] - relay: TRUE
[01:27:50.402] - stdout: TRUE
[01:27:50.402] - signal: TRUE
[01:27:50.403] - resignal: FALSE
[01:27:50.403] - force: TRUE
[01:27:50.403] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.403] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.403]  - until=6
[01:27:50.403] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.404] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.404] signalConditionsASAP(numeric, pos=6) ... done
[01:27:50.404]  length: 0 (resolved future 6)
[01:27:50.404] Relaying remaining futures
[01:27:50.404] signalConditionsASAP(NULL, pos=0) ...
[01:27:50.404] - nx: 6
[01:27:50.405] - relay: TRUE
[01:27:50.405] - stdout: TRUE
[01:27:50.405] - signal: TRUE
[01:27:50.405] - resignal: FALSE
[01:27:50.405] - force: TRUE
[01:27:50.405] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.405] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:50.406] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.406] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.406] signalConditionsASAP(NULL, pos=0) ... done
[01:27:50.406] resolve() on list environment ... DONE
[01:27:50.406] result() for ClusterFuture ...
[01:27:50.407] - result already collected: FutureResult
[01:27:50.407] result() for ClusterFuture ... done
[01:27:50.407] result() for ClusterFuture ...
[01:27:50.407] - result already collected: FutureResult
[01:27:50.407] result() for ClusterFuture ... done
[01:27:50.407] result() for ClusterFuture ...
[01:27:50.408] - result already collected: FutureResult
[01:27:50.408] result() for ClusterFuture ... done
[01:27:50.408] result() for ClusterFuture ...
[01:27:50.408] - result already collected: FutureResult
[01:27:50.408] result() for ClusterFuture ... done
[01:27:50.408] result() for ClusterFuture ...
[01:27:50.409] - result already collected: FutureResult
[01:27:50.409] result() for ClusterFuture ... done
[01:27:50.409] result() for ClusterFuture ...
[01:27:50.409] - result already collected: FutureResult
[01:27:50.409] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000025b0a4a8308> 
Dimensions: c(1, 6)
[01:27:50.410] getGlobalsAndPackages() ...
[01:27:50.410] Searching for globals...
[01:27:50.411] 
[01:27:50.411] Searching for globals ... DONE
[01:27:50.411] - globals: [0] <none>
[01:27:50.411] getGlobalsAndPackages() ... DONE
[01:27:50.411] run() for 'Future' ...
[01:27:50.412] - state: 'created'
[01:27:50.412] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.426] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.427] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.427]   - Field: 'node'
[01:27:50.427]   - Field: 'label'
[01:27:50.427]   - Field: 'local'
[01:27:50.427]   - Field: 'owner'
[01:27:50.427]   - Field: 'envir'
[01:27:50.428]   - Field: 'workers'
[01:27:50.428]   - Field: 'packages'
[01:27:50.428]   - Field: 'gc'
[01:27:50.428]   - Field: 'conditions'
[01:27:50.428]   - Field: 'persistent'
[01:27:50.428]   - Field: 'expr'
[01:27:50.429]   - Field: 'uuid'
[01:27:50.429]   - Field: 'seed'
[01:27:50.429]   - Field: 'version'
[01:27:50.429]   - Field: 'result'
[01:27:50.429]   - Field: 'asynchronous'
[01:27:50.430]   - Field: 'calls'
[01:27:50.430]   - Field: 'globals'
[01:27:50.430]   - Field: 'stdout'
[01:27:50.430]   - Field: 'earlySignal'
[01:27:50.430]   - Field: 'lazy'
[01:27:50.430]   - Field: 'state'
[01:27:50.431] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.431] - Launch lazy future ...
[01:27:50.431] Packages needed by the future expression (n = 0): <none>
[01:27:50.431] Packages needed by future strategies (n = 0): <none>
[01:27:50.432] {
[01:27:50.432]     {
[01:27:50.432]         {
[01:27:50.432]             ...future.startTime <- base::Sys.time()
[01:27:50.432]             {
[01:27:50.432]                 {
[01:27:50.432]                   {
[01:27:50.432]                     {
[01:27:50.432]                       base::local({
[01:27:50.432]                         has_future <- base::requireNamespace("future", 
[01:27:50.432]                           quietly = TRUE)
[01:27:50.432]                         if (has_future) {
[01:27:50.432]                           ns <- base::getNamespace("future")
[01:27:50.432]                           version <- ns[[".package"]][["version"]]
[01:27:50.432]                           if (is.null(version)) 
[01:27:50.432]                             version <- utils::packageVersion("future")
[01:27:50.432]                         }
[01:27:50.432]                         else {
[01:27:50.432]                           version <- NULL
[01:27:50.432]                         }
[01:27:50.432]                         if (!has_future || version < "1.8.0") {
[01:27:50.432]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.432]                             "", base::R.version$version.string), 
[01:27:50.432]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.432]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.432]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.432]                               "release", "version")], collapse = " "), 
[01:27:50.432]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.432]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.432]                             info)
[01:27:50.432]                           info <- base::paste(info, collapse = "; ")
[01:27:50.432]                           if (!has_future) {
[01:27:50.432]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.432]                               info)
[01:27:50.432]                           }
[01:27:50.432]                           else {
[01:27:50.432]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.432]                               info, version)
[01:27:50.432]                           }
[01:27:50.432]                           base::stop(msg)
[01:27:50.432]                         }
[01:27:50.432]                       })
[01:27:50.432]                     }
[01:27:50.432]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.432]                     base::options(mc.cores = 1L)
[01:27:50.432]                   }
[01:27:50.432]                   options(future.plan = NULL)
[01:27:50.432]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.432]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.432]                 }
[01:27:50.432]                 ...future.workdir <- getwd()
[01:27:50.432]             }
[01:27:50.432]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.432]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.432]         }
[01:27:50.432]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.432]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.432]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.432]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.432]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.432]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.432]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.432]             base::names(...future.oldOptions))
[01:27:50.432]     }
[01:27:50.432]     if (FALSE) {
[01:27:50.432]     }
[01:27:50.432]     else {
[01:27:50.432]         if (TRUE) {
[01:27:50.432]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.432]                 open = "w")
[01:27:50.432]         }
[01:27:50.432]         else {
[01:27:50.432]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.432]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.432]         }
[01:27:50.432]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.432]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.432]             base::sink(type = "output", split = FALSE)
[01:27:50.432]             base::close(...future.stdout)
[01:27:50.432]         }, add = TRUE)
[01:27:50.432]     }
[01:27:50.432]     ...future.frame <- base::sys.nframe()
[01:27:50.432]     ...future.conditions <- base::list()
[01:27:50.432]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.432]     if (FALSE) {
[01:27:50.432]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.432]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.432]     }
[01:27:50.432]     ...future.result <- base::tryCatch({
[01:27:50.432]         base::withCallingHandlers({
[01:27:50.432]             ...future.value <- base::withVisible(base::local({
[01:27:50.432]                 ...future.makeSendCondition <- base::local({
[01:27:50.432]                   sendCondition <- NULL
[01:27:50.432]                   function(frame = 1L) {
[01:27:50.432]                     if (is.function(sendCondition)) 
[01:27:50.432]                       return(sendCondition)
[01:27:50.432]                     ns <- getNamespace("parallel")
[01:27:50.432]                     if (exists("sendData", mode = "function", 
[01:27:50.432]                       envir = ns)) {
[01:27:50.432]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.432]                         envir = ns)
[01:27:50.432]                       envir <- sys.frame(frame)
[01:27:50.432]                       master <- NULL
[01:27:50.432]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.432]                         !identical(envir, emptyenv())) {
[01:27:50.432]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.432]                           inherits = FALSE)) {
[01:27:50.432]                           master <- get("master", mode = "list", 
[01:27:50.432]                             envir = envir, inherits = FALSE)
[01:27:50.432]                           if (inherits(master, c("SOCKnode", 
[01:27:50.432]                             "SOCK0node"))) {
[01:27:50.432]                             sendCondition <<- function(cond) {
[01:27:50.432]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.432]                                 success = TRUE)
[01:27:50.432]                               parallel_sendData(master, data)
[01:27:50.432]                             }
[01:27:50.432]                             return(sendCondition)
[01:27:50.432]                           }
[01:27:50.432]                         }
[01:27:50.432]                         frame <- frame + 1L
[01:27:50.432]                         envir <- sys.frame(frame)
[01:27:50.432]                       }
[01:27:50.432]                     }
[01:27:50.432]                     sendCondition <<- function(cond) NULL
[01:27:50.432]                   }
[01:27:50.432]                 })
[01:27:50.432]                 withCallingHandlers({
[01:27:50.432]                   2
[01:27:50.432]                 }, immediateCondition = function(cond) {
[01:27:50.432]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.432]                   sendCondition(cond)
[01:27:50.432]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.432]                   {
[01:27:50.432]                     inherits <- base::inherits
[01:27:50.432]                     invokeRestart <- base::invokeRestart
[01:27:50.432]                     is.null <- base::is.null
[01:27:50.432]                     muffled <- FALSE
[01:27:50.432]                     if (inherits(cond, "message")) {
[01:27:50.432]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.432]                       if (muffled) 
[01:27:50.432]                         invokeRestart("muffleMessage")
[01:27:50.432]                     }
[01:27:50.432]                     else if (inherits(cond, "warning")) {
[01:27:50.432]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.432]                       if (muffled) 
[01:27:50.432]                         invokeRestart("muffleWarning")
[01:27:50.432]                     }
[01:27:50.432]                     else if (inherits(cond, "condition")) {
[01:27:50.432]                       if (!is.null(pattern)) {
[01:27:50.432]                         computeRestarts <- base::computeRestarts
[01:27:50.432]                         grepl <- base::grepl
[01:27:50.432]                         restarts <- computeRestarts(cond)
[01:27:50.432]                         for (restart in restarts) {
[01:27:50.432]                           name <- restart$name
[01:27:50.432]                           if (is.null(name)) 
[01:27:50.432]                             next
[01:27:50.432]                           if (!grepl(pattern, name)) 
[01:27:50.432]                             next
[01:27:50.432]                           invokeRestart(restart)
[01:27:50.432]                           muffled <- TRUE
[01:27:50.432]                           break
[01:27:50.432]                         }
[01:27:50.432]                       }
[01:27:50.432]                     }
[01:27:50.432]                     invisible(muffled)
[01:27:50.432]                   }
[01:27:50.432]                   muffleCondition(cond)
[01:27:50.432]                 })
[01:27:50.432]             }))
[01:27:50.432]             future::FutureResult(value = ...future.value$value, 
[01:27:50.432]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.432]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.432]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.432]                     ...future.globalenv.names))
[01:27:50.432]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.432]         }, condition = base::local({
[01:27:50.432]             c <- base::c
[01:27:50.432]             inherits <- base::inherits
[01:27:50.432]             invokeRestart <- base::invokeRestart
[01:27:50.432]             length <- base::length
[01:27:50.432]             list <- base::list
[01:27:50.432]             seq.int <- base::seq.int
[01:27:50.432]             signalCondition <- base::signalCondition
[01:27:50.432]             sys.calls <- base::sys.calls
[01:27:50.432]             `[[` <- base::`[[`
[01:27:50.432]             `+` <- base::`+`
[01:27:50.432]             `<<-` <- base::`<<-`
[01:27:50.432]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.432]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.432]                   3L)]
[01:27:50.432]             }
[01:27:50.432]             function(cond) {
[01:27:50.432]                 is_error <- inherits(cond, "error")
[01:27:50.432]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.432]                   NULL)
[01:27:50.432]                 if (is_error) {
[01:27:50.432]                   sessionInformation <- function() {
[01:27:50.432]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.432]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.432]                       search = base::search(), system = base::Sys.info())
[01:27:50.432]                   }
[01:27:50.432]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.432]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.432]                     cond$call), session = sessionInformation(), 
[01:27:50.432]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.432]                   signalCondition(cond)
[01:27:50.432]                 }
[01:27:50.432]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.432]                 "immediateCondition"))) {
[01:27:50.432]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.432]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.432]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.432]                   if (TRUE && !signal) {
[01:27:50.432]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.432]                     {
[01:27:50.432]                       inherits <- base::inherits
[01:27:50.432]                       invokeRestart <- base::invokeRestart
[01:27:50.432]                       is.null <- base::is.null
[01:27:50.432]                       muffled <- FALSE
[01:27:50.432]                       if (inherits(cond, "message")) {
[01:27:50.432]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.432]                         if (muffled) 
[01:27:50.432]                           invokeRestart("muffleMessage")
[01:27:50.432]                       }
[01:27:50.432]                       else if (inherits(cond, "warning")) {
[01:27:50.432]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.432]                         if (muffled) 
[01:27:50.432]                           invokeRestart("muffleWarning")
[01:27:50.432]                       }
[01:27:50.432]                       else if (inherits(cond, "condition")) {
[01:27:50.432]                         if (!is.null(pattern)) {
[01:27:50.432]                           computeRestarts <- base::computeRestarts
[01:27:50.432]                           grepl <- base::grepl
[01:27:50.432]                           restarts <- computeRestarts(cond)
[01:27:50.432]                           for (restart in restarts) {
[01:27:50.432]                             name <- restart$name
[01:27:50.432]                             if (is.null(name)) 
[01:27:50.432]                               next
[01:27:50.432]                             if (!grepl(pattern, name)) 
[01:27:50.432]                               next
[01:27:50.432]                             invokeRestart(restart)
[01:27:50.432]                             muffled <- TRUE
[01:27:50.432]                             break
[01:27:50.432]                           }
[01:27:50.432]                         }
[01:27:50.432]                       }
[01:27:50.432]                       invisible(muffled)
[01:27:50.432]                     }
[01:27:50.432]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.432]                   }
[01:27:50.432]                 }
[01:27:50.432]                 else {
[01:27:50.432]                   if (TRUE) {
[01:27:50.432]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.432]                     {
[01:27:50.432]                       inherits <- base::inherits
[01:27:50.432]                       invokeRestart <- base::invokeRestart
[01:27:50.432]                       is.null <- base::is.null
[01:27:50.432]                       muffled <- FALSE
[01:27:50.432]                       if (inherits(cond, "message")) {
[01:27:50.432]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.432]                         if (muffled) 
[01:27:50.432]                           invokeRestart("muffleMessage")
[01:27:50.432]                       }
[01:27:50.432]                       else if (inherits(cond, "warning")) {
[01:27:50.432]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.432]                         if (muffled) 
[01:27:50.432]                           invokeRestart("muffleWarning")
[01:27:50.432]                       }
[01:27:50.432]                       else if (inherits(cond, "condition")) {
[01:27:50.432]                         if (!is.null(pattern)) {
[01:27:50.432]                           computeRestarts <- base::computeRestarts
[01:27:50.432]                           grepl <- base::grepl
[01:27:50.432]                           restarts <- computeRestarts(cond)
[01:27:50.432]                           for (restart in restarts) {
[01:27:50.432]                             name <- restart$name
[01:27:50.432]                             if (is.null(name)) 
[01:27:50.432]                               next
[01:27:50.432]                             if (!grepl(pattern, name)) 
[01:27:50.432]                               next
[01:27:50.432]                             invokeRestart(restart)
[01:27:50.432]                             muffled <- TRUE
[01:27:50.432]                             break
[01:27:50.432]                           }
[01:27:50.432]                         }
[01:27:50.432]                       }
[01:27:50.432]                       invisible(muffled)
[01:27:50.432]                     }
[01:27:50.432]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.432]                   }
[01:27:50.432]                 }
[01:27:50.432]             }
[01:27:50.432]         }))
[01:27:50.432]     }, error = function(ex) {
[01:27:50.432]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.432]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.432]                 ...future.rng), started = ...future.startTime, 
[01:27:50.432]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.432]             version = "1.8"), class = "FutureResult")
[01:27:50.432]     }, finally = {
[01:27:50.432]         if (!identical(...future.workdir, getwd())) 
[01:27:50.432]             setwd(...future.workdir)
[01:27:50.432]         {
[01:27:50.432]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.432]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.432]             }
[01:27:50.432]             base::options(...future.oldOptions)
[01:27:50.432]             if (.Platform$OS.type == "windows") {
[01:27:50.432]                 old_names <- names(...future.oldEnvVars)
[01:27:50.432]                 envs <- base::Sys.getenv()
[01:27:50.432]                 names <- names(envs)
[01:27:50.432]                 common <- intersect(names, old_names)
[01:27:50.432]                 added <- setdiff(names, old_names)
[01:27:50.432]                 removed <- setdiff(old_names, names)
[01:27:50.432]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.432]                   envs[common]]
[01:27:50.432]                 NAMES <- toupper(changed)
[01:27:50.432]                 args <- list()
[01:27:50.432]                 for (kk in seq_along(NAMES)) {
[01:27:50.432]                   name <- changed[[kk]]
[01:27:50.432]                   NAME <- NAMES[[kk]]
[01:27:50.432]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.432]                     next
[01:27:50.432]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.432]                 }
[01:27:50.432]                 NAMES <- toupper(added)
[01:27:50.432]                 for (kk in seq_along(NAMES)) {
[01:27:50.432]                   name <- added[[kk]]
[01:27:50.432]                   NAME <- NAMES[[kk]]
[01:27:50.432]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.432]                     next
[01:27:50.432]                   args[[name]] <- ""
[01:27:50.432]                 }
[01:27:50.432]                 NAMES <- toupper(removed)
[01:27:50.432]                 for (kk in seq_along(NAMES)) {
[01:27:50.432]                   name <- removed[[kk]]
[01:27:50.432]                   NAME <- NAMES[[kk]]
[01:27:50.432]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.432]                     next
[01:27:50.432]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.432]                 }
[01:27:50.432]                 if (length(args) > 0) 
[01:27:50.432]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.432]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.432]             }
[01:27:50.432]             else {
[01:27:50.432]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.432]             }
[01:27:50.432]             {
[01:27:50.432]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.432]                   0L) {
[01:27:50.432]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.432]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.432]                   base::options(opts)
[01:27:50.432]                 }
[01:27:50.432]                 {
[01:27:50.432]                   {
[01:27:50.432]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.432]                     NULL
[01:27:50.432]                   }
[01:27:50.432]                   options(future.plan = NULL)
[01:27:50.432]                   if (is.na(NA_character_)) 
[01:27:50.432]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.432]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.432]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.432]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.432]                     envir = parent.frame()) 
[01:27:50.432]                   {
[01:27:50.432]                     if (is.function(workers)) 
[01:27:50.432]                       workers <- workers()
[01:27:50.432]                     workers <- structure(as.integer(workers), 
[01:27:50.432]                       class = class(workers))
[01:27:50.432]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.432]                       workers >= 1)
[01:27:50.432]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.432]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.432]                     }
[01:27:50.432]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.432]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.432]                       envir = envir)
[01:27:50.432]                     if (!future$lazy) 
[01:27:50.432]                       future <- run(future)
[01:27:50.432]                     invisible(future)
[01:27:50.432]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.432]                 }
[01:27:50.432]             }
[01:27:50.432]         }
[01:27:50.432]     })
[01:27:50.432]     if (TRUE) {
[01:27:50.432]         base::sink(type = "output", split = FALSE)
[01:27:50.432]         if (TRUE) {
[01:27:50.432]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.432]         }
[01:27:50.432]         else {
[01:27:50.432]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.432]         }
[01:27:50.432]         base::close(...future.stdout)
[01:27:50.432]         ...future.stdout <- NULL
[01:27:50.432]     }
[01:27:50.432]     ...future.result$conditions <- ...future.conditions
[01:27:50.432]     ...future.result$finished <- base::Sys.time()
[01:27:50.432]     ...future.result
[01:27:50.432] }
[01:27:50.438] MultisessionFuture started
[01:27:50.438] - Launch lazy future ... done
[01:27:50.438] run() for 'MultisessionFuture' ... done
[01:27:50.439] getGlobalsAndPackages() ...
[01:27:50.439] Searching for globals...
[01:27:50.439] 
[01:27:50.439] Searching for globals ... DONE
[01:27:50.440] - globals: [0] <none>
[01:27:50.440] getGlobalsAndPackages() ... DONE
[01:27:50.440] run() for 'Future' ...
[01:27:50.440] - state: 'created'
[01:27:50.440] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.455] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.455] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.455]   - Field: 'node'
[01:27:50.455]   - Field: 'label'
[01:27:50.455]   - Field: 'local'
[01:27:50.456]   - Field: 'owner'
[01:27:50.456]   - Field: 'envir'
[01:27:50.456]   - Field: 'workers'
[01:27:50.456]   - Field: 'packages'
[01:27:50.456]   - Field: 'gc'
[01:27:50.457]   - Field: 'conditions'
[01:27:50.457]   - Field: 'persistent'
[01:27:50.457]   - Field: 'expr'
[01:27:50.457]   - Field: 'uuid'
[01:27:50.457]   - Field: 'seed'
[01:27:50.457]   - Field: 'version'
[01:27:50.458]   - Field: 'result'
[01:27:50.458]   - Field: 'asynchronous'
[01:27:50.458]   - Field: 'calls'
[01:27:50.458]   - Field: 'globals'
[01:27:50.458]   - Field: 'stdout'
[01:27:50.458]   - Field: 'earlySignal'
[01:27:50.459]   - Field: 'lazy'
[01:27:50.459]   - Field: 'state'
[01:27:50.459] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.459] - Launch lazy future ...
[01:27:50.460] Packages needed by the future expression (n = 0): <none>
[01:27:50.460] Packages needed by future strategies (n = 0): <none>
[01:27:50.463] {
[01:27:50.463]     {
[01:27:50.463]         {
[01:27:50.463]             ...future.startTime <- base::Sys.time()
[01:27:50.463]             {
[01:27:50.463]                 {
[01:27:50.463]                   {
[01:27:50.463]                     {
[01:27:50.463]                       base::local({
[01:27:50.463]                         has_future <- base::requireNamespace("future", 
[01:27:50.463]                           quietly = TRUE)
[01:27:50.463]                         if (has_future) {
[01:27:50.463]                           ns <- base::getNamespace("future")
[01:27:50.463]                           version <- ns[[".package"]][["version"]]
[01:27:50.463]                           if (is.null(version)) 
[01:27:50.463]                             version <- utils::packageVersion("future")
[01:27:50.463]                         }
[01:27:50.463]                         else {
[01:27:50.463]                           version <- NULL
[01:27:50.463]                         }
[01:27:50.463]                         if (!has_future || version < "1.8.0") {
[01:27:50.463]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.463]                             "", base::R.version$version.string), 
[01:27:50.463]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.463]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.463]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.463]                               "release", "version")], collapse = " "), 
[01:27:50.463]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.463]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.463]                             info)
[01:27:50.463]                           info <- base::paste(info, collapse = "; ")
[01:27:50.463]                           if (!has_future) {
[01:27:50.463]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.463]                               info)
[01:27:50.463]                           }
[01:27:50.463]                           else {
[01:27:50.463]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.463]                               info, version)
[01:27:50.463]                           }
[01:27:50.463]                           base::stop(msg)
[01:27:50.463]                         }
[01:27:50.463]                       })
[01:27:50.463]                     }
[01:27:50.463]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.463]                     base::options(mc.cores = 1L)
[01:27:50.463]                   }
[01:27:50.463]                   options(future.plan = NULL)
[01:27:50.463]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.463]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.463]                 }
[01:27:50.463]                 ...future.workdir <- getwd()
[01:27:50.463]             }
[01:27:50.463]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.463]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.463]         }
[01:27:50.463]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.463]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.463]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.463]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.463]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.463]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.463]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.463]             base::names(...future.oldOptions))
[01:27:50.463]     }
[01:27:50.463]     if (FALSE) {
[01:27:50.463]     }
[01:27:50.463]     else {
[01:27:50.463]         if (TRUE) {
[01:27:50.463]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.463]                 open = "w")
[01:27:50.463]         }
[01:27:50.463]         else {
[01:27:50.463]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.463]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.463]         }
[01:27:50.463]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.463]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.463]             base::sink(type = "output", split = FALSE)
[01:27:50.463]             base::close(...future.stdout)
[01:27:50.463]         }, add = TRUE)
[01:27:50.463]     }
[01:27:50.463]     ...future.frame <- base::sys.nframe()
[01:27:50.463]     ...future.conditions <- base::list()
[01:27:50.463]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.463]     if (FALSE) {
[01:27:50.463]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.463]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.463]     }
[01:27:50.463]     ...future.result <- base::tryCatch({
[01:27:50.463]         base::withCallingHandlers({
[01:27:50.463]             ...future.value <- base::withVisible(base::local({
[01:27:50.463]                 ...future.makeSendCondition <- base::local({
[01:27:50.463]                   sendCondition <- NULL
[01:27:50.463]                   function(frame = 1L) {
[01:27:50.463]                     if (is.function(sendCondition)) 
[01:27:50.463]                       return(sendCondition)
[01:27:50.463]                     ns <- getNamespace("parallel")
[01:27:50.463]                     if (exists("sendData", mode = "function", 
[01:27:50.463]                       envir = ns)) {
[01:27:50.463]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.463]                         envir = ns)
[01:27:50.463]                       envir <- sys.frame(frame)
[01:27:50.463]                       master <- NULL
[01:27:50.463]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.463]                         !identical(envir, emptyenv())) {
[01:27:50.463]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.463]                           inherits = FALSE)) {
[01:27:50.463]                           master <- get("master", mode = "list", 
[01:27:50.463]                             envir = envir, inherits = FALSE)
[01:27:50.463]                           if (inherits(master, c("SOCKnode", 
[01:27:50.463]                             "SOCK0node"))) {
[01:27:50.463]                             sendCondition <<- function(cond) {
[01:27:50.463]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.463]                                 success = TRUE)
[01:27:50.463]                               parallel_sendData(master, data)
[01:27:50.463]                             }
[01:27:50.463]                             return(sendCondition)
[01:27:50.463]                           }
[01:27:50.463]                         }
[01:27:50.463]                         frame <- frame + 1L
[01:27:50.463]                         envir <- sys.frame(frame)
[01:27:50.463]                       }
[01:27:50.463]                     }
[01:27:50.463]                     sendCondition <<- function(cond) NULL
[01:27:50.463]                   }
[01:27:50.463]                 })
[01:27:50.463]                 withCallingHandlers({
[01:27:50.463]                   NULL
[01:27:50.463]                 }, immediateCondition = function(cond) {
[01:27:50.463]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.463]                   sendCondition(cond)
[01:27:50.463]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.463]                   {
[01:27:50.463]                     inherits <- base::inherits
[01:27:50.463]                     invokeRestart <- base::invokeRestart
[01:27:50.463]                     is.null <- base::is.null
[01:27:50.463]                     muffled <- FALSE
[01:27:50.463]                     if (inherits(cond, "message")) {
[01:27:50.463]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.463]                       if (muffled) 
[01:27:50.463]                         invokeRestart("muffleMessage")
[01:27:50.463]                     }
[01:27:50.463]                     else if (inherits(cond, "warning")) {
[01:27:50.463]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.463]                       if (muffled) 
[01:27:50.463]                         invokeRestart("muffleWarning")
[01:27:50.463]                     }
[01:27:50.463]                     else if (inherits(cond, "condition")) {
[01:27:50.463]                       if (!is.null(pattern)) {
[01:27:50.463]                         computeRestarts <- base::computeRestarts
[01:27:50.463]                         grepl <- base::grepl
[01:27:50.463]                         restarts <- computeRestarts(cond)
[01:27:50.463]                         for (restart in restarts) {
[01:27:50.463]                           name <- restart$name
[01:27:50.463]                           if (is.null(name)) 
[01:27:50.463]                             next
[01:27:50.463]                           if (!grepl(pattern, name)) 
[01:27:50.463]                             next
[01:27:50.463]                           invokeRestart(restart)
[01:27:50.463]                           muffled <- TRUE
[01:27:50.463]                           break
[01:27:50.463]                         }
[01:27:50.463]                       }
[01:27:50.463]                     }
[01:27:50.463]                     invisible(muffled)
[01:27:50.463]                   }
[01:27:50.463]                   muffleCondition(cond)
[01:27:50.463]                 })
[01:27:50.463]             }))
[01:27:50.463]             future::FutureResult(value = ...future.value$value, 
[01:27:50.463]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.463]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.463]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.463]                     ...future.globalenv.names))
[01:27:50.463]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.463]         }, condition = base::local({
[01:27:50.463]             c <- base::c
[01:27:50.463]             inherits <- base::inherits
[01:27:50.463]             invokeRestart <- base::invokeRestart
[01:27:50.463]             length <- base::length
[01:27:50.463]             list <- base::list
[01:27:50.463]             seq.int <- base::seq.int
[01:27:50.463]             signalCondition <- base::signalCondition
[01:27:50.463]             sys.calls <- base::sys.calls
[01:27:50.463]             `[[` <- base::`[[`
[01:27:50.463]             `+` <- base::`+`
[01:27:50.463]             `<<-` <- base::`<<-`
[01:27:50.463]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.463]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.463]                   3L)]
[01:27:50.463]             }
[01:27:50.463]             function(cond) {
[01:27:50.463]                 is_error <- inherits(cond, "error")
[01:27:50.463]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.463]                   NULL)
[01:27:50.463]                 if (is_error) {
[01:27:50.463]                   sessionInformation <- function() {
[01:27:50.463]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.463]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.463]                       search = base::search(), system = base::Sys.info())
[01:27:50.463]                   }
[01:27:50.463]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.463]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.463]                     cond$call), session = sessionInformation(), 
[01:27:50.463]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.463]                   signalCondition(cond)
[01:27:50.463]                 }
[01:27:50.463]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.463]                 "immediateCondition"))) {
[01:27:50.463]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.463]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.463]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.463]                   if (TRUE && !signal) {
[01:27:50.463]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.463]                     {
[01:27:50.463]                       inherits <- base::inherits
[01:27:50.463]                       invokeRestart <- base::invokeRestart
[01:27:50.463]                       is.null <- base::is.null
[01:27:50.463]                       muffled <- FALSE
[01:27:50.463]                       if (inherits(cond, "message")) {
[01:27:50.463]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.463]                         if (muffled) 
[01:27:50.463]                           invokeRestart("muffleMessage")
[01:27:50.463]                       }
[01:27:50.463]                       else if (inherits(cond, "warning")) {
[01:27:50.463]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.463]                         if (muffled) 
[01:27:50.463]                           invokeRestart("muffleWarning")
[01:27:50.463]                       }
[01:27:50.463]                       else if (inherits(cond, "condition")) {
[01:27:50.463]                         if (!is.null(pattern)) {
[01:27:50.463]                           computeRestarts <- base::computeRestarts
[01:27:50.463]                           grepl <- base::grepl
[01:27:50.463]                           restarts <- computeRestarts(cond)
[01:27:50.463]                           for (restart in restarts) {
[01:27:50.463]                             name <- restart$name
[01:27:50.463]                             if (is.null(name)) 
[01:27:50.463]                               next
[01:27:50.463]                             if (!grepl(pattern, name)) 
[01:27:50.463]                               next
[01:27:50.463]                             invokeRestart(restart)
[01:27:50.463]                             muffled <- TRUE
[01:27:50.463]                             break
[01:27:50.463]                           }
[01:27:50.463]                         }
[01:27:50.463]                       }
[01:27:50.463]                       invisible(muffled)
[01:27:50.463]                     }
[01:27:50.463]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.463]                   }
[01:27:50.463]                 }
[01:27:50.463]                 else {
[01:27:50.463]                   if (TRUE) {
[01:27:50.463]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.463]                     {
[01:27:50.463]                       inherits <- base::inherits
[01:27:50.463]                       invokeRestart <- base::invokeRestart
[01:27:50.463]                       is.null <- base::is.null
[01:27:50.463]                       muffled <- FALSE
[01:27:50.463]                       if (inherits(cond, "message")) {
[01:27:50.463]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.463]                         if (muffled) 
[01:27:50.463]                           invokeRestart("muffleMessage")
[01:27:50.463]                       }
[01:27:50.463]                       else if (inherits(cond, "warning")) {
[01:27:50.463]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.463]                         if (muffled) 
[01:27:50.463]                           invokeRestart("muffleWarning")
[01:27:50.463]                       }
[01:27:50.463]                       else if (inherits(cond, "condition")) {
[01:27:50.463]                         if (!is.null(pattern)) {
[01:27:50.463]                           computeRestarts <- base::computeRestarts
[01:27:50.463]                           grepl <- base::grepl
[01:27:50.463]                           restarts <- computeRestarts(cond)
[01:27:50.463]                           for (restart in restarts) {
[01:27:50.463]                             name <- restart$name
[01:27:50.463]                             if (is.null(name)) 
[01:27:50.463]                               next
[01:27:50.463]                             if (!grepl(pattern, name)) 
[01:27:50.463]                               next
[01:27:50.463]                             invokeRestart(restart)
[01:27:50.463]                             muffled <- TRUE
[01:27:50.463]                             break
[01:27:50.463]                           }
[01:27:50.463]                         }
[01:27:50.463]                       }
[01:27:50.463]                       invisible(muffled)
[01:27:50.463]                     }
[01:27:50.463]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.463]                   }
[01:27:50.463]                 }
[01:27:50.463]             }
[01:27:50.463]         }))
[01:27:50.463]     }, error = function(ex) {
[01:27:50.463]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.463]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.463]                 ...future.rng), started = ...future.startTime, 
[01:27:50.463]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.463]             version = "1.8"), class = "FutureResult")
[01:27:50.463]     }, finally = {
[01:27:50.463]         if (!identical(...future.workdir, getwd())) 
[01:27:50.463]             setwd(...future.workdir)
[01:27:50.463]         {
[01:27:50.463]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.463]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.463]             }
[01:27:50.463]             base::options(...future.oldOptions)
[01:27:50.463]             if (.Platform$OS.type == "windows") {
[01:27:50.463]                 old_names <- names(...future.oldEnvVars)
[01:27:50.463]                 envs <- base::Sys.getenv()
[01:27:50.463]                 names <- names(envs)
[01:27:50.463]                 common <- intersect(names, old_names)
[01:27:50.463]                 added <- setdiff(names, old_names)
[01:27:50.463]                 removed <- setdiff(old_names, names)
[01:27:50.463]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.463]                   envs[common]]
[01:27:50.463]                 NAMES <- toupper(changed)
[01:27:50.463]                 args <- list()
[01:27:50.463]                 for (kk in seq_along(NAMES)) {
[01:27:50.463]                   name <- changed[[kk]]
[01:27:50.463]                   NAME <- NAMES[[kk]]
[01:27:50.463]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.463]                     next
[01:27:50.463]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.463]                 }
[01:27:50.463]                 NAMES <- toupper(added)
[01:27:50.463]                 for (kk in seq_along(NAMES)) {
[01:27:50.463]                   name <- added[[kk]]
[01:27:50.463]                   NAME <- NAMES[[kk]]
[01:27:50.463]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.463]                     next
[01:27:50.463]                   args[[name]] <- ""
[01:27:50.463]                 }
[01:27:50.463]                 NAMES <- toupper(removed)
[01:27:50.463]                 for (kk in seq_along(NAMES)) {
[01:27:50.463]                   name <- removed[[kk]]
[01:27:50.463]                   NAME <- NAMES[[kk]]
[01:27:50.463]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.463]                     next
[01:27:50.463]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.463]                 }
[01:27:50.463]                 if (length(args) > 0) 
[01:27:50.463]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.463]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.463]             }
[01:27:50.463]             else {
[01:27:50.463]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.463]             }
[01:27:50.463]             {
[01:27:50.463]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.463]                   0L) {
[01:27:50.463]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.463]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.463]                   base::options(opts)
[01:27:50.463]                 }
[01:27:50.463]                 {
[01:27:50.463]                   {
[01:27:50.463]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.463]                     NULL
[01:27:50.463]                   }
[01:27:50.463]                   options(future.plan = NULL)
[01:27:50.463]                   if (is.na(NA_character_)) 
[01:27:50.463]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.463]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.463]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.463]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.463]                     envir = parent.frame()) 
[01:27:50.463]                   {
[01:27:50.463]                     if (is.function(workers)) 
[01:27:50.463]                       workers <- workers()
[01:27:50.463]                     workers <- structure(as.integer(workers), 
[01:27:50.463]                       class = class(workers))
[01:27:50.463]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.463]                       workers >= 1)
[01:27:50.463]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.463]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.463]                     }
[01:27:50.463]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.463]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.463]                       envir = envir)
[01:27:50.463]                     if (!future$lazy) 
[01:27:50.463]                       future <- run(future)
[01:27:50.463]                     invisible(future)
[01:27:50.463]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.463]                 }
[01:27:50.463]             }
[01:27:50.463]         }
[01:27:50.463]     })
[01:27:50.463]     if (TRUE) {
[01:27:50.463]         base::sink(type = "output", split = FALSE)
[01:27:50.463]         if (TRUE) {
[01:27:50.463]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.463]         }
[01:27:50.463]         else {
[01:27:50.463]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.463]         }
[01:27:50.463]         base::close(...future.stdout)
[01:27:50.463]         ...future.stdout <- NULL
[01:27:50.463]     }
[01:27:50.463]     ...future.result$conditions <- ...future.conditions
[01:27:50.463]     ...future.result$finished <- base::Sys.time()
[01:27:50.463]     ...future.result
[01:27:50.463] }
[01:27:50.469] MultisessionFuture started
[01:27:50.469] - Launch lazy future ... done
[01:27:50.469] run() for 'MultisessionFuture' ... done
[01:27:50.470] getGlobalsAndPackages() ...
[01:27:50.470] Searching for globals...
[01:27:50.471] - globals found: [1] '{'
[01:27:50.471] Searching for globals ... DONE
[01:27:50.471] Resolving globals: FALSE
[01:27:50.472] 
[01:27:50.472] 
[01:27:50.472] getGlobalsAndPackages() ... DONE
[01:27:50.473] run() for 'Future' ...
[01:27:50.473] - state: 'created'
[01:27:50.473] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.492] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.493] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.493]   - Field: 'node'
[01:27:50.494]   - Field: 'label'
[01:27:50.494]   - Field: 'local'
[01:27:50.494]   - Field: 'owner'
[01:27:50.495]   - Field: 'envir'
[01:27:50.495]   - Field: 'workers'
[01:27:50.495]   - Field: 'packages'
[01:27:50.496]   - Field: 'gc'
[01:27:50.496]   - Field: 'conditions'
[01:27:50.496]   - Field: 'persistent'
[01:27:50.497]   - Field: 'expr'
[01:27:50.497]   - Field: 'uuid'
[01:27:50.497]   - Field: 'seed'
[01:27:50.498]   - Field: 'version'
[01:27:50.498]   - Field: 'result'
[01:27:50.498]   - Field: 'asynchronous'
[01:27:50.499]   - Field: 'calls'
[01:27:50.499]   - Field: 'globals'
[01:27:50.499]   - Field: 'stdout'
[01:27:50.500]   - Field: 'earlySignal'
[01:27:50.500]   - Field: 'lazy'
[01:27:50.500]   - Field: 'state'
[01:27:50.501] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.501] - Launch lazy future ...
[01:27:50.502] Packages needed by the future expression (n = 0): <none>
[01:27:50.502] Packages needed by future strategies (n = 0): <none>
[01:27:50.503] {
[01:27:50.503]     {
[01:27:50.503]         {
[01:27:50.503]             ...future.startTime <- base::Sys.time()
[01:27:50.503]             {
[01:27:50.503]                 {
[01:27:50.503]                   {
[01:27:50.503]                     {
[01:27:50.503]                       base::local({
[01:27:50.503]                         has_future <- base::requireNamespace("future", 
[01:27:50.503]                           quietly = TRUE)
[01:27:50.503]                         if (has_future) {
[01:27:50.503]                           ns <- base::getNamespace("future")
[01:27:50.503]                           version <- ns[[".package"]][["version"]]
[01:27:50.503]                           if (is.null(version)) 
[01:27:50.503]                             version <- utils::packageVersion("future")
[01:27:50.503]                         }
[01:27:50.503]                         else {
[01:27:50.503]                           version <- NULL
[01:27:50.503]                         }
[01:27:50.503]                         if (!has_future || version < "1.8.0") {
[01:27:50.503]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.503]                             "", base::R.version$version.string), 
[01:27:50.503]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.503]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.503]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.503]                               "release", "version")], collapse = " "), 
[01:27:50.503]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.503]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.503]                             info)
[01:27:50.503]                           info <- base::paste(info, collapse = "; ")
[01:27:50.503]                           if (!has_future) {
[01:27:50.503]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.503]                               info)
[01:27:50.503]                           }
[01:27:50.503]                           else {
[01:27:50.503]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.503]                               info, version)
[01:27:50.503]                           }
[01:27:50.503]                           base::stop(msg)
[01:27:50.503]                         }
[01:27:50.503]                       })
[01:27:50.503]                     }
[01:27:50.503]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.503]                     base::options(mc.cores = 1L)
[01:27:50.503]                   }
[01:27:50.503]                   options(future.plan = NULL)
[01:27:50.503]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.503]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.503]                 }
[01:27:50.503]                 ...future.workdir <- getwd()
[01:27:50.503]             }
[01:27:50.503]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.503]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.503]         }
[01:27:50.503]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.503]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.503]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.503]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.503]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.503]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.503]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.503]             base::names(...future.oldOptions))
[01:27:50.503]     }
[01:27:50.503]     if (FALSE) {
[01:27:50.503]     }
[01:27:50.503]     else {
[01:27:50.503]         if (TRUE) {
[01:27:50.503]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.503]                 open = "w")
[01:27:50.503]         }
[01:27:50.503]         else {
[01:27:50.503]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.503]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.503]         }
[01:27:50.503]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.503]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.503]             base::sink(type = "output", split = FALSE)
[01:27:50.503]             base::close(...future.stdout)
[01:27:50.503]         }, add = TRUE)
[01:27:50.503]     }
[01:27:50.503]     ...future.frame <- base::sys.nframe()
[01:27:50.503]     ...future.conditions <- base::list()
[01:27:50.503]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.503]     if (FALSE) {
[01:27:50.503]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.503]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.503]     }
[01:27:50.503]     ...future.result <- base::tryCatch({
[01:27:50.503]         base::withCallingHandlers({
[01:27:50.503]             ...future.value <- base::withVisible(base::local({
[01:27:50.503]                 ...future.makeSendCondition <- base::local({
[01:27:50.503]                   sendCondition <- NULL
[01:27:50.503]                   function(frame = 1L) {
[01:27:50.503]                     if (is.function(sendCondition)) 
[01:27:50.503]                       return(sendCondition)
[01:27:50.503]                     ns <- getNamespace("parallel")
[01:27:50.503]                     if (exists("sendData", mode = "function", 
[01:27:50.503]                       envir = ns)) {
[01:27:50.503]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.503]                         envir = ns)
[01:27:50.503]                       envir <- sys.frame(frame)
[01:27:50.503]                       master <- NULL
[01:27:50.503]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.503]                         !identical(envir, emptyenv())) {
[01:27:50.503]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.503]                           inherits = FALSE)) {
[01:27:50.503]                           master <- get("master", mode = "list", 
[01:27:50.503]                             envir = envir, inherits = FALSE)
[01:27:50.503]                           if (inherits(master, c("SOCKnode", 
[01:27:50.503]                             "SOCK0node"))) {
[01:27:50.503]                             sendCondition <<- function(cond) {
[01:27:50.503]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.503]                                 success = TRUE)
[01:27:50.503]                               parallel_sendData(master, data)
[01:27:50.503]                             }
[01:27:50.503]                             return(sendCondition)
[01:27:50.503]                           }
[01:27:50.503]                         }
[01:27:50.503]                         frame <- frame + 1L
[01:27:50.503]                         envir <- sys.frame(frame)
[01:27:50.503]                       }
[01:27:50.503]                     }
[01:27:50.503]                     sendCondition <<- function(cond) NULL
[01:27:50.503]                   }
[01:27:50.503]                 })
[01:27:50.503]                 withCallingHandlers({
[01:27:50.503]                   {
[01:27:50.503]                     4
[01:27:50.503]                   }
[01:27:50.503]                 }, immediateCondition = function(cond) {
[01:27:50.503]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.503]                   sendCondition(cond)
[01:27:50.503]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.503]                   {
[01:27:50.503]                     inherits <- base::inherits
[01:27:50.503]                     invokeRestart <- base::invokeRestart
[01:27:50.503]                     is.null <- base::is.null
[01:27:50.503]                     muffled <- FALSE
[01:27:50.503]                     if (inherits(cond, "message")) {
[01:27:50.503]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.503]                       if (muffled) 
[01:27:50.503]                         invokeRestart("muffleMessage")
[01:27:50.503]                     }
[01:27:50.503]                     else if (inherits(cond, "warning")) {
[01:27:50.503]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.503]                       if (muffled) 
[01:27:50.503]                         invokeRestart("muffleWarning")
[01:27:50.503]                     }
[01:27:50.503]                     else if (inherits(cond, "condition")) {
[01:27:50.503]                       if (!is.null(pattern)) {
[01:27:50.503]                         computeRestarts <- base::computeRestarts
[01:27:50.503]                         grepl <- base::grepl
[01:27:50.503]                         restarts <- computeRestarts(cond)
[01:27:50.503]                         for (restart in restarts) {
[01:27:50.503]                           name <- restart$name
[01:27:50.503]                           if (is.null(name)) 
[01:27:50.503]                             next
[01:27:50.503]                           if (!grepl(pattern, name)) 
[01:27:50.503]                             next
[01:27:50.503]                           invokeRestart(restart)
[01:27:50.503]                           muffled <- TRUE
[01:27:50.503]                           break
[01:27:50.503]                         }
[01:27:50.503]                       }
[01:27:50.503]                     }
[01:27:50.503]                     invisible(muffled)
[01:27:50.503]                   }
[01:27:50.503]                   muffleCondition(cond)
[01:27:50.503]                 })
[01:27:50.503]             }))
[01:27:50.503]             future::FutureResult(value = ...future.value$value, 
[01:27:50.503]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.503]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.503]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.503]                     ...future.globalenv.names))
[01:27:50.503]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.503]         }, condition = base::local({
[01:27:50.503]             c <- base::c
[01:27:50.503]             inherits <- base::inherits
[01:27:50.503]             invokeRestart <- base::invokeRestart
[01:27:50.503]             length <- base::length
[01:27:50.503]             list <- base::list
[01:27:50.503]             seq.int <- base::seq.int
[01:27:50.503]             signalCondition <- base::signalCondition
[01:27:50.503]             sys.calls <- base::sys.calls
[01:27:50.503]             `[[` <- base::`[[`
[01:27:50.503]             `+` <- base::`+`
[01:27:50.503]             `<<-` <- base::`<<-`
[01:27:50.503]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.503]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.503]                   3L)]
[01:27:50.503]             }
[01:27:50.503]             function(cond) {
[01:27:50.503]                 is_error <- inherits(cond, "error")
[01:27:50.503]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.503]                   NULL)
[01:27:50.503]                 if (is_error) {
[01:27:50.503]                   sessionInformation <- function() {
[01:27:50.503]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.503]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.503]                       search = base::search(), system = base::Sys.info())
[01:27:50.503]                   }
[01:27:50.503]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.503]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.503]                     cond$call), session = sessionInformation(), 
[01:27:50.503]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.503]                   signalCondition(cond)
[01:27:50.503]                 }
[01:27:50.503]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.503]                 "immediateCondition"))) {
[01:27:50.503]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.503]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.503]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.503]                   if (TRUE && !signal) {
[01:27:50.503]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.503]                     {
[01:27:50.503]                       inherits <- base::inherits
[01:27:50.503]                       invokeRestart <- base::invokeRestart
[01:27:50.503]                       is.null <- base::is.null
[01:27:50.503]                       muffled <- FALSE
[01:27:50.503]                       if (inherits(cond, "message")) {
[01:27:50.503]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.503]                         if (muffled) 
[01:27:50.503]                           invokeRestart("muffleMessage")
[01:27:50.503]                       }
[01:27:50.503]                       else if (inherits(cond, "warning")) {
[01:27:50.503]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.503]                         if (muffled) 
[01:27:50.503]                           invokeRestart("muffleWarning")
[01:27:50.503]                       }
[01:27:50.503]                       else if (inherits(cond, "condition")) {
[01:27:50.503]                         if (!is.null(pattern)) {
[01:27:50.503]                           computeRestarts <- base::computeRestarts
[01:27:50.503]                           grepl <- base::grepl
[01:27:50.503]                           restarts <- computeRestarts(cond)
[01:27:50.503]                           for (restart in restarts) {
[01:27:50.503]                             name <- restart$name
[01:27:50.503]                             if (is.null(name)) 
[01:27:50.503]                               next
[01:27:50.503]                             if (!grepl(pattern, name)) 
[01:27:50.503]                               next
[01:27:50.503]                             invokeRestart(restart)
[01:27:50.503]                             muffled <- TRUE
[01:27:50.503]                             break
[01:27:50.503]                           }
[01:27:50.503]                         }
[01:27:50.503]                       }
[01:27:50.503]                       invisible(muffled)
[01:27:50.503]                     }
[01:27:50.503]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.503]                   }
[01:27:50.503]                 }
[01:27:50.503]                 else {
[01:27:50.503]                   if (TRUE) {
[01:27:50.503]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.503]                     {
[01:27:50.503]                       inherits <- base::inherits
[01:27:50.503]                       invokeRestart <- base::invokeRestart
[01:27:50.503]                       is.null <- base::is.null
[01:27:50.503]                       muffled <- FALSE
[01:27:50.503]                       if (inherits(cond, "message")) {
[01:27:50.503]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.503]                         if (muffled) 
[01:27:50.503]                           invokeRestart("muffleMessage")
[01:27:50.503]                       }
[01:27:50.503]                       else if (inherits(cond, "warning")) {
[01:27:50.503]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.503]                         if (muffled) 
[01:27:50.503]                           invokeRestart("muffleWarning")
[01:27:50.503]                       }
[01:27:50.503]                       else if (inherits(cond, "condition")) {
[01:27:50.503]                         if (!is.null(pattern)) {
[01:27:50.503]                           computeRestarts <- base::computeRestarts
[01:27:50.503]                           grepl <- base::grepl
[01:27:50.503]                           restarts <- computeRestarts(cond)
[01:27:50.503]                           for (restart in restarts) {
[01:27:50.503]                             name <- restart$name
[01:27:50.503]                             if (is.null(name)) 
[01:27:50.503]                               next
[01:27:50.503]                             if (!grepl(pattern, name)) 
[01:27:50.503]                               next
[01:27:50.503]                             invokeRestart(restart)
[01:27:50.503]                             muffled <- TRUE
[01:27:50.503]                             break
[01:27:50.503]                           }
[01:27:50.503]                         }
[01:27:50.503]                       }
[01:27:50.503]                       invisible(muffled)
[01:27:50.503]                     }
[01:27:50.503]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.503]                   }
[01:27:50.503]                 }
[01:27:50.503]             }
[01:27:50.503]         }))
[01:27:50.503]     }, error = function(ex) {
[01:27:50.503]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.503]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.503]                 ...future.rng), started = ...future.startTime, 
[01:27:50.503]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.503]             version = "1.8"), class = "FutureResult")
[01:27:50.503]     }, finally = {
[01:27:50.503]         if (!identical(...future.workdir, getwd())) 
[01:27:50.503]             setwd(...future.workdir)
[01:27:50.503]         {
[01:27:50.503]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.503]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.503]             }
[01:27:50.503]             base::options(...future.oldOptions)
[01:27:50.503]             if (.Platform$OS.type == "windows") {
[01:27:50.503]                 old_names <- names(...future.oldEnvVars)
[01:27:50.503]                 envs <- base::Sys.getenv()
[01:27:50.503]                 names <- names(envs)
[01:27:50.503]                 common <- intersect(names, old_names)
[01:27:50.503]                 added <- setdiff(names, old_names)
[01:27:50.503]                 removed <- setdiff(old_names, names)
[01:27:50.503]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.503]                   envs[common]]
[01:27:50.503]                 NAMES <- toupper(changed)
[01:27:50.503]                 args <- list()
[01:27:50.503]                 for (kk in seq_along(NAMES)) {
[01:27:50.503]                   name <- changed[[kk]]
[01:27:50.503]                   NAME <- NAMES[[kk]]
[01:27:50.503]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.503]                     next
[01:27:50.503]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.503]                 }
[01:27:50.503]                 NAMES <- toupper(added)
[01:27:50.503]                 for (kk in seq_along(NAMES)) {
[01:27:50.503]                   name <- added[[kk]]
[01:27:50.503]                   NAME <- NAMES[[kk]]
[01:27:50.503]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.503]                     next
[01:27:50.503]                   args[[name]] <- ""
[01:27:50.503]                 }
[01:27:50.503]                 NAMES <- toupper(removed)
[01:27:50.503]                 for (kk in seq_along(NAMES)) {
[01:27:50.503]                   name <- removed[[kk]]
[01:27:50.503]                   NAME <- NAMES[[kk]]
[01:27:50.503]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.503]                     next
[01:27:50.503]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.503]                 }
[01:27:50.503]                 if (length(args) > 0) 
[01:27:50.503]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.503]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.503]             }
[01:27:50.503]             else {
[01:27:50.503]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.503]             }
[01:27:50.503]             {
[01:27:50.503]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.503]                   0L) {
[01:27:50.503]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.503]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.503]                   base::options(opts)
[01:27:50.503]                 }
[01:27:50.503]                 {
[01:27:50.503]                   {
[01:27:50.503]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.503]                     NULL
[01:27:50.503]                   }
[01:27:50.503]                   options(future.plan = NULL)
[01:27:50.503]                   if (is.na(NA_character_)) 
[01:27:50.503]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.503]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.503]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.503]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.503]                     envir = parent.frame()) 
[01:27:50.503]                   {
[01:27:50.503]                     if (is.function(workers)) 
[01:27:50.503]                       workers <- workers()
[01:27:50.503]                     workers <- structure(as.integer(workers), 
[01:27:50.503]                       class = class(workers))
[01:27:50.503]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.503]                       workers >= 1)
[01:27:50.503]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.503]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.503]                     }
[01:27:50.503]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.503]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.503]                       envir = envir)
[01:27:50.503]                     if (!future$lazy) 
[01:27:50.503]                       future <- run(future)
[01:27:50.503]                     invisible(future)
[01:27:50.503]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.503]                 }
[01:27:50.503]             }
[01:27:50.503]         }
[01:27:50.503]     })
[01:27:50.503]     if (TRUE) {
[01:27:50.503]         base::sink(type = "output", split = FALSE)
[01:27:50.503]         if (TRUE) {
[01:27:50.503]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.503]         }
[01:27:50.503]         else {
[01:27:50.503]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.503]         }
[01:27:50.503]         base::close(...future.stdout)
[01:27:50.503]         ...future.stdout <- NULL
[01:27:50.503]     }
[01:27:50.503]     ...future.result$conditions <- ...future.conditions
[01:27:50.503]     ...future.result$finished <- base::Sys.time()
[01:27:50.503]     ...future.result
[01:27:50.503] }
[01:27:50.511] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:50.524] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.525] - Validating connection of MultisessionFuture
[01:27:50.525] - received message: FutureResult
[01:27:50.525] - Received FutureResult
[01:27:50.526] - Erased future from FutureRegistry
[01:27:50.526] result() for ClusterFuture ...
[01:27:50.526] - result already collected: FutureResult
[01:27:50.526] result() for ClusterFuture ... done
[01:27:50.526] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.527] result() for ClusterFuture ...
[01:27:50.527] - result already collected: FutureResult
[01:27:50.527] result() for ClusterFuture ... done
[01:27:50.527] result() for ClusterFuture ...
[01:27:50.527] - result already collected: FutureResult
[01:27:50.528] result() for ClusterFuture ... done
[01:27:50.529] MultisessionFuture started
[01:27:50.530] - Launch lazy future ... done
[01:27:50.530] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b0b22fd48> 
Classes 'listenv', 'environment' <environment: 0x0000025b07cac880> 
 - attr(*, "dim.")= int [1:2] 1 6
 - attr(*, "dimnames.")=List of 2
  ..$ : chr "a"
  ..$ : chr [1:6] "a" "b" "c" "d" ...
[01:27:50.535] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.536] - Validating connection of MultisessionFuture
[01:27:50.536] - received message: FutureResult
[01:27:50.536] - Received FutureResult
[01:27:50.537] - Erased future from FutureRegistry
[01:27:50.537] result() for ClusterFuture ...
[01:27:50.537] - result already collected: FutureResult
[01:27:50.537] result() for ClusterFuture ... done
[01:27:50.538] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.550] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.551] - Validating connection of MultisessionFuture
[01:27:50.551] - received message: FutureResult
[01:27:50.551] - Received FutureResult
[01:27:50.551] - Erased future from FutureRegistry
[01:27:50.551] result() for ClusterFuture ...
[01:27:50.552] - result already collected: FutureResult
[01:27:50.552] result() for ClusterFuture ... done
[01:27:50.552] 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" ...
[01:27:50.555] resolve() on list environment ...
[01:27:50.555]  recursive: 0
[01:27:50.558]  length: 6
[01:27:50.558]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:50.558] signalConditionsASAP(numeric, pos=1) ...
[01:27:50.558] - nx: 6
[01:27:50.558] - relay: TRUE
[01:27:50.559] - stdout: TRUE
[01:27:50.559] - signal: TRUE
[01:27:50.559] - resignal: FALSE
[01:27:50.559] - force: TRUE
[01:27:50.559] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.560] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.560]  - until=2
[01:27:50.560]  - relaying element #2
[01:27:50.560] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.560] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.561] signalConditionsASAP(NULL, pos=1) ... done
[01:27:50.561]  length: 5 (resolved future 1)
[01:27:50.561] Future #2
[01:27:50.561] result() for ClusterFuture ...
[01:27:50.562] - result already collected: FutureResult
[01:27:50.562] result() for ClusterFuture ... done
[01:27:50.562] result() for ClusterFuture ...
[01:27:50.562] - result already collected: FutureResult
[01:27:50.562] result() for ClusterFuture ... done
[01:27:50.563] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:50.563] - nx: 6
[01:27:50.563] - relay: TRUE
[01:27:50.563] - stdout: TRUE
[01:27:50.563] - signal: TRUE
[01:27:50.564] - resignal: FALSE
[01:27:50.564] - force: TRUE
[01:27:50.564] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.564] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.564]  - until=2
[01:27:50.564]  - relaying element #2
[01:27:50.565] result() for ClusterFuture ...
[01:27:50.565] - result already collected: FutureResult
[01:27:50.565] result() for ClusterFuture ... done
[01:27:50.565] result() for ClusterFuture ...
[01:27:50.565] - result already collected: FutureResult
[01:27:50.566] result() for ClusterFuture ... done
[01:27:50.566] result() for ClusterFuture ...
[01:27:50.566] - result already collected: FutureResult
[01:27:50.566] result() for ClusterFuture ... done
[01:27:50.566] result() for ClusterFuture ...
[01:27:50.567] - result already collected: FutureResult
[01:27:50.567] result() for ClusterFuture ... done
[01:27:50.567] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.567] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.567] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:50.568]  length: 4 (resolved future 2)
[01:27:50.568] Future #3
[01:27:50.568] result() for ClusterFuture ...
[01:27:50.568] - result already collected: FutureResult
[01:27:50.568] result() for ClusterFuture ... done
[01:27:50.569] result() for ClusterFuture ...
[01:27:50.569] - result already collected: FutureResult
[01:27:50.569] result() for ClusterFuture ... done
[01:27:50.569] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:50.569] - nx: 6
[01:27:50.569] - relay: TRUE
[01:27:50.570] - stdout: TRUE
[01:27:50.570] - signal: TRUE
[01:27:50.570] - resignal: FALSE
[01:27:50.570] - force: TRUE
[01:27:50.570] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.571] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.571]  - until=3
[01:27:50.571]  - relaying element #3
[01:27:50.571] result() for ClusterFuture ...
[01:27:50.571] - result already collected: FutureResult
[01:27:50.571] result() for ClusterFuture ... done
[01:27:50.572] result() for ClusterFuture ...
[01:27:50.572] - result already collected: FutureResult
[01:27:50.572] result() for ClusterFuture ... done
[01:27:50.572] result() for ClusterFuture ...
[01:27:50.572] - result already collected: FutureResult
[01:27:50.573] result() for ClusterFuture ... done
[01:27:50.573] result() for ClusterFuture ...
[01:27:50.573] - result already collected: FutureResult
[01:27:50.573] result() for ClusterFuture ... done
[01:27:50.573] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.574] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.574] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:50.574]  length: 3 (resolved future 3)
[01:27:50.574] Future #4
[01:27:50.574] result() for ClusterFuture ...
[01:27:50.575] - result already collected: FutureResult
[01:27:50.575] result() for ClusterFuture ... done
[01:27:50.575] result() for ClusterFuture ...
[01:27:50.575] - result already collected: FutureResult
[01:27:50.575] result() for ClusterFuture ... done
[01:27:50.575] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:50.576] - nx: 6
[01:27:50.576] - relay: TRUE
[01:27:50.576] - stdout: TRUE
[01:27:50.576] - signal: TRUE
[01:27:50.576] - resignal: FALSE
[01:27:50.576] - force: TRUE
[01:27:50.577] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.577] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.577]  - until=4
[01:27:50.577]  - relaying element #4
[01:27:50.577] result() for ClusterFuture ...
[01:27:50.578] - result already collected: FutureResult
[01:27:50.578] result() for ClusterFuture ... done
[01:27:50.578] result() for ClusterFuture ...
[01:27:50.578] - result already collected: FutureResult
[01:27:50.578] result() for ClusterFuture ... done
[01:27:50.579] result() for ClusterFuture ...
[01:27:50.579] - result already collected: FutureResult
[01:27:50.579] result() for ClusterFuture ... done
[01:27:50.579] result() for ClusterFuture ...
[01:27:50.579] - result already collected: FutureResult
[01:27:50.579] result() for ClusterFuture ... done
[01:27:50.580] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.580] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.580] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:50.580]  length: 2 (resolved future 4)
[01:27:50.580] signalConditionsASAP(NULL, pos=5) ...
[01:27:50.581] - nx: 6
[01:27:50.581] - relay: TRUE
[01:27:50.581] - stdout: TRUE
[01:27:50.581] - signal: TRUE
[01:27:50.581] - resignal: FALSE
[01:27:50.582] - force: TRUE
[01:27:50.582] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.582] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.582]  - until=6
[01:27:50.583]  - relaying element #6
[01:27:50.583] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.583] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.583] signalConditionsASAP(NULL, pos=5) ... done
[01:27:50.583]  length: 1 (resolved future 5)
[01:27:50.583] signalConditionsASAP(numeric, pos=6) ...
[01:27:50.584] - nx: 6
[01:27:50.584] - relay: TRUE
[01:27:50.584] - stdout: TRUE
[01:27:50.584] - signal: TRUE
[01:27:50.584] - resignal: FALSE
[01:27:50.584] - force: TRUE
[01:27:50.585] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.585] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.585]  - until=6
[01:27:50.585] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.585] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.586] signalConditionsASAP(numeric, pos=6) ... done
[01:27:50.586]  length: 0 (resolved future 6)
[01:27:50.586] Relaying remaining futures
[01:27:50.586] signalConditionsASAP(NULL, pos=0) ...
[01:27:50.586] - nx: 6
[01:27:50.587] - relay: TRUE
[01:27:50.587] - stdout: TRUE
[01:27:50.587] - signal: TRUE
[01:27:50.587] - resignal: FALSE
[01:27:50.587] - force: TRUE
[01:27:50.588] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.588] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:50.588] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.588] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.588] signalConditionsASAP(NULL, pos=0) ... done
[01:27:50.589] resolve() on list environment ... DONE
[01:27:50.589] result() for ClusterFuture ...
[01:27:50.589] - result already collected: FutureResult
[01:27:50.589] result() for ClusterFuture ... done
[01:27:50.589] result() for ClusterFuture ...
[01:27:50.590] - result already collected: FutureResult
[01:27:50.590] result() for ClusterFuture ... done
[01:27:50.590] result() for ClusterFuture ...
[01:27:50.590] - result already collected: FutureResult
[01:27:50.590] result() for ClusterFuture ... done
[01:27:50.590] result() for ClusterFuture ...
[01:27:50.591] - result already collected: FutureResult
[01:27:50.591] result() for ClusterFuture ... done
[01:27:50.591] result() for ClusterFuture ...
[01:27:50.591] - result already collected: FutureResult
[01:27:50.591] result() for ClusterFuture ... done
[01:27:50.592] result() for ClusterFuture ...
[01:27:50.592] - result already collected: FutureResult
[01:27:50.592] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000025b04c4d998> 
 - 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)
[01:27:50.594] getGlobalsAndPackages() ...
[01:27:50.594] Searching for globals...
[01:27:50.595] 
[01:27:50.595] Searching for globals ... DONE
[01:27:50.595] - globals: [0] <none>
[01:27:50.595] getGlobalsAndPackages() ... DONE
[01:27:50.596] run() for 'Future' ...
[01:27:50.596] - state: 'created'
[01:27:50.596] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.612] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.612] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.613]   - Field: 'node'
[01:27:50.613]   - Field: 'label'
[01:27:50.613]   - Field: 'local'
[01:27:50.613]   - Field: 'owner'
[01:27:50.613]   - Field: 'envir'
[01:27:50.614]   - Field: 'workers'
[01:27:50.614]   - Field: 'packages'
[01:27:50.614]   - Field: 'gc'
[01:27:50.614]   - Field: 'conditions'
[01:27:50.614]   - Field: 'persistent'
[01:27:50.615]   - Field: 'expr'
[01:27:50.615]   - Field: 'uuid'
[01:27:50.615]   - Field: 'seed'
[01:27:50.615]   - Field: 'version'
[01:27:50.615]   - Field: 'result'
[01:27:50.616]   - Field: 'asynchronous'
[01:27:50.616]   - Field: 'calls'
[01:27:50.616]   - Field: 'globals'
[01:27:50.616]   - Field: 'stdout'
[01:27:50.616]   - Field: 'earlySignal'
[01:27:50.617]   - Field: 'lazy'
[01:27:50.617]   - Field: 'state'
[01:27:50.617] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.617] - Launch lazy future ...
[01:27:50.618] Packages needed by the future expression (n = 0): <none>
[01:27:50.618] Packages needed by future strategies (n = 0): <none>
[01:27:50.619] {
[01:27:50.619]     {
[01:27:50.619]         {
[01:27:50.619]             ...future.startTime <- base::Sys.time()
[01:27:50.619]             {
[01:27:50.619]                 {
[01:27:50.619]                   {
[01:27:50.619]                     {
[01:27:50.619]                       base::local({
[01:27:50.619]                         has_future <- base::requireNamespace("future", 
[01:27:50.619]                           quietly = TRUE)
[01:27:50.619]                         if (has_future) {
[01:27:50.619]                           ns <- base::getNamespace("future")
[01:27:50.619]                           version <- ns[[".package"]][["version"]]
[01:27:50.619]                           if (is.null(version)) 
[01:27:50.619]                             version <- utils::packageVersion("future")
[01:27:50.619]                         }
[01:27:50.619]                         else {
[01:27:50.619]                           version <- NULL
[01:27:50.619]                         }
[01:27:50.619]                         if (!has_future || version < "1.8.0") {
[01:27:50.619]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.619]                             "", base::R.version$version.string), 
[01:27:50.619]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.619]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.619]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.619]                               "release", "version")], collapse = " "), 
[01:27:50.619]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.619]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.619]                             info)
[01:27:50.619]                           info <- base::paste(info, collapse = "; ")
[01:27:50.619]                           if (!has_future) {
[01:27:50.619]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.619]                               info)
[01:27:50.619]                           }
[01:27:50.619]                           else {
[01:27:50.619]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.619]                               info, version)
[01:27:50.619]                           }
[01:27:50.619]                           base::stop(msg)
[01:27:50.619]                         }
[01:27:50.619]                       })
[01:27:50.619]                     }
[01:27:50.619]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.619]                     base::options(mc.cores = 1L)
[01:27:50.619]                   }
[01:27:50.619]                   options(future.plan = NULL)
[01:27:50.619]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.619]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.619]                 }
[01:27:50.619]                 ...future.workdir <- getwd()
[01:27:50.619]             }
[01:27:50.619]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.619]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.619]         }
[01:27:50.619]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.619]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.619]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.619]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.619]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.619]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.619]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.619]             base::names(...future.oldOptions))
[01:27:50.619]     }
[01:27:50.619]     if (FALSE) {
[01:27:50.619]     }
[01:27:50.619]     else {
[01:27:50.619]         if (TRUE) {
[01:27:50.619]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.619]                 open = "w")
[01:27:50.619]         }
[01:27:50.619]         else {
[01:27:50.619]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.619]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.619]         }
[01:27:50.619]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.619]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.619]             base::sink(type = "output", split = FALSE)
[01:27:50.619]             base::close(...future.stdout)
[01:27:50.619]         }, add = TRUE)
[01:27:50.619]     }
[01:27:50.619]     ...future.frame <- base::sys.nframe()
[01:27:50.619]     ...future.conditions <- base::list()
[01:27:50.619]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.619]     if (FALSE) {
[01:27:50.619]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.619]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.619]     }
[01:27:50.619]     ...future.result <- base::tryCatch({
[01:27:50.619]         base::withCallingHandlers({
[01:27:50.619]             ...future.value <- base::withVisible(base::local({
[01:27:50.619]                 ...future.makeSendCondition <- base::local({
[01:27:50.619]                   sendCondition <- NULL
[01:27:50.619]                   function(frame = 1L) {
[01:27:50.619]                     if (is.function(sendCondition)) 
[01:27:50.619]                       return(sendCondition)
[01:27:50.619]                     ns <- getNamespace("parallel")
[01:27:50.619]                     if (exists("sendData", mode = "function", 
[01:27:50.619]                       envir = ns)) {
[01:27:50.619]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.619]                         envir = ns)
[01:27:50.619]                       envir <- sys.frame(frame)
[01:27:50.619]                       master <- NULL
[01:27:50.619]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.619]                         !identical(envir, emptyenv())) {
[01:27:50.619]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.619]                           inherits = FALSE)) {
[01:27:50.619]                           master <- get("master", mode = "list", 
[01:27:50.619]                             envir = envir, inherits = FALSE)
[01:27:50.619]                           if (inherits(master, c("SOCKnode", 
[01:27:50.619]                             "SOCK0node"))) {
[01:27:50.619]                             sendCondition <<- function(cond) {
[01:27:50.619]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.619]                                 success = TRUE)
[01:27:50.619]                               parallel_sendData(master, data)
[01:27:50.619]                             }
[01:27:50.619]                             return(sendCondition)
[01:27:50.619]                           }
[01:27:50.619]                         }
[01:27:50.619]                         frame <- frame + 1L
[01:27:50.619]                         envir <- sys.frame(frame)
[01:27:50.619]                       }
[01:27:50.619]                     }
[01:27:50.619]                     sendCondition <<- function(cond) NULL
[01:27:50.619]                   }
[01:27:50.619]                 })
[01:27:50.619]                 withCallingHandlers({
[01:27:50.619]                   2
[01:27:50.619]                 }, immediateCondition = function(cond) {
[01:27:50.619]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.619]                   sendCondition(cond)
[01:27:50.619]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.619]                   {
[01:27:50.619]                     inherits <- base::inherits
[01:27:50.619]                     invokeRestart <- base::invokeRestart
[01:27:50.619]                     is.null <- base::is.null
[01:27:50.619]                     muffled <- FALSE
[01:27:50.619]                     if (inherits(cond, "message")) {
[01:27:50.619]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.619]                       if (muffled) 
[01:27:50.619]                         invokeRestart("muffleMessage")
[01:27:50.619]                     }
[01:27:50.619]                     else if (inherits(cond, "warning")) {
[01:27:50.619]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.619]                       if (muffled) 
[01:27:50.619]                         invokeRestart("muffleWarning")
[01:27:50.619]                     }
[01:27:50.619]                     else if (inherits(cond, "condition")) {
[01:27:50.619]                       if (!is.null(pattern)) {
[01:27:50.619]                         computeRestarts <- base::computeRestarts
[01:27:50.619]                         grepl <- base::grepl
[01:27:50.619]                         restarts <- computeRestarts(cond)
[01:27:50.619]                         for (restart in restarts) {
[01:27:50.619]                           name <- restart$name
[01:27:50.619]                           if (is.null(name)) 
[01:27:50.619]                             next
[01:27:50.619]                           if (!grepl(pattern, name)) 
[01:27:50.619]                             next
[01:27:50.619]                           invokeRestart(restart)
[01:27:50.619]                           muffled <- TRUE
[01:27:50.619]                           break
[01:27:50.619]                         }
[01:27:50.619]                       }
[01:27:50.619]                     }
[01:27:50.619]                     invisible(muffled)
[01:27:50.619]                   }
[01:27:50.619]                   muffleCondition(cond)
[01:27:50.619]                 })
[01:27:50.619]             }))
[01:27:50.619]             future::FutureResult(value = ...future.value$value, 
[01:27:50.619]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.619]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.619]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.619]                     ...future.globalenv.names))
[01:27:50.619]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.619]         }, condition = base::local({
[01:27:50.619]             c <- base::c
[01:27:50.619]             inherits <- base::inherits
[01:27:50.619]             invokeRestart <- base::invokeRestart
[01:27:50.619]             length <- base::length
[01:27:50.619]             list <- base::list
[01:27:50.619]             seq.int <- base::seq.int
[01:27:50.619]             signalCondition <- base::signalCondition
[01:27:50.619]             sys.calls <- base::sys.calls
[01:27:50.619]             `[[` <- base::`[[`
[01:27:50.619]             `+` <- base::`+`
[01:27:50.619]             `<<-` <- base::`<<-`
[01:27:50.619]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.619]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.619]                   3L)]
[01:27:50.619]             }
[01:27:50.619]             function(cond) {
[01:27:50.619]                 is_error <- inherits(cond, "error")
[01:27:50.619]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.619]                   NULL)
[01:27:50.619]                 if (is_error) {
[01:27:50.619]                   sessionInformation <- function() {
[01:27:50.619]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.619]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.619]                       search = base::search(), system = base::Sys.info())
[01:27:50.619]                   }
[01:27:50.619]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.619]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.619]                     cond$call), session = sessionInformation(), 
[01:27:50.619]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.619]                   signalCondition(cond)
[01:27:50.619]                 }
[01:27:50.619]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.619]                 "immediateCondition"))) {
[01:27:50.619]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.619]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.619]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.619]                   if (TRUE && !signal) {
[01:27:50.619]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.619]                     {
[01:27:50.619]                       inherits <- base::inherits
[01:27:50.619]                       invokeRestart <- base::invokeRestart
[01:27:50.619]                       is.null <- base::is.null
[01:27:50.619]                       muffled <- FALSE
[01:27:50.619]                       if (inherits(cond, "message")) {
[01:27:50.619]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.619]                         if (muffled) 
[01:27:50.619]                           invokeRestart("muffleMessage")
[01:27:50.619]                       }
[01:27:50.619]                       else if (inherits(cond, "warning")) {
[01:27:50.619]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.619]                         if (muffled) 
[01:27:50.619]                           invokeRestart("muffleWarning")
[01:27:50.619]                       }
[01:27:50.619]                       else if (inherits(cond, "condition")) {
[01:27:50.619]                         if (!is.null(pattern)) {
[01:27:50.619]                           computeRestarts <- base::computeRestarts
[01:27:50.619]                           grepl <- base::grepl
[01:27:50.619]                           restarts <- computeRestarts(cond)
[01:27:50.619]                           for (restart in restarts) {
[01:27:50.619]                             name <- restart$name
[01:27:50.619]                             if (is.null(name)) 
[01:27:50.619]                               next
[01:27:50.619]                             if (!grepl(pattern, name)) 
[01:27:50.619]                               next
[01:27:50.619]                             invokeRestart(restart)
[01:27:50.619]                             muffled <- TRUE
[01:27:50.619]                             break
[01:27:50.619]                           }
[01:27:50.619]                         }
[01:27:50.619]                       }
[01:27:50.619]                       invisible(muffled)
[01:27:50.619]                     }
[01:27:50.619]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.619]                   }
[01:27:50.619]                 }
[01:27:50.619]                 else {
[01:27:50.619]                   if (TRUE) {
[01:27:50.619]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.619]                     {
[01:27:50.619]                       inherits <- base::inherits
[01:27:50.619]                       invokeRestart <- base::invokeRestart
[01:27:50.619]                       is.null <- base::is.null
[01:27:50.619]                       muffled <- FALSE
[01:27:50.619]                       if (inherits(cond, "message")) {
[01:27:50.619]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.619]                         if (muffled) 
[01:27:50.619]                           invokeRestart("muffleMessage")
[01:27:50.619]                       }
[01:27:50.619]                       else if (inherits(cond, "warning")) {
[01:27:50.619]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.619]                         if (muffled) 
[01:27:50.619]                           invokeRestart("muffleWarning")
[01:27:50.619]                       }
[01:27:50.619]                       else if (inherits(cond, "condition")) {
[01:27:50.619]                         if (!is.null(pattern)) {
[01:27:50.619]                           computeRestarts <- base::computeRestarts
[01:27:50.619]                           grepl <- base::grepl
[01:27:50.619]                           restarts <- computeRestarts(cond)
[01:27:50.619]                           for (restart in restarts) {
[01:27:50.619]                             name <- restart$name
[01:27:50.619]                             if (is.null(name)) 
[01:27:50.619]                               next
[01:27:50.619]                             if (!grepl(pattern, name)) 
[01:27:50.619]                               next
[01:27:50.619]                             invokeRestart(restart)
[01:27:50.619]                             muffled <- TRUE
[01:27:50.619]                             break
[01:27:50.619]                           }
[01:27:50.619]                         }
[01:27:50.619]                       }
[01:27:50.619]                       invisible(muffled)
[01:27:50.619]                     }
[01:27:50.619]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.619]                   }
[01:27:50.619]                 }
[01:27:50.619]             }
[01:27:50.619]         }))
[01:27:50.619]     }, error = function(ex) {
[01:27:50.619]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.619]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.619]                 ...future.rng), started = ...future.startTime, 
[01:27:50.619]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.619]             version = "1.8"), class = "FutureResult")
[01:27:50.619]     }, finally = {
[01:27:50.619]         if (!identical(...future.workdir, getwd())) 
[01:27:50.619]             setwd(...future.workdir)
[01:27:50.619]         {
[01:27:50.619]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.619]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.619]             }
[01:27:50.619]             base::options(...future.oldOptions)
[01:27:50.619]             if (.Platform$OS.type == "windows") {
[01:27:50.619]                 old_names <- names(...future.oldEnvVars)
[01:27:50.619]                 envs <- base::Sys.getenv()
[01:27:50.619]                 names <- names(envs)
[01:27:50.619]                 common <- intersect(names, old_names)
[01:27:50.619]                 added <- setdiff(names, old_names)
[01:27:50.619]                 removed <- setdiff(old_names, names)
[01:27:50.619]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.619]                   envs[common]]
[01:27:50.619]                 NAMES <- toupper(changed)
[01:27:50.619]                 args <- list()
[01:27:50.619]                 for (kk in seq_along(NAMES)) {
[01:27:50.619]                   name <- changed[[kk]]
[01:27:50.619]                   NAME <- NAMES[[kk]]
[01:27:50.619]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.619]                     next
[01:27:50.619]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.619]                 }
[01:27:50.619]                 NAMES <- toupper(added)
[01:27:50.619]                 for (kk in seq_along(NAMES)) {
[01:27:50.619]                   name <- added[[kk]]
[01:27:50.619]                   NAME <- NAMES[[kk]]
[01:27:50.619]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.619]                     next
[01:27:50.619]                   args[[name]] <- ""
[01:27:50.619]                 }
[01:27:50.619]                 NAMES <- toupper(removed)
[01:27:50.619]                 for (kk in seq_along(NAMES)) {
[01:27:50.619]                   name <- removed[[kk]]
[01:27:50.619]                   NAME <- NAMES[[kk]]
[01:27:50.619]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.619]                     next
[01:27:50.619]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.619]                 }
[01:27:50.619]                 if (length(args) > 0) 
[01:27:50.619]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.619]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.619]             }
[01:27:50.619]             else {
[01:27:50.619]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.619]             }
[01:27:50.619]             {
[01:27:50.619]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.619]                   0L) {
[01:27:50.619]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.619]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.619]                   base::options(opts)
[01:27:50.619]                 }
[01:27:50.619]                 {
[01:27:50.619]                   {
[01:27:50.619]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.619]                     NULL
[01:27:50.619]                   }
[01:27:50.619]                   options(future.plan = NULL)
[01:27:50.619]                   if (is.na(NA_character_)) 
[01:27:50.619]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.619]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.619]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.619]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.619]                     envir = parent.frame()) 
[01:27:50.619]                   {
[01:27:50.619]                     if (is.function(workers)) 
[01:27:50.619]                       workers <- workers()
[01:27:50.619]                     workers <- structure(as.integer(workers), 
[01:27:50.619]                       class = class(workers))
[01:27:50.619]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.619]                       workers >= 1)
[01:27:50.619]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.619]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.619]                     }
[01:27:50.619]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.619]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.619]                       envir = envir)
[01:27:50.619]                     if (!future$lazy) 
[01:27:50.619]                       future <- run(future)
[01:27:50.619]                     invisible(future)
[01:27:50.619]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.619]                 }
[01:27:50.619]             }
[01:27:50.619]         }
[01:27:50.619]     })
[01:27:50.619]     if (TRUE) {
[01:27:50.619]         base::sink(type = "output", split = FALSE)
[01:27:50.619]         if (TRUE) {
[01:27:50.619]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.619]         }
[01:27:50.619]         else {
[01:27:50.619]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.619]         }
[01:27:50.619]         base::close(...future.stdout)
[01:27:50.619]         ...future.stdout <- NULL
[01:27:50.619]     }
[01:27:50.619]     ...future.result$conditions <- ...future.conditions
[01:27:50.619]     ...future.result$finished <- base::Sys.time()
[01:27:50.619]     ...future.result
[01:27:50.619] }
[01:27:50.626] MultisessionFuture started
[01:27:50.627] - Launch lazy future ... done
[01:27:50.627] run() for 'MultisessionFuture' ... done
[01:27:50.627] getGlobalsAndPackages() ...
[01:27:50.627] Searching for globals...
[01:27:50.628] 
[01:27:50.628] Searching for globals ... DONE
[01:27:50.628] - globals: [0] <none>
[01:27:50.628] getGlobalsAndPackages() ... DONE
[01:27:50.629] run() for 'Future' ...
[01:27:50.629] - state: 'created'
[01:27:50.629] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.644] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.645] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.645]   - Field: 'node'
[01:27:50.645]   - Field: 'label'
[01:27:50.645]   - Field: 'local'
[01:27:50.645]   - Field: 'owner'
[01:27:50.645]   - Field: 'envir'
[01:27:50.646]   - Field: 'workers'
[01:27:50.646]   - Field: 'packages'
[01:27:50.646]   - Field: 'gc'
[01:27:50.646]   - Field: 'conditions'
[01:27:50.646]   - Field: 'persistent'
[01:27:50.647]   - Field: 'expr'
[01:27:50.647]   - Field: 'uuid'
[01:27:50.647]   - Field: 'seed'
[01:27:50.647]   - Field: 'version'
[01:27:50.647]   - Field: 'result'
[01:27:50.647]   - Field: 'asynchronous'
[01:27:50.648]   - Field: 'calls'
[01:27:50.648]   - Field: 'globals'
[01:27:50.648]   - Field: 'stdout'
[01:27:50.648]   - Field: 'earlySignal'
[01:27:50.648]   - Field: 'lazy'
[01:27:50.649]   - Field: 'state'
[01:27:50.649] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.649] - Launch lazy future ...
[01:27:50.650] Packages needed by the future expression (n = 0): <none>
[01:27:50.650] Packages needed by future strategies (n = 0): <none>
[01:27:50.651] {
[01:27:50.651]     {
[01:27:50.651]         {
[01:27:50.651]             ...future.startTime <- base::Sys.time()
[01:27:50.651]             {
[01:27:50.651]                 {
[01:27:50.651]                   {
[01:27:50.651]                     {
[01:27:50.651]                       base::local({
[01:27:50.651]                         has_future <- base::requireNamespace("future", 
[01:27:50.651]                           quietly = TRUE)
[01:27:50.651]                         if (has_future) {
[01:27:50.651]                           ns <- base::getNamespace("future")
[01:27:50.651]                           version <- ns[[".package"]][["version"]]
[01:27:50.651]                           if (is.null(version)) 
[01:27:50.651]                             version <- utils::packageVersion("future")
[01:27:50.651]                         }
[01:27:50.651]                         else {
[01:27:50.651]                           version <- NULL
[01:27:50.651]                         }
[01:27:50.651]                         if (!has_future || version < "1.8.0") {
[01:27:50.651]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.651]                             "", base::R.version$version.string), 
[01:27:50.651]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.651]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.651]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.651]                               "release", "version")], collapse = " "), 
[01:27:50.651]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.651]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.651]                             info)
[01:27:50.651]                           info <- base::paste(info, collapse = "; ")
[01:27:50.651]                           if (!has_future) {
[01:27:50.651]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.651]                               info)
[01:27:50.651]                           }
[01:27:50.651]                           else {
[01:27:50.651]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.651]                               info, version)
[01:27:50.651]                           }
[01:27:50.651]                           base::stop(msg)
[01:27:50.651]                         }
[01:27:50.651]                       })
[01:27:50.651]                     }
[01:27:50.651]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.651]                     base::options(mc.cores = 1L)
[01:27:50.651]                   }
[01:27:50.651]                   options(future.plan = NULL)
[01:27:50.651]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.651]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.651]                 }
[01:27:50.651]                 ...future.workdir <- getwd()
[01:27:50.651]             }
[01:27:50.651]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.651]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.651]         }
[01:27:50.651]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.651]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.651]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.651]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.651]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.651]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.651]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.651]             base::names(...future.oldOptions))
[01:27:50.651]     }
[01:27:50.651]     if (FALSE) {
[01:27:50.651]     }
[01:27:50.651]     else {
[01:27:50.651]         if (TRUE) {
[01:27:50.651]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.651]                 open = "w")
[01:27:50.651]         }
[01:27:50.651]         else {
[01:27:50.651]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.651]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.651]         }
[01:27:50.651]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.651]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.651]             base::sink(type = "output", split = FALSE)
[01:27:50.651]             base::close(...future.stdout)
[01:27:50.651]         }, add = TRUE)
[01:27:50.651]     }
[01:27:50.651]     ...future.frame <- base::sys.nframe()
[01:27:50.651]     ...future.conditions <- base::list()
[01:27:50.651]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.651]     if (FALSE) {
[01:27:50.651]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.651]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.651]     }
[01:27:50.651]     ...future.result <- base::tryCatch({
[01:27:50.651]         base::withCallingHandlers({
[01:27:50.651]             ...future.value <- base::withVisible(base::local({
[01:27:50.651]                 ...future.makeSendCondition <- base::local({
[01:27:50.651]                   sendCondition <- NULL
[01:27:50.651]                   function(frame = 1L) {
[01:27:50.651]                     if (is.function(sendCondition)) 
[01:27:50.651]                       return(sendCondition)
[01:27:50.651]                     ns <- getNamespace("parallel")
[01:27:50.651]                     if (exists("sendData", mode = "function", 
[01:27:50.651]                       envir = ns)) {
[01:27:50.651]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.651]                         envir = ns)
[01:27:50.651]                       envir <- sys.frame(frame)
[01:27:50.651]                       master <- NULL
[01:27:50.651]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.651]                         !identical(envir, emptyenv())) {
[01:27:50.651]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.651]                           inherits = FALSE)) {
[01:27:50.651]                           master <- get("master", mode = "list", 
[01:27:50.651]                             envir = envir, inherits = FALSE)
[01:27:50.651]                           if (inherits(master, c("SOCKnode", 
[01:27:50.651]                             "SOCK0node"))) {
[01:27:50.651]                             sendCondition <<- function(cond) {
[01:27:50.651]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.651]                                 success = TRUE)
[01:27:50.651]                               parallel_sendData(master, data)
[01:27:50.651]                             }
[01:27:50.651]                             return(sendCondition)
[01:27:50.651]                           }
[01:27:50.651]                         }
[01:27:50.651]                         frame <- frame + 1L
[01:27:50.651]                         envir <- sys.frame(frame)
[01:27:50.651]                       }
[01:27:50.651]                     }
[01:27:50.651]                     sendCondition <<- function(cond) NULL
[01:27:50.651]                   }
[01:27:50.651]                 })
[01:27:50.651]                 withCallingHandlers({
[01:27:50.651]                   NULL
[01:27:50.651]                 }, immediateCondition = function(cond) {
[01:27:50.651]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.651]                   sendCondition(cond)
[01:27:50.651]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.651]                   {
[01:27:50.651]                     inherits <- base::inherits
[01:27:50.651]                     invokeRestart <- base::invokeRestart
[01:27:50.651]                     is.null <- base::is.null
[01:27:50.651]                     muffled <- FALSE
[01:27:50.651]                     if (inherits(cond, "message")) {
[01:27:50.651]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.651]                       if (muffled) 
[01:27:50.651]                         invokeRestart("muffleMessage")
[01:27:50.651]                     }
[01:27:50.651]                     else if (inherits(cond, "warning")) {
[01:27:50.651]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.651]                       if (muffled) 
[01:27:50.651]                         invokeRestart("muffleWarning")
[01:27:50.651]                     }
[01:27:50.651]                     else if (inherits(cond, "condition")) {
[01:27:50.651]                       if (!is.null(pattern)) {
[01:27:50.651]                         computeRestarts <- base::computeRestarts
[01:27:50.651]                         grepl <- base::grepl
[01:27:50.651]                         restarts <- computeRestarts(cond)
[01:27:50.651]                         for (restart in restarts) {
[01:27:50.651]                           name <- restart$name
[01:27:50.651]                           if (is.null(name)) 
[01:27:50.651]                             next
[01:27:50.651]                           if (!grepl(pattern, name)) 
[01:27:50.651]                             next
[01:27:50.651]                           invokeRestart(restart)
[01:27:50.651]                           muffled <- TRUE
[01:27:50.651]                           break
[01:27:50.651]                         }
[01:27:50.651]                       }
[01:27:50.651]                     }
[01:27:50.651]                     invisible(muffled)
[01:27:50.651]                   }
[01:27:50.651]                   muffleCondition(cond)
[01:27:50.651]                 })
[01:27:50.651]             }))
[01:27:50.651]             future::FutureResult(value = ...future.value$value, 
[01:27:50.651]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.651]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.651]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.651]                     ...future.globalenv.names))
[01:27:50.651]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.651]         }, condition = base::local({
[01:27:50.651]             c <- base::c
[01:27:50.651]             inherits <- base::inherits
[01:27:50.651]             invokeRestart <- base::invokeRestart
[01:27:50.651]             length <- base::length
[01:27:50.651]             list <- base::list
[01:27:50.651]             seq.int <- base::seq.int
[01:27:50.651]             signalCondition <- base::signalCondition
[01:27:50.651]             sys.calls <- base::sys.calls
[01:27:50.651]             `[[` <- base::`[[`
[01:27:50.651]             `+` <- base::`+`
[01:27:50.651]             `<<-` <- base::`<<-`
[01:27:50.651]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.651]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.651]                   3L)]
[01:27:50.651]             }
[01:27:50.651]             function(cond) {
[01:27:50.651]                 is_error <- inherits(cond, "error")
[01:27:50.651]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.651]                   NULL)
[01:27:50.651]                 if (is_error) {
[01:27:50.651]                   sessionInformation <- function() {
[01:27:50.651]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.651]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.651]                       search = base::search(), system = base::Sys.info())
[01:27:50.651]                   }
[01:27:50.651]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.651]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.651]                     cond$call), session = sessionInformation(), 
[01:27:50.651]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.651]                   signalCondition(cond)
[01:27:50.651]                 }
[01:27:50.651]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.651]                 "immediateCondition"))) {
[01:27:50.651]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.651]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.651]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.651]                   if (TRUE && !signal) {
[01:27:50.651]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.651]                     {
[01:27:50.651]                       inherits <- base::inherits
[01:27:50.651]                       invokeRestart <- base::invokeRestart
[01:27:50.651]                       is.null <- base::is.null
[01:27:50.651]                       muffled <- FALSE
[01:27:50.651]                       if (inherits(cond, "message")) {
[01:27:50.651]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.651]                         if (muffled) 
[01:27:50.651]                           invokeRestart("muffleMessage")
[01:27:50.651]                       }
[01:27:50.651]                       else if (inherits(cond, "warning")) {
[01:27:50.651]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.651]                         if (muffled) 
[01:27:50.651]                           invokeRestart("muffleWarning")
[01:27:50.651]                       }
[01:27:50.651]                       else if (inherits(cond, "condition")) {
[01:27:50.651]                         if (!is.null(pattern)) {
[01:27:50.651]                           computeRestarts <- base::computeRestarts
[01:27:50.651]                           grepl <- base::grepl
[01:27:50.651]                           restarts <- computeRestarts(cond)
[01:27:50.651]                           for (restart in restarts) {
[01:27:50.651]                             name <- restart$name
[01:27:50.651]                             if (is.null(name)) 
[01:27:50.651]                               next
[01:27:50.651]                             if (!grepl(pattern, name)) 
[01:27:50.651]                               next
[01:27:50.651]                             invokeRestart(restart)
[01:27:50.651]                             muffled <- TRUE
[01:27:50.651]                             break
[01:27:50.651]                           }
[01:27:50.651]                         }
[01:27:50.651]                       }
[01:27:50.651]                       invisible(muffled)
[01:27:50.651]                     }
[01:27:50.651]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.651]                   }
[01:27:50.651]                 }
[01:27:50.651]                 else {
[01:27:50.651]                   if (TRUE) {
[01:27:50.651]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.651]                     {
[01:27:50.651]                       inherits <- base::inherits
[01:27:50.651]                       invokeRestart <- base::invokeRestart
[01:27:50.651]                       is.null <- base::is.null
[01:27:50.651]                       muffled <- FALSE
[01:27:50.651]                       if (inherits(cond, "message")) {
[01:27:50.651]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.651]                         if (muffled) 
[01:27:50.651]                           invokeRestart("muffleMessage")
[01:27:50.651]                       }
[01:27:50.651]                       else if (inherits(cond, "warning")) {
[01:27:50.651]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.651]                         if (muffled) 
[01:27:50.651]                           invokeRestart("muffleWarning")
[01:27:50.651]                       }
[01:27:50.651]                       else if (inherits(cond, "condition")) {
[01:27:50.651]                         if (!is.null(pattern)) {
[01:27:50.651]                           computeRestarts <- base::computeRestarts
[01:27:50.651]                           grepl <- base::grepl
[01:27:50.651]                           restarts <- computeRestarts(cond)
[01:27:50.651]                           for (restart in restarts) {
[01:27:50.651]                             name <- restart$name
[01:27:50.651]                             if (is.null(name)) 
[01:27:50.651]                               next
[01:27:50.651]                             if (!grepl(pattern, name)) 
[01:27:50.651]                               next
[01:27:50.651]                             invokeRestart(restart)
[01:27:50.651]                             muffled <- TRUE
[01:27:50.651]                             break
[01:27:50.651]                           }
[01:27:50.651]                         }
[01:27:50.651]                       }
[01:27:50.651]                       invisible(muffled)
[01:27:50.651]                     }
[01:27:50.651]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.651]                   }
[01:27:50.651]                 }
[01:27:50.651]             }
[01:27:50.651]         }))
[01:27:50.651]     }, error = function(ex) {
[01:27:50.651]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.651]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.651]                 ...future.rng), started = ...future.startTime, 
[01:27:50.651]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.651]             version = "1.8"), class = "FutureResult")
[01:27:50.651]     }, finally = {
[01:27:50.651]         if (!identical(...future.workdir, getwd())) 
[01:27:50.651]             setwd(...future.workdir)
[01:27:50.651]         {
[01:27:50.651]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.651]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.651]             }
[01:27:50.651]             base::options(...future.oldOptions)
[01:27:50.651]             if (.Platform$OS.type == "windows") {
[01:27:50.651]                 old_names <- names(...future.oldEnvVars)
[01:27:50.651]                 envs <- base::Sys.getenv()
[01:27:50.651]                 names <- names(envs)
[01:27:50.651]                 common <- intersect(names, old_names)
[01:27:50.651]                 added <- setdiff(names, old_names)
[01:27:50.651]                 removed <- setdiff(old_names, names)
[01:27:50.651]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.651]                   envs[common]]
[01:27:50.651]                 NAMES <- toupper(changed)
[01:27:50.651]                 args <- list()
[01:27:50.651]                 for (kk in seq_along(NAMES)) {
[01:27:50.651]                   name <- changed[[kk]]
[01:27:50.651]                   NAME <- NAMES[[kk]]
[01:27:50.651]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.651]                     next
[01:27:50.651]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.651]                 }
[01:27:50.651]                 NAMES <- toupper(added)
[01:27:50.651]                 for (kk in seq_along(NAMES)) {
[01:27:50.651]                   name <- added[[kk]]
[01:27:50.651]                   NAME <- NAMES[[kk]]
[01:27:50.651]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.651]                     next
[01:27:50.651]                   args[[name]] <- ""
[01:27:50.651]                 }
[01:27:50.651]                 NAMES <- toupper(removed)
[01:27:50.651]                 for (kk in seq_along(NAMES)) {
[01:27:50.651]                   name <- removed[[kk]]
[01:27:50.651]                   NAME <- NAMES[[kk]]
[01:27:50.651]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.651]                     next
[01:27:50.651]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.651]                 }
[01:27:50.651]                 if (length(args) > 0) 
[01:27:50.651]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.651]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.651]             }
[01:27:50.651]             else {
[01:27:50.651]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.651]             }
[01:27:50.651]             {
[01:27:50.651]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.651]                   0L) {
[01:27:50.651]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.651]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.651]                   base::options(opts)
[01:27:50.651]                 }
[01:27:50.651]                 {
[01:27:50.651]                   {
[01:27:50.651]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.651]                     NULL
[01:27:50.651]                   }
[01:27:50.651]                   options(future.plan = NULL)
[01:27:50.651]                   if (is.na(NA_character_)) 
[01:27:50.651]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.651]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.651]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.651]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.651]                     envir = parent.frame()) 
[01:27:50.651]                   {
[01:27:50.651]                     if (is.function(workers)) 
[01:27:50.651]                       workers <- workers()
[01:27:50.651]                     workers <- structure(as.integer(workers), 
[01:27:50.651]                       class = class(workers))
[01:27:50.651]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.651]                       workers >= 1)
[01:27:50.651]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.651]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.651]                     }
[01:27:50.651]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.651]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.651]                       envir = envir)
[01:27:50.651]                     if (!future$lazy) 
[01:27:50.651]                       future <- run(future)
[01:27:50.651]                     invisible(future)
[01:27:50.651]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.651]                 }
[01:27:50.651]             }
[01:27:50.651]         }
[01:27:50.651]     })
[01:27:50.651]     if (TRUE) {
[01:27:50.651]         base::sink(type = "output", split = FALSE)
[01:27:50.651]         if (TRUE) {
[01:27:50.651]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.651]         }
[01:27:50.651]         else {
[01:27:50.651]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.651]         }
[01:27:50.651]         base::close(...future.stdout)
[01:27:50.651]         ...future.stdout <- NULL
[01:27:50.651]     }
[01:27:50.651]     ...future.result$conditions <- ...future.conditions
[01:27:50.651]     ...future.result$finished <- base::Sys.time()
[01:27:50.651]     ...future.result
[01:27:50.651] }
[01:27:50.657] MultisessionFuture started
[01:27:50.657] - Launch lazy future ... done
[01:27:50.657] run() for 'MultisessionFuture' ... done
[01:27:50.658] getGlobalsAndPackages() ...
[01:27:50.658] Searching for globals...
[01:27:50.659] - globals found: [1] '{'
[01:27:50.659] Searching for globals ... DONE
[01:27:50.660] Resolving globals: FALSE
[01:27:50.660] 
[01:27:50.660] 
[01:27:50.660] getGlobalsAndPackages() ... DONE
[01:27:50.661] run() for 'Future' ...
[01:27:50.661] - state: 'created'
[01:27:50.661] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.675] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.676] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.676]   - Field: 'node'
[01:27:50.676]   - Field: 'label'
[01:27:50.676]   - Field: 'local'
[01:27:50.676]   - Field: 'owner'
[01:27:50.677]   - Field: 'envir'
[01:27:50.677]   - Field: 'workers'
[01:27:50.677]   - Field: 'packages'
[01:27:50.677]   - Field: 'gc'
[01:27:50.677]   - Field: 'conditions'
[01:27:50.678]   - Field: 'persistent'
[01:27:50.678]   - Field: 'expr'
[01:27:50.678]   - Field: 'uuid'
[01:27:50.678]   - Field: 'seed'
[01:27:50.678]   - Field: 'version'
[01:27:50.678]   - Field: 'result'
[01:27:50.679]   - Field: 'asynchronous'
[01:27:50.679]   - Field: 'calls'
[01:27:50.679]   - Field: 'globals'
[01:27:50.679]   - Field: 'stdout'
[01:27:50.679]   - Field: 'earlySignal'
[01:27:50.680]   - Field: 'lazy'
[01:27:50.680]   - Field: 'state'
[01:27:50.680] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.680] - Launch lazy future ...
[01:27:50.681] Packages needed by the future expression (n = 0): <none>
[01:27:50.681] Packages needed by future strategies (n = 0): <none>
[01:27:50.681] {
[01:27:50.681]     {
[01:27:50.681]         {
[01:27:50.681]             ...future.startTime <- base::Sys.time()
[01:27:50.681]             {
[01:27:50.681]                 {
[01:27:50.681]                   {
[01:27:50.681]                     {
[01:27:50.681]                       base::local({
[01:27:50.681]                         has_future <- base::requireNamespace("future", 
[01:27:50.681]                           quietly = TRUE)
[01:27:50.681]                         if (has_future) {
[01:27:50.681]                           ns <- base::getNamespace("future")
[01:27:50.681]                           version <- ns[[".package"]][["version"]]
[01:27:50.681]                           if (is.null(version)) 
[01:27:50.681]                             version <- utils::packageVersion("future")
[01:27:50.681]                         }
[01:27:50.681]                         else {
[01:27:50.681]                           version <- NULL
[01:27:50.681]                         }
[01:27:50.681]                         if (!has_future || version < "1.8.0") {
[01:27:50.681]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.681]                             "", base::R.version$version.string), 
[01:27:50.681]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.681]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.681]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.681]                               "release", "version")], collapse = " "), 
[01:27:50.681]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.681]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.681]                             info)
[01:27:50.681]                           info <- base::paste(info, collapse = "; ")
[01:27:50.681]                           if (!has_future) {
[01:27:50.681]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.681]                               info)
[01:27:50.681]                           }
[01:27:50.681]                           else {
[01:27:50.681]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.681]                               info, version)
[01:27:50.681]                           }
[01:27:50.681]                           base::stop(msg)
[01:27:50.681]                         }
[01:27:50.681]                       })
[01:27:50.681]                     }
[01:27:50.681]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.681]                     base::options(mc.cores = 1L)
[01:27:50.681]                   }
[01:27:50.681]                   options(future.plan = NULL)
[01:27:50.681]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.681]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.681]                 }
[01:27:50.681]                 ...future.workdir <- getwd()
[01:27:50.681]             }
[01:27:50.681]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.681]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.681]         }
[01:27:50.681]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.681]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.681]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.681]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.681]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.681]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.681]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.681]             base::names(...future.oldOptions))
[01:27:50.681]     }
[01:27:50.681]     if (FALSE) {
[01:27:50.681]     }
[01:27:50.681]     else {
[01:27:50.681]         if (TRUE) {
[01:27:50.681]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.681]                 open = "w")
[01:27:50.681]         }
[01:27:50.681]         else {
[01:27:50.681]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.681]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.681]         }
[01:27:50.681]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.681]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.681]             base::sink(type = "output", split = FALSE)
[01:27:50.681]             base::close(...future.stdout)
[01:27:50.681]         }, add = TRUE)
[01:27:50.681]     }
[01:27:50.681]     ...future.frame <- base::sys.nframe()
[01:27:50.681]     ...future.conditions <- base::list()
[01:27:50.681]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.681]     if (FALSE) {
[01:27:50.681]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.681]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.681]     }
[01:27:50.681]     ...future.result <- base::tryCatch({
[01:27:50.681]         base::withCallingHandlers({
[01:27:50.681]             ...future.value <- base::withVisible(base::local({
[01:27:50.681]                 ...future.makeSendCondition <- base::local({
[01:27:50.681]                   sendCondition <- NULL
[01:27:50.681]                   function(frame = 1L) {
[01:27:50.681]                     if (is.function(sendCondition)) 
[01:27:50.681]                       return(sendCondition)
[01:27:50.681]                     ns <- getNamespace("parallel")
[01:27:50.681]                     if (exists("sendData", mode = "function", 
[01:27:50.681]                       envir = ns)) {
[01:27:50.681]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.681]                         envir = ns)
[01:27:50.681]                       envir <- sys.frame(frame)
[01:27:50.681]                       master <- NULL
[01:27:50.681]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.681]                         !identical(envir, emptyenv())) {
[01:27:50.681]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.681]                           inherits = FALSE)) {
[01:27:50.681]                           master <- get("master", mode = "list", 
[01:27:50.681]                             envir = envir, inherits = FALSE)
[01:27:50.681]                           if (inherits(master, c("SOCKnode", 
[01:27:50.681]                             "SOCK0node"))) {
[01:27:50.681]                             sendCondition <<- function(cond) {
[01:27:50.681]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.681]                                 success = TRUE)
[01:27:50.681]                               parallel_sendData(master, data)
[01:27:50.681]                             }
[01:27:50.681]                             return(sendCondition)
[01:27:50.681]                           }
[01:27:50.681]                         }
[01:27:50.681]                         frame <- frame + 1L
[01:27:50.681]                         envir <- sys.frame(frame)
[01:27:50.681]                       }
[01:27:50.681]                     }
[01:27:50.681]                     sendCondition <<- function(cond) NULL
[01:27:50.681]                   }
[01:27:50.681]                 })
[01:27:50.681]                 withCallingHandlers({
[01:27:50.681]                   {
[01:27:50.681]                     4
[01:27:50.681]                   }
[01:27:50.681]                 }, immediateCondition = function(cond) {
[01:27:50.681]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.681]                   sendCondition(cond)
[01:27:50.681]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.681]                   {
[01:27:50.681]                     inherits <- base::inherits
[01:27:50.681]                     invokeRestart <- base::invokeRestart
[01:27:50.681]                     is.null <- base::is.null
[01:27:50.681]                     muffled <- FALSE
[01:27:50.681]                     if (inherits(cond, "message")) {
[01:27:50.681]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.681]                       if (muffled) 
[01:27:50.681]                         invokeRestart("muffleMessage")
[01:27:50.681]                     }
[01:27:50.681]                     else if (inherits(cond, "warning")) {
[01:27:50.681]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.681]                       if (muffled) 
[01:27:50.681]                         invokeRestart("muffleWarning")
[01:27:50.681]                     }
[01:27:50.681]                     else if (inherits(cond, "condition")) {
[01:27:50.681]                       if (!is.null(pattern)) {
[01:27:50.681]                         computeRestarts <- base::computeRestarts
[01:27:50.681]                         grepl <- base::grepl
[01:27:50.681]                         restarts <- computeRestarts(cond)
[01:27:50.681]                         for (restart in restarts) {
[01:27:50.681]                           name <- restart$name
[01:27:50.681]                           if (is.null(name)) 
[01:27:50.681]                             next
[01:27:50.681]                           if (!grepl(pattern, name)) 
[01:27:50.681]                             next
[01:27:50.681]                           invokeRestart(restart)
[01:27:50.681]                           muffled <- TRUE
[01:27:50.681]                           break
[01:27:50.681]                         }
[01:27:50.681]                       }
[01:27:50.681]                     }
[01:27:50.681]                     invisible(muffled)
[01:27:50.681]                   }
[01:27:50.681]                   muffleCondition(cond)
[01:27:50.681]                 })
[01:27:50.681]             }))
[01:27:50.681]             future::FutureResult(value = ...future.value$value, 
[01:27:50.681]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.681]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.681]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.681]                     ...future.globalenv.names))
[01:27:50.681]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.681]         }, condition = base::local({
[01:27:50.681]             c <- base::c
[01:27:50.681]             inherits <- base::inherits
[01:27:50.681]             invokeRestart <- base::invokeRestart
[01:27:50.681]             length <- base::length
[01:27:50.681]             list <- base::list
[01:27:50.681]             seq.int <- base::seq.int
[01:27:50.681]             signalCondition <- base::signalCondition
[01:27:50.681]             sys.calls <- base::sys.calls
[01:27:50.681]             `[[` <- base::`[[`
[01:27:50.681]             `+` <- base::`+`
[01:27:50.681]             `<<-` <- base::`<<-`
[01:27:50.681]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.681]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.681]                   3L)]
[01:27:50.681]             }
[01:27:50.681]             function(cond) {
[01:27:50.681]                 is_error <- inherits(cond, "error")
[01:27:50.681]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.681]                   NULL)
[01:27:50.681]                 if (is_error) {
[01:27:50.681]                   sessionInformation <- function() {
[01:27:50.681]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.681]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.681]                       search = base::search(), system = base::Sys.info())
[01:27:50.681]                   }
[01:27:50.681]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.681]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.681]                     cond$call), session = sessionInformation(), 
[01:27:50.681]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.681]                   signalCondition(cond)
[01:27:50.681]                 }
[01:27:50.681]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.681]                 "immediateCondition"))) {
[01:27:50.681]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.681]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.681]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.681]                   if (TRUE && !signal) {
[01:27:50.681]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.681]                     {
[01:27:50.681]                       inherits <- base::inherits
[01:27:50.681]                       invokeRestart <- base::invokeRestart
[01:27:50.681]                       is.null <- base::is.null
[01:27:50.681]                       muffled <- FALSE
[01:27:50.681]                       if (inherits(cond, "message")) {
[01:27:50.681]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.681]                         if (muffled) 
[01:27:50.681]                           invokeRestart("muffleMessage")
[01:27:50.681]                       }
[01:27:50.681]                       else if (inherits(cond, "warning")) {
[01:27:50.681]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.681]                         if (muffled) 
[01:27:50.681]                           invokeRestart("muffleWarning")
[01:27:50.681]                       }
[01:27:50.681]                       else if (inherits(cond, "condition")) {
[01:27:50.681]                         if (!is.null(pattern)) {
[01:27:50.681]                           computeRestarts <- base::computeRestarts
[01:27:50.681]                           grepl <- base::grepl
[01:27:50.681]                           restarts <- computeRestarts(cond)
[01:27:50.681]                           for (restart in restarts) {
[01:27:50.681]                             name <- restart$name
[01:27:50.681]                             if (is.null(name)) 
[01:27:50.681]                               next
[01:27:50.681]                             if (!grepl(pattern, name)) 
[01:27:50.681]                               next
[01:27:50.681]                             invokeRestart(restart)
[01:27:50.681]                             muffled <- TRUE
[01:27:50.681]                             break
[01:27:50.681]                           }
[01:27:50.681]                         }
[01:27:50.681]                       }
[01:27:50.681]                       invisible(muffled)
[01:27:50.681]                     }
[01:27:50.681]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.681]                   }
[01:27:50.681]                 }
[01:27:50.681]                 else {
[01:27:50.681]                   if (TRUE) {
[01:27:50.681]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.681]                     {
[01:27:50.681]                       inherits <- base::inherits
[01:27:50.681]                       invokeRestart <- base::invokeRestart
[01:27:50.681]                       is.null <- base::is.null
[01:27:50.681]                       muffled <- FALSE
[01:27:50.681]                       if (inherits(cond, "message")) {
[01:27:50.681]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.681]                         if (muffled) 
[01:27:50.681]                           invokeRestart("muffleMessage")
[01:27:50.681]                       }
[01:27:50.681]                       else if (inherits(cond, "warning")) {
[01:27:50.681]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.681]                         if (muffled) 
[01:27:50.681]                           invokeRestart("muffleWarning")
[01:27:50.681]                       }
[01:27:50.681]                       else if (inherits(cond, "condition")) {
[01:27:50.681]                         if (!is.null(pattern)) {
[01:27:50.681]                           computeRestarts <- base::computeRestarts
[01:27:50.681]                           grepl <- base::grepl
[01:27:50.681]                           restarts <- computeRestarts(cond)
[01:27:50.681]                           for (restart in restarts) {
[01:27:50.681]                             name <- restart$name
[01:27:50.681]                             if (is.null(name)) 
[01:27:50.681]                               next
[01:27:50.681]                             if (!grepl(pattern, name)) 
[01:27:50.681]                               next
[01:27:50.681]                             invokeRestart(restart)
[01:27:50.681]                             muffled <- TRUE
[01:27:50.681]                             break
[01:27:50.681]                           }
[01:27:50.681]                         }
[01:27:50.681]                       }
[01:27:50.681]                       invisible(muffled)
[01:27:50.681]                     }
[01:27:50.681]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.681]                   }
[01:27:50.681]                 }
[01:27:50.681]             }
[01:27:50.681]         }))
[01:27:50.681]     }, error = function(ex) {
[01:27:50.681]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.681]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.681]                 ...future.rng), started = ...future.startTime, 
[01:27:50.681]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.681]             version = "1.8"), class = "FutureResult")
[01:27:50.681]     }, finally = {
[01:27:50.681]         if (!identical(...future.workdir, getwd())) 
[01:27:50.681]             setwd(...future.workdir)
[01:27:50.681]         {
[01:27:50.681]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.681]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.681]             }
[01:27:50.681]             base::options(...future.oldOptions)
[01:27:50.681]             if (.Platform$OS.type == "windows") {
[01:27:50.681]                 old_names <- names(...future.oldEnvVars)
[01:27:50.681]                 envs <- base::Sys.getenv()
[01:27:50.681]                 names <- names(envs)
[01:27:50.681]                 common <- intersect(names, old_names)
[01:27:50.681]                 added <- setdiff(names, old_names)
[01:27:50.681]                 removed <- setdiff(old_names, names)
[01:27:50.681]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.681]                   envs[common]]
[01:27:50.681]                 NAMES <- toupper(changed)
[01:27:50.681]                 args <- list()
[01:27:50.681]                 for (kk in seq_along(NAMES)) {
[01:27:50.681]                   name <- changed[[kk]]
[01:27:50.681]                   NAME <- NAMES[[kk]]
[01:27:50.681]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.681]                     next
[01:27:50.681]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.681]                 }
[01:27:50.681]                 NAMES <- toupper(added)
[01:27:50.681]                 for (kk in seq_along(NAMES)) {
[01:27:50.681]                   name <- added[[kk]]
[01:27:50.681]                   NAME <- NAMES[[kk]]
[01:27:50.681]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.681]                     next
[01:27:50.681]                   args[[name]] <- ""
[01:27:50.681]                 }
[01:27:50.681]                 NAMES <- toupper(removed)
[01:27:50.681]                 for (kk in seq_along(NAMES)) {
[01:27:50.681]                   name <- removed[[kk]]
[01:27:50.681]                   NAME <- NAMES[[kk]]
[01:27:50.681]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.681]                     next
[01:27:50.681]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.681]                 }
[01:27:50.681]                 if (length(args) > 0) 
[01:27:50.681]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.681]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.681]             }
[01:27:50.681]             else {
[01:27:50.681]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.681]             }
[01:27:50.681]             {
[01:27:50.681]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.681]                   0L) {
[01:27:50.681]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.681]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.681]                   base::options(opts)
[01:27:50.681]                 }
[01:27:50.681]                 {
[01:27:50.681]                   {
[01:27:50.681]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.681]                     NULL
[01:27:50.681]                   }
[01:27:50.681]                   options(future.plan = NULL)
[01:27:50.681]                   if (is.na(NA_character_)) 
[01:27:50.681]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.681]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.681]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.681]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.681]                     envir = parent.frame()) 
[01:27:50.681]                   {
[01:27:50.681]                     if (is.function(workers)) 
[01:27:50.681]                       workers <- workers()
[01:27:50.681]                     workers <- structure(as.integer(workers), 
[01:27:50.681]                       class = class(workers))
[01:27:50.681]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.681]                       workers >= 1)
[01:27:50.681]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.681]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.681]                     }
[01:27:50.681]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.681]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.681]                       envir = envir)
[01:27:50.681]                     if (!future$lazy) 
[01:27:50.681]                       future <- run(future)
[01:27:50.681]                     invisible(future)
[01:27:50.681]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.681]                 }
[01:27:50.681]             }
[01:27:50.681]         }
[01:27:50.681]     })
[01:27:50.681]     if (TRUE) {
[01:27:50.681]         base::sink(type = "output", split = FALSE)
[01:27:50.681]         if (TRUE) {
[01:27:50.681]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.681]         }
[01:27:50.681]         else {
[01:27:50.681]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.681]         }
[01:27:50.681]         base::close(...future.stdout)
[01:27:50.681]         ...future.stdout <- NULL
[01:27:50.681]     }
[01:27:50.681]     ...future.result$conditions <- ...future.conditions
[01:27:50.681]     ...future.result$finished <- base::Sys.time()
[01:27:50.681]     ...future.result
[01:27:50.681] }
[01:27:50.687] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:50.712] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.713] - Validating connection of MultisessionFuture
[01:27:50.713] - received message: FutureResult
[01:27:50.713] - Received FutureResult
[01:27:50.713] - Erased future from FutureRegistry
[01:27:50.714] result() for ClusterFuture ...
[01:27:50.714] - result already collected: FutureResult
[01:27:50.714] result() for ClusterFuture ... done
[01:27:50.714] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.715] result() for ClusterFuture ...
[01:27:50.715] - result already collected: FutureResult
[01:27:50.715] result() for ClusterFuture ... done
[01:27:50.715] result() for ClusterFuture ...
[01:27:50.715] - result already collected: FutureResult
[01:27:50.715] result() for ClusterFuture ... done
[01:27:50.717] MultisessionFuture started
[01:27:50.718] - Launch lazy future ... done
[01:27:50.718] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b0a97b128> 
Classes 'listenv', 'environment' <environment: 0x0000025b0bb1ad68> 
 - attr(*, "dim.")= int [1:2] 2 3
 - attr(*, "dimnames.")=List of 2
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:3] "a" "b" "c"
[01:27:50.728] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.728] - Validating connection of MultisessionFuture
[01:27:50.728] - received message: FutureResult
[01:27:50.728] - Received FutureResult
[01:27:50.729] - Erased future from FutureRegistry
[01:27:50.729] result() for ClusterFuture ...
[01:27:50.729] - result already collected: FutureResult
[01:27:50.729] result() for ClusterFuture ... done
[01:27:50.729] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.735] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.735] - Validating connection of MultisessionFuture
[01:27:50.736] - received message: FutureResult
[01:27:50.736] - Received FutureResult
[01:27:50.736] - Erased future from FutureRegistry
[01:27:50.736] result() for ClusterFuture ...
[01:27:50.737] - result already collected: FutureResult
[01:27:50.737] result() for ClusterFuture ... done
[01:27:50.737] 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" ...
[01:27:50.740] resolve() on list environment ...
[01:27:50.740]  recursive: 0
[01:27:50.741]  length: 6
[01:27:50.741]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:50.742] signalConditionsASAP(numeric, pos=1) ...
[01:27:50.742] - nx: 6
[01:27:50.742] - relay: TRUE
[01:27:50.742] - stdout: TRUE
[01:27:50.742] - signal: TRUE
[01:27:50.742] - resignal: FALSE
[01:27:50.743] - force: TRUE
[01:27:50.743] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.743] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.743]  - until=2
[01:27:50.743]  - relaying element #2
[01:27:50.744] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.744] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.744] signalConditionsASAP(NULL, pos=1) ... done
[01:27:50.744]  length: 5 (resolved future 1)
[01:27:50.744] Future #2
[01:27:50.744] result() for ClusterFuture ...
[01:27:50.745] - result already collected: FutureResult
[01:27:50.745] result() for ClusterFuture ... done
[01:27:50.745] result() for ClusterFuture ...
[01:27:50.745] - result already collected: FutureResult
[01:27:50.745] result() for ClusterFuture ... done
[01:27:50.745] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:50.746] - nx: 6
[01:27:50.746] - relay: TRUE
[01:27:50.746] - stdout: TRUE
[01:27:50.746] - signal: TRUE
[01:27:50.746] - resignal: FALSE
[01:27:50.746] - force: TRUE
[01:27:50.747] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.747] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.747]  - until=2
[01:27:50.747]  - relaying element #2
[01:27:50.747] result() for ClusterFuture ...
[01:27:50.747] - result already collected: FutureResult
[01:27:50.748] result() for ClusterFuture ... done
[01:27:50.748] result() for ClusterFuture ...
[01:27:50.748] - result already collected: FutureResult
[01:27:50.748] result() for ClusterFuture ... done
[01:27:50.748] result() for ClusterFuture ...
[01:27:50.748] - result already collected: FutureResult
[01:27:50.749] result() for ClusterFuture ... done
[01:27:50.749] result() for ClusterFuture ...
[01:27:50.749] - result already collected: FutureResult
[01:27:50.749] result() for ClusterFuture ... done
[01:27:50.749] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.749] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.749] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:50.750]  length: 4 (resolved future 2)
[01:27:50.750] Future #3
[01:27:50.750] result() for ClusterFuture ...
[01:27:50.750] - result already collected: FutureResult
[01:27:50.750] result() for ClusterFuture ... done
[01:27:50.751] result() for ClusterFuture ...
[01:27:50.751] - result already collected: FutureResult
[01:27:50.751] result() for ClusterFuture ... done
[01:27:50.751] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:50.751] - nx: 6
[01:27:50.751] - relay: TRUE
[01:27:50.752] - stdout: TRUE
[01:27:50.752] - signal: TRUE
[01:27:50.752] - resignal: FALSE
[01:27:50.752] - force: TRUE
[01:27:50.752] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.752] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.752]  - until=3
[01:27:50.753]  - relaying element #3
[01:27:50.753] result() for ClusterFuture ...
[01:27:50.753] - result already collected: FutureResult
[01:27:50.753] result() for ClusterFuture ... done
[01:27:50.753] result() for ClusterFuture ...
[01:27:50.753] - result already collected: FutureResult
[01:27:50.754] result() for ClusterFuture ... done
[01:27:50.754] result() for ClusterFuture ...
[01:27:50.754] - result already collected: FutureResult
[01:27:50.754] result() for ClusterFuture ... done
[01:27:50.754] result() for ClusterFuture ...
[01:27:50.754] - result already collected: FutureResult
[01:27:50.755] result() for ClusterFuture ... done
[01:27:50.755] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.755] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.755] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:50.755]  length: 3 (resolved future 3)
[01:27:50.756] Future #4
[01:27:50.756] result() for ClusterFuture ...
[01:27:50.756] - result already collected: FutureResult
[01:27:50.756] result() for ClusterFuture ... done
[01:27:50.756] result() for ClusterFuture ...
[01:27:50.756] - result already collected: FutureResult
[01:27:50.757] result() for ClusterFuture ... done
[01:27:50.757] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:50.757] - nx: 6
[01:27:50.757] - relay: TRUE
[01:27:50.757] - stdout: TRUE
[01:27:50.757] - signal: TRUE
[01:27:50.758] - resignal: FALSE
[01:27:50.758] - force: TRUE
[01:27:50.758] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.758] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.758]  - until=4
[01:27:50.758]  - relaying element #4
[01:27:50.759] result() for ClusterFuture ...
[01:27:50.759] - result already collected: FutureResult
[01:27:50.759] result() for ClusterFuture ... done
[01:27:50.759] result() for ClusterFuture ...
[01:27:50.759] - result already collected: FutureResult
[01:27:50.759] result() for ClusterFuture ... done
[01:27:50.760] result() for ClusterFuture ...
[01:27:50.760] - result already collected: FutureResult
[01:27:50.760] result() for ClusterFuture ... done
[01:27:50.760] result() for ClusterFuture ...
[01:27:50.760] - result already collected: FutureResult
[01:27:50.761] result() for ClusterFuture ... done
[01:27:50.761] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.761] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.761] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:50.761]  length: 2 (resolved future 4)
[01:27:50.761] signalConditionsASAP(NULL, pos=5) ...
[01:27:50.762] - nx: 6
[01:27:50.762] - relay: TRUE
[01:27:50.762] - stdout: TRUE
[01:27:50.762] - signal: TRUE
[01:27:50.762] - resignal: FALSE
[01:27:50.762] - force: TRUE
[01:27:50.763] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.763] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.763]  - until=6
[01:27:50.763]  - relaying element #6
[01:27:50.763] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.764] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.764] signalConditionsASAP(NULL, pos=5) ... done
[01:27:50.764]  length: 1 (resolved future 5)
[01:27:50.764] signalConditionsASAP(numeric, pos=6) ...
[01:27:50.764] - nx: 6
[01:27:50.765] - relay: TRUE
[01:27:50.765] - stdout: TRUE
[01:27:50.765] - signal: TRUE
[01:27:50.765] - resignal: FALSE
[01:27:50.765] - force: TRUE
[01:27:50.766] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.766] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.766]  - until=6
[01:27:50.766] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.766] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.767] signalConditionsASAP(numeric, pos=6) ... done
[01:27:50.767]  length: 0 (resolved future 6)
[01:27:50.767] Relaying remaining futures
[01:27:50.767] signalConditionsASAP(NULL, pos=0) ...
[01:27:50.767] - nx: 6
[01:27:50.767] - relay: TRUE
[01:27:50.768] - stdout: TRUE
[01:27:50.768] - signal: TRUE
[01:27:50.768] - resignal: FALSE
[01:27:50.768] - force: TRUE
[01:27:50.768] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.768] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:50.769] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.769] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.769] signalConditionsASAP(NULL, pos=0) ... done
[01:27:50.769] resolve() on list environment ... DONE
[01:27:50.769] result() for ClusterFuture ...
[01:27:50.770] - result already collected: FutureResult
[01:27:50.770] result() for ClusterFuture ... done
[01:27:50.770] result() for ClusterFuture ...
[01:27:50.770] - result already collected: FutureResult
[01:27:50.770] result() for ClusterFuture ... done
[01:27:50.771] result() for ClusterFuture ...
[01:27:50.771] - result already collected: FutureResult
[01:27:50.771] result() for ClusterFuture ... done
[01:27:50.771] result() for ClusterFuture ...
[01:27:50.771] - result already collected: FutureResult
[01:27:50.771] result() for ClusterFuture ... done
[01:27:50.772] result() for ClusterFuture ...
[01:27:50.772] - result already collected: FutureResult
[01:27:50.772] result() for ClusterFuture ... done
[01:27:50.772] result() for ClusterFuture ...
[01:27:50.773] - result already collected: FutureResult
[01:27:50.773] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000025b08070bc0> 
 - 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)
[01:27:50.776] getGlobalsAndPackages() ...
[01:27:50.776] Searching for globals...
[01:27:50.777] 
[01:27:50.777] Searching for globals ... DONE
[01:27:50.778] - globals: [0] <none>
[01:27:50.778] getGlobalsAndPackages() ... DONE
[01:27:50.778] run() for 'Future' ...
[01:27:50.779] - state: 'created'
[01:27:50.779] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.795] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.796] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.796]   - Field: 'node'
[01:27:50.796]   - Field: 'label'
[01:27:50.796]   - Field: 'local'
[01:27:50.797]   - Field: 'owner'
[01:27:50.797]   - Field: 'envir'
[01:27:50.797]   - Field: 'workers'
[01:27:50.797]   - Field: 'packages'
[01:27:50.797]   - Field: 'gc'
[01:27:50.797]   - Field: 'conditions'
[01:27:50.798]   - Field: 'persistent'
[01:27:50.798]   - Field: 'expr'
[01:27:50.798]   - Field: 'uuid'
[01:27:50.798]   - Field: 'seed'
[01:27:50.798]   - Field: 'version'
[01:27:50.799]   - Field: 'result'
[01:27:50.799]   - Field: 'asynchronous'
[01:27:50.799]   - Field: 'calls'
[01:27:50.799]   - Field: 'globals'
[01:27:50.799]   - Field: 'stdout'
[01:27:50.800]   - Field: 'earlySignal'
[01:27:50.800]   - Field: 'lazy'
[01:27:50.800]   - Field: 'state'
[01:27:50.800] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.800] - Launch lazy future ...
[01:27:50.801] Packages needed by the future expression (n = 0): <none>
[01:27:50.801] Packages needed by future strategies (n = 0): <none>
[01:27:50.802] {
[01:27:50.802]     {
[01:27:50.802]         {
[01:27:50.802]             ...future.startTime <- base::Sys.time()
[01:27:50.802]             {
[01:27:50.802]                 {
[01:27:50.802]                   {
[01:27:50.802]                     {
[01:27:50.802]                       base::local({
[01:27:50.802]                         has_future <- base::requireNamespace("future", 
[01:27:50.802]                           quietly = TRUE)
[01:27:50.802]                         if (has_future) {
[01:27:50.802]                           ns <- base::getNamespace("future")
[01:27:50.802]                           version <- ns[[".package"]][["version"]]
[01:27:50.802]                           if (is.null(version)) 
[01:27:50.802]                             version <- utils::packageVersion("future")
[01:27:50.802]                         }
[01:27:50.802]                         else {
[01:27:50.802]                           version <- NULL
[01:27:50.802]                         }
[01:27:50.802]                         if (!has_future || version < "1.8.0") {
[01:27:50.802]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.802]                             "", base::R.version$version.string), 
[01:27:50.802]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.802]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.802]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.802]                               "release", "version")], collapse = " "), 
[01:27:50.802]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.802]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.802]                             info)
[01:27:50.802]                           info <- base::paste(info, collapse = "; ")
[01:27:50.802]                           if (!has_future) {
[01:27:50.802]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.802]                               info)
[01:27:50.802]                           }
[01:27:50.802]                           else {
[01:27:50.802]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.802]                               info, version)
[01:27:50.802]                           }
[01:27:50.802]                           base::stop(msg)
[01:27:50.802]                         }
[01:27:50.802]                       })
[01:27:50.802]                     }
[01:27:50.802]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.802]                     base::options(mc.cores = 1L)
[01:27:50.802]                   }
[01:27:50.802]                   options(future.plan = NULL)
[01:27:50.802]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.802]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.802]                 }
[01:27:50.802]                 ...future.workdir <- getwd()
[01:27:50.802]             }
[01:27:50.802]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.802]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.802]         }
[01:27:50.802]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.802]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.802]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.802]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.802]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.802]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.802]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.802]             base::names(...future.oldOptions))
[01:27:50.802]     }
[01:27:50.802]     if (FALSE) {
[01:27:50.802]     }
[01:27:50.802]     else {
[01:27:50.802]         if (TRUE) {
[01:27:50.802]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.802]                 open = "w")
[01:27:50.802]         }
[01:27:50.802]         else {
[01:27:50.802]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.802]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.802]         }
[01:27:50.802]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.802]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.802]             base::sink(type = "output", split = FALSE)
[01:27:50.802]             base::close(...future.stdout)
[01:27:50.802]         }, add = TRUE)
[01:27:50.802]     }
[01:27:50.802]     ...future.frame <- base::sys.nframe()
[01:27:50.802]     ...future.conditions <- base::list()
[01:27:50.802]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.802]     if (FALSE) {
[01:27:50.802]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.802]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.802]     }
[01:27:50.802]     ...future.result <- base::tryCatch({
[01:27:50.802]         base::withCallingHandlers({
[01:27:50.802]             ...future.value <- base::withVisible(base::local({
[01:27:50.802]                 ...future.makeSendCondition <- base::local({
[01:27:50.802]                   sendCondition <- NULL
[01:27:50.802]                   function(frame = 1L) {
[01:27:50.802]                     if (is.function(sendCondition)) 
[01:27:50.802]                       return(sendCondition)
[01:27:50.802]                     ns <- getNamespace("parallel")
[01:27:50.802]                     if (exists("sendData", mode = "function", 
[01:27:50.802]                       envir = ns)) {
[01:27:50.802]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.802]                         envir = ns)
[01:27:50.802]                       envir <- sys.frame(frame)
[01:27:50.802]                       master <- NULL
[01:27:50.802]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.802]                         !identical(envir, emptyenv())) {
[01:27:50.802]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.802]                           inherits = FALSE)) {
[01:27:50.802]                           master <- get("master", mode = "list", 
[01:27:50.802]                             envir = envir, inherits = FALSE)
[01:27:50.802]                           if (inherits(master, c("SOCKnode", 
[01:27:50.802]                             "SOCK0node"))) {
[01:27:50.802]                             sendCondition <<- function(cond) {
[01:27:50.802]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.802]                                 success = TRUE)
[01:27:50.802]                               parallel_sendData(master, data)
[01:27:50.802]                             }
[01:27:50.802]                             return(sendCondition)
[01:27:50.802]                           }
[01:27:50.802]                         }
[01:27:50.802]                         frame <- frame + 1L
[01:27:50.802]                         envir <- sys.frame(frame)
[01:27:50.802]                       }
[01:27:50.802]                     }
[01:27:50.802]                     sendCondition <<- function(cond) NULL
[01:27:50.802]                   }
[01:27:50.802]                 })
[01:27:50.802]                 withCallingHandlers({
[01:27:50.802]                   2
[01:27:50.802]                 }, immediateCondition = function(cond) {
[01:27:50.802]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.802]                   sendCondition(cond)
[01:27:50.802]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.802]                   {
[01:27:50.802]                     inherits <- base::inherits
[01:27:50.802]                     invokeRestart <- base::invokeRestart
[01:27:50.802]                     is.null <- base::is.null
[01:27:50.802]                     muffled <- FALSE
[01:27:50.802]                     if (inherits(cond, "message")) {
[01:27:50.802]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.802]                       if (muffled) 
[01:27:50.802]                         invokeRestart("muffleMessage")
[01:27:50.802]                     }
[01:27:50.802]                     else if (inherits(cond, "warning")) {
[01:27:50.802]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.802]                       if (muffled) 
[01:27:50.802]                         invokeRestart("muffleWarning")
[01:27:50.802]                     }
[01:27:50.802]                     else if (inherits(cond, "condition")) {
[01:27:50.802]                       if (!is.null(pattern)) {
[01:27:50.802]                         computeRestarts <- base::computeRestarts
[01:27:50.802]                         grepl <- base::grepl
[01:27:50.802]                         restarts <- computeRestarts(cond)
[01:27:50.802]                         for (restart in restarts) {
[01:27:50.802]                           name <- restart$name
[01:27:50.802]                           if (is.null(name)) 
[01:27:50.802]                             next
[01:27:50.802]                           if (!grepl(pattern, name)) 
[01:27:50.802]                             next
[01:27:50.802]                           invokeRestart(restart)
[01:27:50.802]                           muffled <- TRUE
[01:27:50.802]                           break
[01:27:50.802]                         }
[01:27:50.802]                       }
[01:27:50.802]                     }
[01:27:50.802]                     invisible(muffled)
[01:27:50.802]                   }
[01:27:50.802]                   muffleCondition(cond)
[01:27:50.802]                 })
[01:27:50.802]             }))
[01:27:50.802]             future::FutureResult(value = ...future.value$value, 
[01:27:50.802]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.802]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.802]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.802]                     ...future.globalenv.names))
[01:27:50.802]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.802]         }, condition = base::local({
[01:27:50.802]             c <- base::c
[01:27:50.802]             inherits <- base::inherits
[01:27:50.802]             invokeRestart <- base::invokeRestart
[01:27:50.802]             length <- base::length
[01:27:50.802]             list <- base::list
[01:27:50.802]             seq.int <- base::seq.int
[01:27:50.802]             signalCondition <- base::signalCondition
[01:27:50.802]             sys.calls <- base::sys.calls
[01:27:50.802]             `[[` <- base::`[[`
[01:27:50.802]             `+` <- base::`+`
[01:27:50.802]             `<<-` <- base::`<<-`
[01:27:50.802]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.802]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.802]                   3L)]
[01:27:50.802]             }
[01:27:50.802]             function(cond) {
[01:27:50.802]                 is_error <- inherits(cond, "error")
[01:27:50.802]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.802]                   NULL)
[01:27:50.802]                 if (is_error) {
[01:27:50.802]                   sessionInformation <- function() {
[01:27:50.802]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.802]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.802]                       search = base::search(), system = base::Sys.info())
[01:27:50.802]                   }
[01:27:50.802]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.802]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.802]                     cond$call), session = sessionInformation(), 
[01:27:50.802]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.802]                   signalCondition(cond)
[01:27:50.802]                 }
[01:27:50.802]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.802]                 "immediateCondition"))) {
[01:27:50.802]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.802]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.802]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.802]                   if (TRUE && !signal) {
[01:27:50.802]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.802]                     {
[01:27:50.802]                       inherits <- base::inherits
[01:27:50.802]                       invokeRestart <- base::invokeRestart
[01:27:50.802]                       is.null <- base::is.null
[01:27:50.802]                       muffled <- FALSE
[01:27:50.802]                       if (inherits(cond, "message")) {
[01:27:50.802]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.802]                         if (muffled) 
[01:27:50.802]                           invokeRestart("muffleMessage")
[01:27:50.802]                       }
[01:27:50.802]                       else if (inherits(cond, "warning")) {
[01:27:50.802]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.802]                         if (muffled) 
[01:27:50.802]                           invokeRestart("muffleWarning")
[01:27:50.802]                       }
[01:27:50.802]                       else if (inherits(cond, "condition")) {
[01:27:50.802]                         if (!is.null(pattern)) {
[01:27:50.802]                           computeRestarts <- base::computeRestarts
[01:27:50.802]                           grepl <- base::grepl
[01:27:50.802]                           restarts <- computeRestarts(cond)
[01:27:50.802]                           for (restart in restarts) {
[01:27:50.802]                             name <- restart$name
[01:27:50.802]                             if (is.null(name)) 
[01:27:50.802]                               next
[01:27:50.802]                             if (!grepl(pattern, name)) 
[01:27:50.802]                               next
[01:27:50.802]                             invokeRestart(restart)
[01:27:50.802]                             muffled <- TRUE
[01:27:50.802]                             break
[01:27:50.802]                           }
[01:27:50.802]                         }
[01:27:50.802]                       }
[01:27:50.802]                       invisible(muffled)
[01:27:50.802]                     }
[01:27:50.802]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.802]                   }
[01:27:50.802]                 }
[01:27:50.802]                 else {
[01:27:50.802]                   if (TRUE) {
[01:27:50.802]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.802]                     {
[01:27:50.802]                       inherits <- base::inherits
[01:27:50.802]                       invokeRestart <- base::invokeRestart
[01:27:50.802]                       is.null <- base::is.null
[01:27:50.802]                       muffled <- FALSE
[01:27:50.802]                       if (inherits(cond, "message")) {
[01:27:50.802]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.802]                         if (muffled) 
[01:27:50.802]                           invokeRestart("muffleMessage")
[01:27:50.802]                       }
[01:27:50.802]                       else if (inherits(cond, "warning")) {
[01:27:50.802]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.802]                         if (muffled) 
[01:27:50.802]                           invokeRestart("muffleWarning")
[01:27:50.802]                       }
[01:27:50.802]                       else if (inherits(cond, "condition")) {
[01:27:50.802]                         if (!is.null(pattern)) {
[01:27:50.802]                           computeRestarts <- base::computeRestarts
[01:27:50.802]                           grepl <- base::grepl
[01:27:50.802]                           restarts <- computeRestarts(cond)
[01:27:50.802]                           for (restart in restarts) {
[01:27:50.802]                             name <- restart$name
[01:27:50.802]                             if (is.null(name)) 
[01:27:50.802]                               next
[01:27:50.802]                             if (!grepl(pattern, name)) 
[01:27:50.802]                               next
[01:27:50.802]                             invokeRestart(restart)
[01:27:50.802]                             muffled <- TRUE
[01:27:50.802]                             break
[01:27:50.802]                           }
[01:27:50.802]                         }
[01:27:50.802]                       }
[01:27:50.802]                       invisible(muffled)
[01:27:50.802]                     }
[01:27:50.802]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.802]                   }
[01:27:50.802]                 }
[01:27:50.802]             }
[01:27:50.802]         }))
[01:27:50.802]     }, error = function(ex) {
[01:27:50.802]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.802]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.802]                 ...future.rng), started = ...future.startTime, 
[01:27:50.802]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.802]             version = "1.8"), class = "FutureResult")
[01:27:50.802]     }, finally = {
[01:27:50.802]         if (!identical(...future.workdir, getwd())) 
[01:27:50.802]             setwd(...future.workdir)
[01:27:50.802]         {
[01:27:50.802]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.802]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.802]             }
[01:27:50.802]             base::options(...future.oldOptions)
[01:27:50.802]             if (.Platform$OS.type == "windows") {
[01:27:50.802]                 old_names <- names(...future.oldEnvVars)
[01:27:50.802]                 envs <- base::Sys.getenv()
[01:27:50.802]                 names <- names(envs)
[01:27:50.802]                 common <- intersect(names, old_names)
[01:27:50.802]                 added <- setdiff(names, old_names)
[01:27:50.802]                 removed <- setdiff(old_names, names)
[01:27:50.802]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.802]                   envs[common]]
[01:27:50.802]                 NAMES <- toupper(changed)
[01:27:50.802]                 args <- list()
[01:27:50.802]                 for (kk in seq_along(NAMES)) {
[01:27:50.802]                   name <- changed[[kk]]
[01:27:50.802]                   NAME <- NAMES[[kk]]
[01:27:50.802]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.802]                     next
[01:27:50.802]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.802]                 }
[01:27:50.802]                 NAMES <- toupper(added)
[01:27:50.802]                 for (kk in seq_along(NAMES)) {
[01:27:50.802]                   name <- added[[kk]]
[01:27:50.802]                   NAME <- NAMES[[kk]]
[01:27:50.802]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.802]                     next
[01:27:50.802]                   args[[name]] <- ""
[01:27:50.802]                 }
[01:27:50.802]                 NAMES <- toupper(removed)
[01:27:50.802]                 for (kk in seq_along(NAMES)) {
[01:27:50.802]                   name <- removed[[kk]]
[01:27:50.802]                   NAME <- NAMES[[kk]]
[01:27:50.802]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.802]                     next
[01:27:50.802]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.802]                 }
[01:27:50.802]                 if (length(args) > 0) 
[01:27:50.802]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.802]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.802]             }
[01:27:50.802]             else {
[01:27:50.802]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.802]             }
[01:27:50.802]             {
[01:27:50.802]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.802]                   0L) {
[01:27:50.802]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.802]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.802]                   base::options(opts)
[01:27:50.802]                 }
[01:27:50.802]                 {
[01:27:50.802]                   {
[01:27:50.802]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.802]                     NULL
[01:27:50.802]                   }
[01:27:50.802]                   options(future.plan = NULL)
[01:27:50.802]                   if (is.na(NA_character_)) 
[01:27:50.802]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.802]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.802]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.802]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.802]                     envir = parent.frame()) 
[01:27:50.802]                   {
[01:27:50.802]                     if (is.function(workers)) 
[01:27:50.802]                       workers <- workers()
[01:27:50.802]                     workers <- structure(as.integer(workers), 
[01:27:50.802]                       class = class(workers))
[01:27:50.802]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.802]                       workers >= 1)
[01:27:50.802]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.802]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.802]                     }
[01:27:50.802]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.802]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.802]                       envir = envir)
[01:27:50.802]                     if (!future$lazy) 
[01:27:50.802]                       future <- run(future)
[01:27:50.802]                     invisible(future)
[01:27:50.802]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.802]                 }
[01:27:50.802]             }
[01:27:50.802]         }
[01:27:50.802]     })
[01:27:50.802]     if (TRUE) {
[01:27:50.802]         base::sink(type = "output", split = FALSE)
[01:27:50.802]         if (TRUE) {
[01:27:50.802]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.802]         }
[01:27:50.802]         else {
[01:27:50.802]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.802]         }
[01:27:50.802]         base::close(...future.stdout)
[01:27:50.802]         ...future.stdout <- NULL
[01:27:50.802]     }
[01:27:50.802]     ...future.result$conditions <- ...future.conditions
[01:27:50.802]     ...future.result$finished <- base::Sys.time()
[01:27:50.802]     ...future.result
[01:27:50.802] }
[01:27:50.810] MultisessionFuture started
[01:27:50.810] - Launch lazy future ... done
[01:27:50.810] run() for 'MultisessionFuture' ... done
[01:27:50.811] getGlobalsAndPackages() ...
[01:27:50.811] Searching for globals...
[01:27:50.811] 
[01:27:50.812] Searching for globals ... DONE
[01:27:50.812] - globals: [0] <none>
[01:27:50.812] getGlobalsAndPackages() ... DONE
[01:27:50.812] run() for 'Future' ...
[01:27:50.812] - state: 'created'
[01:27:50.813] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.829] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.829] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.829]   - Field: 'node'
[01:27:50.830]   - Field: 'label'
[01:27:50.830]   - Field: 'local'
[01:27:50.830]   - Field: 'owner'
[01:27:50.830]   - Field: 'envir'
[01:27:50.830]   - Field: 'workers'
[01:27:50.831]   - Field: 'packages'
[01:27:50.831]   - Field: 'gc'
[01:27:50.831]   - Field: 'conditions'
[01:27:50.831]   - Field: 'persistent'
[01:27:50.831]   - Field: 'expr'
[01:27:50.832]   - Field: 'uuid'
[01:27:50.832]   - Field: 'seed'
[01:27:50.832]   - Field: 'version'
[01:27:50.832]   - Field: 'result'
[01:27:50.832]   - Field: 'asynchronous'
[01:27:50.832]   - Field: 'calls'
[01:27:50.833]   - Field: 'globals'
[01:27:50.833]   - Field: 'stdout'
[01:27:50.833]   - Field: 'earlySignal'
[01:27:50.833]   - Field: 'lazy'
[01:27:50.833]   - Field: 'state'
[01:27:50.834] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.834] - Launch lazy future ...
[01:27:50.834] Packages needed by the future expression (n = 0): <none>
[01:27:50.834] Packages needed by future strategies (n = 0): <none>
[01:27:50.835] {
[01:27:50.835]     {
[01:27:50.835]         {
[01:27:50.835]             ...future.startTime <- base::Sys.time()
[01:27:50.835]             {
[01:27:50.835]                 {
[01:27:50.835]                   {
[01:27:50.835]                     {
[01:27:50.835]                       base::local({
[01:27:50.835]                         has_future <- base::requireNamespace("future", 
[01:27:50.835]                           quietly = TRUE)
[01:27:50.835]                         if (has_future) {
[01:27:50.835]                           ns <- base::getNamespace("future")
[01:27:50.835]                           version <- ns[[".package"]][["version"]]
[01:27:50.835]                           if (is.null(version)) 
[01:27:50.835]                             version <- utils::packageVersion("future")
[01:27:50.835]                         }
[01:27:50.835]                         else {
[01:27:50.835]                           version <- NULL
[01:27:50.835]                         }
[01:27:50.835]                         if (!has_future || version < "1.8.0") {
[01:27:50.835]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.835]                             "", base::R.version$version.string), 
[01:27:50.835]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.835]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.835]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.835]                               "release", "version")], collapse = " "), 
[01:27:50.835]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.835]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.835]                             info)
[01:27:50.835]                           info <- base::paste(info, collapse = "; ")
[01:27:50.835]                           if (!has_future) {
[01:27:50.835]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.835]                               info)
[01:27:50.835]                           }
[01:27:50.835]                           else {
[01:27:50.835]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.835]                               info, version)
[01:27:50.835]                           }
[01:27:50.835]                           base::stop(msg)
[01:27:50.835]                         }
[01:27:50.835]                       })
[01:27:50.835]                     }
[01:27:50.835]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.835]                     base::options(mc.cores = 1L)
[01:27:50.835]                   }
[01:27:50.835]                   options(future.plan = NULL)
[01:27:50.835]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.835]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.835]                 }
[01:27:50.835]                 ...future.workdir <- getwd()
[01:27:50.835]             }
[01:27:50.835]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.835]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.835]         }
[01:27:50.835]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.835]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.835]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.835]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.835]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.835]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.835]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.835]             base::names(...future.oldOptions))
[01:27:50.835]     }
[01:27:50.835]     if (FALSE) {
[01:27:50.835]     }
[01:27:50.835]     else {
[01:27:50.835]         if (TRUE) {
[01:27:50.835]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.835]                 open = "w")
[01:27:50.835]         }
[01:27:50.835]         else {
[01:27:50.835]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.835]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.835]         }
[01:27:50.835]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.835]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.835]             base::sink(type = "output", split = FALSE)
[01:27:50.835]             base::close(...future.stdout)
[01:27:50.835]         }, add = TRUE)
[01:27:50.835]     }
[01:27:50.835]     ...future.frame <- base::sys.nframe()
[01:27:50.835]     ...future.conditions <- base::list()
[01:27:50.835]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.835]     if (FALSE) {
[01:27:50.835]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.835]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.835]     }
[01:27:50.835]     ...future.result <- base::tryCatch({
[01:27:50.835]         base::withCallingHandlers({
[01:27:50.835]             ...future.value <- base::withVisible(base::local({
[01:27:50.835]                 ...future.makeSendCondition <- base::local({
[01:27:50.835]                   sendCondition <- NULL
[01:27:50.835]                   function(frame = 1L) {
[01:27:50.835]                     if (is.function(sendCondition)) 
[01:27:50.835]                       return(sendCondition)
[01:27:50.835]                     ns <- getNamespace("parallel")
[01:27:50.835]                     if (exists("sendData", mode = "function", 
[01:27:50.835]                       envir = ns)) {
[01:27:50.835]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.835]                         envir = ns)
[01:27:50.835]                       envir <- sys.frame(frame)
[01:27:50.835]                       master <- NULL
[01:27:50.835]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.835]                         !identical(envir, emptyenv())) {
[01:27:50.835]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.835]                           inherits = FALSE)) {
[01:27:50.835]                           master <- get("master", mode = "list", 
[01:27:50.835]                             envir = envir, inherits = FALSE)
[01:27:50.835]                           if (inherits(master, c("SOCKnode", 
[01:27:50.835]                             "SOCK0node"))) {
[01:27:50.835]                             sendCondition <<- function(cond) {
[01:27:50.835]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.835]                                 success = TRUE)
[01:27:50.835]                               parallel_sendData(master, data)
[01:27:50.835]                             }
[01:27:50.835]                             return(sendCondition)
[01:27:50.835]                           }
[01:27:50.835]                         }
[01:27:50.835]                         frame <- frame + 1L
[01:27:50.835]                         envir <- sys.frame(frame)
[01:27:50.835]                       }
[01:27:50.835]                     }
[01:27:50.835]                     sendCondition <<- function(cond) NULL
[01:27:50.835]                   }
[01:27:50.835]                 })
[01:27:50.835]                 withCallingHandlers({
[01:27:50.835]                   NULL
[01:27:50.835]                 }, immediateCondition = function(cond) {
[01:27:50.835]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.835]                   sendCondition(cond)
[01:27:50.835]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.835]                   {
[01:27:50.835]                     inherits <- base::inherits
[01:27:50.835]                     invokeRestart <- base::invokeRestart
[01:27:50.835]                     is.null <- base::is.null
[01:27:50.835]                     muffled <- FALSE
[01:27:50.835]                     if (inherits(cond, "message")) {
[01:27:50.835]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.835]                       if (muffled) 
[01:27:50.835]                         invokeRestart("muffleMessage")
[01:27:50.835]                     }
[01:27:50.835]                     else if (inherits(cond, "warning")) {
[01:27:50.835]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.835]                       if (muffled) 
[01:27:50.835]                         invokeRestart("muffleWarning")
[01:27:50.835]                     }
[01:27:50.835]                     else if (inherits(cond, "condition")) {
[01:27:50.835]                       if (!is.null(pattern)) {
[01:27:50.835]                         computeRestarts <- base::computeRestarts
[01:27:50.835]                         grepl <- base::grepl
[01:27:50.835]                         restarts <- computeRestarts(cond)
[01:27:50.835]                         for (restart in restarts) {
[01:27:50.835]                           name <- restart$name
[01:27:50.835]                           if (is.null(name)) 
[01:27:50.835]                             next
[01:27:50.835]                           if (!grepl(pattern, name)) 
[01:27:50.835]                             next
[01:27:50.835]                           invokeRestart(restart)
[01:27:50.835]                           muffled <- TRUE
[01:27:50.835]                           break
[01:27:50.835]                         }
[01:27:50.835]                       }
[01:27:50.835]                     }
[01:27:50.835]                     invisible(muffled)
[01:27:50.835]                   }
[01:27:50.835]                   muffleCondition(cond)
[01:27:50.835]                 })
[01:27:50.835]             }))
[01:27:50.835]             future::FutureResult(value = ...future.value$value, 
[01:27:50.835]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.835]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.835]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.835]                     ...future.globalenv.names))
[01:27:50.835]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.835]         }, condition = base::local({
[01:27:50.835]             c <- base::c
[01:27:50.835]             inherits <- base::inherits
[01:27:50.835]             invokeRestart <- base::invokeRestart
[01:27:50.835]             length <- base::length
[01:27:50.835]             list <- base::list
[01:27:50.835]             seq.int <- base::seq.int
[01:27:50.835]             signalCondition <- base::signalCondition
[01:27:50.835]             sys.calls <- base::sys.calls
[01:27:50.835]             `[[` <- base::`[[`
[01:27:50.835]             `+` <- base::`+`
[01:27:50.835]             `<<-` <- base::`<<-`
[01:27:50.835]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.835]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.835]                   3L)]
[01:27:50.835]             }
[01:27:50.835]             function(cond) {
[01:27:50.835]                 is_error <- inherits(cond, "error")
[01:27:50.835]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.835]                   NULL)
[01:27:50.835]                 if (is_error) {
[01:27:50.835]                   sessionInformation <- function() {
[01:27:50.835]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.835]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.835]                       search = base::search(), system = base::Sys.info())
[01:27:50.835]                   }
[01:27:50.835]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.835]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.835]                     cond$call), session = sessionInformation(), 
[01:27:50.835]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.835]                   signalCondition(cond)
[01:27:50.835]                 }
[01:27:50.835]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.835]                 "immediateCondition"))) {
[01:27:50.835]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.835]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.835]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.835]                   if (TRUE && !signal) {
[01:27:50.835]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.835]                     {
[01:27:50.835]                       inherits <- base::inherits
[01:27:50.835]                       invokeRestart <- base::invokeRestart
[01:27:50.835]                       is.null <- base::is.null
[01:27:50.835]                       muffled <- FALSE
[01:27:50.835]                       if (inherits(cond, "message")) {
[01:27:50.835]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.835]                         if (muffled) 
[01:27:50.835]                           invokeRestart("muffleMessage")
[01:27:50.835]                       }
[01:27:50.835]                       else if (inherits(cond, "warning")) {
[01:27:50.835]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.835]                         if (muffled) 
[01:27:50.835]                           invokeRestart("muffleWarning")
[01:27:50.835]                       }
[01:27:50.835]                       else if (inherits(cond, "condition")) {
[01:27:50.835]                         if (!is.null(pattern)) {
[01:27:50.835]                           computeRestarts <- base::computeRestarts
[01:27:50.835]                           grepl <- base::grepl
[01:27:50.835]                           restarts <- computeRestarts(cond)
[01:27:50.835]                           for (restart in restarts) {
[01:27:50.835]                             name <- restart$name
[01:27:50.835]                             if (is.null(name)) 
[01:27:50.835]                               next
[01:27:50.835]                             if (!grepl(pattern, name)) 
[01:27:50.835]                               next
[01:27:50.835]                             invokeRestart(restart)
[01:27:50.835]                             muffled <- TRUE
[01:27:50.835]                             break
[01:27:50.835]                           }
[01:27:50.835]                         }
[01:27:50.835]                       }
[01:27:50.835]                       invisible(muffled)
[01:27:50.835]                     }
[01:27:50.835]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.835]                   }
[01:27:50.835]                 }
[01:27:50.835]                 else {
[01:27:50.835]                   if (TRUE) {
[01:27:50.835]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.835]                     {
[01:27:50.835]                       inherits <- base::inherits
[01:27:50.835]                       invokeRestart <- base::invokeRestart
[01:27:50.835]                       is.null <- base::is.null
[01:27:50.835]                       muffled <- FALSE
[01:27:50.835]                       if (inherits(cond, "message")) {
[01:27:50.835]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.835]                         if (muffled) 
[01:27:50.835]                           invokeRestart("muffleMessage")
[01:27:50.835]                       }
[01:27:50.835]                       else if (inherits(cond, "warning")) {
[01:27:50.835]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.835]                         if (muffled) 
[01:27:50.835]                           invokeRestart("muffleWarning")
[01:27:50.835]                       }
[01:27:50.835]                       else if (inherits(cond, "condition")) {
[01:27:50.835]                         if (!is.null(pattern)) {
[01:27:50.835]                           computeRestarts <- base::computeRestarts
[01:27:50.835]                           grepl <- base::grepl
[01:27:50.835]                           restarts <- computeRestarts(cond)
[01:27:50.835]                           for (restart in restarts) {
[01:27:50.835]                             name <- restart$name
[01:27:50.835]                             if (is.null(name)) 
[01:27:50.835]                               next
[01:27:50.835]                             if (!grepl(pattern, name)) 
[01:27:50.835]                               next
[01:27:50.835]                             invokeRestart(restart)
[01:27:50.835]                             muffled <- TRUE
[01:27:50.835]                             break
[01:27:50.835]                           }
[01:27:50.835]                         }
[01:27:50.835]                       }
[01:27:50.835]                       invisible(muffled)
[01:27:50.835]                     }
[01:27:50.835]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.835]                   }
[01:27:50.835]                 }
[01:27:50.835]             }
[01:27:50.835]         }))
[01:27:50.835]     }, error = function(ex) {
[01:27:50.835]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.835]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.835]                 ...future.rng), started = ...future.startTime, 
[01:27:50.835]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.835]             version = "1.8"), class = "FutureResult")
[01:27:50.835]     }, finally = {
[01:27:50.835]         if (!identical(...future.workdir, getwd())) 
[01:27:50.835]             setwd(...future.workdir)
[01:27:50.835]         {
[01:27:50.835]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.835]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.835]             }
[01:27:50.835]             base::options(...future.oldOptions)
[01:27:50.835]             if (.Platform$OS.type == "windows") {
[01:27:50.835]                 old_names <- names(...future.oldEnvVars)
[01:27:50.835]                 envs <- base::Sys.getenv()
[01:27:50.835]                 names <- names(envs)
[01:27:50.835]                 common <- intersect(names, old_names)
[01:27:50.835]                 added <- setdiff(names, old_names)
[01:27:50.835]                 removed <- setdiff(old_names, names)
[01:27:50.835]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.835]                   envs[common]]
[01:27:50.835]                 NAMES <- toupper(changed)
[01:27:50.835]                 args <- list()
[01:27:50.835]                 for (kk in seq_along(NAMES)) {
[01:27:50.835]                   name <- changed[[kk]]
[01:27:50.835]                   NAME <- NAMES[[kk]]
[01:27:50.835]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.835]                     next
[01:27:50.835]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.835]                 }
[01:27:50.835]                 NAMES <- toupper(added)
[01:27:50.835]                 for (kk in seq_along(NAMES)) {
[01:27:50.835]                   name <- added[[kk]]
[01:27:50.835]                   NAME <- NAMES[[kk]]
[01:27:50.835]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.835]                     next
[01:27:50.835]                   args[[name]] <- ""
[01:27:50.835]                 }
[01:27:50.835]                 NAMES <- toupper(removed)
[01:27:50.835]                 for (kk in seq_along(NAMES)) {
[01:27:50.835]                   name <- removed[[kk]]
[01:27:50.835]                   NAME <- NAMES[[kk]]
[01:27:50.835]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.835]                     next
[01:27:50.835]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.835]                 }
[01:27:50.835]                 if (length(args) > 0) 
[01:27:50.835]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.835]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.835]             }
[01:27:50.835]             else {
[01:27:50.835]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.835]             }
[01:27:50.835]             {
[01:27:50.835]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.835]                   0L) {
[01:27:50.835]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.835]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.835]                   base::options(opts)
[01:27:50.835]                 }
[01:27:50.835]                 {
[01:27:50.835]                   {
[01:27:50.835]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.835]                     NULL
[01:27:50.835]                   }
[01:27:50.835]                   options(future.plan = NULL)
[01:27:50.835]                   if (is.na(NA_character_)) 
[01:27:50.835]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.835]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.835]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.835]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.835]                     envir = parent.frame()) 
[01:27:50.835]                   {
[01:27:50.835]                     if (is.function(workers)) 
[01:27:50.835]                       workers <- workers()
[01:27:50.835]                     workers <- structure(as.integer(workers), 
[01:27:50.835]                       class = class(workers))
[01:27:50.835]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.835]                       workers >= 1)
[01:27:50.835]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.835]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.835]                     }
[01:27:50.835]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.835]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.835]                       envir = envir)
[01:27:50.835]                     if (!future$lazy) 
[01:27:50.835]                       future <- run(future)
[01:27:50.835]                     invisible(future)
[01:27:50.835]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.835]                 }
[01:27:50.835]             }
[01:27:50.835]         }
[01:27:50.835]     })
[01:27:50.835]     if (TRUE) {
[01:27:50.835]         base::sink(type = "output", split = FALSE)
[01:27:50.835]         if (TRUE) {
[01:27:50.835]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.835]         }
[01:27:50.835]         else {
[01:27:50.835]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.835]         }
[01:27:50.835]         base::close(...future.stdout)
[01:27:50.835]         ...future.stdout <- NULL
[01:27:50.835]     }
[01:27:50.835]     ...future.result$conditions <- ...future.conditions
[01:27:50.835]     ...future.result$finished <- base::Sys.time()
[01:27:50.835]     ...future.result
[01:27:50.835] }
[01:27:50.843] MultisessionFuture started
[01:27:50.843] - Launch lazy future ... done
[01:27:50.843] run() for 'MultisessionFuture' ... done
[01:27:50.844] getGlobalsAndPackages() ...
[01:27:50.844] Searching for globals...
[01:27:50.845] - globals found: [1] '{'
[01:27:50.845] Searching for globals ... DONE
[01:27:50.845] Resolving globals: FALSE
[01:27:50.846] 
[01:27:50.846] 
[01:27:50.846] getGlobalsAndPackages() ... DONE
[01:27:50.846] run() for 'Future' ...
[01:27:50.847] - state: 'created'
[01:27:50.847] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.863] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.863] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.864]   - Field: 'node'
[01:27:50.864]   - Field: 'label'
[01:27:50.864]   - Field: 'local'
[01:27:50.864]   - Field: 'owner'
[01:27:50.865]   - Field: 'envir'
[01:27:50.865]   - Field: 'workers'
[01:27:50.865]   - Field: 'packages'
[01:27:50.865]   - Field: 'gc'
[01:27:50.865]   - Field: 'conditions'
[01:27:50.866]   - Field: 'persistent'
[01:27:50.866]   - Field: 'expr'
[01:27:50.866]   - Field: 'uuid'
[01:27:50.866]   - Field: 'seed'
[01:27:50.866]   - Field: 'version'
[01:27:50.867]   - Field: 'result'
[01:27:50.867]   - Field: 'asynchronous'
[01:27:50.867]   - Field: 'calls'
[01:27:50.867]   - Field: 'globals'
[01:27:50.867]   - Field: 'stdout'
[01:27:50.867]   - Field: 'earlySignal'
[01:27:50.868]   - Field: 'lazy'
[01:27:50.868]   - Field: 'state'
[01:27:50.868] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.868] - Launch lazy future ...
[01:27:50.869] Packages needed by the future expression (n = 0): <none>
[01:27:50.869] Packages needed by future strategies (n = 0): <none>
[01:27:50.869] {
[01:27:50.869]     {
[01:27:50.869]         {
[01:27:50.869]             ...future.startTime <- base::Sys.time()
[01:27:50.869]             {
[01:27:50.869]                 {
[01:27:50.869]                   {
[01:27:50.869]                     {
[01:27:50.869]                       base::local({
[01:27:50.869]                         has_future <- base::requireNamespace("future", 
[01:27:50.869]                           quietly = TRUE)
[01:27:50.869]                         if (has_future) {
[01:27:50.869]                           ns <- base::getNamespace("future")
[01:27:50.869]                           version <- ns[[".package"]][["version"]]
[01:27:50.869]                           if (is.null(version)) 
[01:27:50.869]                             version <- utils::packageVersion("future")
[01:27:50.869]                         }
[01:27:50.869]                         else {
[01:27:50.869]                           version <- NULL
[01:27:50.869]                         }
[01:27:50.869]                         if (!has_future || version < "1.8.0") {
[01:27:50.869]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.869]                             "", base::R.version$version.string), 
[01:27:50.869]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.869]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.869]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.869]                               "release", "version")], collapse = " "), 
[01:27:50.869]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.869]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.869]                             info)
[01:27:50.869]                           info <- base::paste(info, collapse = "; ")
[01:27:50.869]                           if (!has_future) {
[01:27:50.869]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.869]                               info)
[01:27:50.869]                           }
[01:27:50.869]                           else {
[01:27:50.869]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.869]                               info, version)
[01:27:50.869]                           }
[01:27:50.869]                           base::stop(msg)
[01:27:50.869]                         }
[01:27:50.869]                       })
[01:27:50.869]                     }
[01:27:50.869]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.869]                     base::options(mc.cores = 1L)
[01:27:50.869]                   }
[01:27:50.869]                   options(future.plan = NULL)
[01:27:50.869]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.869]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.869]                 }
[01:27:50.869]                 ...future.workdir <- getwd()
[01:27:50.869]             }
[01:27:50.869]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.869]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.869]         }
[01:27:50.869]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.869]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.869]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.869]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.869]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.869]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.869]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.869]             base::names(...future.oldOptions))
[01:27:50.869]     }
[01:27:50.869]     if (FALSE) {
[01:27:50.869]     }
[01:27:50.869]     else {
[01:27:50.869]         if (TRUE) {
[01:27:50.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.869]                 open = "w")
[01:27:50.869]         }
[01:27:50.869]         else {
[01:27:50.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.869]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.869]         }
[01:27:50.869]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.869]             base::sink(type = "output", split = FALSE)
[01:27:50.869]             base::close(...future.stdout)
[01:27:50.869]         }, add = TRUE)
[01:27:50.869]     }
[01:27:50.869]     ...future.frame <- base::sys.nframe()
[01:27:50.869]     ...future.conditions <- base::list()
[01:27:50.869]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.869]     if (FALSE) {
[01:27:50.869]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.869]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.869]     }
[01:27:50.869]     ...future.result <- base::tryCatch({
[01:27:50.869]         base::withCallingHandlers({
[01:27:50.869]             ...future.value <- base::withVisible(base::local({
[01:27:50.869]                 ...future.makeSendCondition <- base::local({
[01:27:50.869]                   sendCondition <- NULL
[01:27:50.869]                   function(frame = 1L) {
[01:27:50.869]                     if (is.function(sendCondition)) 
[01:27:50.869]                       return(sendCondition)
[01:27:50.869]                     ns <- getNamespace("parallel")
[01:27:50.869]                     if (exists("sendData", mode = "function", 
[01:27:50.869]                       envir = ns)) {
[01:27:50.869]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.869]                         envir = ns)
[01:27:50.869]                       envir <- sys.frame(frame)
[01:27:50.869]                       master <- NULL
[01:27:50.869]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.869]                         !identical(envir, emptyenv())) {
[01:27:50.869]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.869]                           inherits = FALSE)) {
[01:27:50.869]                           master <- get("master", mode = "list", 
[01:27:50.869]                             envir = envir, inherits = FALSE)
[01:27:50.869]                           if (inherits(master, c("SOCKnode", 
[01:27:50.869]                             "SOCK0node"))) {
[01:27:50.869]                             sendCondition <<- function(cond) {
[01:27:50.869]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.869]                                 success = TRUE)
[01:27:50.869]                               parallel_sendData(master, data)
[01:27:50.869]                             }
[01:27:50.869]                             return(sendCondition)
[01:27:50.869]                           }
[01:27:50.869]                         }
[01:27:50.869]                         frame <- frame + 1L
[01:27:50.869]                         envir <- sys.frame(frame)
[01:27:50.869]                       }
[01:27:50.869]                     }
[01:27:50.869]                     sendCondition <<- function(cond) NULL
[01:27:50.869]                   }
[01:27:50.869]                 })
[01:27:50.869]                 withCallingHandlers({
[01:27:50.869]                   {
[01:27:50.869]                     4
[01:27:50.869]                   }
[01:27:50.869]                 }, immediateCondition = function(cond) {
[01:27:50.869]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.869]                   sendCondition(cond)
[01:27:50.869]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.869]                   {
[01:27:50.869]                     inherits <- base::inherits
[01:27:50.869]                     invokeRestart <- base::invokeRestart
[01:27:50.869]                     is.null <- base::is.null
[01:27:50.869]                     muffled <- FALSE
[01:27:50.869]                     if (inherits(cond, "message")) {
[01:27:50.869]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.869]                       if (muffled) 
[01:27:50.869]                         invokeRestart("muffleMessage")
[01:27:50.869]                     }
[01:27:50.869]                     else if (inherits(cond, "warning")) {
[01:27:50.869]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.869]                       if (muffled) 
[01:27:50.869]                         invokeRestart("muffleWarning")
[01:27:50.869]                     }
[01:27:50.869]                     else if (inherits(cond, "condition")) {
[01:27:50.869]                       if (!is.null(pattern)) {
[01:27:50.869]                         computeRestarts <- base::computeRestarts
[01:27:50.869]                         grepl <- base::grepl
[01:27:50.869]                         restarts <- computeRestarts(cond)
[01:27:50.869]                         for (restart in restarts) {
[01:27:50.869]                           name <- restart$name
[01:27:50.869]                           if (is.null(name)) 
[01:27:50.869]                             next
[01:27:50.869]                           if (!grepl(pattern, name)) 
[01:27:50.869]                             next
[01:27:50.869]                           invokeRestart(restart)
[01:27:50.869]                           muffled <- TRUE
[01:27:50.869]                           break
[01:27:50.869]                         }
[01:27:50.869]                       }
[01:27:50.869]                     }
[01:27:50.869]                     invisible(muffled)
[01:27:50.869]                   }
[01:27:50.869]                   muffleCondition(cond)
[01:27:50.869]                 })
[01:27:50.869]             }))
[01:27:50.869]             future::FutureResult(value = ...future.value$value, 
[01:27:50.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.869]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.869]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.869]                     ...future.globalenv.names))
[01:27:50.869]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.869]         }, condition = base::local({
[01:27:50.869]             c <- base::c
[01:27:50.869]             inherits <- base::inherits
[01:27:50.869]             invokeRestart <- base::invokeRestart
[01:27:50.869]             length <- base::length
[01:27:50.869]             list <- base::list
[01:27:50.869]             seq.int <- base::seq.int
[01:27:50.869]             signalCondition <- base::signalCondition
[01:27:50.869]             sys.calls <- base::sys.calls
[01:27:50.869]             `[[` <- base::`[[`
[01:27:50.869]             `+` <- base::`+`
[01:27:50.869]             `<<-` <- base::`<<-`
[01:27:50.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.869]                   3L)]
[01:27:50.869]             }
[01:27:50.869]             function(cond) {
[01:27:50.869]                 is_error <- inherits(cond, "error")
[01:27:50.869]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.869]                   NULL)
[01:27:50.869]                 if (is_error) {
[01:27:50.869]                   sessionInformation <- function() {
[01:27:50.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.869]                       search = base::search(), system = base::Sys.info())
[01:27:50.869]                   }
[01:27:50.869]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.869]                     cond$call), session = sessionInformation(), 
[01:27:50.869]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.869]                   signalCondition(cond)
[01:27:50.869]                 }
[01:27:50.869]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.869]                 "immediateCondition"))) {
[01:27:50.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.869]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.869]                   if (TRUE && !signal) {
[01:27:50.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.869]                     {
[01:27:50.869]                       inherits <- base::inherits
[01:27:50.869]                       invokeRestart <- base::invokeRestart
[01:27:50.869]                       is.null <- base::is.null
[01:27:50.869]                       muffled <- FALSE
[01:27:50.869]                       if (inherits(cond, "message")) {
[01:27:50.869]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.869]                         if (muffled) 
[01:27:50.869]                           invokeRestart("muffleMessage")
[01:27:50.869]                       }
[01:27:50.869]                       else if (inherits(cond, "warning")) {
[01:27:50.869]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.869]                         if (muffled) 
[01:27:50.869]                           invokeRestart("muffleWarning")
[01:27:50.869]                       }
[01:27:50.869]                       else if (inherits(cond, "condition")) {
[01:27:50.869]                         if (!is.null(pattern)) {
[01:27:50.869]                           computeRestarts <- base::computeRestarts
[01:27:50.869]                           grepl <- base::grepl
[01:27:50.869]                           restarts <- computeRestarts(cond)
[01:27:50.869]                           for (restart in restarts) {
[01:27:50.869]                             name <- restart$name
[01:27:50.869]                             if (is.null(name)) 
[01:27:50.869]                               next
[01:27:50.869]                             if (!grepl(pattern, name)) 
[01:27:50.869]                               next
[01:27:50.869]                             invokeRestart(restart)
[01:27:50.869]                             muffled <- TRUE
[01:27:50.869]                             break
[01:27:50.869]                           }
[01:27:50.869]                         }
[01:27:50.869]                       }
[01:27:50.869]                       invisible(muffled)
[01:27:50.869]                     }
[01:27:50.869]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.869]                   }
[01:27:50.869]                 }
[01:27:50.869]                 else {
[01:27:50.869]                   if (TRUE) {
[01:27:50.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.869]                     {
[01:27:50.869]                       inherits <- base::inherits
[01:27:50.869]                       invokeRestart <- base::invokeRestart
[01:27:50.869]                       is.null <- base::is.null
[01:27:50.869]                       muffled <- FALSE
[01:27:50.869]                       if (inherits(cond, "message")) {
[01:27:50.869]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.869]                         if (muffled) 
[01:27:50.869]                           invokeRestart("muffleMessage")
[01:27:50.869]                       }
[01:27:50.869]                       else if (inherits(cond, "warning")) {
[01:27:50.869]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.869]                         if (muffled) 
[01:27:50.869]                           invokeRestart("muffleWarning")
[01:27:50.869]                       }
[01:27:50.869]                       else if (inherits(cond, "condition")) {
[01:27:50.869]                         if (!is.null(pattern)) {
[01:27:50.869]                           computeRestarts <- base::computeRestarts
[01:27:50.869]                           grepl <- base::grepl
[01:27:50.869]                           restarts <- computeRestarts(cond)
[01:27:50.869]                           for (restart in restarts) {
[01:27:50.869]                             name <- restart$name
[01:27:50.869]                             if (is.null(name)) 
[01:27:50.869]                               next
[01:27:50.869]                             if (!grepl(pattern, name)) 
[01:27:50.869]                               next
[01:27:50.869]                             invokeRestart(restart)
[01:27:50.869]                             muffled <- TRUE
[01:27:50.869]                             break
[01:27:50.869]                           }
[01:27:50.869]                         }
[01:27:50.869]                       }
[01:27:50.869]                       invisible(muffled)
[01:27:50.869]                     }
[01:27:50.869]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.869]                   }
[01:27:50.869]                 }
[01:27:50.869]             }
[01:27:50.869]         }))
[01:27:50.869]     }, error = function(ex) {
[01:27:50.869]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.869]                 ...future.rng), started = ...future.startTime, 
[01:27:50.869]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.869]             version = "1.8"), class = "FutureResult")
[01:27:50.869]     }, finally = {
[01:27:50.869]         if (!identical(...future.workdir, getwd())) 
[01:27:50.869]             setwd(...future.workdir)
[01:27:50.869]         {
[01:27:50.869]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.869]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.869]             }
[01:27:50.869]             base::options(...future.oldOptions)
[01:27:50.869]             if (.Platform$OS.type == "windows") {
[01:27:50.869]                 old_names <- names(...future.oldEnvVars)
[01:27:50.869]                 envs <- base::Sys.getenv()
[01:27:50.869]                 names <- names(envs)
[01:27:50.869]                 common <- intersect(names, old_names)
[01:27:50.869]                 added <- setdiff(names, old_names)
[01:27:50.869]                 removed <- setdiff(old_names, names)
[01:27:50.869]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.869]                   envs[common]]
[01:27:50.869]                 NAMES <- toupper(changed)
[01:27:50.869]                 args <- list()
[01:27:50.869]                 for (kk in seq_along(NAMES)) {
[01:27:50.869]                   name <- changed[[kk]]
[01:27:50.869]                   NAME <- NAMES[[kk]]
[01:27:50.869]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.869]                     next
[01:27:50.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.869]                 }
[01:27:50.869]                 NAMES <- toupper(added)
[01:27:50.869]                 for (kk in seq_along(NAMES)) {
[01:27:50.869]                   name <- added[[kk]]
[01:27:50.869]                   NAME <- NAMES[[kk]]
[01:27:50.869]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.869]                     next
[01:27:50.869]                   args[[name]] <- ""
[01:27:50.869]                 }
[01:27:50.869]                 NAMES <- toupper(removed)
[01:27:50.869]                 for (kk in seq_along(NAMES)) {
[01:27:50.869]                   name <- removed[[kk]]
[01:27:50.869]                   NAME <- NAMES[[kk]]
[01:27:50.869]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.869]                     next
[01:27:50.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.869]                 }
[01:27:50.869]                 if (length(args) > 0) 
[01:27:50.869]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.869]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.869]             }
[01:27:50.869]             else {
[01:27:50.869]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.869]             }
[01:27:50.869]             {
[01:27:50.869]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.869]                   0L) {
[01:27:50.869]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.869]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.869]                   base::options(opts)
[01:27:50.869]                 }
[01:27:50.869]                 {
[01:27:50.869]                   {
[01:27:50.869]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.869]                     NULL
[01:27:50.869]                   }
[01:27:50.869]                   options(future.plan = NULL)
[01:27:50.869]                   if (is.na(NA_character_)) 
[01:27:50.869]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.869]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.869]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.869]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.869]                     envir = parent.frame()) 
[01:27:50.869]                   {
[01:27:50.869]                     if (is.function(workers)) 
[01:27:50.869]                       workers <- workers()
[01:27:50.869]                     workers <- structure(as.integer(workers), 
[01:27:50.869]                       class = class(workers))
[01:27:50.869]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.869]                       workers >= 1)
[01:27:50.869]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.869]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.869]                     }
[01:27:50.869]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.869]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.869]                       envir = envir)
[01:27:50.869]                     if (!future$lazy) 
[01:27:50.869]                       future <- run(future)
[01:27:50.869]                     invisible(future)
[01:27:50.869]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.869]                 }
[01:27:50.869]             }
[01:27:50.869]         }
[01:27:50.869]     })
[01:27:50.869]     if (TRUE) {
[01:27:50.869]         base::sink(type = "output", split = FALSE)
[01:27:50.869]         if (TRUE) {
[01:27:50.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.869]         }
[01:27:50.869]         else {
[01:27:50.869]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.869]         }
[01:27:50.869]         base::close(...future.stdout)
[01:27:50.869]         ...future.stdout <- NULL
[01:27:50.869]     }
[01:27:50.869]     ...future.result$conditions <- ...future.conditions
[01:27:50.869]     ...future.result$finished <- base::Sys.time()
[01:27:50.869]     ...future.result
[01:27:50.869] }
[01:27:50.875] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:50.900] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.900] - Validating connection of MultisessionFuture
[01:27:50.901] - received message: FutureResult
[01:27:50.901] - Received FutureResult
[01:27:50.901] - Erased future from FutureRegistry
[01:27:50.901] result() for ClusterFuture ...
[01:27:50.901] - result already collected: FutureResult
[01:27:50.902] result() for ClusterFuture ... done
[01:27:50.902] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.902] result() for ClusterFuture ...
[01:27:50.902] - result already collected: FutureResult
[01:27:50.902] result() for ClusterFuture ... done
[01:27:50.903] result() for ClusterFuture ...
[01:27:50.903] - result already collected: FutureResult
[01:27:50.903] result() for ClusterFuture ... done
[01:27:50.905] MultisessionFuture started
[01:27:50.905] - Launch lazy future ... done
[01:27:50.905] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b0a0c1098> 
Classes 'listenv', 'environment' <environment: 0x0000025b0b393290> 
 - 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"
[01:27:50.911] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.911] - Validating connection of MultisessionFuture
[01:27:50.911] - received message: FutureResult
[01:27:50.912] - Received FutureResult
[01:27:50.912] - Erased future from FutureRegistry
[01:27:50.912] result() for ClusterFuture ...
[01:27:50.912] - result already collected: FutureResult
[01:27:50.912] result() for ClusterFuture ... done
[01:27:50.913] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:50.921] receiveMessageFromWorker() for ClusterFuture ...
[01:27:50.922] - Validating connection of MultisessionFuture
[01:27:50.922] - received message: FutureResult
[01:27:50.922] - Received FutureResult
[01:27:50.923] - Erased future from FutureRegistry
[01:27:50.923] result() for ClusterFuture ...
[01:27:50.923] - result already collected: FutureResult
[01:27:50.923] result() for ClusterFuture ... done
[01:27:50.923] 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" ...
[01:27:50.927] resolve() on list environment ...
[01:27:50.927]  recursive: 0
[01:27:50.928]  length: 6
[01:27:50.928]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:50.928] signalConditionsASAP(numeric, pos=1) ...
[01:27:50.929] - nx: 6
[01:27:50.929] - relay: TRUE
[01:27:50.929] - stdout: TRUE
[01:27:50.929] - signal: TRUE
[01:27:50.929] - resignal: FALSE
[01:27:50.929] - force: TRUE
[01:27:50.930] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.930] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.930]  - until=2
[01:27:50.930]  - relaying element #2
[01:27:50.930] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.931] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.931] signalConditionsASAP(NULL, pos=1) ... done
[01:27:50.931]  length: 5 (resolved future 1)
[01:27:50.931] Future #2
[01:27:50.931] result() for ClusterFuture ...
[01:27:50.932] - result already collected: FutureResult
[01:27:50.932] result() for ClusterFuture ... done
[01:27:50.932] result() for ClusterFuture ...
[01:27:50.936] - result already collected: FutureResult
[01:27:50.936] result() for ClusterFuture ... done
[01:27:50.936] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:50.937] - nx: 6
[01:27:50.937] - relay: TRUE
[01:27:50.937] - stdout: TRUE
[01:27:50.937] - signal: TRUE
[01:27:50.937] - resignal: FALSE
[01:27:50.938] - force: TRUE
[01:27:50.938] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.938] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:50.938]  - until=2
[01:27:50.938]  - relaying element #2
[01:27:50.939] result() for ClusterFuture ...
[01:27:50.939] - result already collected: FutureResult
[01:27:50.939] result() for ClusterFuture ... done
[01:27:50.939] result() for ClusterFuture ...
[01:27:50.939] - result already collected: FutureResult
[01:27:50.939] result() for ClusterFuture ... done
[01:27:50.940] result() for ClusterFuture ...
[01:27:50.940] - result already collected: FutureResult
[01:27:50.940] result() for ClusterFuture ... done
[01:27:50.940] result() for ClusterFuture ...
[01:27:50.940] - result already collected: FutureResult
[01:27:50.940] result() for ClusterFuture ... done
[01:27:50.940] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.941] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.941] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:50.941]  length: 4 (resolved future 2)
[01:27:50.941] Future #3
[01:27:50.941] result() for ClusterFuture ...
[01:27:50.942] - result already collected: FutureResult
[01:27:50.942] result() for ClusterFuture ... done
[01:27:50.942] result() for ClusterFuture ...
[01:27:50.942] - result already collected: FutureResult
[01:27:50.942] result() for ClusterFuture ... done
[01:27:50.942] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:50.943] - nx: 6
[01:27:50.943] - relay: TRUE
[01:27:50.943] - stdout: TRUE
[01:27:50.943] - signal: TRUE
[01:27:50.943] - resignal: FALSE
[01:27:50.943] - force: TRUE
[01:27:50.943] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.944] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:50.944]  - until=3
[01:27:50.944]  - relaying element #3
[01:27:50.944] result() for ClusterFuture ...
[01:27:50.944] - result already collected: FutureResult
[01:27:50.944] result() for ClusterFuture ... done
[01:27:50.945] result() for ClusterFuture ...
[01:27:50.945] - result already collected: FutureResult
[01:27:50.945] result() for ClusterFuture ... done
[01:27:50.945] result() for ClusterFuture ...
[01:27:50.945] - result already collected: FutureResult
[01:27:50.946] result() for ClusterFuture ... done
[01:27:50.946] result() for ClusterFuture ...
[01:27:50.946] - result already collected: FutureResult
[01:27:50.946] result() for ClusterFuture ... done
[01:27:50.946] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.946] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.947] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:50.947]  length: 3 (resolved future 3)
[01:27:50.947] Future #4
[01:27:50.948] result() for ClusterFuture ...
[01:27:50.948] - result already collected: FutureResult
[01:27:50.948] result() for ClusterFuture ... done
[01:27:50.948] result() for ClusterFuture ...
[01:27:50.949] - result already collected: FutureResult
[01:27:50.949] result() for ClusterFuture ... done
[01:27:50.949] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:50.949] - nx: 6
[01:27:50.950] - relay: TRUE
[01:27:50.950] - stdout: TRUE
[01:27:50.950] - signal: TRUE
[01:27:50.950] - resignal: FALSE
[01:27:50.950] - force: TRUE
[01:27:50.951] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.951] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:50.951]  - until=4
[01:27:50.951]  - relaying element #4
[01:27:50.951] result() for ClusterFuture ...
[01:27:50.952] - result already collected: FutureResult
[01:27:50.952] result() for ClusterFuture ... done
[01:27:50.952] result() for ClusterFuture ...
[01:27:50.952] - result already collected: FutureResult
[01:27:50.952] result() for ClusterFuture ... done
[01:27:50.952] result() for ClusterFuture ...
[01:27:50.953] - result already collected: FutureResult
[01:27:50.953] result() for ClusterFuture ... done
[01:27:50.953] result() for ClusterFuture ...
[01:27:50.953] - result already collected: FutureResult
[01:27:50.953] result() for ClusterFuture ... done
[01:27:50.953] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.954] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.954] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:50.954]  length: 2 (resolved future 4)
[01:27:50.954] signalConditionsASAP(NULL, pos=5) ...
[01:27:50.954] - nx: 6
[01:27:50.955] - relay: TRUE
[01:27:50.955] - stdout: TRUE
[01:27:50.955] - signal: TRUE
[01:27:50.955] - resignal: FALSE
[01:27:50.955] - force: TRUE
[01:27:50.955] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.956] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.956]  - until=6
[01:27:50.956]  - relaying element #6
[01:27:50.956] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.956] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.957] signalConditionsASAP(NULL, pos=5) ... done
[01:27:50.957]  length: 1 (resolved future 5)
[01:27:50.957] signalConditionsASAP(numeric, pos=6) ...
[01:27:50.957] - nx: 6
[01:27:50.957] - relay: TRUE
[01:27:50.957] - stdout: TRUE
[01:27:50.958] - signal: TRUE
[01:27:50.958] - resignal: FALSE
[01:27:50.958] - force: TRUE
[01:27:50.958] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:50.958] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.958]  - until=6
[01:27:50.958] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.959] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.959] signalConditionsASAP(numeric, pos=6) ... done
[01:27:50.959]  length: 0 (resolved future 6)
[01:27:50.959] Relaying remaining futures
[01:27:50.959] signalConditionsASAP(NULL, pos=0) ...
[01:27:50.959] - nx: 6
[01:27:50.960] - relay: TRUE
[01:27:50.960] - stdout: TRUE
[01:27:50.960] - signal: TRUE
[01:27:50.960] - resignal: FALSE
[01:27:50.960] - force: TRUE
[01:27:50.960] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.961] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:50.961] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:50.961] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:50.961] signalConditionsASAP(NULL, pos=0) ... done
[01:27:50.961] resolve() on list environment ... DONE
[01:27:50.962] result() for ClusterFuture ...
[01:27:50.962] - result already collected: FutureResult
[01:27:50.962] result() for ClusterFuture ... done
[01:27:50.962] result() for ClusterFuture ...
[01:27:50.962] - result already collected: FutureResult
[01:27:50.962] result() for ClusterFuture ... done
[01:27:50.963] result() for ClusterFuture ...
[01:27:50.963] - result already collected: FutureResult
[01:27:50.963] result() for ClusterFuture ... done
[01:27:50.963] result() for ClusterFuture ...
[01:27:50.963] - result already collected: FutureResult
[01:27:50.964] result() for ClusterFuture ... done
[01:27:50.964] result() for ClusterFuture ...
[01:27:50.964] - result already collected: FutureResult
[01:27:50.964] result() for ClusterFuture ... done
[01:27:50.964] result() for ClusterFuture ...
[01:27:50.965] - result already collected: FutureResult
[01:27:50.965] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000025b0b88b388> 
 - 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)
[01:27:50.967] getGlobalsAndPackages() ...
[01:27:50.968] Searching for globals...
[01:27:50.968] 
[01:27:50.968] Searching for globals ... DONE
[01:27:50.968] - globals: [0] <none>
[01:27:50.969] getGlobalsAndPackages() ... DONE
[01:27:50.969] run() for 'Future' ...
[01:27:50.969] - state: 'created'
[01:27:50.969] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:50.985] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:50.986] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:50.986]   - Field: 'node'
[01:27:50.986]   - Field: 'label'
[01:27:50.986]   - Field: 'local'
[01:27:50.986]   - Field: 'owner'
[01:27:50.987]   - Field: 'envir'
[01:27:50.987]   - Field: 'workers'
[01:27:50.987]   - Field: 'packages'
[01:27:50.987]   - Field: 'gc'
[01:27:50.987]   - Field: 'conditions'
[01:27:50.988]   - Field: 'persistent'
[01:27:50.988]   - Field: 'expr'
[01:27:50.988]   - Field: 'uuid'
[01:27:50.988]   - Field: 'seed'
[01:27:50.989]   - Field: 'version'
[01:27:50.989]   - Field: 'result'
[01:27:50.989]   - Field: 'asynchronous'
[01:27:50.989]   - Field: 'calls'
[01:27:50.989]   - Field: 'globals'
[01:27:50.989]   - Field: 'stdout'
[01:27:50.990]   - Field: 'earlySignal'
[01:27:50.990]   - Field: 'lazy'
[01:27:50.990]   - Field: 'state'
[01:27:50.990] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:50.990] - Launch lazy future ...
[01:27:50.991] Packages needed by the future expression (n = 0): <none>
[01:27:50.991] Packages needed by future strategies (n = 0): <none>
[01:27:50.992] {
[01:27:50.992]     {
[01:27:50.992]         {
[01:27:50.992]             ...future.startTime <- base::Sys.time()
[01:27:50.992]             {
[01:27:50.992]                 {
[01:27:50.992]                   {
[01:27:50.992]                     {
[01:27:50.992]                       base::local({
[01:27:50.992]                         has_future <- base::requireNamespace("future", 
[01:27:50.992]                           quietly = TRUE)
[01:27:50.992]                         if (has_future) {
[01:27:50.992]                           ns <- base::getNamespace("future")
[01:27:50.992]                           version <- ns[[".package"]][["version"]]
[01:27:50.992]                           if (is.null(version)) 
[01:27:50.992]                             version <- utils::packageVersion("future")
[01:27:50.992]                         }
[01:27:50.992]                         else {
[01:27:50.992]                           version <- NULL
[01:27:50.992]                         }
[01:27:50.992]                         if (!has_future || version < "1.8.0") {
[01:27:50.992]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:50.992]                             "", base::R.version$version.string), 
[01:27:50.992]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:50.992]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:50.992]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:50.992]                               "release", "version")], collapse = " "), 
[01:27:50.992]                             hostname = base::Sys.info()[["nodename"]])
[01:27:50.992]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:50.992]                             info)
[01:27:50.992]                           info <- base::paste(info, collapse = "; ")
[01:27:50.992]                           if (!has_future) {
[01:27:50.992]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:50.992]                               info)
[01:27:50.992]                           }
[01:27:50.992]                           else {
[01:27:50.992]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:50.992]                               info, version)
[01:27:50.992]                           }
[01:27:50.992]                           base::stop(msg)
[01:27:50.992]                         }
[01:27:50.992]                       })
[01:27:50.992]                     }
[01:27:50.992]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:50.992]                     base::options(mc.cores = 1L)
[01:27:50.992]                   }
[01:27:50.992]                   options(future.plan = NULL)
[01:27:50.992]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.992]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:50.992]                 }
[01:27:50.992]                 ...future.workdir <- getwd()
[01:27:50.992]             }
[01:27:50.992]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:50.992]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:50.992]         }
[01:27:50.992]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:50.992]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:50.992]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:50.992]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:50.992]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:50.992]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:50.992]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:50.992]             base::names(...future.oldOptions))
[01:27:50.992]     }
[01:27:50.992]     if (FALSE) {
[01:27:50.992]     }
[01:27:50.992]     else {
[01:27:50.992]         if (TRUE) {
[01:27:50.992]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:50.992]                 open = "w")
[01:27:50.992]         }
[01:27:50.992]         else {
[01:27:50.992]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:50.992]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:50.992]         }
[01:27:50.992]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:50.992]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:50.992]             base::sink(type = "output", split = FALSE)
[01:27:50.992]             base::close(...future.stdout)
[01:27:50.992]         }, add = TRUE)
[01:27:50.992]     }
[01:27:50.992]     ...future.frame <- base::sys.nframe()
[01:27:50.992]     ...future.conditions <- base::list()
[01:27:50.992]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:50.992]     if (FALSE) {
[01:27:50.992]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:50.992]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:50.992]     }
[01:27:50.992]     ...future.result <- base::tryCatch({
[01:27:50.992]         base::withCallingHandlers({
[01:27:50.992]             ...future.value <- base::withVisible(base::local({
[01:27:50.992]                 ...future.makeSendCondition <- base::local({
[01:27:50.992]                   sendCondition <- NULL
[01:27:50.992]                   function(frame = 1L) {
[01:27:50.992]                     if (is.function(sendCondition)) 
[01:27:50.992]                       return(sendCondition)
[01:27:50.992]                     ns <- getNamespace("parallel")
[01:27:50.992]                     if (exists("sendData", mode = "function", 
[01:27:50.992]                       envir = ns)) {
[01:27:50.992]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:50.992]                         envir = ns)
[01:27:50.992]                       envir <- sys.frame(frame)
[01:27:50.992]                       master <- NULL
[01:27:50.992]                       while (!identical(envir, .GlobalEnv) && 
[01:27:50.992]                         !identical(envir, emptyenv())) {
[01:27:50.992]                         if (exists("master", mode = "list", envir = envir, 
[01:27:50.992]                           inherits = FALSE)) {
[01:27:50.992]                           master <- get("master", mode = "list", 
[01:27:50.992]                             envir = envir, inherits = FALSE)
[01:27:50.992]                           if (inherits(master, c("SOCKnode", 
[01:27:50.992]                             "SOCK0node"))) {
[01:27:50.992]                             sendCondition <<- function(cond) {
[01:27:50.992]                               data <- list(type = "VALUE", value = cond, 
[01:27:50.992]                                 success = TRUE)
[01:27:50.992]                               parallel_sendData(master, data)
[01:27:50.992]                             }
[01:27:50.992]                             return(sendCondition)
[01:27:50.992]                           }
[01:27:50.992]                         }
[01:27:50.992]                         frame <- frame + 1L
[01:27:50.992]                         envir <- sys.frame(frame)
[01:27:50.992]                       }
[01:27:50.992]                     }
[01:27:50.992]                     sendCondition <<- function(cond) NULL
[01:27:50.992]                   }
[01:27:50.992]                 })
[01:27:50.992]                 withCallingHandlers({
[01:27:50.992]                   2
[01:27:50.992]                 }, immediateCondition = function(cond) {
[01:27:50.992]                   sendCondition <- ...future.makeSendCondition()
[01:27:50.992]                   sendCondition(cond)
[01:27:50.992]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.992]                   {
[01:27:50.992]                     inherits <- base::inherits
[01:27:50.992]                     invokeRestart <- base::invokeRestart
[01:27:50.992]                     is.null <- base::is.null
[01:27:50.992]                     muffled <- FALSE
[01:27:50.992]                     if (inherits(cond, "message")) {
[01:27:50.992]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:50.992]                       if (muffled) 
[01:27:50.992]                         invokeRestart("muffleMessage")
[01:27:50.992]                     }
[01:27:50.992]                     else if (inherits(cond, "warning")) {
[01:27:50.992]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:50.992]                       if (muffled) 
[01:27:50.992]                         invokeRestart("muffleWarning")
[01:27:50.992]                     }
[01:27:50.992]                     else if (inherits(cond, "condition")) {
[01:27:50.992]                       if (!is.null(pattern)) {
[01:27:50.992]                         computeRestarts <- base::computeRestarts
[01:27:50.992]                         grepl <- base::grepl
[01:27:50.992]                         restarts <- computeRestarts(cond)
[01:27:50.992]                         for (restart in restarts) {
[01:27:50.992]                           name <- restart$name
[01:27:50.992]                           if (is.null(name)) 
[01:27:50.992]                             next
[01:27:50.992]                           if (!grepl(pattern, name)) 
[01:27:50.992]                             next
[01:27:50.992]                           invokeRestart(restart)
[01:27:50.992]                           muffled <- TRUE
[01:27:50.992]                           break
[01:27:50.992]                         }
[01:27:50.992]                       }
[01:27:50.992]                     }
[01:27:50.992]                     invisible(muffled)
[01:27:50.992]                   }
[01:27:50.992]                   muffleCondition(cond)
[01:27:50.992]                 })
[01:27:50.992]             }))
[01:27:50.992]             future::FutureResult(value = ...future.value$value, 
[01:27:50.992]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.992]                   ...future.rng), globalenv = if (FALSE) 
[01:27:50.992]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:50.992]                     ...future.globalenv.names))
[01:27:50.992]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:50.992]         }, condition = base::local({
[01:27:50.992]             c <- base::c
[01:27:50.992]             inherits <- base::inherits
[01:27:50.992]             invokeRestart <- base::invokeRestart
[01:27:50.992]             length <- base::length
[01:27:50.992]             list <- base::list
[01:27:50.992]             seq.int <- base::seq.int
[01:27:50.992]             signalCondition <- base::signalCondition
[01:27:50.992]             sys.calls <- base::sys.calls
[01:27:50.992]             `[[` <- base::`[[`
[01:27:50.992]             `+` <- base::`+`
[01:27:50.992]             `<<-` <- base::`<<-`
[01:27:50.992]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:50.992]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:50.992]                   3L)]
[01:27:50.992]             }
[01:27:50.992]             function(cond) {
[01:27:50.992]                 is_error <- inherits(cond, "error")
[01:27:50.992]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:50.992]                   NULL)
[01:27:50.992]                 if (is_error) {
[01:27:50.992]                   sessionInformation <- function() {
[01:27:50.992]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:50.992]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:50.992]                       search = base::search(), system = base::Sys.info())
[01:27:50.992]                   }
[01:27:50.992]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.992]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:50.992]                     cond$call), session = sessionInformation(), 
[01:27:50.992]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:50.992]                   signalCondition(cond)
[01:27:50.992]                 }
[01:27:50.992]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:50.992]                 "immediateCondition"))) {
[01:27:50.992]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:50.992]                   ...future.conditions[[length(...future.conditions) + 
[01:27:50.992]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:50.992]                   if (TRUE && !signal) {
[01:27:50.992]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.992]                     {
[01:27:50.992]                       inherits <- base::inherits
[01:27:50.992]                       invokeRestart <- base::invokeRestart
[01:27:50.992]                       is.null <- base::is.null
[01:27:50.992]                       muffled <- FALSE
[01:27:50.992]                       if (inherits(cond, "message")) {
[01:27:50.992]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.992]                         if (muffled) 
[01:27:50.992]                           invokeRestart("muffleMessage")
[01:27:50.992]                       }
[01:27:50.992]                       else if (inherits(cond, "warning")) {
[01:27:50.992]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.992]                         if (muffled) 
[01:27:50.992]                           invokeRestart("muffleWarning")
[01:27:50.992]                       }
[01:27:50.992]                       else if (inherits(cond, "condition")) {
[01:27:50.992]                         if (!is.null(pattern)) {
[01:27:50.992]                           computeRestarts <- base::computeRestarts
[01:27:50.992]                           grepl <- base::grepl
[01:27:50.992]                           restarts <- computeRestarts(cond)
[01:27:50.992]                           for (restart in restarts) {
[01:27:50.992]                             name <- restart$name
[01:27:50.992]                             if (is.null(name)) 
[01:27:50.992]                               next
[01:27:50.992]                             if (!grepl(pattern, name)) 
[01:27:50.992]                               next
[01:27:50.992]                             invokeRestart(restart)
[01:27:50.992]                             muffled <- TRUE
[01:27:50.992]                             break
[01:27:50.992]                           }
[01:27:50.992]                         }
[01:27:50.992]                       }
[01:27:50.992]                       invisible(muffled)
[01:27:50.992]                     }
[01:27:50.992]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.992]                   }
[01:27:50.992]                 }
[01:27:50.992]                 else {
[01:27:50.992]                   if (TRUE) {
[01:27:50.992]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:50.992]                     {
[01:27:50.992]                       inherits <- base::inherits
[01:27:50.992]                       invokeRestart <- base::invokeRestart
[01:27:50.992]                       is.null <- base::is.null
[01:27:50.992]                       muffled <- FALSE
[01:27:50.992]                       if (inherits(cond, "message")) {
[01:27:50.992]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:50.992]                         if (muffled) 
[01:27:50.992]                           invokeRestart("muffleMessage")
[01:27:50.992]                       }
[01:27:50.992]                       else if (inherits(cond, "warning")) {
[01:27:50.992]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:50.992]                         if (muffled) 
[01:27:50.992]                           invokeRestart("muffleWarning")
[01:27:50.992]                       }
[01:27:50.992]                       else if (inherits(cond, "condition")) {
[01:27:50.992]                         if (!is.null(pattern)) {
[01:27:50.992]                           computeRestarts <- base::computeRestarts
[01:27:50.992]                           grepl <- base::grepl
[01:27:50.992]                           restarts <- computeRestarts(cond)
[01:27:50.992]                           for (restart in restarts) {
[01:27:50.992]                             name <- restart$name
[01:27:50.992]                             if (is.null(name)) 
[01:27:50.992]                               next
[01:27:50.992]                             if (!grepl(pattern, name)) 
[01:27:50.992]                               next
[01:27:50.992]                             invokeRestart(restart)
[01:27:50.992]                             muffled <- TRUE
[01:27:50.992]                             break
[01:27:50.992]                           }
[01:27:50.992]                         }
[01:27:50.992]                       }
[01:27:50.992]                       invisible(muffled)
[01:27:50.992]                     }
[01:27:50.992]                     muffleCondition(cond, pattern = "^muffle")
[01:27:50.992]                   }
[01:27:50.992]                 }
[01:27:50.992]             }
[01:27:50.992]         }))
[01:27:50.992]     }, error = function(ex) {
[01:27:50.992]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:50.992]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:50.992]                 ...future.rng), started = ...future.startTime, 
[01:27:50.992]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:50.992]             version = "1.8"), class = "FutureResult")
[01:27:50.992]     }, finally = {
[01:27:50.992]         if (!identical(...future.workdir, getwd())) 
[01:27:50.992]             setwd(...future.workdir)
[01:27:50.992]         {
[01:27:50.992]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:50.992]                 ...future.oldOptions$nwarnings <- NULL
[01:27:50.992]             }
[01:27:50.992]             base::options(...future.oldOptions)
[01:27:50.992]             if (.Platform$OS.type == "windows") {
[01:27:50.992]                 old_names <- names(...future.oldEnvVars)
[01:27:50.992]                 envs <- base::Sys.getenv()
[01:27:50.992]                 names <- names(envs)
[01:27:50.992]                 common <- intersect(names, old_names)
[01:27:50.992]                 added <- setdiff(names, old_names)
[01:27:50.992]                 removed <- setdiff(old_names, names)
[01:27:50.992]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:50.992]                   envs[common]]
[01:27:50.992]                 NAMES <- toupper(changed)
[01:27:50.992]                 args <- list()
[01:27:50.992]                 for (kk in seq_along(NAMES)) {
[01:27:50.992]                   name <- changed[[kk]]
[01:27:50.992]                   NAME <- NAMES[[kk]]
[01:27:50.992]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.992]                     next
[01:27:50.992]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.992]                 }
[01:27:50.992]                 NAMES <- toupper(added)
[01:27:50.992]                 for (kk in seq_along(NAMES)) {
[01:27:50.992]                   name <- added[[kk]]
[01:27:50.992]                   NAME <- NAMES[[kk]]
[01:27:50.992]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.992]                     next
[01:27:50.992]                   args[[name]] <- ""
[01:27:50.992]                 }
[01:27:50.992]                 NAMES <- toupper(removed)
[01:27:50.992]                 for (kk in seq_along(NAMES)) {
[01:27:50.992]                   name <- removed[[kk]]
[01:27:50.992]                   NAME <- NAMES[[kk]]
[01:27:50.992]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:50.992]                     next
[01:27:50.992]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:50.992]                 }
[01:27:50.992]                 if (length(args) > 0) 
[01:27:50.992]                   base::do.call(base::Sys.setenv, args = args)
[01:27:50.992]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:50.992]             }
[01:27:50.992]             else {
[01:27:50.992]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:50.992]             }
[01:27:50.992]             {
[01:27:50.992]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:50.992]                   0L) {
[01:27:50.992]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:50.992]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:50.992]                   base::options(opts)
[01:27:50.992]                 }
[01:27:50.992]                 {
[01:27:50.992]                   {
[01:27:50.992]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:50.992]                     NULL
[01:27:50.992]                   }
[01:27:50.992]                   options(future.plan = NULL)
[01:27:50.992]                   if (is.na(NA_character_)) 
[01:27:50.992]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:50.992]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:50.992]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:50.992]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:50.992]                     envir = parent.frame()) 
[01:27:50.992]                   {
[01:27:50.992]                     if (is.function(workers)) 
[01:27:50.992]                       workers <- workers()
[01:27:50.992]                     workers <- structure(as.integer(workers), 
[01:27:50.992]                       class = class(workers))
[01:27:50.992]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:50.992]                       workers >= 1)
[01:27:50.992]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:50.992]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:50.992]                     }
[01:27:50.992]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:50.992]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:50.992]                       envir = envir)
[01:27:50.992]                     if (!future$lazy) 
[01:27:50.992]                       future <- run(future)
[01:27:50.992]                     invisible(future)
[01:27:50.992]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:50.992]                 }
[01:27:50.992]             }
[01:27:50.992]         }
[01:27:50.992]     })
[01:27:50.992]     if (TRUE) {
[01:27:50.992]         base::sink(type = "output", split = FALSE)
[01:27:50.992]         if (TRUE) {
[01:27:50.992]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:50.992]         }
[01:27:50.992]         else {
[01:27:50.992]             ...future.result["stdout"] <- base::list(NULL)
[01:27:50.992]         }
[01:27:50.992]         base::close(...future.stdout)
[01:27:50.992]         ...future.stdout <- NULL
[01:27:50.992]     }
[01:27:50.992]     ...future.result$conditions <- ...future.conditions
[01:27:50.992]     ...future.result$finished <- base::Sys.time()
[01:27:50.992]     ...future.result
[01:27:50.992] }
[01:27:50.998] MultisessionFuture started
[01:27:50.998] - Launch lazy future ... done
[01:27:50.998] run() for 'MultisessionFuture' ... done
[01:27:50.998] getGlobalsAndPackages() ...
[01:27:50.999] Searching for globals...
[01:27:50.999] 
[01:27:50.999] Searching for globals ... DONE
[01:27:50.999] - globals: [0] <none>
[01:27:51.000] getGlobalsAndPackages() ... DONE
[01:27:51.000] run() for 'Future' ...
[01:27:51.000] - state: 'created'
[01:27:51.000] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:51.014] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:51.014] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:51.015]   - Field: 'node'
[01:27:51.015]   - Field: 'label'
[01:27:51.015]   - Field: 'local'
[01:27:51.015]   - Field: 'owner'
[01:27:51.015]   - Field: 'envir'
[01:27:51.016]   - Field: 'workers'
[01:27:51.016]   - Field: 'packages'
[01:27:51.016]   - Field: 'gc'
[01:27:51.016]   - Field: 'conditions'
[01:27:51.016]   - Field: 'persistent'
[01:27:51.017]   - Field: 'expr'
[01:27:51.017]   - Field: 'uuid'
[01:27:51.017]   - Field: 'seed'
[01:27:51.017]   - Field: 'version'
[01:27:51.017]   - Field: 'result'
[01:27:51.018]   - Field: 'asynchronous'
[01:27:51.018]   - Field: 'calls'
[01:27:51.018]   - Field: 'globals'
[01:27:51.018]   - Field: 'stdout'
[01:27:51.018]   - Field: 'earlySignal'
[01:27:51.018]   - Field: 'lazy'
[01:27:51.019]   - Field: 'state'
[01:27:51.019] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:51.019] - Launch lazy future ...
[01:27:51.019] Packages needed by the future expression (n = 0): <none>
[01:27:51.020] Packages needed by future strategies (n = 0): <none>
[01:27:51.020] {
[01:27:51.020]     {
[01:27:51.020]         {
[01:27:51.020]             ...future.startTime <- base::Sys.time()
[01:27:51.020]             {
[01:27:51.020]                 {
[01:27:51.020]                   {
[01:27:51.020]                     {
[01:27:51.020]                       base::local({
[01:27:51.020]                         has_future <- base::requireNamespace("future", 
[01:27:51.020]                           quietly = TRUE)
[01:27:51.020]                         if (has_future) {
[01:27:51.020]                           ns <- base::getNamespace("future")
[01:27:51.020]                           version <- ns[[".package"]][["version"]]
[01:27:51.020]                           if (is.null(version)) 
[01:27:51.020]                             version <- utils::packageVersion("future")
[01:27:51.020]                         }
[01:27:51.020]                         else {
[01:27:51.020]                           version <- NULL
[01:27:51.020]                         }
[01:27:51.020]                         if (!has_future || version < "1.8.0") {
[01:27:51.020]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:51.020]                             "", base::R.version$version.string), 
[01:27:51.020]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:51.020]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:51.020]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:51.020]                               "release", "version")], collapse = " "), 
[01:27:51.020]                             hostname = base::Sys.info()[["nodename"]])
[01:27:51.020]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:51.020]                             info)
[01:27:51.020]                           info <- base::paste(info, collapse = "; ")
[01:27:51.020]                           if (!has_future) {
[01:27:51.020]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:51.020]                               info)
[01:27:51.020]                           }
[01:27:51.020]                           else {
[01:27:51.020]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:51.020]                               info, version)
[01:27:51.020]                           }
[01:27:51.020]                           base::stop(msg)
[01:27:51.020]                         }
[01:27:51.020]                       })
[01:27:51.020]                     }
[01:27:51.020]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:51.020]                     base::options(mc.cores = 1L)
[01:27:51.020]                   }
[01:27:51.020]                   options(future.plan = NULL)
[01:27:51.020]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:51.020]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:51.020]                 }
[01:27:51.020]                 ...future.workdir <- getwd()
[01:27:51.020]             }
[01:27:51.020]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:51.020]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:51.020]         }
[01:27:51.020]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:51.020]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:51.020]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:51.020]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:51.020]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:51.020]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:51.020]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:51.020]             base::names(...future.oldOptions))
[01:27:51.020]     }
[01:27:51.020]     if (FALSE) {
[01:27:51.020]     }
[01:27:51.020]     else {
[01:27:51.020]         if (TRUE) {
[01:27:51.020]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:51.020]                 open = "w")
[01:27:51.020]         }
[01:27:51.020]         else {
[01:27:51.020]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:51.020]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:51.020]         }
[01:27:51.020]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:51.020]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:51.020]             base::sink(type = "output", split = FALSE)
[01:27:51.020]             base::close(...future.stdout)
[01:27:51.020]         }, add = TRUE)
[01:27:51.020]     }
[01:27:51.020]     ...future.frame <- base::sys.nframe()
[01:27:51.020]     ...future.conditions <- base::list()
[01:27:51.020]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:51.020]     if (FALSE) {
[01:27:51.020]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:51.020]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:51.020]     }
[01:27:51.020]     ...future.result <- base::tryCatch({
[01:27:51.020]         base::withCallingHandlers({
[01:27:51.020]             ...future.value <- base::withVisible(base::local({
[01:27:51.020]                 ...future.makeSendCondition <- base::local({
[01:27:51.020]                   sendCondition <- NULL
[01:27:51.020]                   function(frame = 1L) {
[01:27:51.020]                     if (is.function(sendCondition)) 
[01:27:51.020]                       return(sendCondition)
[01:27:51.020]                     ns <- getNamespace("parallel")
[01:27:51.020]                     if (exists("sendData", mode = "function", 
[01:27:51.020]                       envir = ns)) {
[01:27:51.020]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:51.020]                         envir = ns)
[01:27:51.020]                       envir <- sys.frame(frame)
[01:27:51.020]                       master <- NULL
[01:27:51.020]                       while (!identical(envir, .GlobalEnv) && 
[01:27:51.020]                         !identical(envir, emptyenv())) {
[01:27:51.020]                         if (exists("master", mode = "list", envir = envir, 
[01:27:51.020]                           inherits = FALSE)) {
[01:27:51.020]                           master <- get("master", mode = "list", 
[01:27:51.020]                             envir = envir, inherits = FALSE)
[01:27:51.020]                           if (inherits(master, c("SOCKnode", 
[01:27:51.020]                             "SOCK0node"))) {
[01:27:51.020]                             sendCondition <<- function(cond) {
[01:27:51.020]                               data <- list(type = "VALUE", value = cond, 
[01:27:51.020]                                 success = TRUE)
[01:27:51.020]                               parallel_sendData(master, data)
[01:27:51.020]                             }
[01:27:51.020]                             return(sendCondition)
[01:27:51.020]                           }
[01:27:51.020]                         }
[01:27:51.020]                         frame <- frame + 1L
[01:27:51.020]                         envir <- sys.frame(frame)
[01:27:51.020]                       }
[01:27:51.020]                     }
[01:27:51.020]                     sendCondition <<- function(cond) NULL
[01:27:51.020]                   }
[01:27:51.020]                 })
[01:27:51.020]                 withCallingHandlers({
[01:27:51.020]                   NULL
[01:27:51.020]                 }, immediateCondition = function(cond) {
[01:27:51.020]                   sendCondition <- ...future.makeSendCondition()
[01:27:51.020]                   sendCondition(cond)
[01:27:51.020]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:51.020]                   {
[01:27:51.020]                     inherits <- base::inherits
[01:27:51.020]                     invokeRestart <- base::invokeRestart
[01:27:51.020]                     is.null <- base::is.null
[01:27:51.020]                     muffled <- FALSE
[01:27:51.020]                     if (inherits(cond, "message")) {
[01:27:51.020]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:51.020]                       if (muffled) 
[01:27:51.020]                         invokeRestart("muffleMessage")
[01:27:51.020]                     }
[01:27:51.020]                     else if (inherits(cond, "warning")) {
[01:27:51.020]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:51.020]                       if (muffled) 
[01:27:51.020]                         invokeRestart("muffleWarning")
[01:27:51.020]                     }
[01:27:51.020]                     else if (inherits(cond, "condition")) {
[01:27:51.020]                       if (!is.null(pattern)) {
[01:27:51.020]                         computeRestarts <- base::computeRestarts
[01:27:51.020]                         grepl <- base::grepl
[01:27:51.020]                         restarts <- computeRestarts(cond)
[01:27:51.020]                         for (restart in restarts) {
[01:27:51.020]                           name <- restart$name
[01:27:51.020]                           if (is.null(name)) 
[01:27:51.020]                             next
[01:27:51.020]                           if (!grepl(pattern, name)) 
[01:27:51.020]                             next
[01:27:51.020]                           invokeRestart(restart)
[01:27:51.020]                           muffled <- TRUE
[01:27:51.020]                           break
[01:27:51.020]                         }
[01:27:51.020]                       }
[01:27:51.020]                     }
[01:27:51.020]                     invisible(muffled)
[01:27:51.020]                   }
[01:27:51.020]                   muffleCondition(cond)
[01:27:51.020]                 })
[01:27:51.020]             }))
[01:27:51.020]             future::FutureResult(value = ...future.value$value, 
[01:27:51.020]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:51.020]                   ...future.rng), globalenv = if (FALSE) 
[01:27:51.020]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:51.020]                     ...future.globalenv.names))
[01:27:51.020]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:51.020]         }, condition = base::local({
[01:27:51.020]             c <- base::c
[01:27:51.020]             inherits <- base::inherits
[01:27:51.020]             invokeRestart <- base::invokeRestart
[01:27:51.020]             length <- base::length
[01:27:51.020]             list <- base::list
[01:27:51.020]             seq.int <- base::seq.int
[01:27:51.020]             signalCondition <- base::signalCondition
[01:27:51.020]             sys.calls <- base::sys.calls
[01:27:51.020]             `[[` <- base::`[[`
[01:27:51.020]             `+` <- base::`+`
[01:27:51.020]             `<<-` <- base::`<<-`
[01:27:51.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:51.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:51.020]                   3L)]
[01:27:51.020]             }
[01:27:51.020]             function(cond) {
[01:27:51.020]                 is_error <- inherits(cond, "error")
[01:27:51.020]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:51.020]                   NULL)
[01:27:51.020]                 if (is_error) {
[01:27:51.020]                   sessionInformation <- function() {
[01:27:51.020]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:51.020]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:51.020]                       search = base::search(), system = base::Sys.info())
[01:27:51.020]                   }
[01:27:51.020]                   ...future.conditions[[length(...future.conditions) + 
[01:27:51.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:51.020]                     cond$call), session = sessionInformation(), 
[01:27:51.020]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:51.020]                   signalCondition(cond)
[01:27:51.020]                 }
[01:27:51.020]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:51.020]                 "immediateCondition"))) {
[01:27:51.020]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:51.020]                   ...future.conditions[[length(...future.conditions) + 
[01:27:51.020]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:51.020]                   if (TRUE && !signal) {
[01:27:51.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:51.020]                     {
[01:27:51.020]                       inherits <- base::inherits
[01:27:51.020]                       invokeRestart <- base::invokeRestart
[01:27:51.020]                       is.null <- base::is.null
[01:27:51.020]                       muffled <- FALSE
[01:27:51.020]                       if (inherits(cond, "message")) {
[01:27:51.020]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:51.020]                         if (muffled) 
[01:27:51.020]                           invokeRestart("muffleMessage")
[01:27:51.020]                       }
[01:27:51.020]                       else if (inherits(cond, "warning")) {
[01:27:51.020]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:51.020]                         if (muffled) 
[01:27:51.020]                           invokeRestart("muffleWarning")
[01:27:51.020]                       }
[01:27:51.020]                       else if (inherits(cond, "condition")) {
[01:27:51.020]                         if (!is.null(pattern)) {
[01:27:51.020]                           computeRestarts <- base::computeRestarts
[01:27:51.020]                           grepl <- base::grepl
[01:27:51.020]                           restarts <- computeRestarts(cond)
[01:27:51.020]                           for (restart in restarts) {
[01:27:51.020]                             name <- restart$name
[01:27:51.020]                             if (is.null(name)) 
[01:27:51.020]                               next
[01:27:51.020]                             if (!grepl(pattern, name)) 
[01:27:51.020]                               next
[01:27:51.020]                             invokeRestart(restart)
[01:27:51.020]                             muffled <- TRUE
[01:27:51.020]                             break
[01:27:51.020]                           }
[01:27:51.020]                         }
[01:27:51.020]                       }
[01:27:51.020]                       invisible(muffled)
[01:27:51.020]                     }
[01:27:51.020]                     muffleCondition(cond, pattern = "^muffle")
[01:27:51.020]                   }
[01:27:51.020]                 }
[01:27:51.020]                 else {
[01:27:51.020]                   if (TRUE) {
[01:27:51.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:51.020]                     {
[01:27:51.020]                       inherits <- base::inherits
[01:27:51.020]                       invokeRestart <- base::invokeRestart
[01:27:51.020]                       is.null <- base::is.null
[01:27:51.020]                       muffled <- FALSE
[01:27:51.020]                       if (inherits(cond, "message")) {
[01:27:51.020]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:51.020]                         if (muffled) 
[01:27:51.020]                           invokeRestart("muffleMessage")
[01:27:51.020]                       }
[01:27:51.020]                       else if (inherits(cond, "warning")) {
[01:27:51.020]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:51.020]                         if (muffled) 
[01:27:51.020]                           invokeRestart("muffleWarning")
[01:27:51.020]                       }
[01:27:51.020]                       else if (inherits(cond, "condition")) {
[01:27:51.020]                         if (!is.null(pattern)) {
[01:27:51.020]                           computeRestarts <- base::computeRestarts
[01:27:51.020]                           grepl <- base::grepl
[01:27:51.020]                           restarts <- computeRestarts(cond)
[01:27:51.020]                           for (restart in restarts) {
[01:27:51.020]                             name <- restart$name
[01:27:51.020]                             if (is.null(name)) 
[01:27:51.020]                               next
[01:27:51.020]                             if (!grepl(pattern, name)) 
[01:27:51.020]                               next
[01:27:51.020]                             invokeRestart(restart)
[01:27:51.020]                             muffled <- TRUE
[01:27:51.020]                             break
[01:27:51.020]                           }
[01:27:51.020]                         }
[01:27:51.020]                       }
[01:27:51.020]                       invisible(muffled)
[01:27:51.020]                     }
[01:27:51.020]                     muffleCondition(cond, pattern = "^muffle")
[01:27:51.020]                   }
[01:27:51.020]                 }
[01:27:51.020]             }
[01:27:51.020]         }))
[01:27:51.020]     }, error = function(ex) {
[01:27:51.020]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:51.020]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:51.020]                 ...future.rng), started = ...future.startTime, 
[01:27:51.020]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:51.020]             version = "1.8"), class = "FutureResult")
[01:27:51.020]     }, finally = {
[01:27:51.020]         if (!identical(...future.workdir, getwd())) 
[01:27:51.020]             setwd(...future.workdir)
[01:27:51.020]         {
[01:27:51.020]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:51.020]                 ...future.oldOptions$nwarnings <- NULL
[01:27:51.020]             }
[01:27:51.020]             base::options(...future.oldOptions)
[01:27:51.020]             if (.Platform$OS.type == "windows") {
[01:27:51.020]                 old_names <- names(...future.oldEnvVars)
[01:27:51.020]                 envs <- base::Sys.getenv()
[01:27:51.020]                 names <- names(envs)
[01:27:51.020]                 common <- intersect(names, old_names)
[01:27:51.020]                 added <- setdiff(names, old_names)
[01:27:51.020]                 removed <- setdiff(old_names, names)
[01:27:51.020]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:51.020]                   envs[common]]
[01:27:51.020]                 NAMES <- toupper(changed)
[01:27:51.020]                 args <- list()
[01:27:51.020]                 for (kk in seq_along(NAMES)) {
[01:27:51.020]                   name <- changed[[kk]]
[01:27:51.020]                   NAME <- NAMES[[kk]]
[01:27:51.020]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:51.020]                     next
[01:27:51.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:51.020]                 }
[01:27:51.020]                 NAMES <- toupper(added)
[01:27:51.020]                 for (kk in seq_along(NAMES)) {
[01:27:51.020]                   name <- added[[kk]]
[01:27:51.020]                   NAME <- NAMES[[kk]]
[01:27:51.020]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:51.020]                     next
[01:27:51.020]                   args[[name]] <- ""
[01:27:51.020]                 }
[01:27:51.020]                 NAMES <- toupper(removed)
[01:27:51.020]                 for (kk in seq_along(NAMES)) {
[01:27:51.020]                   name <- removed[[kk]]
[01:27:51.020]                   NAME <- NAMES[[kk]]
[01:27:51.020]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:51.020]                     next
[01:27:51.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:51.020]                 }
[01:27:51.020]                 if (length(args) > 0) 
[01:27:51.020]                   base::do.call(base::Sys.setenv, args = args)
[01:27:51.020]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:51.020]             }
[01:27:51.020]             else {
[01:27:51.020]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:51.020]             }
[01:27:51.020]             {
[01:27:51.020]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:51.020]                   0L) {
[01:27:51.020]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:51.020]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:51.020]                   base::options(opts)
[01:27:51.020]                 }
[01:27:51.020]                 {
[01:27:51.020]                   {
[01:27:51.020]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:51.020]                     NULL
[01:27:51.020]                   }
[01:27:51.020]                   options(future.plan = NULL)
[01:27:51.020]                   if (is.na(NA_character_)) 
[01:27:51.020]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:51.020]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:51.020]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:51.020]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:51.020]                     envir = parent.frame()) 
[01:27:51.020]                   {
[01:27:51.020]                     if (is.function(workers)) 
[01:27:51.020]                       workers <- workers()
[01:27:51.020]                     workers <- structure(as.integer(workers), 
[01:27:51.020]                       class = class(workers))
[01:27:51.020]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:51.020]                       workers >= 1)
[01:27:51.020]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:51.020]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:51.020]                     }
[01:27:51.020]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:51.020]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:51.020]                       envir = envir)
[01:27:51.020]                     if (!future$lazy) 
[01:27:51.020]                       future <- run(future)
[01:27:51.020]                     invisible(future)
[01:27:51.020]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:51.020]                 }
[01:27:51.020]             }
[01:27:51.020]         }
[01:27:51.020]     })
[01:27:51.020]     if (TRUE) {
[01:27:51.020]         base::sink(type = "output", split = FALSE)
[01:27:51.020]         if (TRUE) {
[01:27:51.020]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:51.020]         }
[01:27:51.020]         else {
[01:27:51.020]             ...future.result["stdout"] <- base::list(NULL)
[01:27:51.020]         }
[01:27:51.020]         base::close(...future.stdout)
[01:27:51.020]         ...future.stdout <- NULL
[01:27:51.020]     }
[01:27:51.020]     ...future.result$conditions <- ...future.conditions
[01:27:51.020]     ...future.result$finished <- base::Sys.time()
[01:27:51.020]     ...future.result
[01:27:51.020] }
[01:27:51.026] MultisessionFuture started
[01:27:51.026] - Launch lazy future ... done
[01:27:51.026] run() for 'MultisessionFuture' ... done
[01:27:51.027] getGlobalsAndPackages() ...
[01:27:51.027] Searching for globals...
[01:27:51.028] - globals found: [1] '{'
[01:27:51.028] Searching for globals ... DONE
[01:27:51.028] Resolving globals: FALSE
[01:27:51.029] 
[01:27:51.029] 
[01:27:51.029] getGlobalsAndPackages() ... DONE
[01:27:51.029] run() for 'Future' ...
[01:27:51.029] - state: 'created'
[01:27:51.030] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:27:51.044] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:27:51.044] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:27:51.044]   - Field: 'node'
[01:27:51.044]   - Field: 'label'
[01:27:51.045]   - Field: 'local'
[01:27:51.045]   - Field: 'owner'
[01:27:51.045]   - Field: 'envir'
[01:27:51.045]   - Field: 'workers'
[01:27:51.045]   - Field: 'packages'
[01:27:51.045]   - Field: 'gc'
[01:27:51.046]   - Field: 'conditions'
[01:27:51.046]   - Field: 'persistent'
[01:27:51.046]   - Field: 'expr'
[01:27:51.046]   - Field: 'uuid'
[01:27:51.046]   - Field: 'seed'
[01:27:51.047]   - Field: 'version'
[01:27:51.047]   - Field: 'result'
[01:27:51.047]   - Field: 'asynchronous'
[01:27:51.047]   - Field: 'calls'
[01:27:51.047]   - Field: 'globals'
[01:27:51.047]   - Field: 'stdout'
[01:27:51.048]   - Field: 'earlySignal'
[01:27:51.048]   - Field: 'lazy'
[01:27:51.048]   - Field: 'state'
[01:27:51.048] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:27:51.048] - Launch lazy future ...
[01:27:51.049] Packages needed by the future expression (n = 0): <none>
[01:27:51.049] Packages needed by future strategies (n = 0): <none>
[01:27:51.050] {
[01:27:51.050]     {
[01:27:51.050]         {
[01:27:51.050]             ...future.startTime <- base::Sys.time()
[01:27:51.050]             {
[01:27:51.050]                 {
[01:27:51.050]                   {
[01:27:51.050]                     {
[01:27:51.050]                       base::local({
[01:27:51.050]                         has_future <- base::requireNamespace("future", 
[01:27:51.050]                           quietly = TRUE)
[01:27:51.050]                         if (has_future) {
[01:27:51.050]                           ns <- base::getNamespace("future")
[01:27:51.050]                           version <- ns[[".package"]][["version"]]
[01:27:51.050]                           if (is.null(version)) 
[01:27:51.050]                             version <- utils::packageVersion("future")
[01:27:51.050]                         }
[01:27:51.050]                         else {
[01:27:51.050]                           version <- NULL
[01:27:51.050]                         }
[01:27:51.050]                         if (!has_future || version < "1.8.0") {
[01:27:51.050]                           info <- base::c(r_version = base::gsub("R version ", 
[01:27:51.050]                             "", base::R.version$version.string), 
[01:27:51.050]                             platform = base::sprintf("%s (%s-bit)", 
[01:27:51.050]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:27:51.050]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:27:51.050]                               "release", "version")], collapse = " "), 
[01:27:51.050]                             hostname = base::Sys.info()[["nodename"]])
[01:27:51.050]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:27:51.050]                             info)
[01:27:51.050]                           info <- base::paste(info, collapse = "; ")
[01:27:51.050]                           if (!has_future) {
[01:27:51.050]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:27:51.050]                               info)
[01:27:51.050]                           }
[01:27:51.050]                           else {
[01:27:51.050]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:27:51.050]                               info, version)
[01:27:51.050]                           }
[01:27:51.050]                           base::stop(msg)
[01:27:51.050]                         }
[01:27:51.050]                       })
[01:27:51.050]                     }
[01:27:51.050]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:27:51.050]                     base::options(mc.cores = 1L)
[01:27:51.050]                   }
[01:27:51.050]                   options(future.plan = NULL)
[01:27:51.050]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:27:51.050]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:27:51.050]                 }
[01:27:51.050]                 ...future.workdir <- getwd()
[01:27:51.050]             }
[01:27:51.050]             ...future.oldOptions <- base::as.list(base::.Options)
[01:27:51.050]             ...future.oldEnvVars <- base::Sys.getenv()
[01:27:51.050]         }
[01:27:51.050]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:27:51.050]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:27:51.050]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:27:51.050]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:27:51.050]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:27:51.050]             future.stdout.windows.reencode = NULL, width = 80L)
[01:27:51.050]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:27:51.050]             base::names(...future.oldOptions))
[01:27:51.050]     }
[01:27:51.050]     if (FALSE) {
[01:27:51.050]     }
[01:27:51.050]     else {
[01:27:51.050]         if (TRUE) {
[01:27:51.050]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:27:51.050]                 open = "w")
[01:27:51.050]         }
[01:27:51.050]         else {
[01:27:51.050]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:27:51.050]                 windows = "NUL", "/dev/null"), open = "w")
[01:27:51.050]         }
[01:27:51.050]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:27:51.050]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:27:51.050]             base::sink(type = "output", split = FALSE)
[01:27:51.050]             base::close(...future.stdout)
[01:27:51.050]         }, add = TRUE)
[01:27:51.050]     }
[01:27:51.050]     ...future.frame <- base::sys.nframe()
[01:27:51.050]     ...future.conditions <- base::list()
[01:27:51.050]     ...future.rng <- base::globalenv()$.Random.seed
[01:27:51.050]     if (FALSE) {
[01:27:51.050]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:27:51.050]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:27:51.050]     }
[01:27:51.050]     ...future.result <- base::tryCatch({
[01:27:51.050]         base::withCallingHandlers({
[01:27:51.050]             ...future.value <- base::withVisible(base::local({
[01:27:51.050]                 ...future.makeSendCondition <- base::local({
[01:27:51.050]                   sendCondition <- NULL
[01:27:51.050]                   function(frame = 1L) {
[01:27:51.050]                     if (is.function(sendCondition)) 
[01:27:51.050]                       return(sendCondition)
[01:27:51.050]                     ns <- getNamespace("parallel")
[01:27:51.050]                     if (exists("sendData", mode = "function", 
[01:27:51.050]                       envir = ns)) {
[01:27:51.050]                       parallel_sendData <- get("sendData", mode = "function", 
[01:27:51.050]                         envir = ns)
[01:27:51.050]                       envir <- sys.frame(frame)
[01:27:51.050]                       master <- NULL
[01:27:51.050]                       while (!identical(envir, .GlobalEnv) && 
[01:27:51.050]                         !identical(envir, emptyenv())) {
[01:27:51.050]                         if (exists("master", mode = "list", envir = envir, 
[01:27:51.050]                           inherits = FALSE)) {
[01:27:51.050]                           master <- get("master", mode = "list", 
[01:27:51.050]                             envir = envir, inherits = FALSE)
[01:27:51.050]                           if (inherits(master, c("SOCKnode", 
[01:27:51.050]                             "SOCK0node"))) {
[01:27:51.050]                             sendCondition <<- function(cond) {
[01:27:51.050]                               data <- list(type = "VALUE", value = cond, 
[01:27:51.050]                                 success = TRUE)
[01:27:51.050]                               parallel_sendData(master, data)
[01:27:51.050]                             }
[01:27:51.050]                             return(sendCondition)
[01:27:51.050]                           }
[01:27:51.050]                         }
[01:27:51.050]                         frame <- frame + 1L
[01:27:51.050]                         envir <- sys.frame(frame)
[01:27:51.050]                       }
[01:27:51.050]                     }
[01:27:51.050]                     sendCondition <<- function(cond) NULL
[01:27:51.050]                   }
[01:27:51.050]                 })
[01:27:51.050]                 withCallingHandlers({
[01:27:51.050]                   {
[01:27:51.050]                     4
[01:27:51.050]                   }
[01:27:51.050]                 }, immediateCondition = function(cond) {
[01:27:51.050]                   sendCondition <- ...future.makeSendCondition()
[01:27:51.050]                   sendCondition(cond)
[01:27:51.050]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:51.050]                   {
[01:27:51.050]                     inherits <- base::inherits
[01:27:51.050]                     invokeRestart <- base::invokeRestart
[01:27:51.050]                     is.null <- base::is.null
[01:27:51.050]                     muffled <- FALSE
[01:27:51.050]                     if (inherits(cond, "message")) {
[01:27:51.050]                       muffled <- grepl(pattern, "muffleMessage")
[01:27:51.050]                       if (muffled) 
[01:27:51.050]                         invokeRestart("muffleMessage")
[01:27:51.050]                     }
[01:27:51.050]                     else if (inherits(cond, "warning")) {
[01:27:51.050]                       muffled <- grepl(pattern, "muffleWarning")
[01:27:51.050]                       if (muffled) 
[01:27:51.050]                         invokeRestart("muffleWarning")
[01:27:51.050]                     }
[01:27:51.050]                     else if (inherits(cond, "condition")) {
[01:27:51.050]                       if (!is.null(pattern)) {
[01:27:51.050]                         computeRestarts <- base::computeRestarts
[01:27:51.050]                         grepl <- base::grepl
[01:27:51.050]                         restarts <- computeRestarts(cond)
[01:27:51.050]                         for (restart in restarts) {
[01:27:51.050]                           name <- restart$name
[01:27:51.050]                           if (is.null(name)) 
[01:27:51.050]                             next
[01:27:51.050]                           if (!grepl(pattern, name)) 
[01:27:51.050]                             next
[01:27:51.050]                           invokeRestart(restart)
[01:27:51.050]                           muffled <- TRUE
[01:27:51.050]                           break
[01:27:51.050]                         }
[01:27:51.050]                       }
[01:27:51.050]                     }
[01:27:51.050]                     invisible(muffled)
[01:27:51.050]                   }
[01:27:51.050]                   muffleCondition(cond)
[01:27:51.050]                 })
[01:27:51.050]             }))
[01:27:51.050]             future::FutureResult(value = ...future.value$value, 
[01:27:51.050]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:51.050]                   ...future.rng), globalenv = if (FALSE) 
[01:27:51.050]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:27:51.050]                     ...future.globalenv.names))
[01:27:51.050]                 else NULL, started = ...future.startTime, version = "1.8")
[01:27:51.050]         }, condition = base::local({
[01:27:51.050]             c <- base::c
[01:27:51.050]             inherits <- base::inherits
[01:27:51.050]             invokeRestart <- base::invokeRestart
[01:27:51.050]             length <- base::length
[01:27:51.050]             list <- base::list
[01:27:51.050]             seq.int <- base::seq.int
[01:27:51.050]             signalCondition <- base::signalCondition
[01:27:51.050]             sys.calls <- base::sys.calls
[01:27:51.050]             `[[` <- base::`[[`
[01:27:51.050]             `+` <- base::`+`
[01:27:51.050]             `<<-` <- base::`<<-`
[01:27:51.050]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:27:51.050]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:27:51.050]                   3L)]
[01:27:51.050]             }
[01:27:51.050]             function(cond) {
[01:27:51.050]                 is_error <- inherits(cond, "error")
[01:27:51.050]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:27:51.050]                   NULL)
[01:27:51.050]                 if (is_error) {
[01:27:51.050]                   sessionInformation <- function() {
[01:27:51.050]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:27:51.050]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:27:51.050]                       search = base::search(), system = base::Sys.info())
[01:27:51.050]                   }
[01:27:51.050]                   ...future.conditions[[length(...future.conditions) + 
[01:27:51.050]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:27:51.050]                     cond$call), session = sessionInformation(), 
[01:27:51.050]                     timestamp = base::Sys.time(), signaled = 0L)
[01:27:51.050]                   signalCondition(cond)
[01:27:51.050]                 }
[01:27:51.050]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:27:51.050]                 "immediateCondition"))) {
[01:27:51.050]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:27:51.050]                   ...future.conditions[[length(...future.conditions) + 
[01:27:51.050]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:27:51.050]                   if (TRUE && !signal) {
[01:27:51.050]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:51.050]                     {
[01:27:51.050]                       inherits <- base::inherits
[01:27:51.050]                       invokeRestart <- base::invokeRestart
[01:27:51.050]                       is.null <- base::is.null
[01:27:51.050]                       muffled <- FALSE
[01:27:51.050]                       if (inherits(cond, "message")) {
[01:27:51.050]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:51.050]                         if (muffled) 
[01:27:51.050]                           invokeRestart("muffleMessage")
[01:27:51.050]                       }
[01:27:51.050]                       else if (inherits(cond, "warning")) {
[01:27:51.050]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:51.050]                         if (muffled) 
[01:27:51.050]                           invokeRestart("muffleWarning")
[01:27:51.050]                       }
[01:27:51.050]                       else if (inherits(cond, "condition")) {
[01:27:51.050]                         if (!is.null(pattern)) {
[01:27:51.050]                           computeRestarts <- base::computeRestarts
[01:27:51.050]                           grepl <- base::grepl
[01:27:51.050]                           restarts <- computeRestarts(cond)
[01:27:51.050]                           for (restart in restarts) {
[01:27:51.050]                             name <- restart$name
[01:27:51.050]                             if (is.null(name)) 
[01:27:51.050]                               next
[01:27:51.050]                             if (!grepl(pattern, name)) 
[01:27:51.050]                               next
[01:27:51.050]                             invokeRestart(restart)
[01:27:51.050]                             muffled <- TRUE
[01:27:51.050]                             break
[01:27:51.050]                           }
[01:27:51.050]                         }
[01:27:51.050]                       }
[01:27:51.050]                       invisible(muffled)
[01:27:51.050]                     }
[01:27:51.050]                     muffleCondition(cond, pattern = "^muffle")
[01:27:51.050]                   }
[01:27:51.050]                 }
[01:27:51.050]                 else {
[01:27:51.050]                   if (TRUE) {
[01:27:51.050]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:27:51.050]                     {
[01:27:51.050]                       inherits <- base::inherits
[01:27:51.050]                       invokeRestart <- base::invokeRestart
[01:27:51.050]                       is.null <- base::is.null
[01:27:51.050]                       muffled <- FALSE
[01:27:51.050]                       if (inherits(cond, "message")) {
[01:27:51.050]                         muffled <- grepl(pattern, "muffleMessage")
[01:27:51.050]                         if (muffled) 
[01:27:51.050]                           invokeRestart("muffleMessage")
[01:27:51.050]                       }
[01:27:51.050]                       else if (inherits(cond, "warning")) {
[01:27:51.050]                         muffled <- grepl(pattern, "muffleWarning")
[01:27:51.050]                         if (muffled) 
[01:27:51.050]                           invokeRestart("muffleWarning")
[01:27:51.050]                       }
[01:27:51.050]                       else if (inherits(cond, "condition")) {
[01:27:51.050]                         if (!is.null(pattern)) {
[01:27:51.050]                           computeRestarts <- base::computeRestarts
[01:27:51.050]                           grepl <- base::grepl
[01:27:51.050]                           restarts <- computeRestarts(cond)
[01:27:51.050]                           for (restart in restarts) {
[01:27:51.050]                             name <- restart$name
[01:27:51.050]                             if (is.null(name)) 
[01:27:51.050]                               next
[01:27:51.050]                             if (!grepl(pattern, name)) 
[01:27:51.050]                               next
[01:27:51.050]                             invokeRestart(restart)
[01:27:51.050]                             muffled <- TRUE
[01:27:51.050]                             break
[01:27:51.050]                           }
[01:27:51.050]                         }
[01:27:51.050]                       }
[01:27:51.050]                       invisible(muffled)
[01:27:51.050]                     }
[01:27:51.050]                     muffleCondition(cond, pattern = "^muffle")
[01:27:51.050]                   }
[01:27:51.050]                 }
[01:27:51.050]             }
[01:27:51.050]         }))
[01:27:51.050]     }, error = function(ex) {
[01:27:51.050]         base::structure(base::list(value = NULL, visible = NULL, 
[01:27:51.050]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:27:51.050]                 ...future.rng), started = ...future.startTime, 
[01:27:51.050]             finished = Sys.time(), session_uuid = NA_character_, 
[01:27:51.050]             version = "1.8"), class = "FutureResult")
[01:27:51.050]     }, finally = {
[01:27:51.050]         if (!identical(...future.workdir, getwd())) 
[01:27:51.050]             setwd(...future.workdir)
[01:27:51.050]         {
[01:27:51.050]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:27:51.050]                 ...future.oldOptions$nwarnings <- NULL
[01:27:51.050]             }
[01:27:51.050]             base::options(...future.oldOptions)
[01:27:51.050]             if (.Platform$OS.type == "windows") {
[01:27:51.050]                 old_names <- names(...future.oldEnvVars)
[01:27:51.050]                 envs <- base::Sys.getenv()
[01:27:51.050]                 names <- names(envs)
[01:27:51.050]                 common <- intersect(names, old_names)
[01:27:51.050]                 added <- setdiff(names, old_names)
[01:27:51.050]                 removed <- setdiff(old_names, names)
[01:27:51.050]                 changed <- common[...future.oldEnvVars[common] != 
[01:27:51.050]                   envs[common]]
[01:27:51.050]                 NAMES <- toupper(changed)
[01:27:51.050]                 args <- list()
[01:27:51.050]                 for (kk in seq_along(NAMES)) {
[01:27:51.050]                   name <- changed[[kk]]
[01:27:51.050]                   NAME <- NAMES[[kk]]
[01:27:51.050]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:51.050]                     next
[01:27:51.050]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:51.050]                 }
[01:27:51.050]                 NAMES <- toupper(added)
[01:27:51.050]                 for (kk in seq_along(NAMES)) {
[01:27:51.050]                   name <- added[[kk]]
[01:27:51.050]                   NAME <- NAMES[[kk]]
[01:27:51.050]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:51.050]                     next
[01:27:51.050]                   args[[name]] <- ""
[01:27:51.050]                 }
[01:27:51.050]                 NAMES <- toupper(removed)
[01:27:51.050]                 for (kk in seq_along(NAMES)) {
[01:27:51.050]                   name <- removed[[kk]]
[01:27:51.050]                   NAME <- NAMES[[kk]]
[01:27:51.050]                   if (name != NAME && is.element(NAME, old_names)) 
[01:27:51.050]                     next
[01:27:51.050]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:27:51.050]                 }
[01:27:51.050]                 if (length(args) > 0) 
[01:27:51.050]                   base::do.call(base::Sys.setenv, args = args)
[01:27:51.050]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:27:51.050]             }
[01:27:51.050]             else {
[01:27:51.050]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:27:51.050]             }
[01:27:51.050]             {
[01:27:51.050]                 if (base::length(...future.futureOptionsAdded) > 
[01:27:51.050]                   0L) {
[01:27:51.050]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:27:51.050]                   base::names(opts) <- ...future.futureOptionsAdded
[01:27:51.050]                   base::options(opts)
[01:27:51.050]                 }
[01:27:51.050]                 {
[01:27:51.050]                   {
[01:27:51.050]                     base::options(mc.cores = ...future.mc.cores.old)
[01:27:51.050]                     NULL
[01:27:51.050]                   }
[01:27:51.050]                   options(future.plan = NULL)
[01:27:51.050]                   if (is.na(NA_character_)) 
[01:27:51.050]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:27:51.050]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:27:51.050]                   future::plan(list(function (..., workers = availableCores(), 
[01:27:51.050]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:27:51.050]                     envir = parent.frame()) 
[01:27:51.050]                   {
[01:27:51.050]                     if (is.function(workers)) 
[01:27:51.050]                       workers <- workers()
[01:27:51.050]                     workers <- structure(as.integer(workers), 
[01:27:51.050]                       class = class(workers))
[01:27:51.050]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:27:51.050]                       workers >= 1)
[01:27:51.050]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:27:51.050]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:27:51.050]                     }
[01:27:51.050]                     future <- MultisessionFuture(..., workers = workers, 
[01:27:51.050]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:27:51.050]                       envir = envir)
[01:27:51.050]                     if (!future$lazy) 
[01:27:51.050]                       future <- run(future)
[01:27:51.050]                     invisible(future)
[01:27:51.050]                   }), .cleanup = FALSE, .init = FALSE)
[01:27:51.050]                 }
[01:27:51.050]             }
[01:27:51.050]         }
[01:27:51.050]     })
[01:27:51.050]     if (TRUE) {
[01:27:51.050]         base::sink(type = "output", split = FALSE)
[01:27:51.050]         if (TRUE) {
[01:27:51.050]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:27:51.050]         }
[01:27:51.050]         else {
[01:27:51.050]             ...future.result["stdout"] <- base::list(NULL)
[01:27:51.050]         }
[01:27:51.050]         base::close(...future.stdout)
[01:27:51.050]         ...future.stdout <- NULL
[01:27:51.050]     }
[01:27:51.050]     ...future.result$conditions <- ...future.conditions
[01:27:51.050]     ...future.result$finished <- base::Sys.time()
[01:27:51.050]     ...future.result
[01:27:51.050] }
[01:27:51.055] Poll #1 (0): usedNodes() = 2, workers = 2
[01:27:51.071] receiveMessageFromWorker() for ClusterFuture ...
[01:27:51.071] - Validating connection of MultisessionFuture
[01:27:51.072] - received message: FutureResult
[01:27:51.072] - Received FutureResult
[01:27:51.072] - Erased future from FutureRegistry
[01:27:51.072] result() for ClusterFuture ...
[01:27:51.073] - result already collected: FutureResult
[01:27:51.073] result() for ClusterFuture ... done
[01:27:51.073] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:51.073] result() for ClusterFuture ...
[01:27:51.073] - result already collected: FutureResult
[01:27:51.074] result() for ClusterFuture ... done
[01:27:51.074] result() for ClusterFuture ...
[01:27:51.074] - result already collected: FutureResult
[01:27:51.074] result() for ClusterFuture ... done
[01:27:51.075] MultisessionFuture started
[01:27:51.076] - Launch lazy future ... done
[01:27:51.076] run() for 'MultisessionFuture' ... done
Classes 'listenv', 'environment' <environment: 0x0000025b04f2ec38> 
Classes 'listenv', 'environment' <environment: 0x0000025b0ac12b58> 
 - 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"
[01:27:51.081] receiveMessageFromWorker() for ClusterFuture ...
[01:27:51.082] - Validating connection of MultisessionFuture
[01:27:51.082] - received message: FutureResult
[01:27:51.082] - Received FutureResult
[01:27:51.082] - Erased future from FutureRegistry
[01:27:51.083] result() for ClusterFuture ...
[01:27:51.083] - result already collected: FutureResult
[01:27:51.083] result() for ClusterFuture ... done
[01:27:51.083] receiveMessageFromWorker() for ClusterFuture ... done
[01:27:51.093] receiveMessageFromWorker() for ClusterFuture ...
[01:27:51.093] - Validating connection of MultisessionFuture
[01:27:51.094] - received message: FutureResult
[01:27:51.094] - Received FutureResult
[01:27:51.094] - Erased future from FutureRegistry
[01:27:51.094] result() for ClusterFuture ...
[01:27:51.094] - result already collected: FutureResult
[01:27:51.095] result() for ClusterFuture ... done
[01:27:51.095] 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" ...
[01:27:51.098] resolve() on list environment ...
[01:27:51.099]  recursive: 0
[01:27:51.100]  length: 6
[01:27:51.100]  elements: 'a', 'b', 'c', 'd', '', ''
[01:27:51.101] signalConditionsASAP(numeric, pos=1) ...
[01:27:51.101] - nx: 6
[01:27:51.101] - relay: TRUE
[01:27:51.101] - stdout: TRUE
[01:27:51.101] - signal: TRUE
[01:27:51.101] - resignal: FALSE
[01:27:51.102] - force: TRUE
[01:27:51.102] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:51.102] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:51.103]  - until=2
[01:27:51.103]  - relaying element #2
[01:27:51.103] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:51.103] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:51.104] signalConditionsASAP(NULL, pos=1) ... done
[01:27:51.104]  length: 5 (resolved future 1)
[01:27:51.104] Future #2
[01:27:51.104] result() for ClusterFuture ...
[01:27:51.105] - result already collected: FutureResult
[01:27:51.105] result() for ClusterFuture ... done
[01:27:51.105] result() for ClusterFuture ...
[01:27:51.105] - result already collected: FutureResult
[01:27:51.105] result() for ClusterFuture ... done
[01:27:51.106] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:27:51.106] - nx: 6
[01:27:51.106] - relay: TRUE
[01:27:51.106] - stdout: TRUE
[01:27:51.106] - signal: TRUE
[01:27:51.107] - resignal: FALSE
[01:27:51.107] - force: TRUE
[01:27:51.107] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:51.107] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
[01:27:51.107]  - until=2
[01:27:51.107]  - relaying element #2
[01:27:51.108] result() for ClusterFuture ...
[01:27:51.108] - result already collected: FutureResult
[01:27:51.108] result() for ClusterFuture ... done
[01:27:51.108] result() for ClusterFuture ...
[01:27:51.108] - result already collected: FutureResult
[01:27:51.109] result() for ClusterFuture ... done
[01:27:51.109] result() for ClusterFuture ...
[01:27:51.109] - result already collected: FutureResult
[01:27:51.109] result() for ClusterFuture ... done
[01:27:51.109] result() for ClusterFuture ...
[01:27:51.110] - result already collected: FutureResult
[01:27:51.110] result() for ClusterFuture ... done
[01:27:51.110] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:51.110] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:51.110] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:27:51.110]  length: 4 (resolved future 2)
[01:27:51.111] Future #3
[01:27:51.111] result() for ClusterFuture ...
[01:27:51.111] - result already collected: FutureResult
[01:27:51.111] result() for ClusterFuture ... done
[01:27:51.111] result() for ClusterFuture ...
[01:27:51.112] - result already collected: FutureResult
[01:27:51.112] result() for ClusterFuture ... done
[01:27:51.112] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:27:51.112] - nx: 6
[01:27:51.112] - relay: TRUE
[01:27:51.113] - stdout: TRUE
[01:27:51.113] - signal: TRUE
[01:27:51.113] - resignal: FALSE
[01:27:51.113] - force: TRUE
[01:27:51.113] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:51.113] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
[01:27:51.114]  - until=3
[01:27:51.114]  - relaying element #3
[01:27:51.114] result() for ClusterFuture ...
[01:27:51.114] - result already collected: FutureResult
[01:27:51.114] result() for ClusterFuture ... done
[01:27:51.115] result() for ClusterFuture ...
[01:27:51.115] - result already collected: FutureResult
[01:27:51.115] result() for ClusterFuture ... done
[01:27:51.115] result() for ClusterFuture ...
[01:27:51.115] - result already collected: FutureResult
[01:27:51.115] result() for ClusterFuture ... done
[01:27:51.116] result() for ClusterFuture ...
[01:27:51.116] - result already collected: FutureResult
[01:27:51.116] result() for ClusterFuture ... done
[01:27:51.116] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:51.117] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:51.117] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:27:51.117]  length: 3 (resolved future 3)
[01:27:51.117] Future #4
[01:27:51.117] result() for ClusterFuture ...
[01:27:51.118] - result already collected: FutureResult
[01:27:51.118] result() for ClusterFuture ... done
[01:27:51.118] result() for ClusterFuture ...
[01:27:51.118] - result already collected: FutureResult
[01:27:51.118] result() for ClusterFuture ... done
[01:27:51.119] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:27:51.119] - nx: 6
[01:27:51.119] - relay: TRUE
[01:27:51.119] - stdout: TRUE
[01:27:51.119] - signal: TRUE
[01:27:51.120] - resignal: FALSE
[01:27:51.120] - force: TRUE
[01:27:51.120] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:51.120] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
[01:27:51.120]  - until=4
[01:27:51.120]  - relaying element #4
[01:27:51.121] result() for ClusterFuture ...
[01:27:51.121] - result already collected: FutureResult
[01:27:51.121] result() for ClusterFuture ... done
[01:27:51.121] result() for ClusterFuture ...
[01:27:51.121] - result already collected: FutureResult
[01:27:51.122] result() for ClusterFuture ... done
[01:27:51.122] result() for ClusterFuture ...
[01:27:51.122] - result already collected: FutureResult
[01:27:51.122] result() for ClusterFuture ... done
[01:27:51.122] result() for ClusterFuture ...
[01:27:51.122] - result already collected: FutureResult
[01:27:51.123] result() for ClusterFuture ... done
[01:27:51.123] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.123] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.123] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:27:51.123]  length: 2 (resolved future 4)
[01:27:51.124] signalConditionsASAP(NULL, pos=5) ...
[01:27:51.124] - nx: 6
[01:27:51.124] - relay: TRUE
[01:27:51.124] - stdout: TRUE
[01:27:51.124] - signal: TRUE
[01:27:51.124] - resignal: FALSE
[01:27:51.125] - force: TRUE
[01:27:51.125] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.125] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.125]  - until=6
[01:27:51.131]  - relaying element #6
[01:27:51.132] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:51.132] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.132] signalConditionsASAP(NULL, pos=5) ... done
[01:27:51.132]  length: 1 (resolved future 5)
[01:27:51.133] signalConditionsASAP(numeric, pos=6) ...
[01:27:51.133] - nx: 6
[01:27:51.133] - relay: TRUE
[01:27:51.133] - stdout: TRUE
[01:27:51.134] - signal: TRUE
[01:27:51.134] - resignal: FALSE
[01:27:51.134] - force: TRUE
[01:27:51.134] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
[01:27:51.134] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.135]  - until=6
[01:27:51.135] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:51.135] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.135] signalConditionsASAP(numeric, pos=6) ... done
[01:27:51.135]  length: 0 (resolved future 6)
[01:27:51.135] Relaying remaining futures
[01:27:51.136] signalConditionsASAP(NULL, pos=0) ...
[01:27:51.136] - nx: 6
[01:27:51.136] - relay: TRUE
[01:27:51.136] - stdout: TRUE
[01:27:51.136] - signal: TRUE
[01:27:51.136] - resignal: FALSE
[01:27:51.137] - force: TRUE
[01:27:51.137] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:51.137] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
 - flush all
[01:27:51.137] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
[01:27:51.137] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
[01:27:51.138] signalConditionsASAP(NULL, pos=0) ... done
[01:27:51.138] resolve() on list environment ... DONE
[01:27:51.138] result() for ClusterFuture ...
[01:27:51.138] - result already collected: FutureResult
[01:27:51.138] result() for ClusterFuture ... done
[01:27:51.139] result() for ClusterFuture ...
[01:27:51.139] - result already collected: FutureResult
[01:27:51.139] result() for ClusterFuture ... done
[01:27:51.139] result() for ClusterFuture ...
[01:27:51.139] - result already collected: FutureResult
[01:27:51.140] result() for ClusterFuture ... done
[01:27:51.140] result() for ClusterFuture ...
[01:27:51.140] - result already collected: FutureResult
[01:27:51.140] result() for ClusterFuture ... done
[01:27:51.141] result() for ClusterFuture ...
[01:27:51.141] - result already collected: FutureResult
[01:27:51.141] result() for ClusterFuture ... done
[01:27:51.141] result() for ClusterFuture ...
[01:27:51.141] - result already collected: FutureResult
[01:27:51.141] result() for ClusterFuture ... done
Classes 'listenv', 'environment' <environment: 0x0000025b0b1b63e8> 
 - 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")
[01:27:51.146] plan(): Setting new future strategy stack:
[01:27:51.146] List of future strategies:
[01:27:51.146] 1. FutureStrategy:
[01:27:51.146]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:27:51.146]    - tweaked: FALSE
[01:27:51.146]    - call: future::plan(oplan)
[01:27:51.148] 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', '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_RTOOLS43_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_SUBDIRS_STRICT_', '_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_INSTALL_TIME_PATCHES_', '_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.89    0.17    6.20