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

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

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

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

> source("incl/start.R")
[17:27:21.722] plan(): Setting new future strategy stack:
[17:27:21.724] List of future strategies:
[17:27:21.724] 1. sequential:
[17:27:21.724]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:21.724]    - tweaked: FALSE
[17:27:21.724]    - call: future::plan("sequential")
[17:27:21.754] plan(): nbrOfWorkers() = 1
> 
> message("*** %<-% ...")
*** %<-% ...
> 
> for (cores in 1:availCores) {
+   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
+   if (!fullTest && isWin32) next
+   
+   message(sprintf("Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+ 
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("*** %%<-%% with %s futures ...", sQuote(strategy)))
+     plan(strategy)
+ 
+     rm(list = intersect(c("x", "y"), ls()))
+ 
+     message("** Future evaluation without globals")
+     v1 %<-% { x <- 1 }
+     stopifnot(!exists("x", inherits = FALSE), identical(v1, 1))
+ 
+     message("** Future evaluation with globals")
+     a <- 2
+     v2 %<-% { x <- a }
+     stopifnot(!exists("x", inherits = FALSE), identical(v2, a))
+ 
+     message("** Future evaluation with errors")
+     v3 %<-% {
+       x <- 3
+       stop("Woops!")
+       x
+     }
+     stopifnot(!exists("x", inherits = FALSE))
+     res <- tryCatch(identical(v3, 3), error = identity)
+     stopifnot(inherits(res, "error"))
+ 
+ 
+     y <- listenv::listenv()
+     for (ii in 1:3) {
+       y[[ii]] %<-% {
+         if (ii %% 2 == 0) stop("Woops!")
+         ii
+       }
+     }
+     res <- tryCatch(as.list(y), error = identity)
+     stopifnot(inherits(res, "error"))
+     z <- y[c(1, 3)]
+     z <- unlist(z)
+     stopifnot(all(z == c(1, 3)))
+     res <- tryCatch(y[[2]], error = identity)
+     stopifnot(inherits(res, "error"))
+     res <- tryCatch(y[1:2], error = identity)
+     stopifnot(inherits(res, "error"))
+ 
+ 
+     message("** Future evaluation with a poor-man's \"progress bar\"")
+     v4 %<-% {
+       cat("Processing: ")
+       for (ii in 1:10) { cat(".") }
+       cat(" [100%]\n")
+       4
+     }
+ 
+ 
+     message("** Collecting results")
+     printf("v1 = %s\n", v1)
+     stopifnot(v1 == 1)
+ 
+     printf("v2 = %s\n", v2)
+     stopifnot(v2 == a)
+ 
+     stopifnot(tryCatch({
+       printf("v3 = %s\n", v3)
+     }, error = function(ex) {
+       printf("v3: <%s> (as expect)\n", class(ex)[1])
+       TRUE
+     }))
+ 
+     printf("v4 = %s\n", v4)
+     #stopifnot(v4 == 4)
+ 
+ 
+     message("** Left-to-right and right-to-left future assignments")
+     c %<-% 1
+     printf("c = %s\n", c)
+     1 %->% d
+     printf("d = %s\n", d)
+     stopifnot(d == c)
+ 
+ 
+ 
+     message("** Nested future assignments")
+     a %<-% {
+       b <- 1
+       c %<-% 2
+       3 -> d
+       4 %->% e
+       b + c + d + e
+     }
+     printf("a = %s\n", a)
+     stopifnot(a == 10)
+ 
+     { a + 1 } %->% b
+     printf("b = %s\n", b)
+     stopifnot(b == a + 1)
+ 
+     message(sprintf("*** %%<-%% with %s futures ... DONE", sQuote(strategy)))
+   } # for (strategy in ...)
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
*** %<-% with 'sequential' futures ...
[17:27:21.876] plan(): Setting new future strategy stack:
[17:27:21.877] List of future strategies:
[17:27:21.877] 1. sequential:
[17:27:21.877]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:21.877]    - tweaked: FALSE
[17:27:21.877]    - call: plan(strategy)
[17:27:21.905] plan(): nbrOfWorkers() = 1
** Future evaluation without globals
[17:27:21.909] getGlobalsAndPackages() ...
[17:27:21.909] Searching for globals...
[17:27:21.918] - globals found: [2] '{', '<-'
[17:27:21.919] Searching for globals ... DONE
[17:27:21.919] Resolving globals: FALSE
[17:27:21.920] 
[17:27:21.921] 
[17:27:21.921] getGlobalsAndPackages() ... DONE
[17:27:21.922] run() for 'Future' ...
[17:27:21.923] - state: 'created'
[17:27:21.923] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:21.924] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:21.925] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:21.925]   - Field: 'label'
[17:27:21.926]   - Field: 'local'
[17:27:21.926]   - Field: 'owner'
[17:27:21.926]   - Field: 'envir'
[17:27:21.927]   - Field: 'packages'
[17:27:21.927]   - Field: 'gc'
[17:27:21.927]   - Field: 'conditions'
[17:27:21.928]   - Field: 'expr'
[17:27:21.928]   - Field: 'uuid'
[17:27:21.929]   - Field: 'seed'
[17:27:21.929]   - Field: 'version'
[17:27:21.929]   - Field: 'result'
[17:27:21.930]   - Field: 'asynchronous'
[17:27:21.930]   - Field: 'calls'
[17:27:21.930]   - Field: 'globals'
[17:27:21.931]   - Field: 'stdout'
[17:27:21.931]   - Field: 'earlySignal'
[17:27:21.932]   - Field: 'lazy'
[17:27:21.932]   - Field: 'state'
[17:27:21.932] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:21.933] - Launch lazy future ...
[17:27:21.934] Packages needed by the future expression (n = 0): <none>
[17:27:21.935] Packages needed by future strategies (n = 0): <none>
[17:27:21.937] {
[17:27:21.937]     {
[17:27:21.937]         {
[17:27:21.937]             ...future.startTime <- base::Sys.time()
[17:27:21.937]             {
[17:27:21.937]                 {
[17:27:21.937]                   {
[17:27:21.937]                     base::local({
[17:27:21.937]                       has_future <- base::requireNamespace("future", 
[17:27:21.937]                         quietly = TRUE)
[17:27:21.937]                       if (has_future) {
[17:27:21.937]                         ns <- base::getNamespace("future")
[17:27:21.937]                         version <- ns[[".package"]][["version"]]
[17:27:21.937]                         if (is.null(version)) 
[17:27:21.937]                           version <- utils::packageVersion("future")
[17:27:21.937]                       }
[17:27:21.937]                       else {
[17:27:21.937]                         version <- NULL
[17:27:21.937]                       }
[17:27:21.937]                       if (!has_future || version < "1.8.0") {
[17:27:21.937]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:21.937]                           "", base::R.version$version.string), 
[17:27:21.937]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:21.937]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:21.937]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:21.937]                             "release", "version")], collapse = " "), 
[17:27:21.937]                           hostname = base::Sys.info()[["nodename"]])
[17:27:21.937]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:21.937]                           info)
[17:27:21.937]                         info <- base::paste(info, collapse = "; ")
[17:27:21.937]                         if (!has_future) {
[17:27:21.937]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:21.937]                             info)
[17:27:21.937]                         }
[17:27:21.937]                         else {
[17:27:21.937]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:21.937]                             info, version)
[17:27:21.937]                         }
[17:27:21.937]                         base::stop(msg)
[17:27:21.937]                       }
[17:27:21.937]                     })
[17:27:21.937]                   }
[17:27:21.937]                   ...future.strategy.old <- future::plan("list")
[17:27:21.937]                   options(future.plan = NULL)
[17:27:21.937]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:21.937]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:21.937]                 }
[17:27:21.937]                 ...future.workdir <- getwd()
[17:27:21.937]             }
[17:27:21.937]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:21.937]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:21.937]         }
[17:27:21.937]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:21.937]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:21.937]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:21.937]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:21.937]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:21.937]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:21.937]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:21.937]             base::names(...future.oldOptions))
[17:27:21.937]     }
[17:27:21.937]     if (FALSE) {
[17:27:21.937]     }
[17:27:21.937]     else {
[17:27:21.937]         if (TRUE) {
[17:27:21.937]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:21.937]                 open = "w")
[17:27:21.937]         }
[17:27:21.937]         else {
[17:27:21.937]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:21.937]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:21.937]         }
[17:27:21.937]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:21.937]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:21.937]             base::sink(type = "output", split = FALSE)
[17:27:21.937]             base::close(...future.stdout)
[17:27:21.937]         }, add = TRUE)
[17:27:21.937]     }
[17:27:21.937]     ...future.frame <- base::sys.nframe()
[17:27:21.937]     ...future.conditions <- base::list()
[17:27:21.937]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:21.937]     if (FALSE) {
[17:27:21.937]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:21.937]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:21.937]     }
[17:27:21.937]     ...future.result <- base::tryCatch({
[17:27:21.937]         base::withCallingHandlers({
[17:27:21.937]             ...future.value <- base::withVisible(base::local({
[17:27:21.937]                 x <- 1
[17:27:21.937]             }))
[17:27:21.937]             future::FutureResult(value = ...future.value$value, 
[17:27:21.937]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:21.937]                   ...future.rng), globalenv = if (FALSE) 
[17:27:21.937]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:21.937]                     ...future.globalenv.names))
[17:27:21.937]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:21.937]         }, condition = base::local({
[17:27:21.937]             c <- base::c
[17:27:21.937]             inherits <- base::inherits
[17:27:21.937]             invokeRestart <- base::invokeRestart
[17:27:21.937]             length <- base::length
[17:27:21.937]             list <- base::list
[17:27:21.937]             seq.int <- base::seq.int
[17:27:21.937]             signalCondition <- base::signalCondition
[17:27:21.937]             sys.calls <- base::sys.calls
[17:27:21.937]             `[[` <- base::`[[`
[17:27:21.937]             `+` <- base::`+`
[17:27:21.937]             `<<-` <- base::`<<-`
[17:27:21.937]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:21.937]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:21.937]                   3L)]
[17:27:21.937]             }
[17:27:21.937]             function(cond) {
[17:27:21.937]                 is_error <- inherits(cond, "error")
[17:27:21.937]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:21.937]                   NULL)
[17:27:21.937]                 if (is_error) {
[17:27:21.937]                   sessionInformation <- function() {
[17:27:21.937]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:21.937]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:21.937]                       search = base::search(), system = base::Sys.info())
[17:27:21.937]                   }
[17:27:21.937]                   ...future.conditions[[length(...future.conditions) + 
[17:27:21.937]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:21.937]                     cond$call), session = sessionInformation(), 
[17:27:21.937]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:21.937]                   signalCondition(cond)
[17:27:21.937]                 }
[17:27:21.937]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:21.937]                 "immediateCondition"))) {
[17:27:21.937]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:21.937]                   ...future.conditions[[length(...future.conditions) + 
[17:27:21.937]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:21.937]                   if (TRUE && !signal) {
[17:27:21.937]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:21.937]                     {
[17:27:21.937]                       inherits <- base::inherits
[17:27:21.937]                       invokeRestart <- base::invokeRestart
[17:27:21.937]                       is.null <- base::is.null
[17:27:21.937]                       muffled <- FALSE
[17:27:21.937]                       if (inherits(cond, "message")) {
[17:27:21.937]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:21.937]                         if (muffled) 
[17:27:21.937]                           invokeRestart("muffleMessage")
[17:27:21.937]                       }
[17:27:21.937]                       else if (inherits(cond, "warning")) {
[17:27:21.937]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:21.937]                         if (muffled) 
[17:27:21.937]                           invokeRestart("muffleWarning")
[17:27:21.937]                       }
[17:27:21.937]                       else if (inherits(cond, "condition")) {
[17:27:21.937]                         if (!is.null(pattern)) {
[17:27:21.937]                           computeRestarts <- base::computeRestarts
[17:27:21.937]                           grepl <- base::grepl
[17:27:21.937]                           restarts <- computeRestarts(cond)
[17:27:21.937]                           for (restart in restarts) {
[17:27:21.937]                             name <- restart$name
[17:27:21.937]                             if (is.null(name)) 
[17:27:21.937]                               next
[17:27:21.937]                             if (!grepl(pattern, name)) 
[17:27:21.937]                               next
[17:27:21.937]                             invokeRestart(restart)
[17:27:21.937]                             muffled <- TRUE
[17:27:21.937]                             break
[17:27:21.937]                           }
[17:27:21.937]                         }
[17:27:21.937]                       }
[17:27:21.937]                       invisible(muffled)
[17:27:21.937]                     }
[17:27:21.937]                     muffleCondition(cond, pattern = "^muffle")
[17:27:21.937]                   }
[17:27:21.937]                 }
[17:27:21.937]                 else {
[17:27:21.937]                   if (TRUE) {
[17:27:21.937]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:21.937]                     {
[17:27:21.937]                       inherits <- base::inherits
[17:27:21.937]                       invokeRestart <- base::invokeRestart
[17:27:21.937]                       is.null <- base::is.null
[17:27:21.937]                       muffled <- FALSE
[17:27:21.937]                       if (inherits(cond, "message")) {
[17:27:21.937]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:21.937]                         if (muffled) 
[17:27:21.937]                           invokeRestart("muffleMessage")
[17:27:21.937]                       }
[17:27:21.937]                       else if (inherits(cond, "warning")) {
[17:27:21.937]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:21.937]                         if (muffled) 
[17:27:21.937]                           invokeRestart("muffleWarning")
[17:27:21.937]                       }
[17:27:21.937]                       else if (inherits(cond, "condition")) {
[17:27:21.937]                         if (!is.null(pattern)) {
[17:27:21.937]                           computeRestarts <- base::computeRestarts
[17:27:21.937]                           grepl <- base::grepl
[17:27:21.937]                           restarts <- computeRestarts(cond)
[17:27:21.937]                           for (restart in restarts) {
[17:27:21.937]                             name <- restart$name
[17:27:21.937]                             if (is.null(name)) 
[17:27:21.937]                               next
[17:27:21.937]                             if (!grepl(pattern, name)) 
[17:27:21.937]                               next
[17:27:21.937]                             invokeRestart(restart)
[17:27:21.937]                             muffled <- TRUE
[17:27:21.937]                             break
[17:27:21.937]                           }
[17:27:21.937]                         }
[17:27:21.937]                       }
[17:27:21.937]                       invisible(muffled)
[17:27:21.937]                     }
[17:27:21.937]                     muffleCondition(cond, pattern = "^muffle")
[17:27:21.937]                   }
[17:27:21.937]                 }
[17:27:21.937]             }
[17:27:21.937]         }))
[17:27:21.937]     }, error = function(ex) {
[17:27:21.937]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:21.937]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:21.937]                 ...future.rng), started = ...future.startTime, 
[17:27:21.937]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:21.937]             version = "1.8"), class = "FutureResult")
[17:27:21.937]     }, finally = {
[17:27:21.937]         if (!identical(...future.workdir, getwd())) 
[17:27:21.937]             setwd(...future.workdir)
[17:27:21.937]         {
[17:27:21.937]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:21.937]                 ...future.oldOptions$nwarnings <- NULL
[17:27:21.937]             }
[17:27:21.937]             base::options(...future.oldOptions)
[17:27:21.937]             if (.Platform$OS.type == "windows") {
[17:27:21.937]                 old_names <- names(...future.oldEnvVars)
[17:27:21.937]                 envs <- base::Sys.getenv()
[17:27:21.937]                 names <- names(envs)
[17:27:21.937]                 common <- intersect(names, old_names)
[17:27:21.937]                 added <- setdiff(names, old_names)
[17:27:21.937]                 removed <- setdiff(old_names, names)
[17:27:21.937]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:21.937]                   envs[common]]
[17:27:21.937]                 NAMES <- toupper(changed)
[17:27:21.937]                 args <- list()
[17:27:21.937]                 for (kk in seq_along(NAMES)) {
[17:27:21.937]                   name <- changed[[kk]]
[17:27:21.937]                   NAME <- NAMES[[kk]]
[17:27:21.937]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:21.937]                     next
[17:27:21.937]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:21.937]                 }
[17:27:21.937]                 NAMES <- toupper(added)
[17:27:21.937]                 for (kk in seq_along(NAMES)) {
[17:27:21.937]                   name <- added[[kk]]
[17:27:21.937]                   NAME <- NAMES[[kk]]
[17:27:21.937]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:21.937]                     next
[17:27:21.937]                   args[[name]] <- ""
[17:27:21.937]                 }
[17:27:21.937]                 NAMES <- toupper(removed)
[17:27:21.937]                 for (kk in seq_along(NAMES)) {
[17:27:21.937]                   name <- removed[[kk]]
[17:27:21.937]                   NAME <- NAMES[[kk]]
[17:27:21.937]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:21.937]                     next
[17:27:21.937]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:21.937]                 }
[17:27:21.937]                 if (length(args) > 0) 
[17:27:21.937]                   base::do.call(base::Sys.setenv, args = args)
[17:27:21.937]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:21.937]             }
[17:27:21.937]             else {
[17:27:21.937]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:21.937]             }
[17:27:21.937]             {
[17:27:21.937]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:21.937]                   0L) {
[17:27:21.937]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:21.937]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:21.937]                   base::options(opts)
[17:27:21.937]                 }
[17:27:21.937]                 {
[17:27:21.937]                   {
[17:27:21.937]                     NULL
[17:27:21.937]                     RNGkind("Mersenne-Twister")
[17:27:21.937]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:21.937]                       inherits = FALSE)
[17:27:21.937]                   }
[17:27:21.937]                   options(future.plan = NULL)
[17:27:21.937]                   if (is.na(NA_character_)) 
[17:27:21.937]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:21.937]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:21.937]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:21.937]                     .init = FALSE)
[17:27:21.937]                 }
[17:27:21.937]             }
[17:27:21.937]         }
[17:27:21.937]     })
[17:27:21.937]     if (TRUE) {
[17:27:21.937]         base::sink(type = "output", split = FALSE)
[17:27:21.937]         if (TRUE) {
[17:27:21.937]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:21.937]         }
[17:27:21.937]         else {
[17:27:21.937]             ...future.result["stdout"] <- base::list(NULL)
[17:27:21.937]         }
[17:27:21.937]         base::close(...future.stdout)
[17:27:21.937]         ...future.stdout <- NULL
[17:27:21.937]     }
[17:27:21.937]     ...future.result$conditions <- ...future.conditions
[17:27:21.937]     ...future.result$finished <- base::Sys.time()
[17:27:21.937]     ...future.result
[17:27:21.937] }
[17:27:21.945] plan(): Setting new future strategy stack:
[17:27:21.946] List of future strategies:
[17:27:21.946] 1. sequential:
[17:27:21.946]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:21.946]    - tweaked: FALSE
[17:27:21.946]    - call: NULL
[17:27:21.947] plan(): nbrOfWorkers() = 1
[17:27:21.951] plan(): Setting new future strategy stack:
[17:27:21.951] List of future strategies:
[17:27:21.951] 1. sequential:
[17:27:21.951]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:21.951]    - tweaked: FALSE
[17:27:21.951]    - call: plan(strategy)
[17:27:21.953] plan(): nbrOfWorkers() = 1
[17:27:21.953] SequentialFuture started (and completed)
[17:27:21.954] - Launch lazy future ... done
[17:27:21.955] run() for 'SequentialFuture' ... done
** Future evaluation with globals
[17:27:21.956] getGlobalsAndPackages() ...
[17:27:21.957] Searching for globals...
[17:27:21.959] - globals found: [3] '{', '<-', 'a'
[17:27:21.959] Searching for globals ... DONE
[17:27:21.960] Resolving globals: FALSE
[17:27:21.962] The total size of the 1 globals is 39 bytes (39 bytes)
[17:27:21.963] The total size of the 1 globals exported for future expression ('{; x <- a; }') is 39 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (39 bytes of class 'numeric')
[17:27:21.963] - globals: [1] 'a'
[17:27:21.963] 
[17:27:21.964] getGlobalsAndPackages() ... DONE
[17:27:21.964] run() for 'Future' ...
[17:27:21.965] - state: 'created'
[17:27:21.965] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:21.966] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:21.966] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:21.967]   - Field: 'label'
[17:27:21.967]   - Field: 'local'
[17:27:21.968]   - Field: 'owner'
[17:27:21.968]   - Field: 'envir'
[17:27:21.968]   - Field: 'packages'
[17:27:21.969]   - Field: 'gc'
[17:27:21.969]   - Field: 'conditions'
[17:27:21.969]   - Field: 'expr'
[17:27:21.970]   - Field: 'uuid'
[17:27:21.970]   - Field: 'seed'
[17:27:21.971]   - Field: 'version'
[17:27:21.971]   - Field: 'result'
[17:27:21.975]   - Field: 'asynchronous'
[17:27:21.976]   - Field: 'calls'
[17:27:21.976]   - Field: 'globals'
[17:27:21.977]   - Field: 'stdout'
[17:27:21.977]   - Field: 'earlySignal'
[17:27:21.977]   - Field: 'lazy'
[17:27:21.978]   - Field: 'state'
[17:27:21.978] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:21.978] - Launch lazy future ...
[17:27:21.979] Packages needed by the future expression (n = 0): <none>
[17:27:21.979] Packages needed by future strategies (n = 0): <none>
[17:27:21.981] {
[17:27:21.981]     {
[17:27:21.981]         {
[17:27:21.981]             ...future.startTime <- base::Sys.time()
[17:27:21.981]             {
[17:27:21.981]                 {
[17:27:21.981]                   {
[17:27:21.981]                     base::local({
[17:27:21.981]                       has_future <- base::requireNamespace("future", 
[17:27:21.981]                         quietly = TRUE)
[17:27:21.981]                       if (has_future) {
[17:27:21.981]                         ns <- base::getNamespace("future")
[17:27:21.981]                         version <- ns[[".package"]][["version"]]
[17:27:21.981]                         if (is.null(version)) 
[17:27:21.981]                           version <- utils::packageVersion("future")
[17:27:21.981]                       }
[17:27:21.981]                       else {
[17:27:21.981]                         version <- NULL
[17:27:21.981]                       }
[17:27:21.981]                       if (!has_future || version < "1.8.0") {
[17:27:21.981]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:21.981]                           "", base::R.version$version.string), 
[17:27:21.981]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:21.981]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:21.981]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:21.981]                             "release", "version")], collapse = " "), 
[17:27:21.981]                           hostname = base::Sys.info()[["nodename"]])
[17:27:21.981]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:21.981]                           info)
[17:27:21.981]                         info <- base::paste(info, collapse = "; ")
[17:27:21.981]                         if (!has_future) {
[17:27:21.981]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:21.981]                             info)
[17:27:21.981]                         }
[17:27:21.981]                         else {
[17:27:21.981]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:21.981]                             info, version)
[17:27:21.981]                         }
[17:27:21.981]                         base::stop(msg)
[17:27:21.981]                       }
[17:27:21.981]                     })
[17:27:21.981]                   }
[17:27:21.981]                   ...future.strategy.old <- future::plan("list")
[17:27:21.981]                   options(future.plan = NULL)
[17:27:21.981]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:21.981]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:21.981]                 }
[17:27:21.981]                 ...future.workdir <- getwd()
[17:27:21.981]             }
[17:27:21.981]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:21.981]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:21.981]         }
[17:27:21.981]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:21.981]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:21.981]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:21.981]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:21.981]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:21.981]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:21.981]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:21.981]             base::names(...future.oldOptions))
[17:27:21.981]     }
[17:27:21.981]     if (FALSE) {
[17:27:21.981]     }
[17:27:21.981]     else {
[17:27:21.981]         if (TRUE) {
[17:27:21.981]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:21.981]                 open = "w")
[17:27:21.981]         }
[17:27:21.981]         else {
[17:27:21.981]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:21.981]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:21.981]         }
[17:27:21.981]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:21.981]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:21.981]             base::sink(type = "output", split = FALSE)
[17:27:21.981]             base::close(...future.stdout)
[17:27:21.981]         }, add = TRUE)
[17:27:21.981]     }
[17:27:21.981]     ...future.frame <- base::sys.nframe()
[17:27:21.981]     ...future.conditions <- base::list()
[17:27:21.981]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:21.981]     if (FALSE) {
[17:27:21.981]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:21.981]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:21.981]     }
[17:27:21.981]     ...future.result <- base::tryCatch({
[17:27:21.981]         base::withCallingHandlers({
[17:27:21.981]             ...future.value <- base::withVisible(base::local({
[17:27:21.981]                 x <- a
[17:27:21.981]             }))
[17:27:21.981]             future::FutureResult(value = ...future.value$value, 
[17:27:21.981]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:21.981]                   ...future.rng), globalenv = if (FALSE) 
[17:27:21.981]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:21.981]                     ...future.globalenv.names))
[17:27:21.981]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:21.981]         }, condition = base::local({
[17:27:21.981]             c <- base::c
[17:27:21.981]             inherits <- base::inherits
[17:27:21.981]             invokeRestart <- base::invokeRestart
[17:27:21.981]             length <- base::length
[17:27:21.981]             list <- base::list
[17:27:21.981]             seq.int <- base::seq.int
[17:27:21.981]             signalCondition <- base::signalCondition
[17:27:21.981]             sys.calls <- base::sys.calls
[17:27:21.981]             `[[` <- base::`[[`
[17:27:21.981]             `+` <- base::`+`
[17:27:21.981]             `<<-` <- base::`<<-`
[17:27:21.981]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:21.981]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:21.981]                   3L)]
[17:27:21.981]             }
[17:27:21.981]             function(cond) {
[17:27:21.981]                 is_error <- inherits(cond, "error")
[17:27:21.981]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:21.981]                   NULL)
[17:27:21.981]                 if (is_error) {
[17:27:21.981]                   sessionInformation <- function() {
[17:27:21.981]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:21.981]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:21.981]                       search = base::search(), system = base::Sys.info())
[17:27:21.981]                   }
[17:27:21.981]                   ...future.conditions[[length(...future.conditions) + 
[17:27:21.981]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:21.981]                     cond$call), session = sessionInformation(), 
[17:27:21.981]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:21.981]                   signalCondition(cond)
[17:27:21.981]                 }
[17:27:21.981]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:21.981]                 "immediateCondition"))) {
[17:27:21.981]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:21.981]                   ...future.conditions[[length(...future.conditions) + 
[17:27:21.981]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:21.981]                   if (TRUE && !signal) {
[17:27:21.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:21.981]                     {
[17:27:21.981]                       inherits <- base::inherits
[17:27:21.981]                       invokeRestart <- base::invokeRestart
[17:27:21.981]                       is.null <- base::is.null
[17:27:21.981]                       muffled <- FALSE
[17:27:21.981]                       if (inherits(cond, "message")) {
[17:27:21.981]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:21.981]                         if (muffled) 
[17:27:21.981]                           invokeRestart("muffleMessage")
[17:27:21.981]                       }
[17:27:21.981]                       else if (inherits(cond, "warning")) {
[17:27:21.981]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:21.981]                         if (muffled) 
[17:27:21.981]                           invokeRestart("muffleWarning")
[17:27:21.981]                       }
[17:27:21.981]                       else if (inherits(cond, "condition")) {
[17:27:21.981]                         if (!is.null(pattern)) {
[17:27:21.981]                           computeRestarts <- base::computeRestarts
[17:27:21.981]                           grepl <- base::grepl
[17:27:21.981]                           restarts <- computeRestarts(cond)
[17:27:21.981]                           for (restart in restarts) {
[17:27:21.981]                             name <- restart$name
[17:27:21.981]                             if (is.null(name)) 
[17:27:21.981]                               next
[17:27:21.981]                             if (!grepl(pattern, name)) 
[17:27:21.981]                               next
[17:27:21.981]                             invokeRestart(restart)
[17:27:21.981]                             muffled <- TRUE
[17:27:21.981]                             break
[17:27:21.981]                           }
[17:27:21.981]                         }
[17:27:21.981]                       }
[17:27:21.981]                       invisible(muffled)
[17:27:21.981]                     }
[17:27:21.981]                     muffleCondition(cond, pattern = "^muffle")
[17:27:21.981]                   }
[17:27:21.981]                 }
[17:27:21.981]                 else {
[17:27:21.981]                   if (TRUE) {
[17:27:21.981]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:21.981]                     {
[17:27:21.981]                       inherits <- base::inherits
[17:27:21.981]                       invokeRestart <- base::invokeRestart
[17:27:21.981]                       is.null <- base::is.null
[17:27:21.981]                       muffled <- FALSE
[17:27:21.981]                       if (inherits(cond, "message")) {
[17:27:21.981]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:21.981]                         if (muffled) 
[17:27:21.981]                           invokeRestart("muffleMessage")
[17:27:21.981]                       }
[17:27:21.981]                       else if (inherits(cond, "warning")) {
[17:27:21.981]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:21.981]                         if (muffled) 
[17:27:21.981]                           invokeRestart("muffleWarning")
[17:27:21.981]                       }
[17:27:21.981]                       else if (inherits(cond, "condition")) {
[17:27:21.981]                         if (!is.null(pattern)) {
[17:27:21.981]                           computeRestarts <- base::computeRestarts
[17:27:21.981]                           grepl <- base::grepl
[17:27:21.981]                           restarts <- computeRestarts(cond)
[17:27:21.981]                           for (restart in restarts) {
[17:27:21.981]                             name <- restart$name
[17:27:21.981]                             if (is.null(name)) 
[17:27:21.981]                               next
[17:27:21.981]                             if (!grepl(pattern, name)) 
[17:27:21.981]                               next
[17:27:21.981]                             invokeRestart(restart)
[17:27:21.981]                             muffled <- TRUE
[17:27:21.981]                             break
[17:27:21.981]                           }
[17:27:21.981]                         }
[17:27:21.981]                       }
[17:27:21.981]                       invisible(muffled)
[17:27:21.981]                     }
[17:27:21.981]                     muffleCondition(cond, pattern = "^muffle")
[17:27:21.981]                   }
[17:27:21.981]                 }
[17:27:21.981]             }
[17:27:21.981]         }))
[17:27:21.981]     }, error = function(ex) {
[17:27:21.981]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:21.981]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:21.981]                 ...future.rng), started = ...future.startTime, 
[17:27:21.981]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:21.981]             version = "1.8"), class = "FutureResult")
[17:27:21.981]     }, finally = {
[17:27:21.981]         if (!identical(...future.workdir, getwd())) 
[17:27:21.981]             setwd(...future.workdir)
[17:27:21.981]         {
[17:27:21.981]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:21.981]                 ...future.oldOptions$nwarnings <- NULL
[17:27:21.981]             }
[17:27:21.981]             base::options(...future.oldOptions)
[17:27:21.981]             if (.Platform$OS.type == "windows") {
[17:27:21.981]                 old_names <- names(...future.oldEnvVars)
[17:27:21.981]                 envs <- base::Sys.getenv()
[17:27:21.981]                 names <- names(envs)
[17:27:21.981]                 common <- intersect(names, old_names)
[17:27:21.981]                 added <- setdiff(names, old_names)
[17:27:21.981]                 removed <- setdiff(old_names, names)
[17:27:21.981]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:21.981]                   envs[common]]
[17:27:21.981]                 NAMES <- toupper(changed)
[17:27:21.981]                 args <- list()
[17:27:21.981]                 for (kk in seq_along(NAMES)) {
[17:27:21.981]                   name <- changed[[kk]]
[17:27:21.981]                   NAME <- NAMES[[kk]]
[17:27:21.981]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:21.981]                     next
[17:27:21.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:21.981]                 }
[17:27:21.981]                 NAMES <- toupper(added)
[17:27:21.981]                 for (kk in seq_along(NAMES)) {
[17:27:21.981]                   name <- added[[kk]]
[17:27:21.981]                   NAME <- NAMES[[kk]]
[17:27:21.981]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:21.981]                     next
[17:27:21.981]                   args[[name]] <- ""
[17:27:21.981]                 }
[17:27:21.981]                 NAMES <- toupper(removed)
[17:27:21.981]                 for (kk in seq_along(NAMES)) {
[17:27:21.981]                   name <- removed[[kk]]
[17:27:21.981]                   NAME <- NAMES[[kk]]
[17:27:21.981]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:21.981]                     next
[17:27:21.981]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:21.981]                 }
[17:27:21.981]                 if (length(args) > 0) 
[17:27:21.981]                   base::do.call(base::Sys.setenv, args = args)
[17:27:21.981]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:21.981]             }
[17:27:21.981]             else {
[17:27:21.981]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:21.981]             }
[17:27:21.981]             {
[17:27:21.981]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:21.981]                   0L) {
[17:27:21.981]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:21.981]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:21.981]                   base::options(opts)
[17:27:21.981]                 }
[17:27:21.981]                 {
[17:27:21.981]                   {
[17:27:21.981]                     NULL
[17:27:21.981]                     RNGkind("Mersenne-Twister")
[17:27:21.981]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:21.981]                       inherits = FALSE)
[17:27:21.981]                   }
[17:27:21.981]                   options(future.plan = NULL)
[17:27:21.981]                   if (is.na(NA_character_)) 
[17:27:21.981]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:21.981]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:21.981]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:21.981]                     .init = FALSE)
[17:27:21.981]                 }
[17:27:21.981]             }
[17:27:21.981]         }
[17:27:21.981]     })
[17:27:21.981]     if (TRUE) {
[17:27:21.981]         base::sink(type = "output", split = FALSE)
[17:27:21.981]         if (TRUE) {
[17:27:21.981]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:21.981]         }
[17:27:21.981]         else {
[17:27:21.981]             ...future.result["stdout"] <- base::list(NULL)
[17:27:21.981]         }
[17:27:21.981]         base::close(...future.stdout)
[17:27:21.981]         ...future.stdout <- NULL
[17:27:21.981]     }
[17:27:21.981]     ...future.result$conditions <- ...future.conditions
[17:27:21.981]     ...future.result$finished <- base::Sys.time()
[17:27:21.981]     ...future.result
[17:27:21.981] }
[17:27:21.989] assign_globals() ...
[17:27:21.989] List of 1
[17:27:21.989]  $ a: num 2
[17:27:21.989]  - attr(*, "where")=List of 1
[17:27:21.989]   ..$ a:<environment: R_EmptyEnv> 
[17:27:21.989]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:21.989]  - attr(*, "resolved")= logi FALSE
[17:27:21.989]  - attr(*, "total_size")= int 39
[17:27:21.989]  - attr(*, "already-done")= logi TRUE
[17:27:21.999] - copied 'a' to environment
[17:27:21.999] assign_globals() ... done
[17:27:22.000] plan(): Setting new future strategy stack:
[17:27:22.000] List of future strategies:
[17:27:22.000] 1. sequential:
[17:27:22.000]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.000]    - tweaked: FALSE
[17:27:22.000]    - call: NULL
[17:27:22.002] plan(): nbrOfWorkers() = 1
[17:27:22.004] plan(): Setting new future strategy stack:
[17:27:22.004] List of future strategies:
[17:27:22.004] 1. sequential:
[17:27:22.004]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.004]    - tweaked: FALSE
[17:27:22.004]    - call: plan(strategy)
[17:27:22.006] plan(): nbrOfWorkers() = 1
[17:27:22.006] SequentialFuture started (and completed)
[17:27:22.007] - Launch lazy future ... done
[17:27:22.007] run() for 'SequentialFuture' ... done
** Future evaluation with errors
[17:27:22.008] getGlobalsAndPackages() ...
[17:27:22.009] Searching for globals...
[17:27:22.017] - globals found: [3] '{', '<-', 'stop'
[17:27:22.017] Searching for globals ... DONE
[17:27:22.017] Resolving globals: FALSE
[17:27:22.018] 
[17:27:22.018] 
[17:27:22.019] getGlobalsAndPackages() ... DONE
[17:27:22.019] run() for 'Future' ...
[17:27:22.020] - state: 'created'
[17:27:22.020] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.021] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.022] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.022]   - Field: 'label'
[17:27:22.022]   - Field: 'local'
[17:27:22.023]   - Field: 'owner'
[17:27:22.023]   - Field: 'envir'
[17:27:22.023]   - Field: 'packages'
[17:27:22.024]   - Field: 'gc'
[17:27:22.024]   - Field: 'conditions'
[17:27:22.025]   - Field: 'expr'
[17:27:22.025]   - Field: 'uuid'
[17:27:22.025]   - Field: 'seed'
[17:27:22.026]   - Field: 'version'
[17:27:22.026]   - Field: 'result'
[17:27:22.027]   - Field: 'asynchronous'
[17:27:22.027]   - Field: 'calls'
[17:27:22.027]   - Field: 'globals'
[17:27:22.028]   - Field: 'stdout'
[17:27:22.028]   - Field: 'earlySignal'
[17:27:22.028]   - Field: 'lazy'
[17:27:22.029]   - Field: 'state'
[17:27:22.029] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.030] - Launch lazy future ...
[17:27:22.030] Packages needed by the future expression (n = 0): <none>
[17:27:22.031] Packages needed by future strategies (n = 0): <none>
[17:27:22.032] {
[17:27:22.032]     {
[17:27:22.032]         {
[17:27:22.032]             ...future.startTime <- base::Sys.time()
[17:27:22.032]             {
[17:27:22.032]                 {
[17:27:22.032]                   {
[17:27:22.032]                     base::local({
[17:27:22.032]                       has_future <- base::requireNamespace("future", 
[17:27:22.032]                         quietly = TRUE)
[17:27:22.032]                       if (has_future) {
[17:27:22.032]                         ns <- base::getNamespace("future")
[17:27:22.032]                         version <- ns[[".package"]][["version"]]
[17:27:22.032]                         if (is.null(version)) 
[17:27:22.032]                           version <- utils::packageVersion("future")
[17:27:22.032]                       }
[17:27:22.032]                       else {
[17:27:22.032]                         version <- NULL
[17:27:22.032]                       }
[17:27:22.032]                       if (!has_future || version < "1.8.0") {
[17:27:22.032]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.032]                           "", base::R.version$version.string), 
[17:27:22.032]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.032]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.032]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.032]                             "release", "version")], collapse = " "), 
[17:27:22.032]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.032]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.032]                           info)
[17:27:22.032]                         info <- base::paste(info, collapse = "; ")
[17:27:22.032]                         if (!has_future) {
[17:27:22.032]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.032]                             info)
[17:27:22.032]                         }
[17:27:22.032]                         else {
[17:27:22.032]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.032]                             info, version)
[17:27:22.032]                         }
[17:27:22.032]                         base::stop(msg)
[17:27:22.032]                       }
[17:27:22.032]                     })
[17:27:22.032]                   }
[17:27:22.032]                   ...future.strategy.old <- future::plan("list")
[17:27:22.032]                   options(future.plan = NULL)
[17:27:22.032]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.032]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.032]                 }
[17:27:22.032]                 ...future.workdir <- getwd()
[17:27:22.032]             }
[17:27:22.032]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.032]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.032]         }
[17:27:22.032]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.032]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.032]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.032]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.032]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.032]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.032]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.032]             base::names(...future.oldOptions))
[17:27:22.032]     }
[17:27:22.032]     if (FALSE) {
[17:27:22.032]     }
[17:27:22.032]     else {
[17:27:22.032]         if (TRUE) {
[17:27:22.032]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.032]                 open = "w")
[17:27:22.032]         }
[17:27:22.032]         else {
[17:27:22.032]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.032]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.032]         }
[17:27:22.032]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.032]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.032]             base::sink(type = "output", split = FALSE)
[17:27:22.032]             base::close(...future.stdout)
[17:27:22.032]         }, add = TRUE)
[17:27:22.032]     }
[17:27:22.032]     ...future.frame <- base::sys.nframe()
[17:27:22.032]     ...future.conditions <- base::list()
[17:27:22.032]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.032]     if (FALSE) {
[17:27:22.032]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.032]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.032]     }
[17:27:22.032]     ...future.result <- base::tryCatch({
[17:27:22.032]         base::withCallingHandlers({
[17:27:22.032]             ...future.value <- base::withVisible(base::local({
[17:27:22.032]                 x <- 3
[17:27:22.032]                 stop("Woops!")
[17:27:22.032]                 x
[17:27:22.032]             }))
[17:27:22.032]             future::FutureResult(value = ...future.value$value, 
[17:27:22.032]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.032]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.032]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.032]                     ...future.globalenv.names))
[17:27:22.032]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.032]         }, condition = base::local({
[17:27:22.032]             c <- base::c
[17:27:22.032]             inherits <- base::inherits
[17:27:22.032]             invokeRestart <- base::invokeRestart
[17:27:22.032]             length <- base::length
[17:27:22.032]             list <- base::list
[17:27:22.032]             seq.int <- base::seq.int
[17:27:22.032]             signalCondition <- base::signalCondition
[17:27:22.032]             sys.calls <- base::sys.calls
[17:27:22.032]             `[[` <- base::`[[`
[17:27:22.032]             `+` <- base::`+`
[17:27:22.032]             `<<-` <- base::`<<-`
[17:27:22.032]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.032]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.032]                   3L)]
[17:27:22.032]             }
[17:27:22.032]             function(cond) {
[17:27:22.032]                 is_error <- inherits(cond, "error")
[17:27:22.032]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.032]                   NULL)
[17:27:22.032]                 if (is_error) {
[17:27:22.032]                   sessionInformation <- function() {
[17:27:22.032]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.032]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.032]                       search = base::search(), system = base::Sys.info())
[17:27:22.032]                   }
[17:27:22.032]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.032]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.032]                     cond$call), session = sessionInformation(), 
[17:27:22.032]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.032]                   signalCondition(cond)
[17:27:22.032]                 }
[17:27:22.032]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.032]                 "immediateCondition"))) {
[17:27:22.032]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.032]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.032]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.032]                   if (TRUE && !signal) {
[17:27:22.032]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.032]                     {
[17:27:22.032]                       inherits <- base::inherits
[17:27:22.032]                       invokeRestart <- base::invokeRestart
[17:27:22.032]                       is.null <- base::is.null
[17:27:22.032]                       muffled <- FALSE
[17:27:22.032]                       if (inherits(cond, "message")) {
[17:27:22.032]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.032]                         if (muffled) 
[17:27:22.032]                           invokeRestart("muffleMessage")
[17:27:22.032]                       }
[17:27:22.032]                       else if (inherits(cond, "warning")) {
[17:27:22.032]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.032]                         if (muffled) 
[17:27:22.032]                           invokeRestart("muffleWarning")
[17:27:22.032]                       }
[17:27:22.032]                       else if (inherits(cond, "condition")) {
[17:27:22.032]                         if (!is.null(pattern)) {
[17:27:22.032]                           computeRestarts <- base::computeRestarts
[17:27:22.032]                           grepl <- base::grepl
[17:27:22.032]                           restarts <- computeRestarts(cond)
[17:27:22.032]                           for (restart in restarts) {
[17:27:22.032]                             name <- restart$name
[17:27:22.032]                             if (is.null(name)) 
[17:27:22.032]                               next
[17:27:22.032]                             if (!grepl(pattern, name)) 
[17:27:22.032]                               next
[17:27:22.032]                             invokeRestart(restart)
[17:27:22.032]                             muffled <- TRUE
[17:27:22.032]                             break
[17:27:22.032]                           }
[17:27:22.032]                         }
[17:27:22.032]                       }
[17:27:22.032]                       invisible(muffled)
[17:27:22.032]                     }
[17:27:22.032]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.032]                   }
[17:27:22.032]                 }
[17:27:22.032]                 else {
[17:27:22.032]                   if (TRUE) {
[17:27:22.032]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.032]                     {
[17:27:22.032]                       inherits <- base::inherits
[17:27:22.032]                       invokeRestart <- base::invokeRestart
[17:27:22.032]                       is.null <- base::is.null
[17:27:22.032]                       muffled <- FALSE
[17:27:22.032]                       if (inherits(cond, "message")) {
[17:27:22.032]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.032]                         if (muffled) 
[17:27:22.032]                           invokeRestart("muffleMessage")
[17:27:22.032]                       }
[17:27:22.032]                       else if (inherits(cond, "warning")) {
[17:27:22.032]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.032]                         if (muffled) 
[17:27:22.032]                           invokeRestart("muffleWarning")
[17:27:22.032]                       }
[17:27:22.032]                       else if (inherits(cond, "condition")) {
[17:27:22.032]                         if (!is.null(pattern)) {
[17:27:22.032]                           computeRestarts <- base::computeRestarts
[17:27:22.032]                           grepl <- base::grepl
[17:27:22.032]                           restarts <- computeRestarts(cond)
[17:27:22.032]                           for (restart in restarts) {
[17:27:22.032]                             name <- restart$name
[17:27:22.032]                             if (is.null(name)) 
[17:27:22.032]                               next
[17:27:22.032]                             if (!grepl(pattern, name)) 
[17:27:22.032]                               next
[17:27:22.032]                             invokeRestart(restart)
[17:27:22.032]                             muffled <- TRUE
[17:27:22.032]                             break
[17:27:22.032]                           }
[17:27:22.032]                         }
[17:27:22.032]                       }
[17:27:22.032]                       invisible(muffled)
[17:27:22.032]                     }
[17:27:22.032]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.032]                   }
[17:27:22.032]                 }
[17:27:22.032]             }
[17:27:22.032]         }))
[17:27:22.032]     }, error = function(ex) {
[17:27:22.032]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.032]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.032]                 ...future.rng), started = ...future.startTime, 
[17:27:22.032]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.032]             version = "1.8"), class = "FutureResult")
[17:27:22.032]     }, finally = {
[17:27:22.032]         if (!identical(...future.workdir, getwd())) 
[17:27:22.032]             setwd(...future.workdir)
[17:27:22.032]         {
[17:27:22.032]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.032]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.032]             }
[17:27:22.032]             base::options(...future.oldOptions)
[17:27:22.032]             if (.Platform$OS.type == "windows") {
[17:27:22.032]                 old_names <- names(...future.oldEnvVars)
[17:27:22.032]                 envs <- base::Sys.getenv()
[17:27:22.032]                 names <- names(envs)
[17:27:22.032]                 common <- intersect(names, old_names)
[17:27:22.032]                 added <- setdiff(names, old_names)
[17:27:22.032]                 removed <- setdiff(old_names, names)
[17:27:22.032]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.032]                   envs[common]]
[17:27:22.032]                 NAMES <- toupper(changed)
[17:27:22.032]                 args <- list()
[17:27:22.032]                 for (kk in seq_along(NAMES)) {
[17:27:22.032]                   name <- changed[[kk]]
[17:27:22.032]                   NAME <- NAMES[[kk]]
[17:27:22.032]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.032]                     next
[17:27:22.032]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.032]                 }
[17:27:22.032]                 NAMES <- toupper(added)
[17:27:22.032]                 for (kk in seq_along(NAMES)) {
[17:27:22.032]                   name <- added[[kk]]
[17:27:22.032]                   NAME <- NAMES[[kk]]
[17:27:22.032]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.032]                     next
[17:27:22.032]                   args[[name]] <- ""
[17:27:22.032]                 }
[17:27:22.032]                 NAMES <- toupper(removed)
[17:27:22.032]                 for (kk in seq_along(NAMES)) {
[17:27:22.032]                   name <- removed[[kk]]
[17:27:22.032]                   NAME <- NAMES[[kk]]
[17:27:22.032]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.032]                     next
[17:27:22.032]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.032]                 }
[17:27:22.032]                 if (length(args) > 0) 
[17:27:22.032]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.032]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.032]             }
[17:27:22.032]             else {
[17:27:22.032]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.032]             }
[17:27:22.032]             {
[17:27:22.032]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.032]                   0L) {
[17:27:22.032]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.032]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.032]                   base::options(opts)
[17:27:22.032]                 }
[17:27:22.032]                 {
[17:27:22.032]                   {
[17:27:22.032]                     NULL
[17:27:22.032]                     RNGkind("Mersenne-Twister")
[17:27:22.032]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.032]                       inherits = FALSE)
[17:27:22.032]                   }
[17:27:22.032]                   options(future.plan = NULL)
[17:27:22.032]                   if (is.na(NA_character_)) 
[17:27:22.032]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.032]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.032]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.032]                     .init = FALSE)
[17:27:22.032]                 }
[17:27:22.032]             }
[17:27:22.032]         }
[17:27:22.032]     })
[17:27:22.032]     if (TRUE) {
[17:27:22.032]         base::sink(type = "output", split = FALSE)
[17:27:22.032]         if (TRUE) {
[17:27:22.032]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.032]         }
[17:27:22.032]         else {
[17:27:22.032]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.032]         }
[17:27:22.032]         base::close(...future.stdout)
[17:27:22.032]         ...future.stdout <- NULL
[17:27:22.032]     }
[17:27:22.032]     ...future.result$conditions <- ...future.conditions
[17:27:22.032]     ...future.result$finished <- base::Sys.time()
[17:27:22.032]     ...future.result
[17:27:22.032] }
[17:27:22.040] plan(): Setting new future strategy stack:
[17:27:22.041] List of future strategies:
[17:27:22.041] 1. sequential:
[17:27:22.041]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.041]    - tweaked: FALSE
[17:27:22.041]    - call: NULL
[17:27:22.042] plan(): nbrOfWorkers() = 1
[17:27:22.045] plan(): Setting new future strategy stack:
[17:27:22.045] List of future strategies:
[17:27:22.045] 1. sequential:
[17:27:22.045]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.045]    - tweaked: FALSE
[17:27:22.045]    - call: plan(strategy)
[17:27:22.047] plan(): nbrOfWorkers() = 1
[17:27:22.047] SequentialFuture started (and completed)
[17:27:22.047] signalConditions() ...
[17:27:22.048]  - include = 'immediateCondition'
[17:27:22.048]  - exclude = 
[17:27:22.049]  - resignal = FALSE
[17:27:22.049]  - Number of conditions: 1
[17:27:22.049] signalConditions() ... done
[17:27:22.050] - Launch lazy future ... done
[17:27:22.053] run() for 'SequentialFuture' ... done
[17:27:22.054] signalConditions() ...
[17:27:22.054]  - include = 'immediateCondition'
[17:27:22.054]  - exclude = 
[17:27:22.055]  - resignal = FALSE
[17:27:22.055]  - Number of conditions: 1
[17:27:22.056] signalConditions() ... done
[17:27:22.056] Future state: 'finished'
[17:27:22.056] signalConditions() ...
[17:27:22.057]  - include = 'condition'
[17:27:22.057]  - exclude = 'immediateCondition'
[17:27:22.057]  - resignal = TRUE
[17:27:22.058]  - Number of conditions: 1
[17:27:22.058]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:22.058] signalConditions() ... done
[17:27:22.060] getGlobalsAndPackages() ...
[17:27:22.060] Searching for globals...
[17:27:22.065] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:27:22.065] Searching for globals ... DONE
[17:27:22.066] Resolving globals: FALSE
[17:27:22.067] The total size of the 1 globals is 35 bytes (35 bytes)
[17:27:22.068] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:27:22.068] - globals: [1] 'ii'
[17:27:22.068] 
[17:27:22.069] getGlobalsAndPackages() ... DONE
[17:27:22.069] run() for 'Future' ...
[17:27:22.070] - state: 'created'
[17:27:22.070] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.071] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.072] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.072]   - Field: 'label'
[17:27:22.072]   - Field: 'local'
[17:27:22.073]   - Field: 'owner'
[17:27:22.073]   - Field: 'envir'
[17:27:22.074]   - Field: 'packages'
[17:27:22.074]   - Field: 'gc'
[17:27:22.074]   - Field: 'conditions'
[17:27:22.075]   - Field: 'expr'
[17:27:22.075]   - Field: 'uuid'
[17:27:22.075]   - Field: 'seed'
[17:27:22.076]   - Field: 'version'
[17:27:22.076]   - Field: 'result'
[17:27:22.077]   - Field: 'asynchronous'
[17:27:22.077]   - Field: 'calls'
[17:27:22.077]   - Field: 'globals'
[17:27:22.078]   - Field: 'stdout'
[17:27:22.078]   - Field: 'earlySignal'
[17:27:22.078]   - Field: 'lazy'
[17:27:22.079]   - Field: 'state'
[17:27:22.079] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.080] - Launch lazy future ...
[17:27:22.080] Packages needed by the future expression (n = 0): <none>
[17:27:22.081] Packages needed by future strategies (n = 0): <none>
[17:27:22.082] {
[17:27:22.082]     {
[17:27:22.082]         {
[17:27:22.082]             ...future.startTime <- base::Sys.time()
[17:27:22.082]             {
[17:27:22.082]                 {
[17:27:22.082]                   {
[17:27:22.082]                     base::local({
[17:27:22.082]                       has_future <- base::requireNamespace("future", 
[17:27:22.082]                         quietly = TRUE)
[17:27:22.082]                       if (has_future) {
[17:27:22.082]                         ns <- base::getNamespace("future")
[17:27:22.082]                         version <- ns[[".package"]][["version"]]
[17:27:22.082]                         if (is.null(version)) 
[17:27:22.082]                           version <- utils::packageVersion("future")
[17:27:22.082]                       }
[17:27:22.082]                       else {
[17:27:22.082]                         version <- NULL
[17:27:22.082]                       }
[17:27:22.082]                       if (!has_future || version < "1.8.0") {
[17:27:22.082]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.082]                           "", base::R.version$version.string), 
[17:27:22.082]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.082]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.082]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.082]                             "release", "version")], collapse = " "), 
[17:27:22.082]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.082]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.082]                           info)
[17:27:22.082]                         info <- base::paste(info, collapse = "; ")
[17:27:22.082]                         if (!has_future) {
[17:27:22.082]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.082]                             info)
[17:27:22.082]                         }
[17:27:22.082]                         else {
[17:27:22.082]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.082]                             info, version)
[17:27:22.082]                         }
[17:27:22.082]                         base::stop(msg)
[17:27:22.082]                       }
[17:27:22.082]                     })
[17:27:22.082]                   }
[17:27:22.082]                   ...future.strategy.old <- future::plan("list")
[17:27:22.082]                   options(future.plan = NULL)
[17:27:22.082]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.082]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.082]                 }
[17:27:22.082]                 ...future.workdir <- getwd()
[17:27:22.082]             }
[17:27:22.082]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.082]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.082]         }
[17:27:22.082]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.082]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.082]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.082]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.082]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.082]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.082]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.082]             base::names(...future.oldOptions))
[17:27:22.082]     }
[17:27:22.082]     if (FALSE) {
[17:27:22.082]     }
[17:27:22.082]     else {
[17:27:22.082]         if (TRUE) {
[17:27:22.082]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.082]                 open = "w")
[17:27:22.082]         }
[17:27:22.082]         else {
[17:27:22.082]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.082]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.082]         }
[17:27:22.082]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.082]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.082]             base::sink(type = "output", split = FALSE)
[17:27:22.082]             base::close(...future.stdout)
[17:27:22.082]         }, add = TRUE)
[17:27:22.082]     }
[17:27:22.082]     ...future.frame <- base::sys.nframe()
[17:27:22.082]     ...future.conditions <- base::list()
[17:27:22.082]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.082]     if (FALSE) {
[17:27:22.082]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.082]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.082]     }
[17:27:22.082]     ...future.result <- base::tryCatch({
[17:27:22.082]         base::withCallingHandlers({
[17:27:22.082]             ...future.value <- base::withVisible(base::local({
[17:27:22.082]                 if (ii%%2 == 0) 
[17:27:22.082]                   stop("Woops!")
[17:27:22.082]                 ii
[17:27:22.082]             }))
[17:27:22.082]             future::FutureResult(value = ...future.value$value, 
[17:27:22.082]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.082]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.082]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.082]                     ...future.globalenv.names))
[17:27:22.082]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.082]         }, condition = base::local({
[17:27:22.082]             c <- base::c
[17:27:22.082]             inherits <- base::inherits
[17:27:22.082]             invokeRestart <- base::invokeRestart
[17:27:22.082]             length <- base::length
[17:27:22.082]             list <- base::list
[17:27:22.082]             seq.int <- base::seq.int
[17:27:22.082]             signalCondition <- base::signalCondition
[17:27:22.082]             sys.calls <- base::sys.calls
[17:27:22.082]             `[[` <- base::`[[`
[17:27:22.082]             `+` <- base::`+`
[17:27:22.082]             `<<-` <- base::`<<-`
[17:27:22.082]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.082]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.082]                   3L)]
[17:27:22.082]             }
[17:27:22.082]             function(cond) {
[17:27:22.082]                 is_error <- inherits(cond, "error")
[17:27:22.082]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.082]                   NULL)
[17:27:22.082]                 if (is_error) {
[17:27:22.082]                   sessionInformation <- function() {
[17:27:22.082]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.082]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.082]                       search = base::search(), system = base::Sys.info())
[17:27:22.082]                   }
[17:27:22.082]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.082]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.082]                     cond$call), session = sessionInformation(), 
[17:27:22.082]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.082]                   signalCondition(cond)
[17:27:22.082]                 }
[17:27:22.082]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.082]                 "immediateCondition"))) {
[17:27:22.082]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.082]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.082]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.082]                   if (TRUE && !signal) {
[17:27:22.082]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.082]                     {
[17:27:22.082]                       inherits <- base::inherits
[17:27:22.082]                       invokeRestart <- base::invokeRestart
[17:27:22.082]                       is.null <- base::is.null
[17:27:22.082]                       muffled <- FALSE
[17:27:22.082]                       if (inherits(cond, "message")) {
[17:27:22.082]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.082]                         if (muffled) 
[17:27:22.082]                           invokeRestart("muffleMessage")
[17:27:22.082]                       }
[17:27:22.082]                       else if (inherits(cond, "warning")) {
[17:27:22.082]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.082]                         if (muffled) 
[17:27:22.082]                           invokeRestart("muffleWarning")
[17:27:22.082]                       }
[17:27:22.082]                       else if (inherits(cond, "condition")) {
[17:27:22.082]                         if (!is.null(pattern)) {
[17:27:22.082]                           computeRestarts <- base::computeRestarts
[17:27:22.082]                           grepl <- base::grepl
[17:27:22.082]                           restarts <- computeRestarts(cond)
[17:27:22.082]                           for (restart in restarts) {
[17:27:22.082]                             name <- restart$name
[17:27:22.082]                             if (is.null(name)) 
[17:27:22.082]                               next
[17:27:22.082]                             if (!grepl(pattern, name)) 
[17:27:22.082]                               next
[17:27:22.082]                             invokeRestart(restart)
[17:27:22.082]                             muffled <- TRUE
[17:27:22.082]                             break
[17:27:22.082]                           }
[17:27:22.082]                         }
[17:27:22.082]                       }
[17:27:22.082]                       invisible(muffled)
[17:27:22.082]                     }
[17:27:22.082]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.082]                   }
[17:27:22.082]                 }
[17:27:22.082]                 else {
[17:27:22.082]                   if (TRUE) {
[17:27:22.082]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.082]                     {
[17:27:22.082]                       inherits <- base::inherits
[17:27:22.082]                       invokeRestart <- base::invokeRestart
[17:27:22.082]                       is.null <- base::is.null
[17:27:22.082]                       muffled <- FALSE
[17:27:22.082]                       if (inherits(cond, "message")) {
[17:27:22.082]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.082]                         if (muffled) 
[17:27:22.082]                           invokeRestart("muffleMessage")
[17:27:22.082]                       }
[17:27:22.082]                       else if (inherits(cond, "warning")) {
[17:27:22.082]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.082]                         if (muffled) 
[17:27:22.082]                           invokeRestart("muffleWarning")
[17:27:22.082]                       }
[17:27:22.082]                       else if (inherits(cond, "condition")) {
[17:27:22.082]                         if (!is.null(pattern)) {
[17:27:22.082]                           computeRestarts <- base::computeRestarts
[17:27:22.082]                           grepl <- base::grepl
[17:27:22.082]                           restarts <- computeRestarts(cond)
[17:27:22.082]                           for (restart in restarts) {
[17:27:22.082]                             name <- restart$name
[17:27:22.082]                             if (is.null(name)) 
[17:27:22.082]                               next
[17:27:22.082]                             if (!grepl(pattern, name)) 
[17:27:22.082]                               next
[17:27:22.082]                             invokeRestart(restart)
[17:27:22.082]                             muffled <- TRUE
[17:27:22.082]                             break
[17:27:22.082]                           }
[17:27:22.082]                         }
[17:27:22.082]                       }
[17:27:22.082]                       invisible(muffled)
[17:27:22.082]                     }
[17:27:22.082]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.082]                   }
[17:27:22.082]                 }
[17:27:22.082]             }
[17:27:22.082]         }))
[17:27:22.082]     }, error = function(ex) {
[17:27:22.082]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.082]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.082]                 ...future.rng), started = ...future.startTime, 
[17:27:22.082]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.082]             version = "1.8"), class = "FutureResult")
[17:27:22.082]     }, finally = {
[17:27:22.082]         if (!identical(...future.workdir, getwd())) 
[17:27:22.082]             setwd(...future.workdir)
[17:27:22.082]         {
[17:27:22.082]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.082]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.082]             }
[17:27:22.082]             base::options(...future.oldOptions)
[17:27:22.082]             if (.Platform$OS.type == "windows") {
[17:27:22.082]                 old_names <- names(...future.oldEnvVars)
[17:27:22.082]                 envs <- base::Sys.getenv()
[17:27:22.082]                 names <- names(envs)
[17:27:22.082]                 common <- intersect(names, old_names)
[17:27:22.082]                 added <- setdiff(names, old_names)
[17:27:22.082]                 removed <- setdiff(old_names, names)
[17:27:22.082]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.082]                   envs[common]]
[17:27:22.082]                 NAMES <- toupper(changed)
[17:27:22.082]                 args <- list()
[17:27:22.082]                 for (kk in seq_along(NAMES)) {
[17:27:22.082]                   name <- changed[[kk]]
[17:27:22.082]                   NAME <- NAMES[[kk]]
[17:27:22.082]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.082]                     next
[17:27:22.082]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.082]                 }
[17:27:22.082]                 NAMES <- toupper(added)
[17:27:22.082]                 for (kk in seq_along(NAMES)) {
[17:27:22.082]                   name <- added[[kk]]
[17:27:22.082]                   NAME <- NAMES[[kk]]
[17:27:22.082]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.082]                     next
[17:27:22.082]                   args[[name]] <- ""
[17:27:22.082]                 }
[17:27:22.082]                 NAMES <- toupper(removed)
[17:27:22.082]                 for (kk in seq_along(NAMES)) {
[17:27:22.082]                   name <- removed[[kk]]
[17:27:22.082]                   NAME <- NAMES[[kk]]
[17:27:22.082]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.082]                     next
[17:27:22.082]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.082]                 }
[17:27:22.082]                 if (length(args) > 0) 
[17:27:22.082]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.082]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.082]             }
[17:27:22.082]             else {
[17:27:22.082]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.082]             }
[17:27:22.082]             {
[17:27:22.082]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.082]                   0L) {
[17:27:22.082]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.082]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.082]                   base::options(opts)
[17:27:22.082]                 }
[17:27:22.082]                 {
[17:27:22.082]                   {
[17:27:22.082]                     NULL
[17:27:22.082]                     RNGkind("Mersenne-Twister")
[17:27:22.082]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.082]                       inherits = FALSE)
[17:27:22.082]                   }
[17:27:22.082]                   options(future.plan = NULL)
[17:27:22.082]                   if (is.na(NA_character_)) 
[17:27:22.082]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.082]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.082]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.082]                     .init = FALSE)
[17:27:22.082]                 }
[17:27:22.082]             }
[17:27:22.082]         }
[17:27:22.082]     })
[17:27:22.082]     if (TRUE) {
[17:27:22.082]         base::sink(type = "output", split = FALSE)
[17:27:22.082]         if (TRUE) {
[17:27:22.082]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.082]         }
[17:27:22.082]         else {
[17:27:22.082]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.082]         }
[17:27:22.082]         base::close(...future.stdout)
[17:27:22.082]         ...future.stdout <- NULL
[17:27:22.082]     }
[17:27:22.082]     ...future.result$conditions <- ...future.conditions
[17:27:22.082]     ...future.result$finished <- base::Sys.time()
[17:27:22.082]     ...future.result
[17:27:22.082] }
[17:27:22.090] assign_globals() ...
[17:27:22.090] List of 1
[17:27:22.090]  $ ii: int 1
[17:27:22.090]  - attr(*, "where")=List of 1
[17:27:22.090]   ..$ ii:<environment: R_EmptyEnv> 
[17:27:22.090]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:22.090]  - attr(*, "resolved")= logi FALSE
[17:27:22.090]  - attr(*, "total_size")= int 35
[17:27:22.090]  - attr(*, "already-done")= logi TRUE
[17:27:22.096] - copied 'ii' to environment
[17:27:22.096] assign_globals() ... done
[17:27:22.097] plan(): Setting new future strategy stack:
[17:27:22.097] List of future strategies:
[17:27:22.097] 1. sequential:
[17:27:22.097]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.097]    - tweaked: FALSE
[17:27:22.097]    - call: NULL
[17:27:22.099] plan(): nbrOfWorkers() = 1
[17:27:22.101] plan(): Setting new future strategy stack:
[17:27:22.101] List of future strategies:
[17:27:22.101] 1. sequential:
[17:27:22.101]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.101]    - tweaked: FALSE
[17:27:22.101]    - call: plan(strategy)
[17:27:22.102] plan(): nbrOfWorkers() = 1
[17:27:22.103] SequentialFuture started (and completed)
[17:27:22.103] - Launch lazy future ... done
[17:27:22.104] run() for 'SequentialFuture' ... done
[17:27:22.105] getGlobalsAndPackages() ...
[17:27:22.105] Searching for globals...
[17:27:22.109] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:27:22.109] Searching for globals ... DONE
[17:27:22.110] Resolving globals: FALSE
[17:27:22.111] The total size of the 1 globals is 35 bytes (35 bytes)
[17:27:22.112] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:27:22.112] - globals: [1] 'ii'
[17:27:22.113] 
[17:27:22.113] getGlobalsAndPackages() ... DONE
[17:27:22.114] run() for 'Future' ...
[17:27:22.114] - state: 'created'
[17:27:22.117] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.118] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.118] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.119]   - Field: 'label'
[17:27:22.119]   - Field: 'local'
[17:27:22.119]   - Field: 'owner'
[17:27:22.120]   - Field: 'envir'
[17:27:22.120]   - Field: 'packages'
[17:27:22.121]   - Field: 'gc'
[17:27:22.121]   - Field: 'conditions'
[17:27:22.121]   - Field: 'expr'
[17:27:22.122]   - Field: 'uuid'
[17:27:22.122]   - Field: 'seed'
[17:27:22.122]   - Field: 'version'
[17:27:22.123]   - Field: 'result'
[17:27:22.123]   - Field: 'asynchronous'
[17:27:22.124]   - Field: 'calls'
[17:27:22.124]   - Field: 'globals'
[17:27:22.124]   - Field: 'stdout'
[17:27:22.125]   - Field: 'earlySignal'
[17:27:22.125]   - Field: 'lazy'
[17:27:22.125]   - Field: 'state'
[17:27:22.126] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.126] - Launch lazy future ...
[17:27:22.127] Packages needed by the future expression (n = 0): <none>
[17:27:22.127] Packages needed by future strategies (n = 0): <none>
[17:27:22.128] {
[17:27:22.128]     {
[17:27:22.128]         {
[17:27:22.128]             ...future.startTime <- base::Sys.time()
[17:27:22.128]             {
[17:27:22.128]                 {
[17:27:22.128]                   {
[17:27:22.128]                     base::local({
[17:27:22.128]                       has_future <- base::requireNamespace("future", 
[17:27:22.128]                         quietly = TRUE)
[17:27:22.128]                       if (has_future) {
[17:27:22.128]                         ns <- base::getNamespace("future")
[17:27:22.128]                         version <- ns[[".package"]][["version"]]
[17:27:22.128]                         if (is.null(version)) 
[17:27:22.128]                           version <- utils::packageVersion("future")
[17:27:22.128]                       }
[17:27:22.128]                       else {
[17:27:22.128]                         version <- NULL
[17:27:22.128]                       }
[17:27:22.128]                       if (!has_future || version < "1.8.0") {
[17:27:22.128]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.128]                           "", base::R.version$version.string), 
[17:27:22.128]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.128]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.128]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.128]                             "release", "version")], collapse = " "), 
[17:27:22.128]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.128]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.128]                           info)
[17:27:22.128]                         info <- base::paste(info, collapse = "; ")
[17:27:22.128]                         if (!has_future) {
[17:27:22.128]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.128]                             info)
[17:27:22.128]                         }
[17:27:22.128]                         else {
[17:27:22.128]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.128]                             info, version)
[17:27:22.128]                         }
[17:27:22.128]                         base::stop(msg)
[17:27:22.128]                       }
[17:27:22.128]                     })
[17:27:22.128]                   }
[17:27:22.128]                   ...future.strategy.old <- future::plan("list")
[17:27:22.128]                   options(future.plan = NULL)
[17:27:22.128]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.128]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.128]                 }
[17:27:22.128]                 ...future.workdir <- getwd()
[17:27:22.128]             }
[17:27:22.128]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.128]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.128]         }
[17:27:22.128]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.128]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.128]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.128]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.128]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.128]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.128]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.128]             base::names(...future.oldOptions))
[17:27:22.128]     }
[17:27:22.128]     if (FALSE) {
[17:27:22.128]     }
[17:27:22.128]     else {
[17:27:22.128]         if (TRUE) {
[17:27:22.128]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.128]                 open = "w")
[17:27:22.128]         }
[17:27:22.128]         else {
[17:27:22.128]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.128]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.128]         }
[17:27:22.128]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.128]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.128]             base::sink(type = "output", split = FALSE)
[17:27:22.128]             base::close(...future.stdout)
[17:27:22.128]         }, add = TRUE)
[17:27:22.128]     }
[17:27:22.128]     ...future.frame <- base::sys.nframe()
[17:27:22.128]     ...future.conditions <- base::list()
[17:27:22.128]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.128]     if (FALSE) {
[17:27:22.128]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.128]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.128]     }
[17:27:22.128]     ...future.result <- base::tryCatch({
[17:27:22.128]         base::withCallingHandlers({
[17:27:22.128]             ...future.value <- base::withVisible(base::local({
[17:27:22.128]                 if (ii%%2 == 0) 
[17:27:22.128]                   stop("Woops!")
[17:27:22.128]                 ii
[17:27:22.128]             }))
[17:27:22.128]             future::FutureResult(value = ...future.value$value, 
[17:27:22.128]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.128]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.128]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.128]                     ...future.globalenv.names))
[17:27:22.128]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.128]         }, condition = base::local({
[17:27:22.128]             c <- base::c
[17:27:22.128]             inherits <- base::inherits
[17:27:22.128]             invokeRestart <- base::invokeRestart
[17:27:22.128]             length <- base::length
[17:27:22.128]             list <- base::list
[17:27:22.128]             seq.int <- base::seq.int
[17:27:22.128]             signalCondition <- base::signalCondition
[17:27:22.128]             sys.calls <- base::sys.calls
[17:27:22.128]             `[[` <- base::`[[`
[17:27:22.128]             `+` <- base::`+`
[17:27:22.128]             `<<-` <- base::`<<-`
[17:27:22.128]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.128]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.128]                   3L)]
[17:27:22.128]             }
[17:27:22.128]             function(cond) {
[17:27:22.128]                 is_error <- inherits(cond, "error")
[17:27:22.128]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.128]                   NULL)
[17:27:22.128]                 if (is_error) {
[17:27:22.128]                   sessionInformation <- function() {
[17:27:22.128]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.128]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.128]                       search = base::search(), system = base::Sys.info())
[17:27:22.128]                   }
[17:27:22.128]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.128]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.128]                     cond$call), session = sessionInformation(), 
[17:27:22.128]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.128]                   signalCondition(cond)
[17:27:22.128]                 }
[17:27:22.128]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.128]                 "immediateCondition"))) {
[17:27:22.128]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.128]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.128]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.128]                   if (TRUE && !signal) {
[17:27:22.128]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.128]                     {
[17:27:22.128]                       inherits <- base::inherits
[17:27:22.128]                       invokeRestart <- base::invokeRestart
[17:27:22.128]                       is.null <- base::is.null
[17:27:22.128]                       muffled <- FALSE
[17:27:22.128]                       if (inherits(cond, "message")) {
[17:27:22.128]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.128]                         if (muffled) 
[17:27:22.128]                           invokeRestart("muffleMessage")
[17:27:22.128]                       }
[17:27:22.128]                       else if (inherits(cond, "warning")) {
[17:27:22.128]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.128]                         if (muffled) 
[17:27:22.128]                           invokeRestart("muffleWarning")
[17:27:22.128]                       }
[17:27:22.128]                       else if (inherits(cond, "condition")) {
[17:27:22.128]                         if (!is.null(pattern)) {
[17:27:22.128]                           computeRestarts <- base::computeRestarts
[17:27:22.128]                           grepl <- base::grepl
[17:27:22.128]                           restarts <- computeRestarts(cond)
[17:27:22.128]                           for (restart in restarts) {
[17:27:22.128]                             name <- restart$name
[17:27:22.128]                             if (is.null(name)) 
[17:27:22.128]                               next
[17:27:22.128]                             if (!grepl(pattern, name)) 
[17:27:22.128]                               next
[17:27:22.128]                             invokeRestart(restart)
[17:27:22.128]                             muffled <- TRUE
[17:27:22.128]                             break
[17:27:22.128]                           }
[17:27:22.128]                         }
[17:27:22.128]                       }
[17:27:22.128]                       invisible(muffled)
[17:27:22.128]                     }
[17:27:22.128]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.128]                   }
[17:27:22.128]                 }
[17:27:22.128]                 else {
[17:27:22.128]                   if (TRUE) {
[17:27:22.128]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.128]                     {
[17:27:22.128]                       inherits <- base::inherits
[17:27:22.128]                       invokeRestart <- base::invokeRestart
[17:27:22.128]                       is.null <- base::is.null
[17:27:22.128]                       muffled <- FALSE
[17:27:22.128]                       if (inherits(cond, "message")) {
[17:27:22.128]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.128]                         if (muffled) 
[17:27:22.128]                           invokeRestart("muffleMessage")
[17:27:22.128]                       }
[17:27:22.128]                       else if (inherits(cond, "warning")) {
[17:27:22.128]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.128]                         if (muffled) 
[17:27:22.128]                           invokeRestart("muffleWarning")
[17:27:22.128]                       }
[17:27:22.128]                       else if (inherits(cond, "condition")) {
[17:27:22.128]                         if (!is.null(pattern)) {
[17:27:22.128]                           computeRestarts <- base::computeRestarts
[17:27:22.128]                           grepl <- base::grepl
[17:27:22.128]                           restarts <- computeRestarts(cond)
[17:27:22.128]                           for (restart in restarts) {
[17:27:22.128]                             name <- restart$name
[17:27:22.128]                             if (is.null(name)) 
[17:27:22.128]                               next
[17:27:22.128]                             if (!grepl(pattern, name)) 
[17:27:22.128]                               next
[17:27:22.128]                             invokeRestart(restart)
[17:27:22.128]                             muffled <- TRUE
[17:27:22.128]                             break
[17:27:22.128]                           }
[17:27:22.128]                         }
[17:27:22.128]                       }
[17:27:22.128]                       invisible(muffled)
[17:27:22.128]                     }
[17:27:22.128]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.128]                   }
[17:27:22.128]                 }
[17:27:22.128]             }
[17:27:22.128]         }))
[17:27:22.128]     }, error = function(ex) {
[17:27:22.128]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.128]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.128]                 ...future.rng), started = ...future.startTime, 
[17:27:22.128]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.128]             version = "1.8"), class = "FutureResult")
[17:27:22.128]     }, finally = {
[17:27:22.128]         if (!identical(...future.workdir, getwd())) 
[17:27:22.128]             setwd(...future.workdir)
[17:27:22.128]         {
[17:27:22.128]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.128]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.128]             }
[17:27:22.128]             base::options(...future.oldOptions)
[17:27:22.128]             if (.Platform$OS.type == "windows") {
[17:27:22.128]                 old_names <- names(...future.oldEnvVars)
[17:27:22.128]                 envs <- base::Sys.getenv()
[17:27:22.128]                 names <- names(envs)
[17:27:22.128]                 common <- intersect(names, old_names)
[17:27:22.128]                 added <- setdiff(names, old_names)
[17:27:22.128]                 removed <- setdiff(old_names, names)
[17:27:22.128]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.128]                   envs[common]]
[17:27:22.128]                 NAMES <- toupper(changed)
[17:27:22.128]                 args <- list()
[17:27:22.128]                 for (kk in seq_along(NAMES)) {
[17:27:22.128]                   name <- changed[[kk]]
[17:27:22.128]                   NAME <- NAMES[[kk]]
[17:27:22.128]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.128]                     next
[17:27:22.128]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.128]                 }
[17:27:22.128]                 NAMES <- toupper(added)
[17:27:22.128]                 for (kk in seq_along(NAMES)) {
[17:27:22.128]                   name <- added[[kk]]
[17:27:22.128]                   NAME <- NAMES[[kk]]
[17:27:22.128]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.128]                     next
[17:27:22.128]                   args[[name]] <- ""
[17:27:22.128]                 }
[17:27:22.128]                 NAMES <- toupper(removed)
[17:27:22.128]                 for (kk in seq_along(NAMES)) {
[17:27:22.128]                   name <- removed[[kk]]
[17:27:22.128]                   NAME <- NAMES[[kk]]
[17:27:22.128]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.128]                     next
[17:27:22.128]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.128]                 }
[17:27:22.128]                 if (length(args) > 0) 
[17:27:22.128]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.128]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.128]             }
[17:27:22.128]             else {
[17:27:22.128]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.128]             }
[17:27:22.128]             {
[17:27:22.128]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.128]                   0L) {
[17:27:22.128]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.128]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.128]                   base::options(opts)
[17:27:22.128]                 }
[17:27:22.128]                 {
[17:27:22.128]                   {
[17:27:22.128]                     NULL
[17:27:22.128]                     RNGkind("Mersenne-Twister")
[17:27:22.128]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.128]                       inherits = FALSE)
[17:27:22.128]                   }
[17:27:22.128]                   options(future.plan = NULL)
[17:27:22.128]                   if (is.na(NA_character_)) 
[17:27:22.128]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.128]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.128]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.128]                     .init = FALSE)
[17:27:22.128]                 }
[17:27:22.128]             }
[17:27:22.128]         }
[17:27:22.128]     })
[17:27:22.128]     if (TRUE) {
[17:27:22.128]         base::sink(type = "output", split = FALSE)
[17:27:22.128]         if (TRUE) {
[17:27:22.128]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.128]         }
[17:27:22.128]         else {
[17:27:22.128]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.128]         }
[17:27:22.128]         base::close(...future.stdout)
[17:27:22.128]         ...future.stdout <- NULL
[17:27:22.128]     }
[17:27:22.128]     ...future.result$conditions <- ...future.conditions
[17:27:22.128]     ...future.result$finished <- base::Sys.time()
[17:27:22.128]     ...future.result
[17:27:22.128] }
[17:27:22.136] assign_globals() ...
[17:27:22.136] List of 1
[17:27:22.136]  $ ii: int 2
[17:27:22.136]  - attr(*, "where")=List of 1
[17:27:22.136]   ..$ ii:<environment: R_EmptyEnv> 
[17:27:22.136]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:22.136]  - attr(*, "resolved")= logi FALSE
[17:27:22.136]  - attr(*, "total_size")= int 35
[17:27:22.136]  - attr(*, "already-done")= logi TRUE
[17:27:22.142] - copied 'ii' to environment
[17:27:22.142] assign_globals() ... done
[17:27:22.143] plan(): Setting new future strategy stack:
[17:27:22.144] List of future strategies:
[17:27:22.144] 1. sequential:
[17:27:22.144]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.144]    - tweaked: FALSE
[17:27:22.144]    - call: NULL
[17:27:22.145] plan(): nbrOfWorkers() = 1
[17:27:22.148] plan(): Setting new future strategy stack:
[17:27:22.148] List of future strategies:
[17:27:22.148] 1. sequential:
[17:27:22.148]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.148]    - tweaked: FALSE
[17:27:22.148]    - call: plan(strategy)
[17:27:22.149] plan(): nbrOfWorkers() = 1
[17:27:22.150] SequentialFuture started (and completed)
[17:27:22.150] signalConditions() ...
[17:27:22.150]  - include = 'immediateCondition'
[17:27:22.151]  - exclude = 
[17:27:22.151]  - resignal = FALSE
[17:27:22.151]  - Number of conditions: 1
[17:27:22.152] signalConditions() ... done
[17:27:22.152] - Launch lazy future ... done
[17:27:22.153] run() for 'SequentialFuture' ... done
[17:27:22.154] getGlobalsAndPackages() ...
[17:27:22.154] Searching for globals...
[17:27:22.158] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:27:22.158] Searching for globals ... DONE
[17:27:22.159] Resolving globals: FALSE
[17:27:22.160] The total size of the 1 globals is 35 bytes (35 bytes)
[17:27:22.161] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:27:22.161] - globals: [1] 'ii'
[17:27:22.161] 
[17:27:22.162] getGlobalsAndPackages() ... DONE
[17:27:22.162] run() for 'Future' ...
[17:27:22.163] - state: 'created'
[17:27:22.163] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.164] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.164] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.165]   - Field: 'label'
[17:27:22.165]   - Field: 'local'
[17:27:22.166]   - Field: 'owner'
[17:27:22.166]   - Field: 'envir'
[17:27:22.166]   - Field: 'packages'
[17:27:22.167]   - Field: 'gc'
[17:27:22.167]   - Field: 'conditions'
[17:27:22.168]   - Field: 'expr'
[17:27:22.168]   - Field: 'uuid'
[17:27:22.168]   - Field: 'seed'
[17:27:22.169]   - Field: 'version'
[17:27:22.169]   - Field: 'result'
[17:27:22.169]   - Field: 'asynchronous'
[17:27:22.170]   - Field: 'calls'
[17:27:22.170]   - Field: 'globals'
[17:27:22.171]   - Field: 'stdout'
[17:27:22.171]   - Field: 'earlySignal'
[17:27:22.171]   - Field: 'lazy'
[17:27:22.172]   - Field: 'state'
[17:27:22.172] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.172] - Launch lazy future ...
[17:27:22.173] Packages needed by the future expression (n = 0): <none>
[17:27:22.173] Packages needed by future strategies (n = 0): <none>
[17:27:22.175] {
[17:27:22.175]     {
[17:27:22.175]         {
[17:27:22.175]             ...future.startTime <- base::Sys.time()
[17:27:22.175]             {
[17:27:22.175]                 {
[17:27:22.175]                   {
[17:27:22.175]                     base::local({
[17:27:22.175]                       has_future <- base::requireNamespace("future", 
[17:27:22.175]                         quietly = TRUE)
[17:27:22.175]                       if (has_future) {
[17:27:22.175]                         ns <- base::getNamespace("future")
[17:27:22.175]                         version <- ns[[".package"]][["version"]]
[17:27:22.175]                         if (is.null(version)) 
[17:27:22.175]                           version <- utils::packageVersion("future")
[17:27:22.175]                       }
[17:27:22.175]                       else {
[17:27:22.175]                         version <- NULL
[17:27:22.175]                       }
[17:27:22.175]                       if (!has_future || version < "1.8.0") {
[17:27:22.175]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.175]                           "", base::R.version$version.string), 
[17:27:22.175]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.175]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.175]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.175]                             "release", "version")], collapse = " "), 
[17:27:22.175]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.175]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.175]                           info)
[17:27:22.175]                         info <- base::paste(info, collapse = "; ")
[17:27:22.175]                         if (!has_future) {
[17:27:22.175]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.175]                             info)
[17:27:22.175]                         }
[17:27:22.175]                         else {
[17:27:22.175]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.175]                             info, version)
[17:27:22.175]                         }
[17:27:22.175]                         base::stop(msg)
[17:27:22.175]                       }
[17:27:22.175]                     })
[17:27:22.175]                   }
[17:27:22.175]                   ...future.strategy.old <- future::plan("list")
[17:27:22.175]                   options(future.plan = NULL)
[17:27:22.175]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.175]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.175]                 }
[17:27:22.175]                 ...future.workdir <- getwd()
[17:27:22.175]             }
[17:27:22.175]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.175]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.175]         }
[17:27:22.175]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.175]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.175]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.175]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.175]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.175]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.175]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.175]             base::names(...future.oldOptions))
[17:27:22.175]     }
[17:27:22.175]     if (FALSE) {
[17:27:22.175]     }
[17:27:22.175]     else {
[17:27:22.175]         if (TRUE) {
[17:27:22.175]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.175]                 open = "w")
[17:27:22.175]         }
[17:27:22.175]         else {
[17:27:22.175]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.175]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.175]         }
[17:27:22.175]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.175]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.175]             base::sink(type = "output", split = FALSE)
[17:27:22.175]             base::close(...future.stdout)
[17:27:22.175]         }, add = TRUE)
[17:27:22.175]     }
[17:27:22.175]     ...future.frame <- base::sys.nframe()
[17:27:22.175]     ...future.conditions <- base::list()
[17:27:22.175]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.175]     if (FALSE) {
[17:27:22.175]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.175]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.175]     }
[17:27:22.175]     ...future.result <- base::tryCatch({
[17:27:22.175]         base::withCallingHandlers({
[17:27:22.175]             ...future.value <- base::withVisible(base::local({
[17:27:22.175]                 if (ii%%2 == 0) 
[17:27:22.175]                   stop("Woops!")
[17:27:22.175]                 ii
[17:27:22.175]             }))
[17:27:22.175]             future::FutureResult(value = ...future.value$value, 
[17:27:22.175]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.175]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.175]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.175]                     ...future.globalenv.names))
[17:27:22.175]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.175]         }, condition = base::local({
[17:27:22.175]             c <- base::c
[17:27:22.175]             inherits <- base::inherits
[17:27:22.175]             invokeRestart <- base::invokeRestart
[17:27:22.175]             length <- base::length
[17:27:22.175]             list <- base::list
[17:27:22.175]             seq.int <- base::seq.int
[17:27:22.175]             signalCondition <- base::signalCondition
[17:27:22.175]             sys.calls <- base::sys.calls
[17:27:22.175]             `[[` <- base::`[[`
[17:27:22.175]             `+` <- base::`+`
[17:27:22.175]             `<<-` <- base::`<<-`
[17:27:22.175]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.175]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.175]                   3L)]
[17:27:22.175]             }
[17:27:22.175]             function(cond) {
[17:27:22.175]                 is_error <- inherits(cond, "error")
[17:27:22.175]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.175]                   NULL)
[17:27:22.175]                 if (is_error) {
[17:27:22.175]                   sessionInformation <- function() {
[17:27:22.175]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.175]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.175]                       search = base::search(), system = base::Sys.info())
[17:27:22.175]                   }
[17:27:22.175]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.175]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.175]                     cond$call), session = sessionInformation(), 
[17:27:22.175]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.175]                   signalCondition(cond)
[17:27:22.175]                 }
[17:27:22.175]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.175]                 "immediateCondition"))) {
[17:27:22.175]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.175]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.175]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.175]                   if (TRUE && !signal) {
[17:27:22.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.175]                     {
[17:27:22.175]                       inherits <- base::inherits
[17:27:22.175]                       invokeRestart <- base::invokeRestart
[17:27:22.175]                       is.null <- base::is.null
[17:27:22.175]                       muffled <- FALSE
[17:27:22.175]                       if (inherits(cond, "message")) {
[17:27:22.175]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.175]                         if (muffled) 
[17:27:22.175]                           invokeRestart("muffleMessage")
[17:27:22.175]                       }
[17:27:22.175]                       else if (inherits(cond, "warning")) {
[17:27:22.175]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.175]                         if (muffled) 
[17:27:22.175]                           invokeRestart("muffleWarning")
[17:27:22.175]                       }
[17:27:22.175]                       else if (inherits(cond, "condition")) {
[17:27:22.175]                         if (!is.null(pattern)) {
[17:27:22.175]                           computeRestarts <- base::computeRestarts
[17:27:22.175]                           grepl <- base::grepl
[17:27:22.175]                           restarts <- computeRestarts(cond)
[17:27:22.175]                           for (restart in restarts) {
[17:27:22.175]                             name <- restart$name
[17:27:22.175]                             if (is.null(name)) 
[17:27:22.175]                               next
[17:27:22.175]                             if (!grepl(pattern, name)) 
[17:27:22.175]                               next
[17:27:22.175]                             invokeRestart(restart)
[17:27:22.175]                             muffled <- TRUE
[17:27:22.175]                             break
[17:27:22.175]                           }
[17:27:22.175]                         }
[17:27:22.175]                       }
[17:27:22.175]                       invisible(muffled)
[17:27:22.175]                     }
[17:27:22.175]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.175]                   }
[17:27:22.175]                 }
[17:27:22.175]                 else {
[17:27:22.175]                   if (TRUE) {
[17:27:22.175]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.175]                     {
[17:27:22.175]                       inherits <- base::inherits
[17:27:22.175]                       invokeRestart <- base::invokeRestart
[17:27:22.175]                       is.null <- base::is.null
[17:27:22.175]                       muffled <- FALSE
[17:27:22.175]                       if (inherits(cond, "message")) {
[17:27:22.175]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.175]                         if (muffled) 
[17:27:22.175]                           invokeRestart("muffleMessage")
[17:27:22.175]                       }
[17:27:22.175]                       else if (inherits(cond, "warning")) {
[17:27:22.175]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.175]                         if (muffled) 
[17:27:22.175]                           invokeRestart("muffleWarning")
[17:27:22.175]                       }
[17:27:22.175]                       else if (inherits(cond, "condition")) {
[17:27:22.175]                         if (!is.null(pattern)) {
[17:27:22.175]                           computeRestarts <- base::computeRestarts
[17:27:22.175]                           grepl <- base::grepl
[17:27:22.175]                           restarts <- computeRestarts(cond)
[17:27:22.175]                           for (restart in restarts) {
[17:27:22.175]                             name <- restart$name
[17:27:22.175]                             if (is.null(name)) 
[17:27:22.175]                               next
[17:27:22.175]                             if (!grepl(pattern, name)) 
[17:27:22.175]                               next
[17:27:22.175]                             invokeRestart(restart)
[17:27:22.175]                             muffled <- TRUE
[17:27:22.175]                             break
[17:27:22.175]                           }
[17:27:22.175]                         }
[17:27:22.175]                       }
[17:27:22.175]                       invisible(muffled)
[17:27:22.175]                     }
[17:27:22.175]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.175]                   }
[17:27:22.175]                 }
[17:27:22.175]             }
[17:27:22.175]         }))
[17:27:22.175]     }, error = function(ex) {
[17:27:22.175]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.175]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.175]                 ...future.rng), started = ...future.startTime, 
[17:27:22.175]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.175]             version = "1.8"), class = "FutureResult")
[17:27:22.175]     }, finally = {
[17:27:22.175]         if (!identical(...future.workdir, getwd())) 
[17:27:22.175]             setwd(...future.workdir)
[17:27:22.175]         {
[17:27:22.175]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.175]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.175]             }
[17:27:22.175]             base::options(...future.oldOptions)
[17:27:22.175]             if (.Platform$OS.type == "windows") {
[17:27:22.175]                 old_names <- names(...future.oldEnvVars)
[17:27:22.175]                 envs <- base::Sys.getenv()
[17:27:22.175]                 names <- names(envs)
[17:27:22.175]                 common <- intersect(names, old_names)
[17:27:22.175]                 added <- setdiff(names, old_names)
[17:27:22.175]                 removed <- setdiff(old_names, names)
[17:27:22.175]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.175]                   envs[common]]
[17:27:22.175]                 NAMES <- toupper(changed)
[17:27:22.175]                 args <- list()
[17:27:22.175]                 for (kk in seq_along(NAMES)) {
[17:27:22.175]                   name <- changed[[kk]]
[17:27:22.175]                   NAME <- NAMES[[kk]]
[17:27:22.175]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.175]                     next
[17:27:22.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.175]                 }
[17:27:22.175]                 NAMES <- toupper(added)
[17:27:22.175]                 for (kk in seq_along(NAMES)) {
[17:27:22.175]                   name <- added[[kk]]
[17:27:22.175]                   NAME <- NAMES[[kk]]
[17:27:22.175]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.175]                     next
[17:27:22.175]                   args[[name]] <- ""
[17:27:22.175]                 }
[17:27:22.175]                 NAMES <- toupper(removed)
[17:27:22.175]                 for (kk in seq_along(NAMES)) {
[17:27:22.175]                   name <- removed[[kk]]
[17:27:22.175]                   NAME <- NAMES[[kk]]
[17:27:22.175]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.175]                     next
[17:27:22.175]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.175]                 }
[17:27:22.175]                 if (length(args) > 0) 
[17:27:22.175]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.175]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.175]             }
[17:27:22.175]             else {
[17:27:22.175]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.175]             }
[17:27:22.175]             {
[17:27:22.175]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.175]                   0L) {
[17:27:22.175]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.175]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.175]                   base::options(opts)
[17:27:22.175]                 }
[17:27:22.175]                 {
[17:27:22.175]                   {
[17:27:22.175]                     NULL
[17:27:22.175]                     RNGkind("Mersenne-Twister")
[17:27:22.175]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.175]                       inherits = FALSE)
[17:27:22.175]                   }
[17:27:22.175]                   options(future.plan = NULL)
[17:27:22.175]                   if (is.na(NA_character_)) 
[17:27:22.175]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.175]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.175]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.175]                     .init = FALSE)
[17:27:22.175]                 }
[17:27:22.175]             }
[17:27:22.175]         }
[17:27:22.175]     })
[17:27:22.175]     if (TRUE) {
[17:27:22.175]         base::sink(type = "output", split = FALSE)
[17:27:22.175]         if (TRUE) {
[17:27:22.175]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.175]         }
[17:27:22.175]         else {
[17:27:22.175]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.175]         }
[17:27:22.175]         base::close(...future.stdout)
[17:27:22.175]         ...future.stdout <- NULL
[17:27:22.175]     }
[17:27:22.175]     ...future.result$conditions <- ...future.conditions
[17:27:22.175]     ...future.result$finished <- base::Sys.time()
[17:27:22.175]     ...future.result
[17:27:22.175] }
[17:27:22.182] assign_globals() ...
[17:27:22.183] List of 1
[17:27:22.183]  $ ii: int 3
[17:27:22.183]  - attr(*, "where")=List of 1
[17:27:22.183]   ..$ ii:<environment: R_EmptyEnv> 
[17:27:22.183]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:22.183]  - attr(*, "resolved")= logi FALSE
[17:27:22.183]  - attr(*, "total_size")= int 35
[17:27:22.183]  - attr(*, "already-done")= logi TRUE
[17:27:22.192] - copied 'ii' to environment
[17:27:22.192] assign_globals() ... done
[17:27:22.193] plan(): Setting new future strategy stack:
[17:27:22.193] List of future strategies:
[17:27:22.193] 1. sequential:
[17:27:22.193]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.193]    - tweaked: FALSE
[17:27:22.193]    - call: NULL
[17:27:22.194] plan(): nbrOfWorkers() = 1
[17:27:22.197] plan(): Setting new future strategy stack:
[17:27:22.197] List of future strategies:
[17:27:22.197] 1. sequential:
[17:27:22.197]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.197]    - tweaked: FALSE
[17:27:22.197]    - call: plan(strategy)
[17:27:22.198] plan(): nbrOfWorkers() = 1
[17:27:22.199] SequentialFuture started (and completed)
[17:27:22.199] - Launch lazy future ... done
[17:27:22.200] run() for 'SequentialFuture' ... done
[17:27:22.201] signalConditions() ...
[17:27:22.201]  - include = 'immediateCondition'
[17:27:22.201]  - exclude = 
[17:27:22.202]  - resignal = FALSE
[17:27:22.202]  - Number of conditions: 1
[17:27:22.202] signalConditions() ... done
[17:27:22.203] Future state: 'finished'
[17:27:22.203] signalConditions() ...
[17:27:22.204]  - include = 'condition'
[17:27:22.204]  - exclude = 'immediateCondition'
[17:27:22.204]  - resignal = TRUE
[17:27:22.205]  - Number of conditions: 1
[17:27:22.205]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:22.206] signalConditions() ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:27:22.208] signalConditions() ...
[17:27:22.208]  - include = 'immediateCondition'
[17:27:22.209]  - exclude = 
[17:27:22.209]  - resignal = FALSE
[17:27:22.210]  - Number of conditions: 1
[17:27:22.210] signalConditions() ... done
[17:27:22.210] Future state: 'finished'
[17:27:22.211] signalConditions() ...
[17:27:22.211]  - include = 'condition'
[17:27:22.211]  - exclude = 'immediateCondition'
[17:27:22.212]  - resignal = TRUE
[17:27:22.212]  - Number of conditions: 1
[17:27:22.213]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:22.213] signalConditions() ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:27:22.214] signalConditions() ...
[17:27:22.214]  - include = 'immediateCondition'
[17:27:22.215]  - exclude = 
[17:27:22.215]  - resignal = FALSE
[17:27:22.216]  - Number of conditions: 1
[17:27:22.216] signalConditions() ... done
[17:27:22.216] Future state: 'finished'
[17:27:22.217] signalConditions() ...
[17:27:22.217]  - include = 'condition'
[17:27:22.217]  - exclude = 'immediateCondition'
[17:27:22.218]  - resignal = TRUE
[17:27:22.218]  - Number of conditions: 1
[17:27:22.218]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:22.219] signalConditions() ... done
** Future evaluation with a poor-man's "progress bar"
[17:27:22.220] getGlobalsAndPackages() ...
[17:27:22.220] Searching for globals...
[17:27:22.225] - globals found: [4] '{', 'cat', 'for', ':'
[17:27:22.225] Searching for globals ... DONE
[17:27:22.226] Resolving globals: FALSE
[17:27:22.227] 
[17:27:22.227] 
[17:27:22.227] getGlobalsAndPackages() ... DONE
[17:27:22.228] run() for 'Future' ...
[17:27:22.228] - state: 'created'
[17:27:22.229] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.229] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.230] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.230]   - Field: 'label'
[17:27:22.231]   - Field: 'local'
[17:27:22.231]   - Field: 'owner'
[17:27:22.231]   - Field: 'envir'
[17:27:22.232]   - Field: 'packages'
[17:27:22.232]   - Field: 'gc'
[17:27:22.233]   - Field: 'conditions'
[17:27:22.233]   - Field: 'expr'
[17:27:22.233]   - Field: 'uuid'
[17:27:22.234]   - Field: 'seed'
[17:27:22.234]   - Field: 'version'
[17:27:22.234]   - Field: 'result'
[17:27:22.235]   - Field: 'asynchronous'
[17:27:22.235]   - Field: 'calls'
[17:27:22.236]   - Field: 'globals'
[17:27:22.236]   - Field: 'stdout'
[17:27:22.236]   - Field: 'earlySignal'
[17:27:22.237]   - Field: 'lazy'
[17:27:22.237]   - Field: 'state'
[17:27:22.237] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.238] - Launch lazy future ...
[17:27:22.238] Packages needed by the future expression (n = 0): <none>
[17:27:22.239] Packages needed by future strategies (n = 0): <none>
[17:27:22.240] {
[17:27:22.240]     {
[17:27:22.240]         {
[17:27:22.240]             ...future.startTime <- base::Sys.time()
[17:27:22.240]             {
[17:27:22.240]                 {
[17:27:22.240]                   {
[17:27:22.240]                     base::local({
[17:27:22.240]                       has_future <- base::requireNamespace("future", 
[17:27:22.240]                         quietly = TRUE)
[17:27:22.240]                       if (has_future) {
[17:27:22.240]                         ns <- base::getNamespace("future")
[17:27:22.240]                         version <- ns[[".package"]][["version"]]
[17:27:22.240]                         if (is.null(version)) 
[17:27:22.240]                           version <- utils::packageVersion("future")
[17:27:22.240]                       }
[17:27:22.240]                       else {
[17:27:22.240]                         version <- NULL
[17:27:22.240]                       }
[17:27:22.240]                       if (!has_future || version < "1.8.0") {
[17:27:22.240]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.240]                           "", base::R.version$version.string), 
[17:27:22.240]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.240]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.240]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.240]                             "release", "version")], collapse = " "), 
[17:27:22.240]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.240]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.240]                           info)
[17:27:22.240]                         info <- base::paste(info, collapse = "; ")
[17:27:22.240]                         if (!has_future) {
[17:27:22.240]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.240]                             info)
[17:27:22.240]                         }
[17:27:22.240]                         else {
[17:27:22.240]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.240]                             info, version)
[17:27:22.240]                         }
[17:27:22.240]                         base::stop(msg)
[17:27:22.240]                       }
[17:27:22.240]                     })
[17:27:22.240]                   }
[17:27:22.240]                   ...future.strategy.old <- future::plan("list")
[17:27:22.240]                   options(future.plan = NULL)
[17:27:22.240]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.240]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.240]                 }
[17:27:22.240]                 ...future.workdir <- getwd()
[17:27:22.240]             }
[17:27:22.240]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.240]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.240]         }
[17:27:22.240]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.240]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.240]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.240]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.240]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.240]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.240]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.240]             base::names(...future.oldOptions))
[17:27:22.240]     }
[17:27:22.240]     if (FALSE) {
[17:27:22.240]     }
[17:27:22.240]     else {
[17:27:22.240]         if (TRUE) {
[17:27:22.240]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.240]                 open = "w")
[17:27:22.240]         }
[17:27:22.240]         else {
[17:27:22.240]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.240]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.240]         }
[17:27:22.240]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.240]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.240]             base::sink(type = "output", split = FALSE)
[17:27:22.240]             base::close(...future.stdout)
[17:27:22.240]         }, add = TRUE)
[17:27:22.240]     }
[17:27:22.240]     ...future.frame <- base::sys.nframe()
[17:27:22.240]     ...future.conditions <- base::list()
[17:27:22.240]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.240]     if (FALSE) {
[17:27:22.240]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.240]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.240]     }
[17:27:22.240]     ...future.result <- base::tryCatch({
[17:27:22.240]         base::withCallingHandlers({
[17:27:22.240]             ...future.value <- base::withVisible(base::local({
[17:27:22.240]                 cat("Processing: ")
[17:27:22.240]                 for (ii in 1:10) {
[17:27:22.240]                   cat(".")
[17:27:22.240]                 }
[17:27:22.240]                 cat(" [100%]\n")
[17:27:22.240]                 4
[17:27:22.240]             }))
[17:27:22.240]             future::FutureResult(value = ...future.value$value, 
[17:27:22.240]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.240]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.240]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.240]                     ...future.globalenv.names))
[17:27:22.240]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.240]         }, condition = base::local({
[17:27:22.240]             c <- base::c
[17:27:22.240]             inherits <- base::inherits
[17:27:22.240]             invokeRestart <- base::invokeRestart
[17:27:22.240]             length <- base::length
[17:27:22.240]             list <- base::list
[17:27:22.240]             seq.int <- base::seq.int
[17:27:22.240]             signalCondition <- base::signalCondition
[17:27:22.240]             sys.calls <- base::sys.calls
[17:27:22.240]             `[[` <- base::`[[`
[17:27:22.240]             `+` <- base::`+`
[17:27:22.240]             `<<-` <- base::`<<-`
[17:27:22.240]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.240]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.240]                   3L)]
[17:27:22.240]             }
[17:27:22.240]             function(cond) {
[17:27:22.240]                 is_error <- inherits(cond, "error")
[17:27:22.240]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.240]                   NULL)
[17:27:22.240]                 if (is_error) {
[17:27:22.240]                   sessionInformation <- function() {
[17:27:22.240]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.240]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.240]                       search = base::search(), system = base::Sys.info())
[17:27:22.240]                   }
[17:27:22.240]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.240]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.240]                     cond$call), session = sessionInformation(), 
[17:27:22.240]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.240]                   signalCondition(cond)
[17:27:22.240]                 }
[17:27:22.240]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.240]                 "immediateCondition"))) {
[17:27:22.240]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.240]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.240]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.240]                   if (TRUE && !signal) {
[17:27:22.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.240]                     {
[17:27:22.240]                       inherits <- base::inherits
[17:27:22.240]                       invokeRestart <- base::invokeRestart
[17:27:22.240]                       is.null <- base::is.null
[17:27:22.240]                       muffled <- FALSE
[17:27:22.240]                       if (inherits(cond, "message")) {
[17:27:22.240]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.240]                         if (muffled) 
[17:27:22.240]                           invokeRestart("muffleMessage")
[17:27:22.240]                       }
[17:27:22.240]                       else if (inherits(cond, "warning")) {
[17:27:22.240]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.240]                         if (muffled) 
[17:27:22.240]                           invokeRestart("muffleWarning")
[17:27:22.240]                       }
[17:27:22.240]                       else if (inherits(cond, "condition")) {
[17:27:22.240]                         if (!is.null(pattern)) {
[17:27:22.240]                           computeRestarts <- base::computeRestarts
[17:27:22.240]                           grepl <- base::grepl
[17:27:22.240]                           restarts <- computeRestarts(cond)
[17:27:22.240]                           for (restart in restarts) {
[17:27:22.240]                             name <- restart$name
[17:27:22.240]                             if (is.null(name)) 
[17:27:22.240]                               next
[17:27:22.240]                             if (!grepl(pattern, name)) 
[17:27:22.240]                               next
[17:27:22.240]                             invokeRestart(restart)
[17:27:22.240]                             muffled <- TRUE
[17:27:22.240]                             break
[17:27:22.240]                           }
[17:27:22.240]                         }
[17:27:22.240]                       }
[17:27:22.240]                       invisible(muffled)
[17:27:22.240]                     }
[17:27:22.240]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.240]                   }
[17:27:22.240]                 }
[17:27:22.240]                 else {
[17:27:22.240]                   if (TRUE) {
[17:27:22.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.240]                     {
[17:27:22.240]                       inherits <- base::inherits
[17:27:22.240]                       invokeRestart <- base::invokeRestart
[17:27:22.240]                       is.null <- base::is.null
[17:27:22.240]                       muffled <- FALSE
[17:27:22.240]                       if (inherits(cond, "message")) {
[17:27:22.240]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.240]                         if (muffled) 
[17:27:22.240]                           invokeRestart("muffleMessage")
[17:27:22.240]                       }
[17:27:22.240]                       else if (inherits(cond, "warning")) {
[17:27:22.240]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.240]                         if (muffled) 
[17:27:22.240]                           invokeRestart("muffleWarning")
[17:27:22.240]                       }
[17:27:22.240]                       else if (inherits(cond, "condition")) {
[17:27:22.240]                         if (!is.null(pattern)) {
[17:27:22.240]                           computeRestarts <- base::computeRestarts
[17:27:22.240]                           grepl <- base::grepl
[17:27:22.240]                           restarts <- computeRestarts(cond)
[17:27:22.240]                           for (restart in restarts) {
[17:27:22.240]                             name <- restart$name
[17:27:22.240]                             if (is.null(name)) 
[17:27:22.240]                               next
[17:27:22.240]                             if (!grepl(pattern, name)) 
[17:27:22.240]                               next
[17:27:22.240]                             invokeRestart(restart)
[17:27:22.240]                             muffled <- TRUE
[17:27:22.240]                             break
[17:27:22.240]                           }
[17:27:22.240]                         }
[17:27:22.240]                       }
[17:27:22.240]                       invisible(muffled)
[17:27:22.240]                     }
[17:27:22.240]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.240]                   }
[17:27:22.240]                 }
[17:27:22.240]             }
[17:27:22.240]         }))
[17:27:22.240]     }, error = function(ex) {
[17:27:22.240]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.240]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.240]                 ...future.rng), started = ...future.startTime, 
[17:27:22.240]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.240]             version = "1.8"), class = "FutureResult")
[17:27:22.240]     }, finally = {
[17:27:22.240]         if (!identical(...future.workdir, getwd())) 
[17:27:22.240]             setwd(...future.workdir)
[17:27:22.240]         {
[17:27:22.240]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.240]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.240]             }
[17:27:22.240]             base::options(...future.oldOptions)
[17:27:22.240]             if (.Platform$OS.type == "windows") {
[17:27:22.240]                 old_names <- names(...future.oldEnvVars)
[17:27:22.240]                 envs <- base::Sys.getenv()
[17:27:22.240]                 names <- names(envs)
[17:27:22.240]                 common <- intersect(names, old_names)
[17:27:22.240]                 added <- setdiff(names, old_names)
[17:27:22.240]                 removed <- setdiff(old_names, names)
[17:27:22.240]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.240]                   envs[common]]
[17:27:22.240]                 NAMES <- toupper(changed)
[17:27:22.240]                 args <- list()
[17:27:22.240]                 for (kk in seq_along(NAMES)) {
[17:27:22.240]                   name <- changed[[kk]]
[17:27:22.240]                   NAME <- NAMES[[kk]]
[17:27:22.240]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.240]                     next
[17:27:22.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.240]                 }
[17:27:22.240]                 NAMES <- toupper(added)
[17:27:22.240]                 for (kk in seq_along(NAMES)) {
[17:27:22.240]                   name <- added[[kk]]
[17:27:22.240]                   NAME <- NAMES[[kk]]
[17:27:22.240]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.240]                     next
[17:27:22.240]                   args[[name]] <- ""
[17:27:22.240]                 }
[17:27:22.240]                 NAMES <- toupper(removed)
[17:27:22.240]                 for (kk in seq_along(NAMES)) {
[17:27:22.240]                   name <- removed[[kk]]
[17:27:22.240]                   NAME <- NAMES[[kk]]
[17:27:22.240]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.240]                     next
[17:27:22.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.240]                 }
[17:27:22.240]                 if (length(args) > 0) 
[17:27:22.240]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.240]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.240]             }
[17:27:22.240]             else {
[17:27:22.240]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.240]             }
[17:27:22.240]             {
[17:27:22.240]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.240]                   0L) {
[17:27:22.240]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.240]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.240]                   base::options(opts)
[17:27:22.240]                 }
[17:27:22.240]                 {
[17:27:22.240]                   {
[17:27:22.240]                     NULL
[17:27:22.240]                     RNGkind("Mersenne-Twister")
[17:27:22.240]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.240]                       inherits = FALSE)
[17:27:22.240]                   }
[17:27:22.240]                   options(future.plan = NULL)
[17:27:22.240]                   if (is.na(NA_character_)) 
[17:27:22.240]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.240]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.240]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.240]                     .init = FALSE)
[17:27:22.240]                 }
[17:27:22.240]             }
[17:27:22.240]         }
[17:27:22.240]     })
[17:27:22.240]     if (TRUE) {
[17:27:22.240]         base::sink(type = "output", split = FALSE)
[17:27:22.240]         if (TRUE) {
[17:27:22.240]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.240]         }
[17:27:22.240]         else {
[17:27:22.240]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.240]         }
[17:27:22.240]         base::close(...future.stdout)
[17:27:22.240]         ...future.stdout <- NULL
[17:27:22.240]     }
[17:27:22.240]     ...future.result$conditions <- ...future.conditions
[17:27:22.240]     ...future.result$finished <- base::Sys.time()
[17:27:22.240]     ...future.result
[17:27:22.240] }
[17:27:22.249] plan(): Setting new future strategy stack:
[17:27:22.249] List of future strategies:
[17:27:22.249] 1. sequential:
[17:27:22.249]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.249]    - tweaked: FALSE
[17:27:22.249]    - call: NULL
[17:27:22.250] plan(): nbrOfWorkers() = 1
[17:27:22.256] plan(): Setting new future strategy stack:
[17:27:22.257] List of future strategies:
[17:27:22.257] 1. sequential:
[17:27:22.257]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.257]    - tweaked: FALSE
[17:27:22.257]    - call: plan(strategy)
[17:27:22.258] plan(): nbrOfWorkers() = 1
[17:27:22.259] SequentialFuture started (and completed)
[17:27:22.259] - Launch lazy future ... done
[17:27:22.259] run() for 'SequentialFuture' ... done
** Collecting results
v1 = 1
v2 = 2
Warning in sprintf(...) : restarting interrupted promise evaluation
[17:27:22.263] signalConditions() ...
[17:27:22.263]  - include = 'immediateCondition'
[17:27:22.264]  - exclude = 
[17:27:22.264]  - resignal = FALSE
[17:27:22.264]  - Number of conditions: 1
[17:27:22.265] signalConditions() ... done
[17:27:22.265] Future state: 'finished'
[17:27:22.266] signalConditions() ...
[17:27:22.266]  - include = 'condition'
[17:27:22.266]  - exclude = 'immediateCondition'
[17:27:22.267]  - resignal = TRUE
[17:27:22.267]  - Number of conditions: 1
[17:27:22.267]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:22.268] signalConditions() ... done
v3: <simpleError> (as expect)
Processing: .......... [100%]
v4 = 4
** Left-to-right and right-to-left future assignments
[17:27:22.269] getGlobalsAndPackages() ...
[17:27:22.269] Searching for globals...
[17:27:22.270] 
[17:27:22.270] Searching for globals ... DONE
[17:27:22.271] - globals: [0] <none>
[17:27:22.271] getGlobalsAndPackages() ... DONE
[17:27:22.272] run() for 'Future' ...
[17:27:22.272] - state: 'created'
[17:27:22.273] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.273] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.274] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.274]   - Field: 'label'
[17:27:22.275]   - Field: 'local'
[17:27:22.275]   - Field: 'owner'
[17:27:22.275]   - Field: 'envir'
[17:27:22.276]   - Field: 'packages'
[17:27:22.276]   - Field: 'gc'
[17:27:22.277]   - Field: 'conditions'
[17:27:22.277]   - Field: 'expr'
[17:27:22.277]   - Field: 'uuid'
[17:27:22.278]   - Field: 'seed'
[17:27:22.278]   - Field: 'version'
[17:27:22.278]   - Field: 'result'
[17:27:22.279]   - Field: 'asynchronous'
[17:27:22.279]   - Field: 'calls'
[17:27:22.280]   - Field: 'globals'
[17:27:22.280]   - Field: 'stdout'
[17:27:22.280]   - Field: 'earlySignal'
[17:27:22.281]   - Field: 'lazy'
[17:27:22.281]   - Field: 'state'
[17:27:22.282] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.282] - Launch lazy future ...
[17:27:22.282] Packages needed by the future expression (n = 0): <none>
[17:27:22.283] Packages needed by future strategies (n = 0): <none>
[17:27:22.284] {
[17:27:22.284]     {
[17:27:22.284]         {
[17:27:22.284]             ...future.startTime <- base::Sys.time()
[17:27:22.284]             {
[17:27:22.284]                 {
[17:27:22.284]                   {
[17:27:22.284]                     base::local({
[17:27:22.284]                       has_future <- base::requireNamespace("future", 
[17:27:22.284]                         quietly = TRUE)
[17:27:22.284]                       if (has_future) {
[17:27:22.284]                         ns <- base::getNamespace("future")
[17:27:22.284]                         version <- ns[[".package"]][["version"]]
[17:27:22.284]                         if (is.null(version)) 
[17:27:22.284]                           version <- utils::packageVersion("future")
[17:27:22.284]                       }
[17:27:22.284]                       else {
[17:27:22.284]                         version <- NULL
[17:27:22.284]                       }
[17:27:22.284]                       if (!has_future || version < "1.8.0") {
[17:27:22.284]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.284]                           "", base::R.version$version.string), 
[17:27:22.284]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.284]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.284]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.284]                             "release", "version")], collapse = " "), 
[17:27:22.284]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.284]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.284]                           info)
[17:27:22.284]                         info <- base::paste(info, collapse = "; ")
[17:27:22.284]                         if (!has_future) {
[17:27:22.284]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.284]                             info)
[17:27:22.284]                         }
[17:27:22.284]                         else {
[17:27:22.284]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.284]                             info, version)
[17:27:22.284]                         }
[17:27:22.284]                         base::stop(msg)
[17:27:22.284]                       }
[17:27:22.284]                     })
[17:27:22.284]                   }
[17:27:22.284]                   ...future.strategy.old <- future::plan("list")
[17:27:22.284]                   options(future.plan = NULL)
[17:27:22.284]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.284]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.284]                 }
[17:27:22.284]                 ...future.workdir <- getwd()
[17:27:22.284]             }
[17:27:22.284]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.284]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.284]         }
[17:27:22.284]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.284]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.284]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.284]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.284]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.284]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.284]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.284]             base::names(...future.oldOptions))
[17:27:22.284]     }
[17:27:22.284]     if (FALSE) {
[17:27:22.284]     }
[17:27:22.284]     else {
[17:27:22.284]         if (TRUE) {
[17:27:22.284]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.284]                 open = "w")
[17:27:22.284]         }
[17:27:22.284]         else {
[17:27:22.284]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.284]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.284]         }
[17:27:22.284]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.284]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.284]             base::sink(type = "output", split = FALSE)
[17:27:22.284]             base::close(...future.stdout)
[17:27:22.284]         }, add = TRUE)
[17:27:22.284]     }
[17:27:22.284]     ...future.frame <- base::sys.nframe()
[17:27:22.284]     ...future.conditions <- base::list()
[17:27:22.284]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.284]     if (FALSE) {
[17:27:22.284]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.284]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.284]     }
[17:27:22.284]     ...future.result <- base::tryCatch({
[17:27:22.284]         base::withCallingHandlers({
[17:27:22.284]             ...future.value <- base::withVisible(base::local(1))
[17:27:22.284]             future::FutureResult(value = ...future.value$value, 
[17:27:22.284]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.284]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.284]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.284]                     ...future.globalenv.names))
[17:27:22.284]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.284]         }, condition = base::local({
[17:27:22.284]             c <- base::c
[17:27:22.284]             inherits <- base::inherits
[17:27:22.284]             invokeRestart <- base::invokeRestart
[17:27:22.284]             length <- base::length
[17:27:22.284]             list <- base::list
[17:27:22.284]             seq.int <- base::seq.int
[17:27:22.284]             signalCondition <- base::signalCondition
[17:27:22.284]             sys.calls <- base::sys.calls
[17:27:22.284]             `[[` <- base::`[[`
[17:27:22.284]             `+` <- base::`+`
[17:27:22.284]             `<<-` <- base::`<<-`
[17:27:22.284]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.284]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.284]                   3L)]
[17:27:22.284]             }
[17:27:22.284]             function(cond) {
[17:27:22.284]                 is_error <- inherits(cond, "error")
[17:27:22.284]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.284]                   NULL)
[17:27:22.284]                 if (is_error) {
[17:27:22.284]                   sessionInformation <- function() {
[17:27:22.284]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.284]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.284]                       search = base::search(), system = base::Sys.info())
[17:27:22.284]                   }
[17:27:22.284]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.284]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.284]                     cond$call), session = sessionInformation(), 
[17:27:22.284]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.284]                   signalCondition(cond)
[17:27:22.284]                 }
[17:27:22.284]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.284]                 "immediateCondition"))) {
[17:27:22.284]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.284]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.284]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.284]                   if (TRUE && !signal) {
[17:27:22.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.284]                     {
[17:27:22.284]                       inherits <- base::inherits
[17:27:22.284]                       invokeRestart <- base::invokeRestart
[17:27:22.284]                       is.null <- base::is.null
[17:27:22.284]                       muffled <- FALSE
[17:27:22.284]                       if (inherits(cond, "message")) {
[17:27:22.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.284]                         if (muffled) 
[17:27:22.284]                           invokeRestart("muffleMessage")
[17:27:22.284]                       }
[17:27:22.284]                       else if (inherits(cond, "warning")) {
[17:27:22.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.284]                         if (muffled) 
[17:27:22.284]                           invokeRestart("muffleWarning")
[17:27:22.284]                       }
[17:27:22.284]                       else if (inherits(cond, "condition")) {
[17:27:22.284]                         if (!is.null(pattern)) {
[17:27:22.284]                           computeRestarts <- base::computeRestarts
[17:27:22.284]                           grepl <- base::grepl
[17:27:22.284]                           restarts <- computeRestarts(cond)
[17:27:22.284]                           for (restart in restarts) {
[17:27:22.284]                             name <- restart$name
[17:27:22.284]                             if (is.null(name)) 
[17:27:22.284]                               next
[17:27:22.284]                             if (!grepl(pattern, name)) 
[17:27:22.284]                               next
[17:27:22.284]                             invokeRestart(restart)
[17:27:22.284]                             muffled <- TRUE
[17:27:22.284]                             break
[17:27:22.284]                           }
[17:27:22.284]                         }
[17:27:22.284]                       }
[17:27:22.284]                       invisible(muffled)
[17:27:22.284]                     }
[17:27:22.284]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.284]                   }
[17:27:22.284]                 }
[17:27:22.284]                 else {
[17:27:22.284]                   if (TRUE) {
[17:27:22.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.284]                     {
[17:27:22.284]                       inherits <- base::inherits
[17:27:22.284]                       invokeRestart <- base::invokeRestart
[17:27:22.284]                       is.null <- base::is.null
[17:27:22.284]                       muffled <- FALSE
[17:27:22.284]                       if (inherits(cond, "message")) {
[17:27:22.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.284]                         if (muffled) 
[17:27:22.284]                           invokeRestart("muffleMessage")
[17:27:22.284]                       }
[17:27:22.284]                       else if (inherits(cond, "warning")) {
[17:27:22.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.284]                         if (muffled) 
[17:27:22.284]                           invokeRestart("muffleWarning")
[17:27:22.284]                       }
[17:27:22.284]                       else if (inherits(cond, "condition")) {
[17:27:22.284]                         if (!is.null(pattern)) {
[17:27:22.284]                           computeRestarts <- base::computeRestarts
[17:27:22.284]                           grepl <- base::grepl
[17:27:22.284]                           restarts <- computeRestarts(cond)
[17:27:22.284]                           for (restart in restarts) {
[17:27:22.284]                             name <- restart$name
[17:27:22.284]                             if (is.null(name)) 
[17:27:22.284]                               next
[17:27:22.284]                             if (!grepl(pattern, name)) 
[17:27:22.284]                               next
[17:27:22.284]                             invokeRestart(restart)
[17:27:22.284]                             muffled <- TRUE
[17:27:22.284]                             break
[17:27:22.284]                           }
[17:27:22.284]                         }
[17:27:22.284]                       }
[17:27:22.284]                       invisible(muffled)
[17:27:22.284]                     }
[17:27:22.284]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.284]                   }
[17:27:22.284]                 }
[17:27:22.284]             }
[17:27:22.284]         }))
[17:27:22.284]     }, error = function(ex) {
[17:27:22.284]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.284]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.284]                 ...future.rng), started = ...future.startTime, 
[17:27:22.284]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.284]             version = "1.8"), class = "FutureResult")
[17:27:22.284]     }, finally = {
[17:27:22.284]         if (!identical(...future.workdir, getwd())) 
[17:27:22.284]             setwd(...future.workdir)
[17:27:22.284]         {
[17:27:22.284]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.284]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.284]             }
[17:27:22.284]             base::options(...future.oldOptions)
[17:27:22.284]             if (.Platform$OS.type == "windows") {
[17:27:22.284]                 old_names <- names(...future.oldEnvVars)
[17:27:22.284]                 envs <- base::Sys.getenv()
[17:27:22.284]                 names <- names(envs)
[17:27:22.284]                 common <- intersect(names, old_names)
[17:27:22.284]                 added <- setdiff(names, old_names)
[17:27:22.284]                 removed <- setdiff(old_names, names)
[17:27:22.284]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.284]                   envs[common]]
[17:27:22.284]                 NAMES <- toupper(changed)
[17:27:22.284]                 args <- list()
[17:27:22.284]                 for (kk in seq_along(NAMES)) {
[17:27:22.284]                   name <- changed[[kk]]
[17:27:22.284]                   NAME <- NAMES[[kk]]
[17:27:22.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.284]                     next
[17:27:22.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.284]                 }
[17:27:22.284]                 NAMES <- toupper(added)
[17:27:22.284]                 for (kk in seq_along(NAMES)) {
[17:27:22.284]                   name <- added[[kk]]
[17:27:22.284]                   NAME <- NAMES[[kk]]
[17:27:22.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.284]                     next
[17:27:22.284]                   args[[name]] <- ""
[17:27:22.284]                 }
[17:27:22.284]                 NAMES <- toupper(removed)
[17:27:22.284]                 for (kk in seq_along(NAMES)) {
[17:27:22.284]                   name <- removed[[kk]]
[17:27:22.284]                   NAME <- NAMES[[kk]]
[17:27:22.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.284]                     next
[17:27:22.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.284]                 }
[17:27:22.284]                 if (length(args) > 0) 
[17:27:22.284]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.284]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.284]             }
[17:27:22.284]             else {
[17:27:22.284]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.284]             }
[17:27:22.284]             {
[17:27:22.284]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.284]                   0L) {
[17:27:22.284]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.284]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.284]                   base::options(opts)
[17:27:22.284]                 }
[17:27:22.284]                 {
[17:27:22.284]                   {
[17:27:22.284]                     NULL
[17:27:22.284]                     RNGkind("Mersenne-Twister")
[17:27:22.284]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.284]                       inherits = FALSE)
[17:27:22.284]                   }
[17:27:22.284]                   options(future.plan = NULL)
[17:27:22.284]                   if (is.na(NA_character_)) 
[17:27:22.284]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.284]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.284]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.284]                     .init = FALSE)
[17:27:22.284]                 }
[17:27:22.284]             }
[17:27:22.284]         }
[17:27:22.284]     })
[17:27:22.284]     if (TRUE) {
[17:27:22.284]         base::sink(type = "output", split = FALSE)
[17:27:22.284]         if (TRUE) {
[17:27:22.284]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.284]         }
[17:27:22.284]         else {
[17:27:22.284]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.284]         }
[17:27:22.284]         base::close(...future.stdout)
[17:27:22.284]         ...future.stdout <- NULL
[17:27:22.284]     }
[17:27:22.284]     ...future.result$conditions <- ...future.conditions
[17:27:22.284]     ...future.result$finished <- base::Sys.time()
[17:27:22.284]     ...future.result
[17:27:22.284] }
[17:27:22.292] plan(): Setting new future strategy stack:
[17:27:22.292] List of future strategies:
[17:27:22.292] 1. sequential:
[17:27:22.292]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.292]    - tweaked: FALSE
[17:27:22.292]    - call: NULL
[17:27:22.294] plan(): nbrOfWorkers() = 1
[17:27:22.296] plan(): Setting new future strategy stack:
[17:27:22.296] List of future strategies:
[17:27:22.296] 1. sequential:
[17:27:22.296]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.296]    - tweaked: FALSE
[17:27:22.296]    - call: plan(strategy)
[17:27:22.298] plan(): nbrOfWorkers() = 1
[17:27:22.298] SequentialFuture started (and completed)
[17:27:22.299] - Launch lazy future ... done
[17:27:22.299] run() for 'SequentialFuture' ... done
c = 1
[17:27:22.300] getGlobalsAndPackages() ...
[17:27:22.300] Searching for globals...
[17:27:22.301] 
[17:27:22.302] Searching for globals ... DONE
[17:27:22.302] - globals: [0] <none>
[17:27:22.302] getGlobalsAndPackages() ... DONE
[17:27:22.303] run() for 'Future' ...
[17:27:22.303] - state: 'created'
[17:27:22.304] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.304] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.305] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.305]   - Field: 'label'
[17:27:22.306]   - Field: 'local'
[17:27:22.306]   - Field: 'owner'
[17:27:22.306]   - Field: 'envir'
[17:27:22.307]   - Field: 'packages'
[17:27:22.307]   - Field: 'gc'
[17:27:22.307]   - Field: 'conditions'
[17:27:22.308]   - Field: 'expr'
[17:27:22.308]   - Field: 'uuid'
[17:27:22.309]   - Field: 'seed'
[17:27:22.309]   - Field: 'version'
[17:27:22.309]   - Field: 'result'
[17:27:22.310]   - Field: 'asynchronous'
[17:27:22.310]   - Field: 'calls'
[17:27:22.310]   - Field: 'globals'
[17:27:22.311]   - Field: 'stdout'
[17:27:22.311]   - Field: 'earlySignal'
[17:27:22.312]   - Field: 'lazy'
[17:27:22.312]   - Field: 'state'
[17:27:22.312] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.313] - Launch lazy future ...
[17:27:22.313] Packages needed by the future expression (n = 0): <none>
[17:27:22.314] Packages needed by future strategies (n = 0): <none>
[17:27:22.315] {
[17:27:22.315]     {
[17:27:22.315]         {
[17:27:22.315]             ...future.startTime <- base::Sys.time()
[17:27:22.315]             {
[17:27:22.315]                 {
[17:27:22.315]                   {
[17:27:22.315]                     base::local({
[17:27:22.315]                       has_future <- base::requireNamespace("future", 
[17:27:22.315]                         quietly = TRUE)
[17:27:22.315]                       if (has_future) {
[17:27:22.315]                         ns <- base::getNamespace("future")
[17:27:22.315]                         version <- ns[[".package"]][["version"]]
[17:27:22.315]                         if (is.null(version)) 
[17:27:22.315]                           version <- utils::packageVersion("future")
[17:27:22.315]                       }
[17:27:22.315]                       else {
[17:27:22.315]                         version <- NULL
[17:27:22.315]                       }
[17:27:22.315]                       if (!has_future || version < "1.8.0") {
[17:27:22.315]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.315]                           "", base::R.version$version.string), 
[17:27:22.315]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.315]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.315]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.315]                             "release", "version")], collapse = " "), 
[17:27:22.315]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.315]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.315]                           info)
[17:27:22.315]                         info <- base::paste(info, collapse = "; ")
[17:27:22.315]                         if (!has_future) {
[17:27:22.315]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.315]                             info)
[17:27:22.315]                         }
[17:27:22.315]                         else {
[17:27:22.315]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.315]                             info, version)
[17:27:22.315]                         }
[17:27:22.315]                         base::stop(msg)
[17:27:22.315]                       }
[17:27:22.315]                     })
[17:27:22.315]                   }
[17:27:22.315]                   ...future.strategy.old <- future::plan("list")
[17:27:22.315]                   options(future.plan = NULL)
[17:27:22.315]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.315]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.315]                 }
[17:27:22.315]                 ...future.workdir <- getwd()
[17:27:22.315]             }
[17:27:22.315]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.315]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.315]         }
[17:27:22.315]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.315]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.315]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.315]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.315]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.315]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.315]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.315]             base::names(...future.oldOptions))
[17:27:22.315]     }
[17:27:22.315]     if (FALSE) {
[17:27:22.315]     }
[17:27:22.315]     else {
[17:27:22.315]         if (TRUE) {
[17:27:22.315]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.315]                 open = "w")
[17:27:22.315]         }
[17:27:22.315]         else {
[17:27:22.315]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.315]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.315]         }
[17:27:22.315]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.315]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.315]             base::sink(type = "output", split = FALSE)
[17:27:22.315]             base::close(...future.stdout)
[17:27:22.315]         }, add = TRUE)
[17:27:22.315]     }
[17:27:22.315]     ...future.frame <- base::sys.nframe()
[17:27:22.315]     ...future.conditions <- base::list()
[17:27:22.315]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.315]     if (FALSE) {
[17:27:22.315]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.315]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.315]     }
[17:27:22.315]     ...future.result <- base::tryCatch({
[17:27:22.315]         base::withCallingHandlers({
[17:27:22.315]             ...future.value <- base::withVisible(base::local(1))
[17:27:22.315]             future::FutureResult(value = ...future.value$value, 
[17:27:22.315]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.315]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.315]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.315]                     ...future.globalenv.names))
[17:27:22.315]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.315]         }, condition = base::local({
[17:27:22.315]             c <- base::c
[17:27:22.315]             inherits <- base::inherits
[17:27:22.315]             invokeRestart <- base::invokeRestart
[17:27:22.315]             length <- base::length
[17:27:22.315]             list <- base::list
[17:27:22.315]             seq.int <- base::seq.int
[17:27:22.315]             signalCondition <- base::signalCondition
[17:27:22.315]             sys.calls <- base::sys.calls
[17:27:22.315]             `[[` <- base::`[[`
[17:27:22.315]             `+` <- base::`+`
[17:27:22.315]             `<<-` <- base::`<<-`
[17:27:22.315]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.315]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.315]                   3L)]
[17:27:22.315]             }
[17:27:22.315]             function(cond) {
[17:27:22.315]                 is_error <- inherits(cond, "error")
[17:27:22.315]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.315]                   NULL)
[17:27:22.315]                 if (is_error) {
[17:27:22.315]                   sessionInformation <- function() {
[17:27:22.315]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.315]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.315]                       search = base::search(), system = base::Sys.info())
[17:27:22.315]                   }
[17:27:22.315]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.315]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.315]                     cond$call), session = sessionInformation(), 
[17:27:22.315]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.315]                   signalCondition(cond)
[17:27:22.315]                 }
[17:27:22.315]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.315]                 "immediateCondition"))) {
[17:27:22.315]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.315]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.315]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.315]                   if (TRUE && !signal) {
[17:27:22.315]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.315]                     {
[17:27:22.315]                       inherits <- base::inherits
[17:27:22.315]                       invokeRestart <- base::invokeRestart
[17:27:22.315]                       is.null <- base::is.null
[17:27:22.315]                       muffled <- FALSE
[17:27:22.315]                       if (inherits(cond, "message")) {
[17:27:22.315]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.315]                         if (muffled) 
[17:27:22.315]                           invokeRestart("muffleMessage")
[17:27:22.315]                       }
[17:27:22.315]                       else if (inherits(cond, "warning")) {
[17:27:22.315]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.315]                         if (muffled) 
[17:27:22.315]                           invokeRestart("muffleWarning")
[17:27:22.315]                       }
[17:27:22.315]                       else if (inherits(cond, "condition")) {
[17:27:22.315]                         if (!is.null(pattern)) {
[17:27:22.315]                           computeRestarts <- base::computeRestarts
[17:27:22.315]                           grepl <- base::grepl
[17:27:22.315]                           restarts <- computeRestarts(cond)
[17:27:22.315]                           for (restart in restarts) {
[17:27:22.315]                             name <- restart$name
[17:27:22.315]                             if (is.null(name)) 
[17:27:22.315]                               next
[17:27:22.315]                             if (!grepl(pattern, name)) 
[17:27:22.315]                               next
[17:27:22.315]                             invokeRestart(restart)
[17:27:22.315]                             muffled <- TRUE
[17:27:22.315]                             break
[17:27:22.315]                           }
[17:27:22.315]                         }
[17:27:22.315]                       }
[17:27:22.315]                       invisible(muffled)
[17:27:22.315]                     }
[17:27:22.315]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.315]                   }
[17:27:22.315]                 }
[17:27:22.315]                 else {
[17:27:22.315]                   if (TRUE) {
[17:27:22.315]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.315]                     {
[17:27:22.315]                       inherits <- base::inherits
[17:27:22.315]                       invokeRestart <- base::invokeRestart
[17:27:22.315]                       is.null <- base::is.null
[17:27:22.315]                       muffled <- FALSE
[17:27:22.315]                       if (inherits(cond, "message")) {
[17:27:22.315]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.315]                         if (muffled) 
[17:27:22.315]                           invokeRestart("muffleMessage")
[17:27:22.315]                       }
[17:27:22.315]                       else if (inherits(cond, "warning")) {
[17:27:22.315]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.315]                         if (muffled) 
[17:27:22.315]                           invokeRestart("muffleWarning")
[17:27:22.315]                       }
[17:27:22.315]                       else if (inherits(cond, "condition")) {
[17:27:22.315]                         if (!is.null(pattern)) {
[17:27:22.315]                           computeRestarts <- base::computeRestarts
[17:27:22.315]                           grepl <- base::grepl
[17:27:22.315]                           restarts <- computeRestarts(cond)
[17:27:22.315]                           for (restart in restarts) {
[17:27:22.315]                             name <- restart$name
[17:27:22.315]                             if (is.null(name)) 
[17:27:22.315]                               next
[17:27:22.315]                             if (!grepl(pattern, name)) 
[17:27:22.315]                               next
[17:27:22.315]                             invokeRestart(restart)
[17:27:22.315]                             muffled <- TRUE
[17:27:22.315]                             break
[17:27:22.315]                           }
[17:27:22.315]                         }
[17:27:22.315]                       }
[17:27:22.315]                       invisible(muffled)
[17:27:22.315]                     }
[17:27:22.315]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.315]                   }
[17:27:22.315]                 }
[17:27:22.315]             }
[17:27:22.315]         }))
[17:27:22.315]     }, error = function(ex) {
[17:27:22.315]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.315]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.315]                 ...future.rng), started = ...future.startTime, 
[17:27:22.315]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.315]             version = "1.8"), class = "FutureResult")
[17:27:22.315]     }, finally = {
[17:27:22.315]         if (!identical(...future.workdir, getwd())) 
[17:27:22.315]             setwd(...future.workdir)
[17:27:22.315]         {
[17:27:22.315]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.315]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.315]             }
[17:27:22.315]             base::options(...future.oldOptions)
[17:27:22.315]             if (.Platform$OS.type == "windows") {
[17:27:22.315]                 old_names <- names(...future.oldEnvVars)
[17:27:22.315]                 envs <- base::Sys.getenv()
[17:27:22.315]                 names <- names(envs)
[17:27:22.315]                 common <- intersect(names, old_names)
[17:27:22.315]                 added <- setdiff(names, old_names)
[17:27:22.315]                 removed <- setdiff(old_names, names)
[17:27:22.315]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.315]                   envs[common]]
[17:27:22.315]                 NAMES <- toupper(changed)
[17:27:22.315]                 args <- list()
[17:27:22.315]                 for (kk in seq_along(NAMES)) {
[17:27:22.315]                   name <- changed[[kk]]
[17:27:22.315]                   NAME <- NAMES[[kk]]
[17:27:22.315]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.315]                     next
[17:27:22.315]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.315]                 }
[17:27:22.315]                 NAMES <- toupper(added)
[17:27:22.315]                 for (kk in seq_along(NAMES)) {
[17:27:22.315]                   name <- added[[kk]]
[17:27:22.315]                   NAME <- NAMES[[kk]]
[17:27:22.315]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.315]                     next
[17:27:22.315]                   args[[name]] <- ""
[17:27:22.315]                 }
[17:27:22.315]                 NAMES <- toupper(removed)
[17:27:22.315]                 for (kk in seq_along(NAMES)) {
[17:27:22.315]                   name <- removed[[kk]]
[17:27:22.315]                   NAME <- NAMES[[kk]]
[17:27:22.315]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.315]                     next
[17:27:22.315]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.315]                 }
[17:27:22.315]                 if (length(args) > 0) 
[17:27:22.315]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.315]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.315]             }
[17:27:22.315]             else {
[17:27:22.315]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.315]             }
[17:27:22.315]             {
[17:27:22.315]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.315]                   0L) {
[17:27:22.315]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.315]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.315]                   base::options(opts)
[17:27:22.315]                 }
[17:27:22.315]                 {
[17:27:22.315]                   {
[17:27:22.315]                     NULL
[17:27:22.315]                     RNGkind("Mersenne-Twister")
[17:27:22.315]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.315]                       inherits = FALSE)
[17:27:22.315]                   }
[17:27:22.315]                   options(future.plan = NULL)
[17:27:22.315]                   if (is.na(NA_character_)) 
[17:27:22.315]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.315]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.315]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.315]                     .init = FALSE)
[17:27:22.315]                 }
[17:27:22.315]             }
[17:27:22.315]         }
[17:27:22.315]     })
[17:27:22.315]     if (TRUE) {
[17:27:22.315]         base::sink(type = "output", split = FALSE)
[17:27:22.315]         if (TRUE) {
[17:27:22.315]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.315]         }
[17:27:22.315]         else {
[17:27:22.315]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.315]         }
[17:27:22.315]         base::close(...future.stdout)
[17:27:22.315]         ...future.stdout <- NULL
[17:27:22.315]     }
[17:27:22.315]     ...future.result$conditions <- ...future.conditions
[17:27:22.315]     ...future.result$finished <- base::Sys.time()
[17:27:22.315]     ...future.result
[17:27:22.315] }
[17:27:22.323] plan(): Setting new future strategy stack:
[17:27:22.324] List of future strategies:
[17:27:22.324] 1. sequential:
[17:27:22.324]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.324]    - tweaked: FALSE
[17:27:22.324]    - call: NULL
[17:27:22.325] plan(): nbrOfWorkers() = 1
[17:27:22.327] plan(): Setting new future strategy stack:
[17:27:22.328] List of future strategies:
[17:27:22.328] 1. sequential:
[17:27:22.328]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.328]    - tweaked: FALSE
[17:27:22.328]    - call: plan(strategy)
[17:27:22.332] plan(): nbrOfWorkers() = 1
[17:27:22.332] SequentialFuture started (and completed)
[17:27:22.332] - Launch lazy future ... done
[17:27:22.333] run() for 'SequentialFuture' ... done
d = 1
** Nested future assignments
[17:27:22.333] getGlobalsAndPackages() ...
[17:27:22.334] Searching for globals...
[17:27:22.341] - globals found: [5] '{', '<-', '%<-%', '%->%', '+'
[17:27:22.341] Searching for globals ... DONE
[17:27:22.342] Resolving globals: FALSE
[17:27:22.342] 
[17:27:22.343] - packages: [1] 'future'
[17:27:22.343] getGlobalsAndPackages() ... DONE
[17:27:22.343] run() for 'Future' ...
[17:27:22.344] - state: 'created'
[17:27:22.344] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.344] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.345] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.345]   - Field: 'label'
[17:27:22.346]   - Field: 'local'
[17:27:22.346]   - Field: 'owner'
[17:27:22.346]   - Field: 'envir'
[17:27:22.347]   - Field: 'packages'
[17:27:22.347]   - Field: 'gc'
[17:27:22.347]   - Field: 'conditions'
[17:27:22.348]   - Field: 'expr'
[17:27:22.348]   - Field: 'uuid'
[17:27:22.348]   - Field: 'seed'
[17:27:22.349]   - Field: 'version'
[17:27:22.349]   - Field: 'result'
[17:27:22.349]   - Field: 'asynchronous'
[17:27:22.349]   - Field: 'calls'
[17:27:22.350]   - Field: 'globals'
[17:27:22.350]   - Field: 'stdout'
[17:27:22.351]   - Field: 'earlySignal'
[17:27:22.351]   - Field: 'lazy'
[17:27:22.352]   - Field: 'state'
[17:27:22.352] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.352] - Launch lazy future ...
[17:27:22.353] Packages needed by the future expression (n = 1): 'future'
[17:27:22.353] Packages needed by future strategies (n = 0): <none>
[17:27:22.354] {
[17:27:22.354]     {
[17:27:22.354]         {
[17:27:22.354]             ...future.startTime <- base::Sys.time()
[17:27:22.354]             {
[17:27:22.354]                 {
[17:27:22.354]                   {
[17:27:22.354]                     {
[17:27:22.354]                       base::local({
[17:27:22.354]                         has_future <- base::requireNamespace("future", 
[17:27:22.354]                           quietly = TRUE)
[17:27:22.354]                         if (has_future) {
[17:27:22.354]                           ns <- base::getNamespace("future")
[17:27:22.354]                           version <- ns[[".package"]][["version"]]
[17:27:22.354]                           if (is.null(version)) 
[17:27:22.354]                             version <- utils::packageVersion("future")
[17:27:22.354]                         }
[17:27:22.354]                         else {
[17:27:22.354]                           version <- NULL
[17:27:22.354]                         }
[17:27:22.354]                         if (!has_future || version < "1.8.0") {
[17:27:22.354]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.354]                             "", base::R.version$version.string), 
[17:27:22.354]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:22.354]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.354]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.354]                               "release", "version")], collapse = " "), 
[17:27:22.354]                             hostname = base::Sys.info()[["nodename"]])
[17:27:22.354]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.354]                             info)
[17:27:22.354]                           info <- base::paste(info, collapse = "; ")
[17:27:22.354]                           if (!has_future) {
[17:27:22.354]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.354]                               info)
[17:27:22.354]                           }
[17:27:22.354]                           else {
[17:27:22.354]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.354]                               info, version)
[17:27:22.354]                           }
[17:27:22.354]                           base::stop(msg)
[17:27:22.354]                         }
[17:27:22.354]                       })
[17:27:22.354]                     }
[17:27:22.354]                     base::local({
[17:27:22.354]                       for (pkg in "future") {
[17:27:22.354]                         base::loadNamespace(pkg)
[17:27:22.354]                         base::library(pkg, character.only = TRUE)
[17:27:22.354]                       }
[17:27:22.354]                     })
[17:27:22.354]                   }
[17:27:22.354]                   ...future.strategy.old <- future::plan("list")
[17:27:22.354]                   options(future.plan = NULL)
[17:27:22.354]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.354]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.354]                 }
[17:27:22.354]                 ...future.workdir <- getwd()
[17:27:22.354]             }
[17:27:22.354]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.354]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.354]         }
[17:27:22.354]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.354]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.354]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.354]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.354]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.354]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.354]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.354]             base::names(...future.oldOptions))
[17:27:22.354]     }
[17:27:22.354]     if (FALSE) {
[17:27:22.354]     }
[17:27:22.354]     else {
[17:27:22.354]         if (TRUE) {
[17:27:22.354]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.354]                 open = "w")
[17:27:22.354]         }
[17:27:22.354]         else {
[17:27:22.354]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.354]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.354]         }
[17:27:22.354]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.354]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.354]             base::sink(type = "output", split = FALSE)
[17:27:22.354]             base::close(...future.stdout)
[17:27:22.354]         }, add = TRUE)
[17:27:22.354]     }
[17:27:22.354]     ...future.frame <- base::sys.nframe()
[17:27:22.354]     ...future.conditions <- base::list()
[17:27:22.354]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.354]     if (FALSE) {
[17:27:22.354]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.354]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.354]     }
[17:27:22.354]     ...future.result <- base::tryCatch({
[17:27:22.354]         base::withCallingHandlers({
[17:27:22.354]             ...future.value <- base::withVisible(base::local({
[17:27:22.354]                 b <- 1
[17:27:22.354]                 c %<-% 2
[17:27:22.354]                 d <- 3
[17:27:22.354]                 4 %->% e
[17:27:22.354]                 b + c + d + e
[17:27:22.354]             }))
[17:27:22.354]             future::FutureResult(value = ...future.value$value, 
[17:27:22.354]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.354]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.354]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.354]                     ...future.globalenv.names))
[17:27:22.354]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.354]         }, condition = base::local({
[17:27:22.354]             c <- base::c
[17:27:22.354]             inherits <- base::inherits
[17:27:22.354]             invokeRestart <- base::invokeRestart
[17:27:22.354]             length <- base::length
[17:27:22.354]             list <- base::list
[17:27:22.354]             seq.int <- base::seq.int
[17:27:22.354]             signalCondition <- base::signalCondition
[17:27:22.354]             sys.calls <- base::sys.calls
[17:27:22.354]             `[[` <- base::`[[`
[17:27:22.354]             `+` <- base::`+`
[17:27:22.354]             `<<-` <- base::`<<-`
[17:27:22.354]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.354]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.354]                   3L)]
[17:27:22.354]             }
[17:27:22.354]             function(cond) {
[17:27:22.354]                 is_error <- inherits(cond, "error")
[17:27:22.354]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.354]                   NULL)
[17:27:22.354]                 if (is_error) {
[17:27:22.354]                   sessionInformation <- function() {
[17:27:22.354]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.354]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.354]                       search = base::search(), system = base::Sys.info())
[17:27:22.354]                   }
[17:27:22.354]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.354]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.354]                     cond$call), session = sessionInformation(), 
[17:27:22.354]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.354]                   signalCondition(cond)
[17:27:22.354]                 }
[17:27:22.354]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.354]                 "immediateCondition"))) {
[17:27:22.354]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.354]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.354]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.354]                   if (TRUE && !signal) {
[17:27:22.354]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.354]                     {
[17:27:22.354]                       inherits <- base::inherits
[17:27:22.354]                       invokeRestart <- base::invokeRestart
[17:27:22.354]                       is.null <- base::is.null
[17:27:22.354]                       muffled <- FALSE
[17:27:22.354]                       if (inherits(cond, "message")) {
[17:27:22.354]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.354]                         if (muffled) 
[17:27:22.354]                           invokeRestart("muffleMessage")
[17:27:22.354]                       }
[17:27:22.354]                       else if (inherits(cond, "warning")) {
[17:27:22.354]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.354]                         if (muffled) 
[17:27:22.354]                           invokeRestart("muffleWarning")
[17:27:22.354]                       }
[17:27:22.354]                       else if (inherits(cond, "condition")) {
[17:27:22.354]                         if (!is.null(pattern)) {
[17:27:22.354]                           computeRestarts <- base::computeRestarts
[17:27:22.354]                           grepl <- base::grepl
[17:27:22.354]                           restarts <- computeRestarts(cond)
[17:27:22.354]                           for (restart in restarts) {
[17:27:22.354]                             name <- restart$name
[17:27:22.354]                             if (is.null(name)) 
[17:27:22.354]                               next
[17:27:22.354]                             if (!grepl(pattern, name)) 
[17:27:22.354]                               next
[17:27:22.354]                             invokeRestart(restart)
[17:27:22.354]                             muffled <- TRUE
[17:27:22.354]                             break
[17:27:22.354]                           }
[17:27:22.354]                         }
[17:27:22.354]                       }
[17:27:22.354]                       invisible(muffled)
[17:27:22.354]                     }
[17:27:22.354]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.354]                   }
[17:27:22.354]                 }
[17:27:22.354]                 else {
[17:27:22.354]                   if (TRUE) {
[17:27:22.354]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.354]                     {
[17:27:22.354]                       inherits <- base::inherits
[17:27:22.354]                       invokeRestart <- base::invokeRestart
[17:27:22.354]                       is.null <- base::is.null
[17:27:22.354]                       muffled <- FALSE
[17:27:22.354]                       if (inherits(cond, "message")) {
[17:27:22.354]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.354]                         if (muffled) 
[17:27:22.354]                           invokeRestart("muffleMessage")
[17:27:22.354]                       }
[17:27:22.354]                       else if (inherits(cond, "warning")) {
[17:27:22.354]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.354]                         if (muffled) 
[17:27:22.354]                           invokeRestart("muffleWarning")
[17:27:22.354]                       }
[17:27:22.354]                       else if (inherits(cond, "condition")) {
[17:27:22.354]                         if (!is.null(pattern)) {
[17:27:22.354]                           computeRestarts <- base::computeRestarts
[17:27:22.354]                           grepl <- base::grepl
[17:27:22.354]                           restarts <- computeRestarts(cond)
[17:27:22.354]                           for (restart in restarts) {
[17:27:22.354]                             name <- restart$name
[17:27:22.354]                             if (is.null(name)) 
[17:27:22.354]                               next
[17:27:22.354]                             if (!grepl(pattern, name)) 
[17:27:22.354]                               next
[17:27:22.354]                             invokeRestart(restart)
[17:27:22.354]                             muffled <- TRUE
[17:27:22.354]                             break
[17:27:22.354]                           }
[17:27:22.354]                         }
[17:27:22.354]                       }
[17:27:22.354]                       invisible(muffled)
[17:27:22.354]                     }
[17:27:22.354]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.354]                   }
[17:27:22.354]                 }
[17:27:22.354]             }
[17:27:22.354]         }))
[17:27:22.354]     }, error = function(ex) {
[17:27:22.354]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.354]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.354]                 ...future.rng), started = ...future.startTime, 
[17:27:22.354]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.354]             version = "1.8"), class = "FutureResult")
[17:27:22.354]     }, finally = {
[17:27:22.354]         if (!identical(...future.workdir, getwd())) 
[17:27:22.354]             setwd(...future.workdir)
[17:27:22.354]         {
[17:27:22.354]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.354]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.354]             }
[17:27:22.354]             base::options(...future.oldOptions)
[17:27:22.354]             if (.Platform$OS.type == "windows") {
[17:27:22.354]                 old_names <- names(...future.oldEnvVars)
[17:27:22.354]                 envs <- base::Sys.getenv()
[17:27:22.354]                 names <- names(envs)
[17:27:22.354]                 common <- intersect(names, old_names)
[17:27:22.354]                 added <- setdiff(names, old_names)
[17:27:22.354]                 removed <- setdiff(old_names, names)
[17:27:22.354]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.354]                   envs[common]]
[17:27:22.354]                 NAMES <- toupper(changed)
[17:27:22.354]                 args <- list()
[17:27:22.354]                 for (kk in seq_along(NAMES)) {
[17:27:22.354]                   name <- changed[[kk]]
[17:27:22.354]                   NAME <- NAMES[[kk]]
[17:27:22.354]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.354]                     next
[17:27:22.354]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.354]                 }
[17:27:22.354]                 NAMES <- toupper(added)
[17:27:22.354]                 for (kk in seq_along(NAMES)) {
[17:27:22.354]                   name <- added[[kk]]
[17:27:22.354]                   NAME <- NAMES[[kk]]
[17:27:22.354]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.354]                     next
[17:27:22.354]                   args[[name]] <- ""
[17:27:22.354]                 }
[17:27:22.354]                 NAMES <- toupper(removed)
[17:27:22.354]                 for (kk in seq_along(NAMES)) {
[17:27:22.354]                   name <- removed[[kk]]
[17:27:22.354]                   NAME <- NAMES[[kk]]
[17:27:22.354]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.354]                     next
[17:27:22.354]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.354]                 }
[17:27:22.354]                 if (length(args) > 0) 
[17:27:22.354]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.354]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.354]             }
[17:27:22.354]             else {
[17:27:22.354]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.354]             }
[17:27:22.354]             {
[17:27:22.354]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.354]                   0L) {
[17:27:22.354]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.354]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.354]                   base::options(opts)
[17:27:22.354]                 }
[17:27:22.354]                 {
[17:27:22.354]                   {
[17:27:22.354]                     NULL
[17:27:22.354]                     RNGkind("Mersenne-Twister")
[17:27:22.354]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.354]                       inherits = FALSE)
[17:27:22.354]                   }
[17:27:22.354]                   options(future.plan = NULL)
[17:27:22.354]                   if (is.na(NA_character_)) 
[17:27:22.354]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.354]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.354]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.354]                     .init = FALSE)
[17:27:22.354]                 }
[17:27:22.354]             }
[17:27:22.354]         }
[17:27:22.354]     })
[17:27:22.354]     if (TRUE) {
[17:27:22.354]         base::sink(type = "output", split = FALSE)
[17:27:22.354]         if (TRUE) {
[17:27:22.354]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.354]         }
[17:27:22.354]         else {
[17:27:22.354]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.354]         }
[17:27:22.354]         base::close(...future.stdout)
[17:27:22.354]         ...future.stdout <- NULL
[17:27:22.354]     }
[17:27:22.354]     ...future.result$conditions <- ...future.conditions
[17:27:22.354]     ...future.result$finished <- base::Sys.time()
[17:27:22.354]     ...future.result
[17:27:22.354] }
[17:27:22.362] plan(): Setting new future strategy stack:
[17:27:22.362] List of future strategies:
[17:27:22.362] 1. sequential:
[17:27:22.362]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.362]    - tweaked: FALSE
[17:27:22.362]    - call: NULL
[17:27:22.363] plan(): nbrOfWorkers() = 1
[17:27:22.451] plan(): Setting new future strategy stack:
[17:27:22.452] List of future strategies:
[17:27:22.452] 1. sequential:
[17:27:22.452]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.452]    - tweaked: FALSE
[17:27:22.452]    - call: plan(strategy)
[17:27:22.452] plan(): nbrOfWorkers() = 1
[17:27:22.453] SequentialFuture started (and completed)
[17:27:22.453] signalConditions() ...
[17:27:22.453]  - include = 'immediateCondition'
[17:27:22.454]  - exclude = 
[17:27:22.454]  - resignal = FALSE
[17:27:22.454]  - Number of conditions: 88
[17:27:22.455] signalConditions() ... done
[17:27:22.455] - Launch lazy future ... done
[17:27:22.455] run() for 'SequentialFuture' ... done
[17:27:22.456] signalConditions() ...
[17:27:22.456]  - include = 'immediateCondition'
[17:27:22.457]  - exclude = 
[17:27:22.457]  - resignal = FALSE
[17:27:22.457]  - Number of conditions: 88
[17:27:22.458] signalConditions() ... done
[17:27:22.458] Future state: 'finished'
[17:27:22.458] signalConditions() ...
[17:27:22.459]  - include = 'condition'
[17:27:22.459]  - exclude = 'immediateCondition'
[17:27:22.459]  - resignal = TRUE
[17:27:22.459]  - Number of conditions: 88
[17:27:22.460]  - Condition #1: 'simpleMessage', 'message', 'condition'
[17:27:22.364] getGlobalsAndPackages() ...
[17:27:22.460]  - Condition #2: 'simpleMessage', 'message', 'condition'
[17:27:22.365] Searching for globals...
[17:27:22.460]  - Condition #3: 'simpleMessage', 'message', 'condition'
[17:27:22.395] 
[17:27:22.461]  - Condition #4: 'simpleMessage', 'message', 'condition'
[17:27:22.395] Searching for globals ... DONE
[17:27:22.461]  - Condition #5: 'simpleMessage', 'message', 'condition'
[17:27:22.396] - globals: [0] <none>
[17:27:22.461]  - Condition #6: 'simpleMessage', 'message', 'condition'
[17:27:22.396] getGlobalsAndPackages() ... DONE
[17:27:22.462]  - Condition #7: 'simpleMessage', 'message', 'condition'
[17:27:22.397] run() for 'Future' ...
[17:27:22.462]  - Condition #8: 'simpleMessage', 'message', 'condition'
[17:27:22.397] - state: 'created'
[17:27:22.466]  - Condition #9: 'simpleMessage', 'message', 'condition'
[17:27:22.397] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.467]  - Condition #10: 'simpleMessage', 'message', 'condition'
[17:27:22.398] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.467]  - Condition #11: 'simpleMessage', 'message', 'condition'
[17:27:22.398] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.468]  - Condition #12: 'simpleMessage', 'message', 'condition'
[17:27:22.398]   - Field: 'label'
[17:27:22.468]  - Condition #13: 'simpleMessage', 'message', 'condition'
[17:27:22.399]   - Field: 'local'
[17:27:22.469]  - Condition #14: 'simpleMessage', 'message', 'condition'
[17:27:22.399]   - Field: 'owner'
[17:27:22.469]  - Condition #15: 'simpleMessage', 'message', 'condition'
[17:27:22.399]   - Field: 'envir'
[17:27:22.469]  - Condition #16: 'simpleMessage', 'message', 'condition'
[17:27:22.400]   - Field: 'packages'
[17:27:22.470]  - Condition #17: 'simpleMessage', 'message', 'condition'
[17:27:22.400]   - Field: 'gc'
[17:27:22.470]  - Condition #18: 'simpleMessage', 'message', 'condition'
[17:27:22.400]   - Field: 'conditions'
[17:27:22.470]  - Condition #19: 'simpleMessage', 'message', 'condition'
[17:27:22.401]   - Field: 'expr'
[17:27:22.471]  - Condition #20: 'simpleMessage', 'message', 'condition'
[17:27:22.401]   - Field: 'uuid'
[17:27:22.471]  - Condition #21: 'simpleMessage', 'message', 'condition'
[17:27:22.401]   - Field: 'seed'
[17:27:22.471]  - Condition #22: 'simpleMessage', 'message', 'condition'
[17:27:22.402]   - Field: 'version'
[17:27:22.472]  - Condition #23: 'simpleMessage', 'message', 'condition'
[17:27:22.402]   - Field: 'result'
[17:27:22.472]  - Condition #24: 'simpleMessage', 'message', 'condition'
[17:27:22.402]   - Field: 'asynchronous'
[17:27:22.472]  - Condition #25: 'simpleMessage', 'message', 'condition'
[17:27:22.403]   - Field: 'calls'
[17:27:22.473]  - Condition #26: 'simpleMessage', 'message', 'condition'
[17:27:22.403]   - Field: 'globals'
[17:27:22.473]  - Condition #27: 'simpleMessage', 'message', 'condition'
[17:27:22.408]   - Field: 'stdout'
[17:27:22.473]  - Condition #28: 'simpleMessage', 'message', 'condition'
[17:27:22.408]   - Field: 'earlySignal'
[17:27:22.474]  - Condition #29: 'simpleMessage', 'message', 'condition'
[17:27:22.408]   - Field: 'lazy'
[17:27:22.474]  - Condition #30: 'simpleMessage', 'message', 'condition'
[17:27:22.408]   - Field: 'state'
[17:27:22.474]  - Condition #31: 'simpleMessage', 'message', 'condition'
[17:27:22.409] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.474]  - Condition #32: 'simpleMessage', 'message', 'condition'
[17:27:22.409] - Launch lazy future ...
[17:27:22.475]  - Condition #33: 'simpleMessage', 'message', 'condition'
[17:27:22.410] Packages needed by the future expression (n = 0): <none>
[17:27:22.475]  - Condition #34: 'simpleMessage', 'message', 'condition'
[17:27:22.410] Packages needed by future strategies (n = 0): <none>
[17:27:22.475]  - Condition #35: 'simpleMessage', 'message', 'condition'
[17:27:22.411] {
[17:27:22.411]     {
[17:27:22.411]         {
[17:27:22.411]             ...future.startTime <- base::Sys.time()
[17:27:22.411]             {
[17:27:22.411]                 {
[17:27:22.411]                   {
[17:27:22.411]                     base::local({
[17:27:22.411]                       has_future <- base::requireNamespace("future", 
[17:27:22.411]                         quietly = TRUE)
[17:27:22.411]                       if (has_future) {
[17:27:22.411]                         ns <- base::getNamespace("future")
[17:27:22.411]                         version <- ns[[".package"]][["version"]]
[17:27:22.411]                         if (is.null(version)) 
[17:27:22.411]                           version <- utils::packageVersion("future")
[17:27:22.411]                       }
[17:27:22.411]                       else {
[17:27:22.411]                         version <- NULL
[17:27:22.411]                       }
[17:27:22.411]                       if (!has_future || version < "1.8.0") {
[17:27:22.411]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.411]                           "", base::R.version$version.string), 
[17:27:22.411]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.411]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.411]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.411]                             "release", "version")], collapse = " "), 
[17:27:22.411]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.411]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.411]                           info)
[17:27:22.411]                         info <- base::paste(info, collapse = "; ")
[17:27:22.411]                         if (!has_future) {
[17:27:22.411]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.411]                             info)
[17:27:22.411]                         }
[17:27:22.411]                         else {
[17:27:22.411]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.411]                             info, version)
[17:27:22.411]                         }
[17:27:22.411]                         base::stop(msg)
[17:27:22.411]                       }
[17:27:22.411]                     })
[17:27:22.411]                   }
[17:27:22.411]                   ...future.strategy.old <- future::plan("list")
[17:27:22.411]                   options(future.plan = NULL)
[17:27:22.411]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.411]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.411]                 }
[17:27:22.411]                 ...future.workdir <- getwd()
[17:27:22.411]             }
[17:27:22.411]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.411]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.411]         }
[17:27:22.411]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.411]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.411]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.411]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.411]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.411]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.411]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.411]             base::names(...future.oldOptions))
[17:27:22.411]     }
[17:27:22.411]     if (FALSE) {
[17:27:22.411]     }
[17:27:22.411]     else {
[17:27:22.411]         if (TRUE) {
[17:27:22.411]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.411]                 open = "w")
[17:27:22.411]         }
[17:27:22.411]         else {
[17:27:22.411]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.411]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.411]         }
[17:27:22.411]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.411]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.411]             base::sink(type = "output", split = FALSE)
[17:27:22.411]             base::close(...future.stdout)
[17:27:22.411]         }, add = TRUE)
[17:27:22.411]     }
[17:27:22.411]     ...future.frame <- base::sys.nframe()
[17:27:22.411]     ...future.conditions <- base::list()
[17:27:22.411]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.411]     if (FALSE) {
[17:27:22.411]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.411]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.411]     }
[17:27:22.411]     ...future.result <- base::tryCatch({
[17:27:22.411]         base::withCallingHandlers({
[17:27:22.411]             ...future.value <- base::withVisible(base::local(2))
[17:27:22.411]             future::FutureResult(value = ...future.value$value, 
[17:27:22.411]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.411]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.411]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.411]                     ...future.globalenv.names))
[17:27:22.411]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.411]         }, condition = base::local({
[17:27:22.411]             c <- base::c
[17:27:22.411]             inherits <- base::inherits
[17:27:22.411]             invokeRestart <- base::invokeRestart
[17:27:22.411]             length <- base::length
[17:27:22.411]             list <- base::list
[17:27:22.411]             seq.int <- base::seq.int
[17:27:22.411]             signalCondition <- base::signalCondition
[17:27:22.411]             sys.calls <- base::sys.calls
[17:27:22.411]             `[[` <- base::`[[`
[17:27:22.411]             `+` <- base::`+`
[17:27:22.411]             `<<-` <- base::`<<-`
[17:27:22.411]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.411]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.411]                   3L)]
[17:27:22.411]             }
[17:27:22.411]             function(cond) {
[17:27:22.411]                 is_error <- inherits(cond, "error")
[17:27:22.411]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.411]                   NULL)
[17:27:22.411]                 if (is_error) {
[17:27:22.411]                   sessionInformation <- function() {
[17:27:22.411]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.411]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.411]                       search = base::search(), system = base::Sys.info())
[17:27:22.411]                   }
[17:27:22.411]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.411]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.411]                     cond$call), session = sessionInformation(), 
[17:27:22.411]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.411]                   signalCondition(cond)
[17:27:22.411]                 }
[17:27:22.411]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.411]                 "immediateCondition"))) {
[17:27:22.411]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.411]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.411]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.411]                   if (TRUE && !signal) {
[17:27:22.411]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.411]                     {
[17:27:22.411]                       inherits <- base::inherits
[17:27:22.411]                       invokeRestart <- base::invokeRestart
[17:27:22.411]                       is.null <- base::is.null
[17:27:22.411]                       muffled <- FALSE
[17:27:22.411]                       if (inherits(cond, "message")) {
[17:27:22.411]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.411]                         if (muffled) 
[17:27:22.411]                           invokeRestart("muffleMessage")
[17:27:22.411]                       }
[17:27:22.411]                       else if (inherits(cond, "warning")) {
[17:27:22.411]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.411]                         if (muffled) 
[17:27:22.411]                           invokeRestart("muffleWarning")
[17:27:22.411]                       }
[17:27:22.411]                       else if (inherits(cond, "condition")) {
[17:27:22.411]                         if (!is.null(pattern)) {
[17:27:22.411]                           computeRestarts <- base::computeRestarts
[17:27:22.411]                           grepl <- base::grepl
[17:27:22.411]                           restarts <- computeRestarts(cond)
[17:27:22.411]                           for (restart in restarts) {
[17:27:22.411]                             name <- restart$name
[17:27:22.411]                             if (is.null(name)) 
[17:27:22.411]                               next
[17:27:22.411]                             if (!grepl(pattern, name)) 
[17:27:22.411]                               next
[17:27:22.411]                             invokeRestart(restart)
[17:27:22.411]                             muffled <- TRUE
[17:27:22.411]                             break
[17:27:22.411]                           }
[17:27:22.411]                         }
[17:27:22.411]                       }
[17:27:22.411]                       invisible(muffled)
[17:27:22.411]                     }
[17:27:22.411]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.411]                   }
[17:27:22.411]                 }
[17:27:22.411]                 else {
[17:27:22.411]                   if (TRUE) {
[17:27:22.411]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.411]                     {
[17:27:22.411]                       inherits <- base::inherits
[17:27:22.411]                       invokeRestart <- base::invokeRestart
[17:27:22.411]                       is.null <- base::is.null
[17:27:22.411]                       muffled <- FALSE
[17:27:22.411]                       if (inherits(cond, "message")) {
[17:27:22.411]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.411]                         if (muffled) 
[17:27:22.411]                           invokeRestart("muffleMessage")
[17:27:22.411]                       }
[17:27:22.411]                       else if (inherits(cond, "warning")) {
[17:27:22.411]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.411]                         if (muffled) 
[17:27:22.411]                           invokeRestart("muffleWarning")
[17:27:22.411]                       }
[17:27:22.411]                       else if (inherits(cond, "condition")) {
[17:27:22.411]                         if (!is.null(pattern)) {
[17:27:22.411]                           computeRestarts <- base::computeRestarts
[17:27:22.411]                           grepl <- base::grepl
[17:27:22.411]                           restarts <- computeRestarts(cond)
[17:27:22.411]                           for (restart in restarts) {
[17:27:22.411]                             name <- restart$name
[17:27:22.411]                             if (is.null(name)) 
[17:27:22.411]                               next
[17:27:22.411]                             if (!grepl(pattern, name)) 
[17:27:22.411]                               next
[17:27:22.411]                             invokeRestart(restart)
[17:27:22.411]                             muffled <- TRUE
[17:27:22.411]                             break
[17:27:22.411]                           }
[17:27:22.411]                         }
[17:27:22.411]                       }
[17:27:22.411]                       invisible(muffled)
[17:27:22.411]                     }
[17:27:22.411]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.411]                   }
[17:27:22.411]                 }
[17:27:22.411]             }
[17:27:22.411]         }))
[17:27:22.411]     }, error = function(ex) {
[17:27:22.411]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.411]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.411]                 ...future.rng), started = ...future.startTime, 
[17:27:22.411]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.411]             version = "1.8"), class = "FutureResult")
[17:27:22.411]     }, finally = {
[17:27:22.411]         if (!identical(...future.workdir, getwd())) 
[17:27:22.411]             setwd(...future.workdir)
[17:27:22.411]         {
[17:27:22.411]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.411]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.411]             }
[17:27:22.411]             base::options(...future.oldOptions)
[17:27:22.411]             if (.Platform$OS.type == "windows") {
[17:27:22.411]                 old_names <- names(...future.oldEnvVars)
[17:27:22.411]                 envs <- base::Sys.getenv()
[17:27:22.411]                 names <- names(envs)
[17:27:22.411]                 common <- intersect(names, old_names)
[17:27:22.411]                 added <- setdiff(names, old_names)
[17:27:22.411]                 removed <- setdiff(old_names, names)
[17:27:22.411]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.411]                   envs[common]]
[17:27:22.411]                 NAMES <- toupper(changed)
[17:27:22.411]                 args <- list()
[17:27:22.411]                 for (kk in seq_along(NAMES)) {
[17:27:22.411]                   name <- changed[[kk]]
[17:27:22.411]                   NAME <- NAMES[[kk]]
[17:27:22.411]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.411]                     next
[17:27:22.411]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.411]                 }
[17:27:22.411]                 NAMES <- toupper(added)
[17:27:22.411]                 for (kk in seq_along(NAMES)) {
[17:27:22.411]                   name <- added[[kk]]
[17:27:22.411]                   NAME <- NAMES[[kk]]
[17:27:22.411]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.411]                     next
[17:27:22.411]                   args[[name]] <- ""
[17:27:22.411]                 }
[17:27:22.411]                 NAMES <- toupper(removed)
[17:27:22.411]                 for (kk in seq_along(NAMES)) {
[17:27:22.411]                   name <- removed[[kk]]
[17:27:22.411]                   NAME <- NAMES[[kk]]
[17:27:22.411]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.411]                     next
[17:27:22.411]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.411]                 }
[17:27:22.411]                 if (length(args) > 0) 
[17:27:22.411]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.411]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.411]             }
[17:27:22.411]             else {
[17:27:22.411]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.411]             }
[17:27:22.411]             {
[17:27:22.411]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.411]                   0L) {
[17:27:22.411]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.411]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.411]                   base::options(opts)
[17:27:22.411]                 }
[17:27:22.411]                 {
[17:27:22.411]                   {
[17:27:22.411]                     NULL
[17:27:22.411]                     RNGkind("Mersenne-Twister")
[17:27:22.411]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.411]                       inherits = FALSE)
[17:27:22.411]                   }
[17:27:22.411]                   options(future.plan = NULL)
[17:27:22.411]                   if (is.na(NA_character_)) 
[17:27:22.411]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.411]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.411]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.411]                     .init = FALSE)
[17:27:22.411]                 }
[17:27:22.411]             }
[17:27:22.411]         }
[17:27:22.411]     })
[17:27:22.411]     if (TRUE) {
[17:27:22.411]         base::sink(type = "output", split = FALSE)
[17:27:22.411]         if (TRUE) {
[17:27:22.411]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.411]         }
[17:27:22.411]         else {
[17:27:22.411]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.411]         }
[17:27:22.411]         base::close(...future.stdout)
[17:27:22.411]         ...future.stdout <- NULL
[17:27:22.411]     }
[17:27:22.411]     ...future.result$conditions <- ...future.conditions
[17:27:22.411]     ...future.result$finished <- base::Sys.time()
[17:27:22.411]     ...future.result
[17:27:22.411] }
[17:27:22.476]  - Condition #36: 'simpleMessage', 'message', 'condition'
[17:27:22.418] plan(): Setting new future strategy stack:
[17:27:22.476]  - Condition #37: 'simpleMessage', 'message', 'condition'
[17:27:22.418] List of future strategies:
[17:27:22.418] 1. sequential:
[17:27:22.418]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.418]    - tweaked: FALSE
[17:27:22.418]    - call: NULL
[17:27:22.477]  - Condition #38: 'simpleMessage', 'message', 'condition'
[17:27:22.419] plan(): nbrOfWorkers() = 1
[17:27:22.477]  - Condition #39: 'simpleMessage', 'message', 'condition'
[17:27:22.421] plan(): Setting new future strategy stack:
[17:27:22.478]  - Condition #40: 'simpleMessage', 'message', 'condition'
[17:27:22.421] List of future strategies:
[17:27:22.421] 1. sequential:
[17:27:22.421]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.421]    - tweaked: FALSE
[17:27:22.421]    - call: NULL
[17:27:22.478]  - Condition #41: 'simpleMessage', 'message', 'condition'
[17:27:22.422] plan(): nbrOfWorkers() = 1
[17:27:22.478]  - Condition #42: 'simpleMessage', 'message', 'condition'
[17:27:22.423] SequentialFuture started (and completed)
[17:27:22.479]  - Condition #43: 'simpleMessage', 'message', 'condition'
[17:27:22.423] - Launch lazy future ... done
[17:27:22.479]  - Condition #44: 'simpleMessage', 'message', 'condition'
[17:27:22.423] run() for 'SequentialFuture' ... done
[17:27:22.480]  - Condition #45: 'simpleMessage', 'message', 'condition'
[17:27:22.424] getGlobalsAndPackages() ...
[17:27:22.480]  - Condition #46: 'simpleMessage', 'message', 'condition'
[17:27:22.425] Searching for globals...
[17:27:22.480]  - Condition #47: 'simpleMessage', 'message', 'condition'
[17:27:22.426] 
[17:27:22.481]  - Condition #48: 'simpleMessage', 'message', 'condition'
[17:27:22.426] Searching for globals ... DONE
[17:27:22.481]  - Condition #49: 'simpleMessage', 'message', 'condition'
[17:27:22.426] - globals: [0] <none>
[17:27:22.481]  - Condition #50: 'simpleMessage', 'message', 'condition'
[17:27:22.426] getGlobalsAndPackages() ... DONE
[17:27:22.482]  - Condition #51: 'simpleMessage', 'message', 'condition'
[17:27:22.427] run() for 'Future' ...
[17:27:22.482]  - Condition #52: 'simpleMessage', 'message', 'condition'
[17:27:22.427] - state: 'created'
[17:27:22.482]  - Condition #53: 'simpleMessage', 'message', 'condition'
[17:27:22.428] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.483]  - Condition #54: 'simpleMessage', 'message', 'condition'
[17:27:22.428] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.483]  - Condition #55: 'simpleMessage', 'message', 'condition'
[17:27:22.429] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.483]  - Condition #56: 'simpleMessage', 'message', 'condition'
[17:27:22.429]   - Field: 'label'
[17:27:22.484]  - Condition #57: 'simpleMessage', 'message', 'condition'
[17:27:22.429]   - Field: 'local'
[17:27:22.484]  - Condition #58: 'simpleMessage', 'message', 'condition'
[17:27:22.430]   - Field: 'owner'
[17:27:22.484]  - Condition #59: 'simpleMessage', 'message', 'condition'
[17:27:22.430]   - Field: 'envir'
[17:27:22.485]  - Condition #60: 'simpleMessage', 'message', 'condition'
[17:27:22.430]   - Field: 'packages'
[17:27:22.485]  - Condition #61: 'simpleMessage', 'message', 'condition'
[17:27:22.430]   - Field: 'gc'
[17:27:22.485]  - Condition #62: 'simpleMessage', 'message', 'condition'
[17:27:22.431]   - Field: 'conditions'
[17:27:22.486]  - Condition #63: 'simpleMessage', 'message', 'condition'
[17:27:22.431]   - Field: 'expr'
[17:27:22.486]  - Condition #64: 'simpleMessage', 'message', 'condition'
[17:27:22.431]   - Field: 'uuid'
[17:27:22.486]  - Condition #65: 'simpleMessage', 'message', 'condition'
[17:27:22.431]   - Field: 'seed'
[17:27:22.487]  - Condition #66: 'simpleMessage', 'message', 'condition'
[17:27:22.432]   - Field: 'version'
[17:27:22.487]  - Condition #67: 'simpleMessage', 'message', 'condition'
[17:27:22.432]   - Field: 'result'
[17:27:22.487]  - Condition #68: 'simpleMessage', 'message', 'condition'
[17:27:22.432]   - Field: 'asynchronous'
[17:27:22.488]  - Condition #69: 'simpleMessage', 'message', 'condition'
[17:27:22.433]   - Field: 'calls'
[17:27:22.488]  - Condition #70: 'simpleMessage', 'message', 'condition'
[17:27:22.433]   - Field: 'globals'
[17:27:22.489]  - Condition #71: 'simpleMessage', 'message', 'condition'
[17:27:22.433]   - Field: 'stdout'
[17:27:22.489]  - Condition #72: 'simpleMessage', 'message', 'condition'
[17:27:22.434]   - Field: 'earlySignal'
[17:27:22.489]  - Condition #73: 'simpleMessage', 'message', 'condition'
[17:27:22.434]   - Field: 'lazy'
[17:27:22.490]  - Condition #74: 'simpleMessage', 'message', 'condition'
[17:27:22.434]   - Field: 'state'
[17:27:22.490]  - Condition #75: 'simpleMessage', 'message', 'condition'
[17:27:22.435] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.491]  - Condition #76: 'simpleMessage', 'message', 'condition'
[17:27:22.435] - Launch lazy future ...
[17:27:22.491]  - Condition #77: 'simpleMessage', 'message', 'condition'
[17:27:22.436] Packages needed by the future expression (n = 0): <none>
[17:27:22.491]  - Condition #78: 'simpleMessage', 'message', 'condition'
[17:27:22.436] Packages needed by future strategies (n = 0): <none>
[17:27:22.492]  - Condition #79: 'simpleMessage', 'message', 'condition'
[17:27:22.437] {
[17:27:22.437]     {
[17:27:22.437]         {
[17:27:22.437]             ...future.startTime <- base::Sys.time()
[17:27:22.437]             {
[17:27:22.437]                 {
[17:27:22.437]                   {
[17:27:22.437]                     base::local({
[17:27:22.437]                       has_future <- base::requireNamespace("future", 
[17:27:22.437]                         quietly = TRUE)
[17:27:22.437]                       if (has_future) {
[17:27:22.437]                         ns <- base::getNamespace("future")
[17:27:22.437]                         version <- ns[[".package"]][["version"]]
[17:27:22.437]                         if (is.null(version)) 
[17:27:22.437]                           version <- utils::packageVersion("future")
[17:27:22.437]                       }
[17:27:22.437]                       else {
[17:27:22.437]                         version <- NULL
[17:27:22.437]                       }
[17:27:22.437]                       if (!has_future || version < "1.8.0") {
[17:27:22.437]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.437]                           "", base::R.version$version.string), 
[17:27:22.437]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.437]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.437]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.437]                             "release", "version")], collapse = " "), 
[17:27:22.437]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.437]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.437]                           info)
[17:27:22.437]                         info <- base::paste(info, collapse = "; ")
[17:27:22.437]                         if (!has_future) {
[17:27:22.437]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.437]                             info)
[17:27:22.437]                         }
[17:27:22.437]                         else {
[17:27:22.437]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.437]                             info, version)
[17:27:22.437]                         }
[17:27:22.437]                         base::stop(msg)
[17:27:22.437]                       }
[17:27:22.437]                     })
[17:27:22.437]                   }
[17:27:22.437]                   ...future.strategy.old <- future::plan("list")
[17:27:22.437]                   options(future.plan = NULL)
[17:27:22.437]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.437]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.437]                 }
[17:27:22.437]                 ...future.workdir <- getwd()
[17:27:22.437]             }
[17:27:22.437]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.437]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.437]         }
[17:27:22.437]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.437]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.437]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.437]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.437]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.437]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.437]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.437]             base::names(...future.oldOptions))
[17:27:22.437]     }
[17:27:22.437]     if (FALSE) {
[17:27:22.437]     }
[17:27:22.437]     else {
[17:27:22.437]         if (TRUE) {
[17:27:22.437]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.437]                 open = "w")
[17:27:22.437]         }
[17:27:22.437]         else {
[17:27:22.437]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.437]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.437]         }
[17:27:22.437]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.437]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.437]             base::sink(type = "output", split = FALSE)
[17:27:22.437]             base::close(...future.stdout)
[17:27:22.437]         }, add = TRUE)
[17:27:22.437]     }
[17:27:22.437]     ...future.frame <- base::sys.nframe()
[17:27:22.437]     ...future.conditions <- base::list()
[17:27:22.437]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.437]     if (FALSE) {
[17:27:22.437]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.437]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.437]     }
[17:27:22.437]     ...future.result <- base::tryCatch({
[17:27:22.437]         base::withCallingHandlers({
[17:27:22.437]             ...future.value <- base::withVisible(base::local(4))
[17:27:22.437]             future::FutureResult(value = ...future.value$value, 
[17:27:22.437]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.437]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.437]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.437]                     ...future.globalenv.names))
[17:27:22.437]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.437]         }, condition = base::local({
[17:27:22.437]             c <- base::c
[17:27:22.437]             inherits <- base::inherits
[17:27:22.437]             invokeRestart <- base::invokeRestart
[17:27:22.437]             length <- base::length
[17:27:22.437]             list <- base::list
[17:27:22.437]             seq.int <- base::seq.int
[17:27:22.437]             signalCondition <- base::signalCondition
[17:27:22.437]             sys.calls <- base::sys.calls
[17:27:22.437]             `[[` <- base::`[[`
[17:27:22.437]             `+` <- base::`+`
[17:27:22.437]             `<<-` <- base::`<<-`
[17:27:22.437]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.437]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.437]                   3L)]
[17:27:22.437]             }
[17:27:22.437]             function(cond) {
[17:27:22.437]                 is_error <- inherits(cond, "error")
[17:27:22.437]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.437]                   NULL)
[17:27:22.437]                 if (is_error) {
[17:27:22.437]                   sessionInformation <- function() {
[17:27:22.437]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.437]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.437]                       search = base::search(), system = base::Sys.info())
[17:27:22.437]                   }
[17:27:22.437]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.437]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.437]                     cond$call), session = sessionInformation(), 
[17:27:22.437]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.437]                   signalCondition(cond)
[17:27:22.437]                 }
[17:27:22.437]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.437]                 "immediateCondition"))) {
[17:27:22.437]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.437]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.437]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.437]                   if (TRUE && !signal) {
[17:27:22.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.437]                     {
[17:27:22.437]                       inherits <- base::inherits
[17:27:22.437]                       invokeRestart <- base::invokeRestart
[17:27:22.437]                       is.null <- base::is.null
[17:27:22.437]                       muffled <- FALSE
[17:27:22.437]                       if (inherits(cond, "message")) {
[17:27:22.437]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.437]                         if (muffled) 
[17:27:22.437]                           invokeRestart("muffleMessage")
[17:27:22.437]                       }
[17:27:22.437]                       else if (inherits(cond, "warning")) {
[17:27:22.437]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.437]                         if (muffled) 
[17:27:22.437]                           invokeRestart("muffleWarning")
[17:27:22.437]                       }
[17:27:22.437]                       else if (inherits(cond, "condition")) {
[17:27:22.437]                         if (!is.null(pattern)) {
[17:27:22.437]                           computeRestarts <- base::computeRestarts
[17:27:22.437]                           grepl <- base::grepl
[17:27:22.437]                           restarts <- computeRestarts(cond)
[17:27:22.437]                           for (restart in restarts) {
[17:27:22.437]                             name <- restart$name
[17:27:22.437]                             if (is.null(name)) 
[17:27:22.437]                               next
[17:27:22.437]                             if (!grepl(pattern, name)) 
[17:27:22.437]                               next
[17:27:22.437]                             invokeRestart(restart)
[17:27:22.437]                             muffled <- TRUE
[17:27:22.437]                             break
[17:27:22.437]                           }
[17:27:22.437]                         }
[17:27:22.437]                       }
[17:27:22.437]                       invisible(muffled)
[17:27:22.437]                     }
[17:27:22.437]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.437]                   }
[17:27:22.437]                 }
[17:27:22.437]                 else {
[17:27:22.437]                   if (TRUE) {
[17:27:22.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.437]                     {
[17:27:22.437]                       inherits <- base::inherits
[17:27:22.437]                       invokeRestart <- base::invokeRestart
[17:27:22.437]                       is.null <- base::is.null
[17:27:22.437]                       muffled <- FALSE
[17:27:22.437]                       if (inherits(cond, "message")) {
[17:27:22.437]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.437]                         if (muffled) 
[17:27:22.437]                           invokeRestart("muffleMessage")
[17:27:22.437]                       }
[17:27:22.437]                       else if (inherits(cond, "warning")) {
[17:27:22.437]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.437]                         if (muffled) 
[17:27:22.437]                           invokeRestart("muffleWarning")
[17:27:22.437]                       }
[17:27:22.437]                       else if (inherits(cond, "condition")) {
[17:27:22.437]                         if (!is.null(pattern)) {
[17:27:22.437]                           computeRestarts <- base::computeRestarts
[17:27:22.437]                           grepl <- base::grepl
[17:27:22.437]                           restarts <- computeRestarts(cond)
[17:27:22.437]                           for (restart in restarts) {
[17:27:22.437]                             name <- restart$name
[17:27:22.437]                             if (is.null(name)) 
[17:27:22.437]                               next
[17:27:22.437]                             if (!grepl(pattern, name)) 
[17:27:22.437]                               next
[17:27:22.437]                             invokeRestart(restart)
[17:27:22.437]                             muffled <- TRUE
[17:27:22.437]                             break
[17:27:22.437]                           }
[17:27:22.437]                         }
[17:27:22.437]                       }
[17:27:22.437]                       invisible(muffled)
[17:27:22.437]                     }
[17:27:22.437]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.437]                   }
[17:27:22.437]                 }
[17:27:22.437]             }
[17:27:22.437]         }))
[17:27:22.437]     }, error = function(ex) {
[17:27:22.437]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.437]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.437]                 ...future.rng), started = ...future.startTime, 
[17:27:22.437]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.437]             version = "1.8"), class = "FutureResult")
[17:27:22.437]     }, finally = {
[17:27:22.437]         if (!identical(...future.workdir, getwd())) 
[17:27:22.437]             setwd(...future.workdir)
[17:27:22.437]         {
[17:27:22.437]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.437]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.437]             }
[17:27:22.437]             base::options(...future.oldOptions)
[17:27:22.437]             if (.Platform$OS.type == "windows") {
[17:27:22.437]                 old_names <- names(...future.oldEnvVars)
[17:27:22.437]                 envs <- base::Sys.getenv()
[17:27:22.437]                 names <- names(envs)
[17:27:22.437]                 common <- intersect(names, old_names)
[17:27:22.437]                 added <- setdiff(names, old_names)
[17:27:22.437]                 removed <- setdiff(old_names, names)
[17:27:22.437]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.437]                   envs[common]]
[17:27:22.437]                 NAMES <- toupper(changed)
[17:27:22.437]                 args <- list()
[17:27:22.437]                 for (kk in seq_along(NAMES)) {
[17:27:22.437]                   name <- changed[[kk]]
[17:27:22.437]                   NAME <- NAMES[[kk]]
[17:27:22.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.437]                     next
[17:27:22.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.437]                 }
[17:27:22.437]                 NAMES <- toupper(added)
[17:27:22.437]                 for (kk in seq_along(NAMES)) {
[17:27:22.437]                   name <- added[[kk]]
[17:27:22.437]                   NAME <- NAMES[[kk]]
[17:27:22.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.437]                     next
[17:27:22.437]                   args[[name]] <- ""
[17:27:22.437]                 }
[17:27:22.437]                 NAMES <- toupper(removed)
[17:27:22.437]                 for (kk in seq_along(NAMES)) {
[17:27:22.437]                   name <- removed[[kk]]
[17:27:22.437]                   NAME <- NAMES[[kk]]
[17:27:22.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.437]                     next
[17:27:22.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.437]                 }
[17:27:22.437]                 if (length(args) > 0) 
[17:27:22.437]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.437]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.437]             }
[17:27:22.437]             else {
[17:27:22.437]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.437]             }
[17:27:22.437]             {
[17:27:22.437]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.437]                   0L) {
[17:27:22.437]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.437]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.437]                   base::options(opts)
[17:27:22.437]                 }
[17:27:22.437]                 {
[17:27:22.437]                   {
[17:27:22.437]                     NULL
[17:27:22.437]                     RNGkind("Mersenne-Twister")
[17:27:22.437]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.437]                       inherits = FALSE)
[17:27:22.437]                   }
[17:27:22.437]                   options(future.plan = NULL)
[17:27:22.437]                   if (is.na(NA_character_)) 
[17:27:22.437]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.437]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.437]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.437]                     .init = FALSE)
[17:27:22.437]                 }
[17:27:22.437]             }
[17:27:22.437]         }
[17:27:22.437]     })
[17:27:22.437]     if (TRUE) {
[17:27:22.437]         base::sink(type = "output", split = FALSE)
[17:27:22.437]         if (TRUE) {
[17:27:22.437]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.437]         }
[17:27:22.437]         else {
[17:27:22.437]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.437]         }
[17:27:22.437]         base::close(...future.stdout)
[17:27:22.437]         ...future.stdout <- NULL
[17:27:22.437]     }
[17:27:22.437]     ...future.result$conditions <- ...future.conditions
[17:27:22.437]     ...future.result$finished <- base::Sys.time()
[17:27:22.437]     ...future.result
[17:27:22.437] }
[17:27:22.493]  - Condition #80: 'simpleMessage', 'message', 'condition'
[17:27:22.443] plan(): Setting new future strategy stack:
[17:27:22.493]  - Condition #81: 'simpleMessage', 'message', 'condition'
[17:27:22.444] List of future strategies:
[17:27:22.444] 1. sequential:
[17:27:22.444]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.444]    - tweaked: FALSE
[17:27:22.444]    - call: NULL
[17:27:22.493]  - Condition #82: 'simpleMessage', 'message', 'condition'
[17:27:22.445] plan(): nbrOfWorkers() = 1
[17:27:22.494]  - Condition #83: 'simpleMessage', 'message', 'condition'
[17:27:22.447] plan(): Setting new future strategy stack:
[17:27:22.494]  - Condition #84: 'simpleMessage', 'message', 'condition'
[17:27:22.448] List of future strategies:
[17:27:22.448] 1. sequential:
[17:27:22.448]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.448]    - tweaked: FALSE
[17:27:22.448]    - call: NULL
[17:27:22.494]  - Condition #85: 'simpleMessage', 'message', 'condition'
[17:27:22.449] plan(): nbrOfWorkers() = 1
[17:27:22.495]  - Condition #86: 'simpleMessage', 'message', 'condition'
[17:27:22.449] SequentialFuture started (and completed)
[17:27:22.495]  - Condition #87: 'simpleMessage', 'message', 'condition'
[17:27:22.449] - Launch lazy future ... done
[17:27:22.496]  - Condition #88: 'simpleMessage', 'message', 'condition'
[17:27:22.450] run() for 'SequentialFuture' ... done
[17:27:22.496] signalConditions() ... done
a = 10
[17:27:22.497] getGlobalsAndPackages() ...
[17:27:22.497] Searching for globals...
[17:27:22.499] - globals found: [3] '{', '+', 'a'
[17:27:22.499] Searching for globals ... DONE
[17:27:22.499] Resolving globals: FALSE
[17:27:22.500] The total size of the 1 globals is 39 bytes (39 bytes)
[17:27:22.501] The total size of the 1 globals exported for future expression ('{; a + 1; }') is 39 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (39 bytes of class 'numeric')
[17:27:22.502] - globals: [1] 'a'
[17:27:22.502] 
[17:27:22.502] getGlobalsAndPackages() ... DONE
[17:27:22.503] run() for 'Future' ...
[17:27:22.503] - state: 'created'
[17:27:22.504] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:27:22.504] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:27:22.505] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:27:22.505]   - Field: 'label'
[17:27:22.505]   - Field: 'local'
[17:27:22.506]   - Field: 'owner'
[17:27:22.506]   - Field: 'envir'
[17:27:22.506]   - Field: 'packages'
[17:27:22.507]   - Field: 'gc'
[17:27:22.507]   - Field: 'conditions'
[17:27:22.507]   - Field: 'expr'
[17:27:22.508]   - Field: 'uuid'
[17:27:22.508]   - Field: 'seed'
[17:27:22.508]   - Field: 'version'
[17:27:22.508]   - Field: 'result'
[17:27:22.509]   - Field: 'asynchronous'
[17:27:22.513]   - Field: 'calls'
[17:27:22.513]   - Field: 'globals'
[17:27:22.514]   - Field: 'stdout'
[17:27:22.514]   - Field: 'earlySignal'
[17:27:22.514]   - Field: 'lazy'
[17:27:22.515]   - Field: 'state'
[17:27:22.515] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:27:22.515] - Launch lazy future ...
[17:27:22.516] Packages needed by the future expression (n = 0): <none>
[17:27:22.516] Packages needed by future strategies (n = 0): <none>
[17:27:22.517] {
[17:27:22.517]     {
[17:27:22.517]         {
[17:27:22.517]             ...future.startTime <- base::Sys.time()
[17:27:22.517]             {
[17:27:22.517]                 {
[17:27:22.517]                   {
[17:27:22.517]                     base::local({
[17:27:22.517]                       has_future <- base::requireNamespace("future", 
[17:27:22.517]                         quietly = TRUE)
[17:27:22.517]                       if (has_future) {
[17:27:22.517]                         ns <- base::getNamespace("future")
[17:27:22.517]                         version <- ns[[".package"]][["version"]]
[17:27:22.517]                         if (is.null(version)) 
[17:27:22.517]                           version <- utils::packageVersion("future")
[17:27:22.517]                       }
[17:27:22.517]                       else {
[17:27:22.517]                         version <- NULL
[17:27:22.517]                       }
[17:27:22.517]                       if (!has_future || version < "1.8.0") {
[17:27:22.517]                         info <- base::c(r_version = base::gsub("R version ", 
[17:27:22.517]                           "", base::R.version$version.string), 
[17:27:22.517]                           platform = base::sprintf("%s (%s-bit)", 
[17:27:22.517]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:22.517]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:22.517]                             "release", "version")], collapse = " "), 
[17:27:22.517]                           hostname = base::Sys.info()[["nodename"]])
[17:27:22.517]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:27:22.517]                           info)
[17:27:22.517]                         info <- base::paste(info, collapse = "; ")
[17:27:22.517]                         if (!has_future) {
[17:27:22.517]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:22.517]                             info)
[17:27:22.517]                         }
[17:27:22.517]                         else {
[17:27:22.517]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:22.517]                             info, version)
[17:27:22.517]                         }
[17:27:22.517]                         base::stop(msg)
[17:27:22.517]                       }
[17:27:22.517]                     })
[17:27:22.517]                   }
[17:27:22.517]                   ...future.strategy.old <- future::plan("list")
[17:27:22.517]                   options(future.plan = NULL)
[17:27:22.517]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.517]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:22.517]                 }
[17:27:22.517]                 ...future.workdir <- getwd()
[17:27:22.517]             }
[17:27:22.517]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:22.517]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:22.517]         }
[17:27:22.517]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:22.517]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:22.517]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:22.517]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:22.517]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:22.517]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:22.517]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:22.517]             base::names(...future.oldOptions))
[17:27:22.517]     }
[17:27:22.517]     if (FALSE) {
[17:27:22.517]     }
[17:27:22.517]     else {
[17:27:22.517]         if (TRUE) {
[17:27:22.517]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:22.517]                 open = "w")
[17:27:22.517]         }
[17:27:22.517]         else {
[17:27:22.517]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:22.517]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:22.517]         }
[17:27:22.517]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:22.517]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:22.517]             base::sink(type = "output", split = FALSE)
[17:27:22.517]             base::close(...future.stdout)
[17:27:22.517]         }, add = TRUE)
[17:27:22.517]     }
[17:27:22.517]     ...future.frame <- base::sys.nframe()
[17:27:22.517]     ...future.conditions <- base::list()
[17:27:22.517]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:22.517]     if (FALSE) {
[17:27:22.517]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:22.517]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:22.517]     }
[17:27:22.517]     ...future.result <- base::tryCatch({
[17:27:22.517]         base::withCallingHandlers({
[17:27:22.517]             ...future.value <- base::withVisible(base::local({
[17:27:22.517]                 a + 1
[17:27:22.517]             }))
[17:27:22.517]             future::FutureResult(value = ...future.value$value, 
[17:27:22.517]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.517]                   ...future.rng), globalenv = if (FALSE) 
[17:27:22.517]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:22.517]                     ...future.globalenv.names))
[17:27:22.517]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:22.517]         }, condition = base::local({
[17:27:22.517]             c <- base::c
[17:27:22.517]             inherits <- base::inherits
[17:27:22.517]             invokeRestart <- base::invokeRestart
[17:27:22.517]             length <- base::length
[17:27:22.517]             list <- base::list
[17:27:22.517]             seq.int <- base::seq.int
[17:27:22.517]             signalCondition <- base::signalCondition
[17:27:22.517]             sys.calls <- base::sys.calls
[17:27:22.517]             `[[` <- base::`[[`
[17:27:22.517]             `+` <- base::`+`
[17:27:22.517]             `<<-` <- base::`<<-`
[17:27:22.517]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:22.517]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:22.517]                   3L)]
[17:27:22.517]             }
[17:27:22.517]             function(cond) {
[17:27:22.517]                 is_error <- inherits(cond, "error")
[17:27:22.517]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:22.517]                   NULL)
[17:27:22.517]                 if (is_error) {
[17:27:22.517]                   sessionInformation <- function() {
[17:27:22.517]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:22.517]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:22.517]                       search = base::search(), system = base::Sys.info())
[17:27:22.517]                   }
[17:27:22.517]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.517]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:22.517]                     cond$call), session = sessionInformation(), 
[17:27:22.517]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:22.517]                   signalCondition(cond)
[17:27:22.517]                 }
[17:27:22.517]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:22.517]                 "immediateCondition"))) {
[17:27:22.517]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:22.517]                   ...future.conditions[[length(...future.conditions) + 
[17:27:22.517]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:22.517]                   if (TRUE && !signal) {
[17:27:22.517]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.517]                     {
[17:27:22.517]                       inherits <- base::inherits
[17:27:22.517]                       invokeRestart <- base::invokeRestart
[17:27:22.517]                       is.null <- base::is.null
[17:27:22.517]                       muffled <- FALSE
[17:27:22.517]                       if (inherits(cond, "message")) {
[17:27:22.517]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.517]                         if (muffled) 
[17:27:22.517]                           invokeRestart("muffleMessage")
[17:27:22.517]                       }
[17:27:22.517]                       else if (inherits(cond, "warning")) {
[17:27:22.517]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.517]                         if (muffled) 
[17:27:22.517]                           invokeRestart("muffleWarning")
[17:27:22.517]                       }
[17:27:22.517]                       else if (inherits(cond, "condition")) {
[17:27:22.517]                         if (!is.null(pattern)) {
[17:27:22.517]                           computeRestarts <- base::computeRestarts
[17:27:22.517]                           grepl <- base::grepl
[17:27:22.517]                           restarts <- computeRestarts(cond)
[17:27:22.517]                           for (restart in restarts) {
[17:27:22.517]                             name <- restart$name
[17:27:22.517]                             if (is.null(name)) 
[17:27:22.517]                               next
[17:27:22.517]                             if (!grepl(pattern, name)) 
[17:27:22.517]                               next
[17:27:22.517]                             invokeRestart(restart)
[17:27:22.517]                             muffled <- TRUE
[17:27:22.517]                             break
[17:27:22.517]                           }
[17:27:22.517]                         }
[17:27:22.517]                       }
[17:27:22.517]                       invisible(muffled)
[17:27:22.517]                     }
[17:27:22.517]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.517]                   }
[17:27:22.517]                 }
[17:27:22.517]                 else {
[17:27:22.517]                   if (TRUE) {
[17:27:22.517]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:22.517]                     {
[17:27:22.517]                       inherits <- base::inherits
[17:27:22.517]                       invokeRestart <- base::invokeRestart
[17:27:22.517]                       is.null <- base::is.null
[17:27:22.517]                       muffled <- FALSE
[17:27:22.517]                       if (inherits(cond, "message")) {
[17:27:22.517]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:22.517]                         if (muffled) 
[17:27:22.517]                           invokeRestart("muffleMessage")
[17:27:22.517]                       }
[17:27:22.517]                       else if (inherits(cond, "warning")) {
[17:27:22.517]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:22.517]                         if (muffled) 
[17:27:22.517]                           invokeRestart("muffleWarning")
[17:27:22.517]                       }
[17:27:22.517]                       else if (inherits(cond, "condition")) {
[17:27:22.517]                         if (!is.null(pattern)) {
[17:27:22.517]                           computeRestarts <- base::computeRestarts
[17:27:22.517]                           grepl <- base::grepl
[17:27:22.517]                           restarts <- computeRestarts(cond)
[17:27:22.517]                           for (restart in restarts) {
[17:27:22.517]                             name <- restart$name
[17:27:22.517]                             if (is.null(name)) 
[17:27:22.517]                               next
[17:27:22.517]                             if (!grepl(pattern, name)) 
[17:27:22.517]                               next
[17:27:22.517]                             invokeRestart(restart)
[17:27:22.517]                             muffled <- TRUE
[17:27:22.517]                             break
[17:27:22.517]                           }
[17:27:22.517]                         }
[17:27:22.517]                       }
[17:27:22.517]                       invisible(muffled)
[17:27:22.517]                     }
[17:27:22.517]                     muffleCondition(cond, pattern = "^muffle")
[17:27:22.517]                   }
[17:27:22.517]                 }
[17:27:22.517]             }
[17:27:22.517]         }))
[17:27:22.517]     }, error = function(ex) {
[17:27:22.517]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:22.517]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:22.517]                 ...future.rng), started = ...future.startTime, 
[17:27:22.517]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:22.517]             version = "1.8"), class = "FutureResult")
[17:27:22.517]     }, finally = {
[17:27:22.517]         if (!identical(...future.workdir, getwd())) 
[17:27:22.517]             setwd(...future.workdir)
[17:27:22.517]         {
[17:27:22.517]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:22.517]                 ...future.oldOptions$nwarnings <- NULL
[17:27:22.517]             }
[17:27:22.517]             base::options(...future.oldOptions)
[17:27:22.517]             if (.Platform$OS.type == "windows") {
[17:27:22.517]                 old_names <- names(...future.oldEnvVars)
[17:27:22.517]                 envs <- base::Sys.getenv()
[17:27:22.517]                 names <- names(envs)
[17:27:22.517]                 common <- intersect(names, old_names)
[17:27:22.517]                 added <- setdiff(names, old_names)
[17:27:22.517]                 removed <- setdiff(old_names, names)
[17:27:22.517]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:22.517]                   envs[common]]
[17:27:22.517]                 NAMES <- toupper(changed)
[17:27:22.517]                 args <- list()
[17:27:22.517]                 for (kk in seq_along(NAMES)) {
[17:27:22.517]                   name <- changed[[kk]]
[17:27:22.517]                   NAME <- NAMES[[kk]]
[17:27:22.517]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.517]                     next
[17:27:22.517]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.517]                 }
[17:27:22.517]                 NAMES <- toupper(added)
[17:27:22.517]                 for (kk in seq_along(NAMES)) {
[17:27:22.517]                   name <- added[[kk]]
[17:27:22.517]                   NAME <- NAMES[[kk]]
[17:27:22.517]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.517]                     next
[17:27:22.517]                   args[[name]] <- ""
[17:27:22.517]                 }
[17:27:22.517]                 NAMES <- toupper(removed)
[17:27:22.517]                 for (kk in seq_along(NAMES)) {
[17:27:22.517]                   name <- removed[[kk]]
[17:27:22.517]                   NAME <- NAMES[[kk]]
[17:27:22.517]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:22.517]                     next
[17:27:22.517]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:22.517]                 }
[17:27:22.517]                 if (length(args) > 0) 
[17:27:22.517]                   base::do.call(base::Sys.setenv, args = args)
[17:27:22.517]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:22.517]             }
[17:27:22.517]             else {
[17:27:22.517]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:22.517]             }
[17:27:22.517]             {
[17:27:22.517]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:22.517]                   0L) {
[17:27:22.517]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:22.517]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:22.517]                   base::options(opts)
[17:27:22.517]                 }
[17:27:22.517]                 {
[17:27:22.517]                   {
[17:27:22.517]                     NULL
[17:27:22.517]                     RNGkind("Mersenne-Twister")
[17:27:22.517]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:27:22.517]                       inherits = FALSE)
[17:27:22.517]                   }
[17:27:22.517]                   options(future.plan = NULL)
[17:27:22.517]                   if (is.na(NA_character_)) 
[17:27:22.517]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:22.517]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:22.517]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:22.517]                     .init = FALSE)
[17:27:22.517]                 }
[17:27:22.517]             }
[17:27:22.517]         }
[17:27:22.517]     })
[17:27:22.517]     if (TRUE) {
[17:27:22.517]         base::sink(type = "output", split = FALSE)
[17:27:22.517]         if (TRUE) {
[17:27:22.517]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:22.517]         }
[17:27:22.517]         else {
[17:27:22.517]             ...future.result["stdout"] <- base::list(NULL)
[17:27:22.517]         }
[17:27:22.517]         base::close(...future.stdout)
[17:27:22.517]         ...future.stdout <- NULL
[17:27:22.517]     }
[17:27:22.517]     ...future.result$conditions <- ...future.conditions
[17:27:22.517]     ...future.result$finished <- base::Sys.time()
[17:27:22.517]     ...future.result
[17:27:22.517] }
[17:27:22.524] assign_globals() ...
[17:27:22.524] List of 1
[17:27:22.524]  $ a: num 10
[17:27:22.524]  - attr(*, "where")=List of 1
[17:27:22.524]   ..$ a:<environment: R_EmptyEnv> 
[17:27:22.524]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:27:22.524]  - attr(*, "resolved")= logi FALSE
[17:27:22.524]  - attr(*, "total_size")= int 39
[17:27:22.524]  - attr(*, "already-done")= logi TRUE
[17:27:22.529] - copied 'a' to environment
[17:27:22.530] assign_globals() ... done
[17:27:22.530] plan(): Setting new future strategy stack:
[17:27:22.531] List of future strategies:
[17:27:22.531] 1. sequential:
[17:27:22.531]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.531]    - tweaked: FALSE
[17:27:22.531]    - call: NULL
[17:27:22.532] plan(): nbrOfWorkers() = 1
[17:27:22.534] plan(): Setting new future strategy stack:
[17:27:22.534] List of future strategies:
[17:27:22.534] 1. sequential:
[17:27:22.534]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:22.534]    - tweaked: FALSE
[17:27:22.534]    - call: plan(strategy)
[17:27:22.535] plan(): nbrOfWorkers() = 1
[17:27:22.536] SequentialFuture started (and completed)
[17:27:22.536] - Launch lazy future ... done
[17:27:22.536] run() for 'SequentialFuture' ... done
b = 11
*** %<-% with 'sequential' futures ... DONE
Testing with 1 cores ... DONE
Testing with 2 cores ...
*** %<-% with 'multisession' futures ...
[17:27:22.548] plan(): Setting new future strategy stack:
[17:27:22.549] List of future strategies:
[17:27:22.549] 1. multisession:
[17:27:22.549]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:27:22.549]    - tweaked: FALSE
[17:27:22.549]    - call: plan(strategy)
[17:27:22.550] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:27:22.550] multisession:
[17:27:22.550] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:27:22.550] - tweaked: FALSE
[17:27:22.550] - call: plan(strategy)
[17:27:22.557] getGlobalsAndPackages() ...
[17:27:22.557] Not searching for globals
[17:27:22.562] - globals: [0] <none>
[17:27:22.562] getGlobalsAndPackages() ... DONE
[17:27:22.563] [local output] makeClusterPSOCK() ...
[17:27:22.642] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:27:22.651] [local output] Base port: 25382
[17:27:22.651] [local output] Getting setup options for 2 cluster nodes ...
[17:27:22.651] [local output]  - Node #1 of 2 ...
[17:27:22.652] [local output] localMachine=TRUE => revtunnel=FALSE

[17:27:22.655] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpygnjNg/worker.rank=1.parallelly.parent=158952.26ce86b202389.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpygnjNg/worker.rank=1.parallelly.parent=158952.26ce86b202389.pid\")"'
[17:27:23.220] - Possible to infer worker's PID: TRUE
[17:27:23.221] [local output] Rscript port: 25382

[17:27:23.222] [local output]  - Node #2 of 2 ...
[17:27:23.223] [local output] localMachine=TRUE => revtunnel=FALSE

[17:27:23.225] [local output] Rscript port: 25382

[17:27:23.226] [local output] Getting setup options for 2 cluster nodes ... done
[17:27:23.227] [local output]  - Parallel setup requested for some PSOCK nodes
[17:27:23.228] [local output] Setting up PSOCK nodes in parallel
[17:27:23.228] List of 36
[17:27:23.228]  $ worker          : chr "localhost"
[17:27:23.228]   ..- attr(*, "localhost")= logi TRUE
[17:27:23.228]  $ master          : chr "localhost"
[17:27:23.228]  $ port            : int 25382
[17:27:23.228]  $ connectTimeout  : num 120
[17:27:23.228]  $ timeout         : num 120
[17:27:23.228]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:27:23.228]  $ homogeneous     : logi TRUE
[17:27:23.228]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futureAssign_OP.R:158952:CRANWIN"| __truncated__
[17:27:23.228]  $ rscript_envs    : NULL
[17:27:23.228]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:27:23.228]  $ rscript_startup : NULL
[17:27:23.228]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:27:23.228]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:27:23.228]  $ methods         : logi TRUE
[17:27:23.228]  $ socketOptions   : chr "no-delay"
[17:27:23.228]  $ useXDR          : logi FALSE
[17:27:23.228]  $ outfile         : chr "/dev/null"
[17:27:23.228]  $ renice          : int NA
[17:27:23.228]  $ rshcmd          : NULL
[17:27:23.228]  $ user            : chr(0) 
[17:27:23.228]  $ revtunnel       : logi FALSE
[17:27:23.228]  $ rshlogfile      : NULL
[17:27:23.228]  $ rshopts         : chr(0) 
[17:27:23.228]  $ rank            : int 1
[17:27:23.228]  $ manual          : logi FALSE
[17:27:23.228]  $ dryrun          : logi FALSE
[17:27:23.228]  $ quiet           : logi FALSE
[17:27:23.228]  $ setup_strategy  : chr "parallel"
[17:27:23.228]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:27:23.228]  $ pidfile         : chr "D:/temp/RtmpygnjNg/worker.rank=1.parallelly.parent=158952.26ce86b202389.pid"
[17:27:23.228]  $ rshcmd_label    : NULL
[17:27:23.228]  $ rsh_call        : NULL
[17:27:23.228]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:27:23.228]  $ localMachine    : logi TRUE
[17:27:23.228]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:27:23.228]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:27:23.228]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:27:23.228]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:27:23.228]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:27:23.228]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:27:23.228]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:27:23.228]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:27:23.228]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:27:23.228]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:27:23.228]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:27:23.228]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:27:23.228]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:27:23.228]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:27:23.228]  $ arguments       :List of 28
[17:27:23.228]   ..$ worker          : chr "localhost"
[17:27:23.228]   ..$ master          : NULL
[17:27:23.228]   ..$ port            : int 25382
[17:27:23.228]   ..$ connectTimeout  : num 120
[17:27:23.228]   ..$ timeout         : num 120
[17:27:23.228]   ..$ rscript         : NULL
[17:27:23.228]   ..$ homogeneous     : NULL
[17:27:23.228]   ..$ rscript_args    : NULL
[17:27:23.228]   ..$ rscript_envs    : NULL
[17:27:23.228]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:27:23.228]   ..$ rscript_startup : NULL
[17:27:23.228]   ..$ rscript_sh      : chr "auto"
[17:27:23.228]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:27:23.228]   ..$ methods         : logi TRUE
[17:27:23.228]   ..$ socketOptions   : chr "no-delay"
[17:27:23.228]   ..$ useXDR          : logi FALSE
[17:27:23.228]   ..$ outfile         : chr "/dev/null"
[17:27:23.228]   ..$ renice          : int NA
[17:27:23.228]   ..$ rshcmd          : NULL
[17:27:23.228]   ..$ user            : NULL
[17:27:23.228]   ..$ revtunnel       : logi NA
[17:27:23.228]   ..$ rshlogfile      : NULL
[17:27:23.228]   ..$ rshopts         : NULL
[17:27:23.228]   ..$ rank            : int 1
[17:27:23.228]   ..$ manual          : logi FALSE
[17:27:23.228]   ..$ dryrun          : logi FALSE
[17:27:23.228]   ..$ quiet           : logi FALSE
[17:27:23.228]   ..$ setup_strategy  : chr "parallel"
[17:27:23.228]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:27:23.267] [local output] System call to launch all workers:
[17:27:23.267] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futureAssign_OP.R:158952:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpygnjNg/worker.rank=1.parallelly.parent=158952.26ce86b202389.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25382 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:27:23.268] [local output] Starting PSOCK main server
[17:27:23.275] [local output] Workers launched
[17:27:23.276] [local output] Waiting for workers to connect back
[17:27:23.276]  - [local output] 0 workers out of 2 ready
[17:27:23.531]  - [local output] 0 workers out of 2 ready
[17:27:23.532]  - [local output] 1 workers out of 2 ready
[17:27:23.543]  - [local output] 1 workers out of 2 ready
[17:27:23.544]  - [local output] 2 workers out of 2 ready
[17:27:23.544] [local output] Launching of 2 workers completed
[17:27:23.544] [local output] Number of nodes in cluster: 2
[17:27:23.544] [local output] Collecting session information from 2 workers
[17:27:23.546] [local output]  - Worker #1 of 2
[17:27:23.547] [local output]  - Worker #2 of 2
[17:27:23.547] [local output] makeClusterPSOCK() ... done
[17:27:23.565] Packages needed by the future expression (n = 0): <none>
[17:27:23.566] Packages needed by future strategies (n = 0): <none>
[17:27:23.567] {
[17:27:23.567]     {
[17:27:23.567]         {
[17:27:23.567]             ...future.startTime <- base::Sys.time()
[17:27:23.567]             {
[17:27:23.567]                 {
[17:27:23.567]                   {
[17:27:23.567]                     {
[17:27:23.567]                       base::local({
[17:27:23.567]                         has_future <- base::requireNamespace("future", 
[17:27:23.567]                           quietly = TRUE)
[17:27:23.567]                         if (has_future) {
[17:27:23.567]                           ns <- base::getNamespace("future")
[17:27:23.567]                           version <- ns[[".package"]][["version"]]
[17:27:23.567]                           if (is.null(version)) 
[17:27:23.567]                             version <- utils::packageVersion("future")
[17:27:23.567]                         }
[17:27:23.567]                         else {
[17:27:23.567]                           version <- NULL
[17:27:23.567]                         }
[17:27:23.567]                         if (!has_future || version < "1.8.0") {
[17:27:23.567]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:23.567]                             "", base::R.version$version.string), 
[17:27:23.567]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:23.567]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:23.567]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:23.567]                               "release", "version")], collapse = " "), 
[17:27:23.567]                             hostname = base::Sys.info()[["nodename"]])
[17:27:23.567]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:23.567]                             info)
[17:27:23.567]                           info <- base::paste(info, collapse = "; ")
[17:27:23.567]                           if (!has_future) {
[17:27:23.567]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:23.567]                               info)
[17:27:23.567]                           }
[17:27:23.567]                           else {
[17:27:23.567]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:23.567]                               info, version)
[17:27:23.567]                           }
[17:27:23.567]                           base::stop(msg)
[17:27:23.567]                         }
[17:27:23.567]                       })
[17:27:23.567]                     }
[17:27:23.567]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:23.567]                     base::options(mc.cores = 1L)
[17:27:23.567]                   }
[17:27:23.567]                   ...future.strategy.old <- future::plan("list")
[17:27:23.567]                   options(future.plan = NULL)
[17:27:23.567]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.567]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:23.567]                 }
[17:27:23.567]                 ...future.workdir <- getwd()
[17:27:23.567]             }
[17:27:23.567]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:23.567]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:23.567]         }
[17:27:23.567]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:23.567]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:23.567]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:23.567]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:23.567]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:23.567]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:23.567]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:23.567]             base::names(...future.oldOptions))
[17:27:23.567]     }
[17:27:23.567]     if (FALSE) {
[17:27:23.567]     }
[17:27:23.567]     else {
[17:27:23.567]         if (TRUE) {
[17:27:23.567]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:23.567]                 open = "w")
[17:27:23.567]         }
[17:27:23.567]         else {
[17:27:23.567]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:23.567]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:23.567]         }
[17:27:23.567]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:23.567]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:23.567]             base::sink(type = "output", split = FALSE)
[17:27:23.567]             base::close(...future.stdout)
[17:27:23.567]         }, add = TRUE)
[17:27:23.567]     }
[17:27:23.567]     ...future.frame <- base::sys.nframe()
[17:27:23.567]     ...future.conditions <- base::list()
[17:27:23.567]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:23.567]     if (FALSE) {
[17:27:23.567]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:23.567]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:23.567]     }
[17:27:23.567]     ...future.result <- base::tryCatch({
[17:27:23.567]         base::withCallingHandlers({
[17:27:23.567]             ...future.value <- base::withVisible(base::local({
[17:27:23.567]                 ...future.makeSendCondition <- base::local({
[17:27:23.567]                   sendCondition <- NULL
[17:27:23.567]                   function(frame = 1L) {
[17:27:23.567]                     if (is.function(sendCondition)) 
[17:27:23.567]                       return(sendCondition)
[17:27:23.567]                     ns <- getNamespace("parallel")
[17:27:23.567]                     if (exists("sendData", mode = "function", 
[17:27:23.567]                       envir = ns)) {
[17:27:23.567]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:23.567]                         envir = ns)
[17:27:23.567]                       envir <- sys.frame(frame)
[17:27:23.567]                       master <- NULL
[17:27:23.567]                       while (!identical(envir, .GlobalEnv) && 
[17:27:23.567]                         !identical(envir, emptyenv())) {
[17:27:23.567]                         if (exists("master", mode = "list", envir = envir, 
[17:27:23.567]                           inherits = FALSE)) {
[17:27:23.567]                           master <- get("master", mode = "list", 
[17:27:23.567]                             envir = envir, inherits = FALSE)
[17:27:23.567]                           if (inherits(master, c("SOCKnode", 
[17:27:23.567]                             "SOCK0node"))) {
[17:27:23.567]                             sendCondition <<- function(cond) {
[17:27:23.567]                               data <- list(type = "VALUE", value = cond, 
[17:27:23.567]                                 success = TRUE)
[17:27:23.567]                               parallel_sendData(master, data)
[17:27:23.567]                             }
[17:27:23.567]                             return(sendCondition)
[17:27:23.567]                           }
[17:27:23.567]                         }
[17:27:23.567]                         frame <- frame + 1L
[17:27:23.567]                         envir <- sys.frame(frame)
[17:27:23.567]                       }
[17:27:23.567]                     }
[17:27:23.567]                     sendCondition <<- function(cond) NULL
[17:27:23.567]                   }
[17:27:23.567]                 })
[17:27:23.567]                 withCallingHandlers({
[17:27:23.567]                   NA
[17:27:23.567]                 }, immediateCondition = function(cond) {
[17:27:23.567]                   sendCondition <- ...future.makeSendCondition()
[17:27:23.567]                   sendCondition(cond)
[17:27:23.567]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.567]                   {
[17:27:23.567]                     inherits <- base::inherits
[17:27:23.567]                     invokeRestart <- base::invokeRestart
[17:27:23.567]                     is.null <- base::is.null
[17:27:23.567]                     muffled <- FALSE
[17:27:23.567]                     if (inherits(cond, "message")) {
[17:27:23.567]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:23.567]                       if (muffled) 
[17:27:23.567]                         invokeRestart("muffleMessage")
[17:27:23.567]                     }
[17:27:23.567]                     else if (inherits(cond, "warning")) {
[17:27:23.567]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:23.567]                       if (muffled) 
[17:27:23.567]                         invokeRestart("muffleWarning")
[17:27:23.567]                     }
[17:27:23.567]                     else if (inherits(cond, "condition")) {
[17:27:23.567]                       if (!is.null(pattern)) {
[17:27:23.567]                         computeRestarts <- base::computeRestarts
[17:27:23.567]                         grepl <- base::grepl
[17:27:23.567]                         restarts <- computeRestarts(cond)
[17:27:23.567]                         for (restart in restarts) {
[17:27:23.567]                           name <- restart$name
[17:27:23.567]                           if (is.null(name)) 
[17:27:23.567]                             next
[17:27:23.567]                           if (!grepl(pattern, name)) 
[17:27:23.567]                             next
[17:27:23.567]                           invokeRestart(restart)
[17:27:23.567]                           muffled <- TRUE
[17:27:23.567]                           break
[17:27:23.567]                         }
[17:27:23.567]                       }
[17:27:23.567]                     }
[17:27:23.567]                     invisible(muffled)
[17:27:23.567]                   }
[17:27:23.567]                   muffleCondition(cond)
[17:27:23.567]                 })
[17:27:23.567]             }))
[17:27:23.567]             future::FutureResult(value = ...future.value$value, 
[17:27:23.567]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.567]                   ...future.rng), globalenv = if (FALSE) 
[17:27:23.567]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:23.567]                     ...future.globalenv.names))
[17:27:23.567]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:23.567]         }, condition = base::local({
[17:27:23.567]             c <- base::c
[17:27:23.567]             inherits <- base::inherits
[17:27:23.567]             invokeRestart <- base::invokeRestart
[17:27:23.567]             length <- base::length
[17:27:23.567]             list <- base::list
[17:27:23.567]             seq.int <- base::seq.int
[17:27:23.567]             signalCondition <- base::signalCondition
[17:27:23.567]             sys.calls <- base::sys.calls
[17:27:23.567]             `[[` <- base::`[[`
[17:27:23.567]             `+` <- base::`+`
[17:27:23.567]             `<<-` <- base::`<<-`
[17:27:23.567]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:23.567]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:23.567]                   3L)]
[17:27:23.567]             }
[17:27:23.567]             function(cond) {
[17:27:23.567]                 is_error <- inherits(cond, "error")
[17:27:23.567]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:23.567]                   NULL)
[17:27:23.567]                 if (is_error) {
[17:27:23.567]                   sessionInformation <- function() {
[17:27:23.567]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:23.567]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:23.567]                       search = base::search(), system = base::Sys.info())
[17:27:23.567]                   }
[17:27:23.567]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.567]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:23.567]                     cond$call), session = sessionInformation(), 
[17:27:23.567]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:23.567]                   signalCondition(cond)
[17:27:23.567]                 }
[17:27:23.567]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:23.567]                 "immediateCondition"))) {
[17:27:23.567]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:23.567]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.567]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:23.567]                   if (TRUE && !signal) {
[17:27:23.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.567]                     {
[17:27:23.567]                       inherits <- base::inherits
[17:27:23.567]                       invokeRestart <- base::invokeRestart
[17:27:23.567]                       is.null <- base::is.null
[17:27:23.567]                       muffled <- FALSE
[17:27:23.567]                       if (inherits(cond, "message")) {
[17:27:23.567]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.567]                         if (muffled) 
[17:27:23.567]                           invokeRestart("muffleMessage")
[17:27:23.567]                       }
[17:27:23.567]                       else if (inherits(cond, "warning")) {
[17:27:23.567]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.567]                         if (muffled) 
[17:27:23.567]                           invokeRestart("muffleWarning")
[17:27:23.567]                       }
[17:27:23.567]                       else if (inherits(cond, "condition")) {
[17:27:23.567]                         if (!is.null(pattern)) {
[17:27:23.567]                           computeRestarts <- base::computeRestarts
[17:27:23.567]                           grepl <- base::grepl
[17:27:23.567]                           restarts <- computeRestarts(cond)
[17:27:23.567]                           for (restart in restarts) {
[17:27:23.567]                             name <- restart$name
[17:27:23.567]                             if (is.null(name)) 
[17:27:23.567]                               next
[17:27:23.567]                             if (!grepl(pattern, name)) 
[17:27:23.567]                               next
[17:27:23.567]                             invokeRestart(restart)
[17:27:23.567]                             muffled <- TRUE
[17:27:23.567]                             break
[17:27:23.567]                           }
[17:27:23.567]                         }
[17:27:23.567]                       }
[17:27:23.567]                       invisible(muffled)
[17:27:23.567]                     }
[17:27:23.567]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.567]                   }
[17:27:23.567]                 }
[17:27:23.567]                 else {
[17:27:23.567]                   if (TRUE) {
[17:27:23.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.567]                     {
[17:27:23.567]                       inherits <- base::inherits
[17:27:23.567]                       invokeRestart <- base::invokeRestart
[17:27:23.567]                       is.null <- base::is.null
[17:27:23.567]                       muffled <- FALSE
[17:27:23.567]                       if (inherits(cond, "message")) {
[17:27:23.567]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.567]                         if (muffled) 
[17:27:23.567]                           invokeRestart("muffleMessage")
[17:27:23.567]                       }
[17:27:23.567]                       else if (inherits(cond, "warning")) {
[17:27:23.567]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.567]                         if (muffled) 
[17:27:23.567]                           invokeRestart("muffleWarning")
[17:27:23.567]                       }
[17:27:23.567]                       else if (inherits(cond, "condition")) {
[17:27:23.567]                         if (!is.null(pattern)) {
[17:27:23.567]                           computeRestarts <- base::computeRestarts
[17:27:23.567]                           grepl <- base::grepl
[17:27:23.567]                           restarts <- computeRestarts(cond)
[17:27:23.567]                           for (restart in restarts) {
[17:27:23.567]                             name <- restart$name
[17:27:23.567]                             if (is.null(name)) 
[17:27:23.567]                               next
[17:27:23.567]                             if (!grepl(pattern, name)) 
[17:27:23.567]                               next
[17:27:23.567]                             invokeRestart(restart)
[17:27:23.567]                             muffled <- TRUE
[17:27:23.567]                             break
[17:27:23.567]                           }
[17:27:23.567]                         }
[17:27:23.567]                       }
[17:27:23.567]                       invisible(muffled)
[17:27:23.567]                     }
[17:27:23.567]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.567]                   }
[17:27:23.567]                 }
[17:27:23.567]             }
[17:27:23.567]         }))
[17:27:23.567]     }, error = function(ex) {
[17:27:23.567]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:23.567]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.567]                 ...future.rng), started = ...future.startTime, 
[17:27:23.567]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:23.567]             version = "1.8"), class = "FutureResult")
[17:27:23.567]     }, finally = {
[17:27:23.567]         if (!identical(...future.workdir, getwd())) 
[17:27:23.567]             setwd(...future.workdir)
[17:27:23.567]         {
[17:27:23.567]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:23.567]                 ...future.oldOptions$nwarnings <- NULL
[17:27:23.567]             }
[17:27:23.567]             base::options(...future.oldOptions)
[17:27:23.567]             if (.Platform$OS.type == "windows") {
[17:27:23.567]                 old_names <- names(...future.oldEnvVars)
[17:27:23.567]                 envs <- base::Sys.getenv()
[17:27:23.567]                 names <- names(envs)
[17:27:23.567]                 common <- intersect(names, old_names)
[17:27:23.567]                 added <- setdiff(names, old_names)
[17:27:23.567]                 removed <- setdiff(old_names, names)
[17:27:23.567]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:23.567]                   envs[common]]
[17:27:23.567]                 NAMES <- toupper(changed)
[17:27:23.567]                 args <- list()
[17:27:23.567]                 for (kk in seq_along(NAMES)) {
[17:27:23.567]                   name <- changed[[kk]]
[17:27:23.567]                   NAME <- NAMES[[kk]]
[17:27:23.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.567]                     next
[17:27:23.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.567]                 }
[17:27:23.567]                 NAMES <- toupper(added)
[17:27:23.567]                 for (kk in seq_along(NAMES)) {
[17:27:23.567]                   name <- added[[kk]]
[17:27:23.567]                   NAME <- NAMES[[kk]]
[17:27:23.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.567]                     next
[17:27:23.567]                   args[[name]] <- ""
[17:27:23.567]                 }
[17:27:23.567]                 NAMES <- toupper(removed)
[17:27:23.567]                 for (kk in seq_along(NAMES)) {
[17:27:23.567]                   name <- removed[[kk]]
[17:27:23.567]                   NAME <- NAMES[[kk]]
[17:27:23.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.567]                     next
[17:27:23.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.567]                 }
[17:27:23.567]                 if (length(args) > 0) 
[17:27:23.567]                   base::do.call(base::Sys.setenv, args = args)
[17:27:23.567]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:23.567]             }
[17:27:23.567]             else {
[17:27:23.567]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:23.567]             }
[17:27:23.567]             {
[17:27:23.567]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:23.567]                   0L) {
[17:27:23.567]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:23.567]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:23.567]                   base::options(opts)
[17:27:23.567]                 }
[17:27:23.567]                 {
[17:27:23.567]                   {
[17:27:23.567]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:23.567]                     NULL
[17:27:23.567]                   }
[17:27:23.567]                   options(future.plan = NULL)
[17:27:23.567]                   if (is.na(NA_character_)) 
[17:27:23.567]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.567]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:23.567]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:23.567]                     .init = FALSE)
[17:27:23.567]                 }
[17:27:23.567]             }
[17:27:23.567]         }
[17:27:23.567]     })
[17:27:23.567]     if (TRUE) {
[17:27:23.567]         base::sink(type = "output", split = FALSE)
[17:27:23.567]         if (TRUE) {
[17:27:23.567]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:23.567]         }
[17:27:23.567]         else {
[17:27:23.567]             ...future.result["stdout"] <- base::list(NULL)
[17:27:23.567]         }
[17:27:23.567]         base::close(...future.stdout)
[17:27:23.567]         ...future.stdout <- NULL
[17:27:23.567]     }
[17:27:23.567]     ...future.result$conditions <- ...future.conditions
[17:27:23.567]     ...future.result$finished <- base::Sys.time()
[17:27:23.567]     ...future.result
[17:27:23.567] }
[17:27:23.685] MultisessionFuture started
[17:27:23.686] result() for ClusterFuture ...
[17:27:23.686] receiveMessageFromWorker() for ClusterFuture ...
[17:27:23.687] - Validating connection of MultisessionFuture
[17:27:23.769] - received message: FutureResult
[17:27:23.770] - Received FutureResult
[17:27:23.776] - Erased future from FutureRegistry
[17:27:23.777] result() for ClusterFuture ...
[17:27:23.777] - result already collected: FutureResult
[17:27:23.777] result() for ClusterFuture ... done
[17:27:23.778] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:23.778] result() for ClusterFuture ... done
[17:27:23.779] result() for ClusterFuture ...
[17:27:23.779] - result already collected: FutureResult
[17:27:23.779] result() for ClusterFuture ... done
[17:27:23.780] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:27:23.785] plan(): nbrOfWorkers() = 2
** Future evaluation without globals
[17:27:23.786] getGlobalsAndPackages() ...
[17:27:23.786] Searching for globals...
[17:27:23.789] - globals found: [2] '{', '<-'
[17:27:23.789] Searching for globals ... DONE
[17:27:23.789] Resolving globals: FALSE
[17:27:23.790] 
[17:27:23.791] 
[17:27:23.791] getGlobalsAndPackages() ... DONE
[17:27:23.792] run() for 'Future' ...
[17:27:23.792] - state: 'created'
[17:27:23.792] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:23.814] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:23.814] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:23.814]   - Field: 'node'
[17:27:23.815]   - Field: 'label'
[17:27:23.815]   - Field: 'local'
[17:27:23.815]   - Field: 'owner'
[17:27:23.816]   - Field: 'envir'
[17:27:23.816]   - Field: 'workers'
[17:27:23.816]   - Field: 'packages'
[17:27:23.816]   - Field: 'gc'
[17:27:23.817]   - Field: 'conditions'
[17:27:23.817]   - Field: 'persistent'
[17:27:23.817]   - Field: 'expr'
[17:27:23.818]   - Field: 'uuid'
[17:27:23.818]   - Field: 'seed'
[17:27:23.818]   - Field: 'version'
[17:27:23.818]   - Field: 'result'
[17:27:23.819]   - Field: 'asynchronous'
[17:27:23.819]   - Field: 'calls'
[17:27:23.819]   - Field: 'globals'
[17:27:23.820]   - Field: 'stdout'
[17:27:23.820]   - Field: 'earlySignal'
[17:27:23.820]   - Field: 'lazy'
[17:27:23.821]   - Field: 'state'
[17:27:23.821] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:23.821] - Launch lazy future ...
[17:27:23.822] Packages needed by the future expression (n = 0): <none>
[17:27:23.822] Packages needed by future strategies (n = 0): <none>
[17:27:23.823] {
[17:27:23.823]     {
[17:27:23.823]         {
[17:27:23.823]             ...future.startTime <- base::Sys.time()
[17:27:23.823]             {
[17:27:23.823]                 {
[17:27:23.823]                   {
[17:27:23.823]                     {
[17:27:23.823]                       base::local({
[17:27:23.823]                         has_future <- base::requireNamespace("future", 
[17:27:23.823]                           quietly = TRUE)
[17:27:23.823]                         if (has_future) {
[17:27:23.823]                           ns <- base::getNamespace("future")
[17:27:23.823]                           version <- ns[[".package"]][["version"]]
[17:27:23.823]                           if (is.null(version)) 
[17:27:23.823]                             version <- utils::packageVersion("future")
[17:27:23.823]                         }
[17:27:23.823]                         else {
[17:27:23.823]                           version <- NULL
[17:27:23.823]                         }
[17:27:23.823]                         if (!has_future || version < "1.8.0") {
[17:27:23.823]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:23.823]                             "", base::R.version$version.string), 
[17:27:23.823]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:23.823]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:23.823]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:23.823]                               "release", "version")], collapse = " "), 
[17:27:23.823]                             hostname = base::Sys.info()[["nodename"]])
[17:27:23.823]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:23.823]                             info)
[17:27:23.823]                           info <- base::paste(info, collapse = "; ")
[17:27:23.823]                           if (!has_future) {
[17:27:23.823]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:23.823]                               info)
[17:27:23.823]                           }
[17:27:23.823]                           else {
[17:27:23.823]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:23.823]                               info, version)
[17:27:23.823]                           }
[17:27:23.823]                           base::stop(msg)
[17:27:23.823]                         }
[17:27:23.823]                       })
[17:27:23.823]                     }
[17:27:23.823]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:23.823]                     base::options(mc.cores = 1L)
[17:27:23.823]                   }
[17:27:23.823]                   ...future.strategy.old <- future::plan("list")
[17:27:23.823]                   options(future.plan = NULL)
[17:27:23.823]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.823]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:23.823]                 }
[17:27:23.823]                 ...future.workdir <- getwd()
[17:27:23.823]             }
[17:27:23.823]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:23.823]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:23.823]         }
[17:27:23.823]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:23.823]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:23.823]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:23.823]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:23.823]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:23.823]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:23.823]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:23.823]             base::names(...future.oldOptions))
[17:27:23.823]     }
[17:27:23.823]     if (FALSE) {
[17:27:23.823]     }
[17:27:23.823]     else {
[17:27:23.823]         if (TRUE) {
[17:27:23.823]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:23.823]                 open = "w")
[17:27:23.823]         }
[17:27:23.823]         else {
[17:27:23.823]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:23.823]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:23.823]         }
[17:27:23.823]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:23.823]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:23.823]             base::sink(type = "output", split = FALSE)
[17:27:23.823]             base::close(...future.stdout)
[17:27:23.823]         }, add = TRUE)
[17:27:23.823]     }
[17:27:23.823]     ...future.frame <- base::sys.nframe()
[17:27:23.823]     ...future.conditions <- base::list()
[17:27:23.823]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:23.823]     if (FALSE) {
[17:27:23.823]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:23.823]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:23.823]     }
[17:27:23.823]     ...future.result <- base::tryCatch({
[17:27:23.823]         base::withCallingHandlers({
[17:27:23.823]             ...future.value <- base::withVisible(base::local({
[17:27:23.823]                 ...future.makeSendCondition <- base::local({
[17:27:23.823]                   sendCondition <- NULL
[17:27:23.823]                   function(frame = 1L) {
[17:27:23.823]                     if (is.function(sendCondition)) 
[17:27:23.823]                       return(sendCondition)
[17:27:23.823]                     ns <- getNamespace("parallel")
[17:27:23.823]                     if (exists("sendData", mode = "function", 
[17:27:23.823]                       envir = ns)) {
[17:27:23.823]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:23.823]                         envir = ns)
[17:27:23.823]                       envir <- sys.frame(frame)
[17:27:23.823]                       master <- NULL
[17:27:23.823]                       while (!identical(envir, .GlobalEnv) && 
[17:27:23.823]                         !identical(envir, emptyenv())) {
[17:27:23.823]                         if (exists("master", mode = "list", envir = envir, 
[17:27:23.823]                           inherits = FALSE)) {
[17:27:23.823]                           master <- get("master", mode = "list", 
[17:27:23.823]                             envir = envir, inherits = FALSE)
[17:27:23.823]                           if (inherits(master, c("SOCKnode", 
[17:27:23.823]                             "SOCK0node"))) {
[17:27:23.823]                             sendCondition <<- function(cond) {
[17:27:23.823]                               data <- list(type = "VALUE", value = cond, 
[17:27:23.823]                                 success = TRUE)
[17:27:23.823]                               parallel_sendData(master, data)
[17:27:23.823]                             }
[17:27:23.823]                             return(sendCondition)
[17:27:23.823]                           }
[17:27:23.823]                         }
[17:27:23.823]                         frame <- frame + 1L
[17:27:23.823]                         envir <- sys.frame(frame)
[17:27:23.823]                       }
[17:27:23.823]                     }
[17:27:23.823]                     sendCondition <<- function(cond) NULL
[17:27:23.823]                   }
[17:27:23.823]                 })
[17:27:23.823]                 withCallingHandlers({
[17:27:23.823]                   {
[17:27:23.823]                     x <- 1
[17:27:23.823]                   }
[17:27:23.823]                 }, immediateCondition = function(cond) {
[17:27:23.823]                   sendCondition <- ...future.makeSendCondition()
[17:27:23.823]                   sendCondition(cond)
[17:27:23.823]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.823]                   {
[17:27:23.823]                     inherits <- base::inherits
[17:27:23.823]                     invokeRestart <- base::invokeRestart
[17:27:23.823]                     is.null <- base::is.null
[17:27:23.823]                     muffled <- FALSE
[17:27:23.823]                     if (inherits(cond, "message")) {
[17:27:23.823]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:23.823]                       if (muffled) 
[17:27:23.823]                         invokeRestart("muffleMessage")
[17:27:23.823]                     }
[17:27:23.823]                     else if (inherits(cond, "warning")) {
[17:27:23.823]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:23.823]                       if (muffled) 
[17:27:23.823]                         invokeRestart("muffleWarning")
[17:27:23.823]                     }
[17:27:23.823]                     else if (inherits(cond, "condition")) {
[17:27:23.823]                       if (!is.null(pattern)) {
[17:27:23.823]                         computeRestarts <- base::computeRestarts
[17:27:23.823]                         grepl <- base::grepl
[17:27:23.823]                         restarts <- computeRestarts(cond)
[17:27:23.823]                         for (restart in restarts) {
[17:27:23.823]                           name <- restart$name
[17:27:23.823]                           if (is.null(name)) 
[17:27:23.823]                             next
[17:27:23.823]                           if (!grepl(pattern, name)) 
[17:27:23.823]                             next
[17:27:23.823]                           invokeRestart(restart)
[17:27:23.823]                           muffled <- TRUE
[17:27:23.823]                           break
[17:27:23.823]                         }
[17:27:23.823]                       }
[17:27:23.823]                     }
[17:27:23.823]                     invisible(muffled)
[17:27:23.823]                   }
[17:27:23.823]                   muffleCondition(cond)
[17:27:23.823]                 })
[17:27:23.823]             }))
[17:27:23.823]             future::FutureResult(value = ...future.value$value, 
[17:27:23.823]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.823]                   ...future.rng), globalenv = if (FALSE) 
[17:27:23.823]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:23.823]                     ...future.globalenv.names))
[17:27:23.823]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:23.823]         }, condition = base::local({
[17:27:23.823]             c <- base::c
[17:27:23.823]             inherits <- base::inherits
[17:27:23.823]             invokeRestart <- base::invokeRestart
[17:27:23.823]             length <- base::length
[17:27:23.823]             list <- base::list
[17:27:23.823]             seq.int <- base::seq.int
[17:27:23.823]             signalCondition <- base::signalCondition
[17:27:23.823]             sys.calls <- base::sys.calls
[17:27:23.823]             `[[` <- base::`[[`
[17:27:23.823]             `+` <- base::`+`
[17:27:23.823]             `<<-` <- base::`<<-`
[17:27:23.823]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:23.823]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:23.823]                   3L)]
[17:27:23.823]             }
[17:27:23.823]             function(cond) {
[17:27:23.823]                 is_error <- inherits(cond, "error")
[17:27:23.823]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:23.823]                   NULL)
[17:27:23.823]                 if (is_error) {
[17:27:23.823]                   sessionInformation <- function() {
[17:27:23.823]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:23.823]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:23.823]                       search = base::search(), system = base::Sys.info())
[17:27:23.823]                   }
[17:27:23.823]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.823]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:23.823]                     cond$call), session = sessionInformation(), 
[17:27:23.823]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:23.823]                   signalCondition(cond)
[17:27:23.823]                 }
[17:27:23.823]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:23.823]                 "immediateCondition"))) {
[17:27:23.823]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:23.823]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.823]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:23.823]                   if (TRUE && !signal) {
[17:27:23.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.823]                     {
[17:27:23.823]                       inherits <- base::inherits
[17:27:23.823]                       invokeRestart <- base::invokeRestart
[17:27:23.823]                       is.null <- base::is.null
[17:27:23.823]                       muffled <- FALSE
[17:27:23.823]                       if (inherits(cond, "message")) {
[17:27:23.823]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.823]                         if (muffled) 
[17:27:23.823]                           invokeRestart("muffleMessage")
[17:27:23.823]                       }
[17:27:23.823]                       else if (inherits(cond, "warning")) {
[17:27:23.823]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.823]                         if (muffled) 
[17:27:23.823]                           invokeRestart("muffleWarning")
[17:27:23.823]                       }
[17:27:23.823]                       else if (inherits(cond, "condition")) {
[17:27:23.823]                         if (!is.null(pattern)) {
[17:27:23.823]                           computeRestarts <- base::computeRestarts
[17:27:23.823]                           grepl <- base::grepl
[17:27:23.823]                           restarts <- computeRestarts(cond)
[17:27:23.823]                           for (restart in restarts) {
[17:27:23.823]                             name <- restart$name
[17:27:23.823]                             if (is.null(name)) 
[17:27:23.823]                               next
[17:27:23.823]                             if (!grepl(pattern, name)) 
[17:27:23.823]                               next
[17:27:23.823]                             invokeRestart(restart)
[17:27:23.823]                             muffled <- TRUE
[17:27:23.823]                             break
[17:27:23.823]                           }
[17:27:23.823]                         }
[17:27:23.823]                       }
[17:27:23.823]                       invisible(muffled)
[17:27:23.823]                     }
[17:27:23.823]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.823]                   }
[17:27:23.823]                 }
[17:27:23.823]                 else {
[17:27:23.823]                   if (TRUE) {
[17:27:23.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.823]                     {
[17:27:23.823]                       inherits <- base::inherits
[17:27:23.823]                       invokeRestart <- base::invokeRestart
[17:27:23.823]                       is.null <- base::is.null
[17:27:23.823]                       muffled <- FALSE
[17:27:23.823]                       if (inherits(cond, "message")) {
[17:27:23.823]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.823]                         if (muffled) 
[17:27:23.823]                           invokeRestart("muffleMessage")
[17:27:23.823]                       }
[17:27:23.823]                       else if (inherits(cond, "warning")) {
[17:27:23.823]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.823]                         if (muffled) 
[17:27:23.823]                           invokeRestart("muffleWarning")
[17:27:23.823]                       }
[17:27:23.823]                       else if (inherits(cond, "condition")) {
[17:27:23.823]                         if (!is.null(pattern)) {
[17:27:23.823]                           computeRestarts <- base::computeRestarts
[17:27:23.823]                           grepl <- base::grepl
[17:27:23.823]                           restarts <- computeRestarts(cond)
[17:27:23.823]                           for (restart in restarts) {
[17:27:23.823]                             name <- restart$name
[17:27:23.823]                             if (is.null(name)) 
[17:27:23.823]                               next
[17:27:23.823]                             if (!grepl(pattern, name)) 
[17:27:23.823]                               next
[17:27:23.823]                             invokeRestart(restart)
[17:27:23.823]                             muffled <- TRUE
[17:27:23.823]                             break
[17:27:23.823]                           }
[17:27:23.823]                         }
[17:27:23.823]                       }
[17:27:23.823]                       invisible(muffled)
[17:27:23.823]                     }
[17:27:23.823]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.823]                   }
[17:27:23.823]                 }
[17:27:23.823]             }
[17:27:23.823]         }))
[17:27:23.823]     }, error = function(ex) {
[17:27:23.823]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:23.823]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.823]                 ...future.rng), started = ...future.startTime, 
[17:27:23.823]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:23.823]             version = "1.8"), class = "FutureResult")
[17:27:23.823]     }, finally = {
[17:27:23.823]         if (!identical(...future.workdir, getwd())) 
[17:27:23.823]             setwd(...future.workdir)
[17:27:23.823]         {
[17:27:23.823]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:23.823]                 ...future.oldOptions$nwarnings <- NULL
[17:27:23.823]             }
[17:27:23.823]             base::options(...future.oldOptions)
[17:27:23.823]             if (.Platform$OS.type == "windows") {
[17:27:23.823]                 old_names <- names(...future.oldEnvVars)
[17:27:23.823]                 envs <- base::Sys.getenv()
[17:27:23.823]                 names <- names(envs)
[17:27:23.823]                 common <- intersect(names, old_names)
[17:27:23.823]                 added <- setdiff(names, old_names)
[17:27:23.823]                 removed <- setdiff(old_names, names)
[17:27:23.823]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:23.823]                   envs[common]]
[17:27:23.823]                 NAMES <- toupper(changed)
[17:27:23.823]                 args <- list()
[17:27:23.823]                 for (kk in seq_along(NAMES)) {
[17:27:23.823]                   name <- changed[[kk]]
[17:27:23.823]                   NAME <- NAMES[[kk]]
[17:27:23.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.823]                     next
[17:27:23.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.823]                 }
[17:27:23.823]                 NAMES <- toupper(added)
[17:27:23.823]                 for (kk in seq_along(NAMES)) {
[17:27:23.823]                   name <- added[[kk]]
[17:27:23.823]                   NAME <- NAMES[[kk]]
[17:27:23.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.823]                     next
[17:27:23.823]                   args[[name]] <- ""
[17:27:23.823]                 }
[17:27:23.823]                 NAMES <- toupper(removed)
[17:27:23.823]                 for (kk in seq_along(NAMES)) {
[17:27:23.823]                   name <- removed[[kk]]
[17:27:23.823]                   NAME <- NAMES[[kk]]
[17:27:23.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.823]                     next
[17:27:23.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.823]                 }
[17:27:23.823]                 if (length(args) > 0) 
[17:27:23.823]                   base::do.call(base::Sys.setenv, args = args)
[17:27:23.823]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:23.823]             }
[17:27:23.823]             else {
[17:27:23.823]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:23.823]             }
[17:27:23.823]             {
[17:27:23.823]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:23.823]                   0L) {
[17:27:23.823]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:23.823]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:23.823]                   base::options(opts)
[17:27:23.823]                 }
[17:27:23.823]                 {
[17:27:23.823]                   {
[17:27:23.823]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:23.823]                     NULL
[17:27:23.823]                   }
[17:27:23.823]                   options(future.plan = NULL)
[17:27:23.823]                   if (is.na(NA_character_)) 
[17:27:23.823]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.823]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:23.823]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:23.823]                     .init = FALSE)
[17:27:23.823]                 }
[17:27:23.823]             }
[17:27:23.823]         }
[17:27:23.823]     })
[17:27:23.823]     if (TRUE) {
[17:27:23.823]         base::sink(type = "output", split = FALSE)
[17:27:23.823]         if (TRUE) {
[17:27:23.823]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:23.823]         }
[17:27:23.823]         else {
[17:27:23.823]             ...future.result["stdout"] <- base::list(NULL)
[17:27:23.823]         }
[17:27:23.823]         base::close(...future.stdout)
[17:27:23.823]         ...future.stdout <- NULL
[17:27:23.823]     }
[17:27:23.823]     ...future.result$conditions <- ...future.conditions
[17:27:23.823]     ...future.result$finished <- base::Sys.time()
[17:27:23.823]     ...future.result
[17:27:23.823] }
[17:27:23.833] MultisessionFuture started
[17:27:23.833] - Launch lazy future ... done
[17:27:23.834] run() for 'MultisessionFuture' ... done
[17:27:23.834] result() for ClusterFuture ...
[17:27:23.834] receiveMessageFromWorker() for ClusterFuture ...
[17:27:23.835] - Validating connection of MultisessionFuture
[17:27:23.864] - received message: FutureResult
[17:27:23.865] - Received FutureResult
[17:27:23.866] - Erased future from FutureRegistry
[17:27:23.866] result() for ClusterFuture ...
[17:27:23.866] - result already collected: FutureResult
[17:27:23.867] result() for ClusterFuture ... done
[17:27:23.867] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:23.867] result() for ClusterFuture ... done
[17:27:23.868] result() for ClusterFuture ...
[17:27:23.868] - result already collected: FutureResult
[17:27:23.868] result() for ClusterFuture ... done
** Future evaluation with globals
[17:27:23.870] getGlobalsAndPackages() ...
[17:27:23.870] Searching for globals...
[17:27:23.873] - globals found: [3] '{', '<-', 'a'
[17:27:23.873] Searching for globals ... DONE
[17:27:23.873] Resolving globals: FALSE
[17:27:23.874] The total size of the 1 globals is 39 bytes (39 bytes)
[17:27:23.875] The total size of the 1 globals exported for future expression ('{; x <- a; }') is 39 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (39 bytes of class 'numeric')
[17:27:23.876] - globals: [1] 'a'
[17:27:23.876] 
[17:27:23.876] getGlobalsAndPackages() ... DONE
[17:27:23.877] run() for 'Future' ...
[17:27:23.878] - state: 'created'
[17:27:23.878] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:23.900] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:23.901] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:23.901]   - Field: 'node'
[17:27:23.902]   - Field: 'label'
[17:27:23.902]   - Field: 'local'
[17:27:23.902]   - Field: 'owner'
[17:27:23.903]   - Field: 'envir'
[17:27:23.903]   - Field: 'workers'
[17:27:23.903]   - Field: 'packages'
[17:27:23.904]   - Field: 'gc'
[17:27:23.904]   - Field: 'conditions'
[17:27:23.904]   - Field: 'persistent'
[17:27:23.905]   - Field: 'expr'
[17:27:23.905]   - Field: 'uuid'
[17:27:23.906]   - Field: 'seed'
[17:27:23.906]   - Field: 'version'
[17:27:23.906]   - Field: 'result'
[17:27:23.907]   - Field: 'asynchronous'
[17:27:23.907]   - Field: 'calls'
[17:27:23.907]   - Field: 'globals'
[17:27:23.908]   - Field: 'stdout'
[17:27:23.908]   - Field: 'earlySignal'
[17:27:23.909]   - Field: 'lazy'
[17:27:23.909]   - Field: 'state'
[17:27:23.910] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:23.910] - Launch lazy future ...
[17:27:23.911] Packages needed by the future expression (n = 0): <none>
[17:27:23.912] Packages needed by future strategies (n = 0): <none>
[17:27:23.913] {
[17:27:23.913]     {
[17:27:23.913]         {
[17:27:23.913]             ...future.startTime <- base::Sys.time()
[17:27:23.913]             {
[17:27:23.913]                 {
[17:27:23.913]                   {
[17:27:23.913]                     {
[17:27:23.913]                       base::local({
[17:27:23.913]                         has_future <- base::requireNamespace("future", 
[17:27:23.913]                           quietly = TRUE)
[17:27:23.913]                         if (has_future) {
[17:27:23.913]                           ns <- base::getNamespace("future")
[17:27:23.913]                           version <- ns[[".package"]][["version"]]
[17:27:23.913]                           if (is.null(version)) 
[17:27:23.913]                             version <- utils::packageVersion("future")
[17:27:23.913]                         }
[17:27:23.913]                         else {
[17:27:23.913]                           version <- NULL
[17:27:23.913]                         }
[17:27:23.913]                         if (!has_future || version < "1.8.0") {
[17:27:23.913]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:23.913]                             "", base::R.version$version.string), 
[17:27:23.913]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:23.913]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:23.913]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:23.913]                               "release", "version")], collapse = " "), 
[17:27:23.913]                             hostname = base::Sys.info()[["nodename"]])
[17:27:23.913]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:23.913]                             info)
[17:27:23.913]                           info <- base::paste(info, collapse = "; ")
[17:27:23.913]                           if (!has_future) {
[17:27:23.913]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:23.913]                               info)
[17:27:23.913]                           }
[17:27:23.913]                           else {
[17:27:23.913]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:23.913]                               info, version)
[17:27:23.913]                           }
[17:27:23.913]                           base::stop(msg)
[17:27:23.913]                         }
[17:27:23.913]                       })
[17:27:23.913]                     }
[17:27:23.913]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:23.913]                     base::options(mc.cores = 1L)
[17:27:23.913]                   }
[17:27:23.913]                   ...future.strategy.old <- future::plan("list")
[17:27:23.913]                   options(future.plan = NULL)
[17:27:23.913]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.913]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:23.913]                 }
[17:27:23.913]                 ...future.workdir <- getwd()
[17:27:23.913]             }
[17:27:23.913]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:23.913]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:23.913]         }
[17:27:23.913]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:23.913]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:23.913]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:23.913]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:23.913]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:23.913]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:23.913]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:23.913]             base::names(...future.oldOptions))
[17:27:23.913]     }
[17:27:23.913]     if (FALSE) {
[17:27:23.913]     }
[17:27:23.913]     else {
[17:27:23.913]         if (TRUE) {
[17:27:23.913]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:23.913]                 open = "w")
[17:27:23.913]         }
[17:27:23.913]         else {
[17:27:23.913]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:23.913]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:23.913]         }
[17:27:23.913]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:23.913]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:23.913]             base::sink(type = "output", split = FALSE)
[17:27:23.913]             base::close(...future.stdout)
[17:27:23.913]         }, add = TRUE)
[17:27:23.913]     }
[17:27:23.913]     ...future.frame <- base::sys.nframe()
[17:27:23.913]     ...future.conditions <- base::list()
[17:27:23.913]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:23.913]     if (FALSE) {
[17:27:23.913]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:23.913]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:23.913]     }
[17:27:23.913]     ...future.result <- base::tryCatch({
[17:27:23.913]         base::withCallingHandlers({
[17:27:23.913]             ...future.value <- base::withVisible(base::local({
[17:27:23.913]                 ...future.makeSendCondition <- base::local({
[17:27:23.913]                   sendCondition <- NULL
[17:27:23.913]                   function(frame = 1L) {
[17:27:23.913]                     if (is.function(sendCondition)) 
[17:27:23.913]                       return(sendCondition)
[17:27:23.913]                     ns <- getNamespace("parallel")
[17:27:23.913]                     if (exists("sendData", mode = "function", 
[17:27:23.913]                       envir = ns)) {
[17:27:23.913]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:23.913]                         envir = ns)
[17:27:23.913]                       envir <- sys.frame(frame)
[17:27:23.913]                       master <- NULL
[17:27:23.913]                       while (!identical(envir, .GlobalEnv) && 
[17:27:23.913]                         !identical(envir, emptyenv())) {
[17:27:23.913]                         if (exists("master", mode = "list", envir = envir, 
[17:27:23.913]                           inherits = FALSE)) {
[17:27:23.913]                           master <- get("master", mode = "list", 
[17:27:23.913]                             envir = envir, inherits = FALSE)
[17:27:23.913]                           if (inherits(master, c("SOCKnode", 
[17:27:23.913]                             "SOCK0node"))) {
[17:27:23.913]                             sendCondition <<- function(cond) {
[17:27:23.913]                               data <- list(type = "VALUE", value = cond, 
[17:27:23.913]                                 success = TRUE)
[17:27:23.913]                               parallel_sendData(master, data)
[17:27:23.913]                             }
[17:27:23.913]                             return(sendCondition)
[17:27:23.913]                           }
[17:27:23.913]                         }
[17:27:23.913]                         frame <- frame + 1L
[17:27:23.913]                         envir <- sys.frame(frame)
[17:27:23.913]                       }
[17:27:23.913]                     }
[17:27:23.913]                     sendCondition <<- function(cond) NULL
[17:27:23.913]                   }
[17:27:23.913]                 })
[17:27:23.913]                 withCallingHandlers({
[17:27:23.913]                   {
[17:27:23.913]                     x <- a
[17:27:23.913]                   }
[17:27:23.913]                 }, immediateCondition = function(cond) {
[17:27:23.913]                   sendCondition <- ...future.makeSendCondition()
[17:27:23.913]                   sendCondition(cond)
[17:27:23.913]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.913]                   {
[17:27:23.913]                     inherits <- base::inherits
[17:27:23.913]                     invokeRestart <- base::invokeRestart
[17:27:23.913]                     is.null <- base::is.null
[17:27:23.913]                     muffled <- FALSE
[17:27:23.913]                     if (inherits(cond, "message")) {
[17:27:23.913]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:23.913]                       if (muffled) 
[17:27:23.913]                         invokeRestart("muffleMessage")
[17:27:23.913]                     }
[17:27:23.913]                     else if (inherits(cond, "warning")) {
[17:27:23.913]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:23.913]                       if (muffled) 
[17:27:23.913]                         invokeRestart("muffleWarning")
[17:27:23.913]                     }
[17:27:23.913]                     else if (inherits(cond, "condition")) {
[17:27:23.913]                       if (!is.null(pattern)) {
[17:27:23.913]                         computeRestarts <- base::computeRestarts
[17:27:23.913]                         grepl <- base::grepl
[17:27:23.913]                         restarts <- computeRestarts(cond)
[17:27:23.913]                         for (restart in restarts) {
[17:27:23.913]                           name <- restart$name
[17:27:23.913]                           if (is.null(name)) 
[17:27:23.913]                             next
[17:27:23.913]                           if (!grepl(pattern, name)) 
[17:27:23.913]                             next
[17:27:23.913]                           invokeRestart(restart)
[17:27:23.913]                           muffled <- TRUE
[17:27:23.913]                           break
[17:27:23.913]                         }
[17:27:23.913]                       }
[17:27:23.913]                     }
[17:27:23.913]                     invisible(muffled)
[17:27:23.913]                   }
[17:27:23.913]                   muffleCondition(cond)
[17:27:23.913]                 })
[17:27:23.913]             }))
[17:27:23.913]             future::FutureResult(value = ...future.value$value, 
[17:27:23.913]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.913]                   ...future.rng), globalenv = if (FALSE) 
[17:27:23.913]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:23.913]                     ...future.globalenv.names))
[17:27:23.913]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:23.913]         }, condition = base::local({
[17:27:23.913]             c <- base::c
[17:27:23.913]             inherits <- base::inherits
[17:27:23.913]             invokeRestart <- base::invokeRestart
[17:27:23.913]             length <- base::length
[17:27:23.913]             list <- base::list
[17:27:23.913]             seq.int <- base::seq.int
[17:27:23.913]             signalCondition <- base::signalCondition
[17:27:23.913]             sys.calls <- base::sys.calls
[17:27:23.913]             `[[` <- base::`[[`
[17:27:23.913]             `+` <- base::`+`
[17:27:23.913]             `<<-` <- base::`<<-`
[17:27:23.913]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:23.913]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:23.913]                   3L)]
[17:27:23.913]             }
[17:27:23.913]             function(cond) {
[17:27:23.913]                 is_error <- inherits(cond, "error")
[17:27:23.913]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:23.913]                   NULL)
[17:27:23.913]                 if (is_error) {
[17:27:23.913]                   sessionInformation <- function() {
[17:27:23.913]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:23.913]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:23.913]                       search = base::search(), system = base::Sys.info())
[17:27:23.913]                   }
[17:27:23.913]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.913]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:23.913]                     cond$call), session = sessionInformation(), 
[17:27:23.913]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:23.913]                   signalCondition(cond)
[17:27:23.913]                 }
[17:27:23.913]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:23.913]                 "immediateCondition"))) {
[17:27:23.913]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:23.913]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.913]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:23.913]                   if (TRUE && !signal) {
[17:27:23.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.913]                     {
[17:27:23.913]                       inherits <- base::inherits
[17:27:23.913]                       invokeRestart <- base::invokeRestart
[17:27:23.913]                       is.null <- base::is.null
[17:27:23.913]                       muffled <- FALSE
[17:27:23.913]                       if (inherits(cond, "message")) {
[17:27:23.913]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.913]                         if (muffled) 
[17:27:23.913]                           invokeRestart("muffleMessage")
[17:27:23.913]                       }
[17:27:23.913]                       else if (inherits(cond, "warning")) {
[17:27:23.913]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.913]                         if (muffled) 
[17:27:23.913]                           invokeRestart("muffleWarning")
[17:27:23.913]                       }
[17:27:23.913]                       else if (inherits(cond, "condition")) {
[17:27:23.913]                         if (!is.null(pattern)) {
[17:27:23.913]                           computeRestarts <- base::computeRestarts
[17:27:23.913]                           grepl <- base::grepl
[17:27:23.913]                           restarts <- computeRestarts(cond)
[17:27:23.913]                           for (restart in restarts) {
[17:27:23.913]                             name <- restart$name
[17:27:23.913]                             if (is.null(name)) 
[17:27:23.913]                               next
[17:27:23.913]                             if (!grepl(pattern, name)) 
[17:27:23.913]                               next
[17:27:23.913]                             invokeRestart(restart)
[17:27:23.913]                             muffled <- TRUE
[17:27:23.913]                             break
[17:27:23.913]                           }
[17:27:23.913]                         }
[17:27:23.913]                       }
[17:27:23.913]                       invisible(muffled)
[17:27:23.913]                     }
[17:27:23.913]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.913]                   }
[17:27:23.913]                 }
[17:27:23.913]                 else {
[17:27:23.913]                   if (TRUE) {
[17:27:23.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.913]                     {
[17:27:23.913]                       inherits <- base::inherits
[17:27:23.913]                       invokeRestart <- base::invokeRestart
[17:27:23.913]                       is.null <- base::is.null
[17:27:23.913]                       muffled <- FALSE
[17:27:23.913]                       if (inherits(cond, "message")) {
[17:27:23.913]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.913]                         if (muffled) 
[17:27:23.913]                           invokeRestart("muffleMessage")
[17:27:23.913]                       }
[17:27:23.913]                       else if (inherits(cond, "warning")) {
[17:27:23.913]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.913]                         if (muffled) 
[17:27:23.913]                           invokeRestart("muffleWarning")
[17:27:23.913]                       }
[17:27:23.913]                       else if (inherits(cond, "condition")) {
[17:27:23.913]                         if (!is.null(pattern)) {
[17:27:23.913]                           computeRestarts <- base::computeRestarts
[17:27:23.913]                           grepl <- base::grepl
[17:27:23.913]                           restarts <- computeRestarts(cond)
[17:27:23.913]                           for (restart in restarts) {
[17:27:23.913]                             name <- restart$name
[17:27:23.913]                             if (is.null(name)) 
[17:27:23.913]                               next
[17:27:23.913]                             if (!grepl(pattern, name)) 
[17:27:23.913]                               next
[17:27:23.913]                             invokeRestart(restart)
[17:27:23.913]                             muffled <- TRUE
[17:27:23.913]                             break
[17:27:23.913]                           }
[17:27:23.913]                         }
[17:27:23.913]                       }
[17:27:23.913]                       invisible(muffled)
[17:27:23.913]                     }
[17:27:23.913]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.913]                   }
[17:27:23.913]                 }
[17:27:23.913]             }
[17:27:23.913]         }))
[17:27:23.913]     }, error = function(ex) {
[17:27:23.913]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:23.913]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.913]                 ...future.rng), started = ...future.startTime, 
[17:27:23.913]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:23.913]             version = "1.8"), class = "FutureResult")
[17:27:23.913]     }, finally = {
[17:27:23.913]         if (!identical(...future.workdir, getwd())) 
[17:27:23.913]             setwd(...future.workdir)
[17:27:23.913]         {
[17:27:23.913]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:23.913]                 ...future.oldOptions$nwarnings <- NULL
[17:27:23.913]             }
[17:27:23.913]             base::options(...future.oldOptions)
[17:27:23.913]             if (.Platform$OS.type == "windows") {
[17:27:23.913]                 old_names <- names(...future.oldEnvVars)
[17:27:23.913]                 envs <- base::Sys.getenv()
[17:27:23.913]                 names <- names(envs)
[17:27:23.913]                 common <- intersect(names, old_names)
[17:27:23.913]                 added <- setdiff(names, old_names)
[17:27:23.913]                 removed <- setdiff(old_names, names)
[17:27:23.913]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:23.913]                   envs[common]]
[17:27:23.913]                 NAMES <- toupper(changed)
[17:27:23.913]                 args <- list()
[17:27:23.913]                 for (kk in seq_along(NAMES)) {
[17:27:23.913]                   name <- changed[[kk]]
[17:27:23.913]                   NAME <- NAMES[[kk]]
[17:27:23.913]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.913]                     next
[17:27:23.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.913]                 }
[17:27:23.913]                 NAMES <- toupper(added)
[17:27:23.913]                 for (kk in seq_along(NAMES)) {
[17:27:23.913]                   name <- added[[kk]]
[17:27:23.913]                   NAME <- NAMES[[kk]]
[17:27:23.913]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.913]                     next
[17:27:23.913]                   args[[name]] <- ""
[17:27:23.913]                 }
[17:27:23.913]                 NAMES <- toupper(removed)
[17:27:23.913]                 for (kk in seq_along(NAMES)) {
[17:27:23.913]                   name <- removed[[kk]]
[17:27:23.913]                   NAME <- NAMES[[kk]]
[17:27:23.913]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.913]                     next
[17:27:23.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.913]                 }
[17:27:23.913]                 if (length(args) > 0) 
[17:27:23.913]                   base::do.call(base::Sys.setenv, args = args)
[17:27:23.913]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:23.913]             }
[17:27:23.913]             else {
[17:27:23.913]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:23.913]             }
[17:27:23.913]             {
[17:27:23.913]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:23.913]                   0L) {
[17:27:23.913]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:23.913]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:23.913]                   base::options(opts)
[17:27:23.913]                 }
[17:27:23.913]                 {
[17:27:23.913]                   {
[17:27:23.913]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:23.913]                     NULL
[17:27:23.913]                   }
[17:27:23.913]                   options(future.plan = NULL)
[17:27:23.913]                   if (is.na(NA_character_)) 
[17:27:23.913]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.913]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:23.913]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:23.913]                     .init = FALSE)
[17:27:23.913]                 }
[17:27:23.913]             }
[17:27:23.913]         }
[17:27:23.913]     })
[17:27:23.913]     if (TRUE) {
[17:27:23.913]         base::sink(type = "output", split = FALSE)
[17:27:23.913]         if (TRUE) {
[17:27:23.913]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:23.913]         }
[17:27:23.913]         else {
[17:27:23.913]             ...future.result["stdout"] <- base::list(NULL)
[17:27:23.913]         }
[17:27:23.913]         base::close(...future.stdout)
[17:27:23.913]         ...future.stdout <- NULL
[17:27:23.913]     }
[17:27:23.913]     ...future.result$conditions <- ...future.conditions
[17:27:23.913]     ...future.result$finished <- base::Sys.time()
[17:27:23.913]     ...future.result
[17:27:23.913] }
[17:27:23.923] Exporting 1 global objects (342 bytes) to cluster node #1 ...
[17:27:23.924] Exporting 'a' (39 bytes) to cluster node #1 ...
[17:27:23.925] Exporting 'a' (39 bytes) to cluster node #1 ... DONE
[17:27:23.925] Exporting 1 global objects (342 bytes) to cluster node #1 ... DONE
[17:27:23.927] MultisessionFuture started
[17:27:23.927] - Launch lazy future ... done
[17:27:23.927] run() for 'MultisessionFuture' ... done
[17:27:23.928] result() for ClusterFuture ...
[17:27:23.928] receiveMessageFromWorker() for ClusterFuture ...
[17:27:23.929] - Validating connection of MultisessionFuture
[17:27:23.954] - received message: FutureResult
[17:27:23.955] - Received FutureResult
[17:27:23.956] - Erased future from FutureRegistry
[17:27:23.956] result() for ClusterFuture ...
[17:27:23.956] - result already collected: FutureResult
[17:27:23.957] result() for ClusterFuture ... done
[17:27:23.957] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:23.957] result() for ClusterFuture ... done
[17:27:23.958] result() for ClusterFuture ...
[17:27:23.958] - result already collected: FutureResult
[17:27:23.958] result() for ClusterFuture ... done
** Future evaluation with errors
[17:27:23.960] getGlobalsAndPackages() ...
[17:27:23.960] Searching for globals...
[17:27:23.964] - globals found: [3] '{', '<-', 'stop'
[17:27:23.964] Searching for globals ... DONE
[17:27:23.965] Resolving globals: FALSE
[17:27:23.966] 
[17:27:23.966] 
[17:27:23.966] getGlobalsAndPackages() ... DONE
[17:27:23.967] run() for 'Future' ...
[17:27:23.967] - state: 'created'
[17:27:23.968] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:23.989] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:23.989] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:23.990]   - Field: 'node'
[17:27:23.990]   - Field: 'label'
[17:27:23.990]   - Field: 'local'
[17:27:23.991]   - Field: 'owner'
[17:27:23.991]   - Field: 'envir'
[17:27:23.992]   - Field: 'workers'
[17:27:23.992]   - Field: 'packages'
[17:27:23.992]   - Field: 'gc'
[17:27:23.993]   - Field: 'conditions'
[17:27:23.993]   - Field: 'persistent'
[17:27:23.993]   - Field: 'expr'
[17:27:23.994]   - Field: 'uuid'
[17:27:23.994]   - Field: 'seed'
[17:27:23.994]   - Field: 'version'
[17:27:23.994]   - Field: 'result'
[17:27:23.995]   - Field: 'asynchronous'
[17:27:23.995]   - Field: 'calls'
[17:27:23.995]   - Field: 'globals'
[17:27:23.995]   - Field: 'stdout'
[17:27:23.995]   - Field: 'earlySignal'
[17:27:23.996]   - Field: 'lazy'
[17:27:23.996]   - Field: 'state'
[17:27:23.996] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:23.996] - Launch lazy future ...
[17:27:23.997] Packages needed by the future expression (n = 0): <none>
[17:27:23.997] Packages needed by future strategies (n = 0): <none>
[17:27:23.998] {
[17:27:23.998]     {
[17:27:23.998]         {
[17:27:23.998]             ...future.startTime <- base::Sys.time()
[17:27:23.998]             {
[17:27:23.998]                 {
[17:27:23.998]                   {
[17:27:23.998]                     {
[17:27:23.998]                       base::local({
[17:27:23.998]                         has_future <- base::requireNamespace("future", 
[17:27:23.998]                           quietly = TRUE)
[17:27:23.998]                         if (has_future) {
[17:27:23.998]                           ns <- base::getNamespace("future")
[17:27:23.998]                           version <- ns[[".package"]][["version"]]
[17:27:23.998]                           if (is.null(version)) 
[17:27:23.998]                             version <- utils::packageVersion("future")
[17:27:23.998]                         }
[17:27:23.998]                         else {
[17:27:23.998]                           version <- NULL
[17:27:23.998]                         }
[17:27:23.998]                         if (!has_future || version < "1.8.0") {
[17:27:23.998]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:23.998]                             "", base::R.version$version.string), 
[17:27:23.998]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:23.998]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:23.998]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:23.998]                               "release", "version")], collapse = " "), 
[17:27:23.998]                             hostname = base::Sys.info()[["nodename"]])
[17:27:23.998]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:23.998]                             info)
[17:27:23.998]                           info <- base::paste(info, collapse = "; ")
[17:27:23.998]                           if (!has_future) {
[17:27:23.998]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:23.998]                               info)
[17:27:23.998]                           }
[17:27:23.998]                           else {
[17:27:23.998]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:23.998]                               info, version)
[17:27:23.998]                           }
[17:27:23.998]                           base::stop(msg)
[17:27:23.998]                         }
[17:27:23.998]                       })
[17:27:23.998]                     }
[17:27:23.998]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:23.998]                     base::options(mc.cores = 1L)
[17:27:23.998]                   }
[17:27:23.998]                   ...future.strategy.old <- future::plan("list")
[17:27:23.998]                   options(future.plan = NULL)
[17:27:23.998]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.998]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:23.998]                 }
[17:27:23.998]                 ...future.workdir <- getwd()
[17:27:23.998]             }
[17:27:23.998]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:23.998]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:23.998]         }
[17:27:23.998]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:23.998]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:23.998]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:23.998]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:23.998]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:23.998]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:23.998]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:23.998]             base::names(...future.oldOptions))
[17:27:23.998]     }
[17:27:23.998]     if (FALSE) {
[17:27:23.998]     }
[17:27:23.998]     else {
[17:27:23.998]         if (TRUE) {
[17:27:23.998]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:23.998]                 open = "w")
[17:27:23.998]         }
[17:27:23.998]         else {
[17:27:23.998]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:23.998]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:23.998]         }
[17:27:23.998]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:23.998]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:23.998]             base::sink(type = "output", split = FALSE)
[17:27:23.998]             base::close(...future.stdout)
[17:27:23.998]         }, add = TRUE)
[17:27:23.998]     }
[17:27:23.998]     ...future.frame <- base::sys.nframe()
[17:27:23.998]     ...future.conditions <- base::list()
[17:27:23.998]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:23.998]     if (FALSE) {
[17:27:23.998]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:23.998]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:23.998]     }
[17:27:23.998]     ...future.result <- base::tryCatch({
[17:27:23.998]         base::withCallingHandlers({
[17:27:23.998]             ...future.value <- base::withVisible(base::local({
[17:27:23.998]                 ...future.makeSendCondition <- base::local({
[17:27:23.998]                   sendCondition <- NULL
[17:27:23.998]                   function(frame = 1L) {
[17:27:23.998]                     if (is.function(sendCondition)) 
[17:27:23.998]                       return(sendCondition)
[17:27:23.998]                     ns <- getNamespace("parallel")
[17:27:23.998]                     if (exists("sendData", mode = "function", 
[17:27:23.998]                       envir = ns)) {
[17:27:23.998]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:23.998]                         envir = ns)
[17:27:23.998]                       envir <- sys.frame(frame)
[17:27:23.998]                       master <- NULL
[17:27:23.998]                       while (!identical(envir, .GlobalEnv) && 
[17:27:23.998]                         !identical(envir, emptyenv())) {
[17:27:23.998]                         if (exists("master", mode = "list", envir = envir, 
[17:27:23.998]                           inherits = FALSE)) {
[17:27:23.998]                           master <- get("master", mode = "list", 
[17:27:23.998]                             envir = envir, inherits = FALSE)
[17:27:23.998]                           if (inherits(master, c("SOCKnode", 
[17:27:23.998]                             "SOCK0node"))) {
[17:27:23.998]                             sendCondition <<- function(cond) {
[17:27:23.998]                               data <- list(type = "VALUE", value = cond, 
[17:27:23.998]                                 success = TRUE)
[17:27:23.998]                               parallel_sendData(master, data)
[17:27:23.998]                             }
[17:27:23.998]                             return(sendCondition)
[17:27:23.998]                           }
[17:27:23.998]                         }
[17:27:23.998]                         frame <- frame + 1L
[17:27:23.998]                         envir <- sys.frame(frame)
[17:27:23.998]                       }
[17:27:23.998]                     }
[17:27:23.998]                     sendCondition <<- function(cond) NULL
[17:27:23.998]                   }
[17:27:23.998]                 })
[17:27:23.998]                 withCallingHandlers({
[17:27:23.998]                   {
[17:27:23.998]                     x <- 3
[17:27:23.998]                     stop("Woops!")
[17:27:23.998]                     x
[17:27:23.998]                   }
[17:27:23.998]                 }, immediateCondition = function(cond) {
[17:27:23.998]                   sendCondition <- ...future.makeSendCondition()
[17:27:23.998]                   sendCondition(cond)
[17:27:23.998]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.998]                   {
[17:27:23.998]                     inherits <- base::inherits
[17:27:23.998]                     invokeRestart <- base::invokeRestart
[17:27:23.998]                     is.null <- base::is.null
[17:27:23.998]                     muffled <- FALSE
[17:27:23.998]                     if (inherits(cond, "message")) {
[17:27:23.998]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:23.998]                       if (muffled) 
[17:27:23.998]                         invokeRestart("muffleMessage")
[17:27:23.998]                     }
[17:27:23.998]                     else if (inherits(cond, "warning")) {
[17:27:23.998]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:23.998]                       if (muffled) 
[17:27:23.998]                         invokeRestart("muffleWarning")
[17:27:23.998]                     }
[17:27:23.998]                     else if (inherits(cond, "condition")) {
[17:27:23.998]                       if (!is.null(pattern)) {
[17:27:23.998]                         computeRestarts <- base::computeRestarts
[17:27:23.998]                         grepl <- base::grepl
[17:27:23.998]                         restarts <- computeRestarts(cond)
[17:27:23.998]                         for (restart in restarts) {
[17:27:23.998]                           name <- restart$name
[17:27:23.998]                           if (is.null(name)) 
[17:27:23.998]                             next
[17:27:23.998]                           if (!grepl(pattern, name)) 
[17:27:23.998]                             next
[17:27:23.998]                           invokeRestart(restart)
[17:27:23.998]                           muffled <- TRUE
[17:27:23.998]                           break
[17:27:23.998]                         }
[17:27:23.998]                       }
[17:27:23.998]                     }
[17:27:23.998]                     invisible(muffled)
[17:27:23.998]                   }
[17:27:23.998]                   muffleCondition(cond)
[17:27:23.998]                 })
[17:27:23.998]             }))
[17:27:23.998]             future::FutureResult(value = ...future.value$value, 
[17:27:23.998]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.998]                   ...future.rng), globalenv = if (FALSE) 
[17:27:23.998]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:23.998]                     ...future.globalenv.names))
[17:27:23.998]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:23.998]         }, condition = base::local({
[17:27:23.998]             c <- base::c
[17:27:23.998]             inherits <- base::inherits
[17:27:23.998]             invokeRestart <- base::invokeRestart
[17:27:23.998]             length <- base::length
[17:27:23.998]             list <- base::list
[17:27:23.998]             seq.int <- base::seq.int
[17:27:23.998]             signalCondition <- base::signalCondition
[17:27:23.998]             sys.calls <- base::sys.calls
[17:27:23.998]             `[[` <- base::`[[`
[17:27:23.998]             `+` <- base::`+`
[17:27:23.998]             `<<-` <- base::`<<-`
[17:27:23.998]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:23.998]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:23.998]                   3L)]
[17:27:23.998]             }
[17:27:23.998]             function(cond) {
[17:27:23.998]                 is_error <- inherits(cond, "error")
[17:27:23.998]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:23.998]                   NULL)
[17:27:23.998]                 if (is_error) {
[17:27:23.998]                   sessionInformation <- function() {
[17:27:23.998]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:23.998]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:23.998]                       search = base::search(), system = base::Sys.info())
[17:27:23.998]                   }
[17:27:23.998]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.998]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:23.998]                     cond$call), session = sessionInformation(), 
[17:27:23.998]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:23.998]                   signalCondition(cond)
[17:27:23.998]                 }
[17:27:23.998]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:23.998]                 "immediateCondition"))) {
[17:27:23.998]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:23.998]                   ...future.conditions[[length(...future.conditions) + 
[17:27:23.998]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:23.998]                   if (TRUE && !signal) {
[17:27:23.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.998]                     {
[17:27:23.998]                       inherits <- base::inherits
[17:27:23.998]                       invokeRestart <- base::invokeRestart
[17:27:23.998]                       is.null <- base::is.null
[17:27:23.998]                       muffled <- FALSE
[17:27:23.998]                       if (inherits(cond, "message")) {
[17:27:23.998]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.998]                         if (muffled) 
[17:27:23.998]                           invokeRestart("muffleMessage")
[17:27:23.998]                       }
[17:27:23.998]                       else if (inherits(cond, "warning")) {
[17:27:23.998]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.998]                         if (muffled) 
[17:27:23.998]                           invokeRestart("muffleWarning")
[17:27:23.998]                       }
[17:27:23.998]                       else if (inherits(cond, "condition")) {
[17:27:23.998]                         if (!is.null(pattern)) {
[17:27:23.998]                           computeRestarts <- base::computeRestarts
[17:27:23.998]                           grepl <- base::grepl
[17:27:23.998]                           restarts <- computeRestarts(cond)
[17:27:23.998]                           for (restart in restarts) {
[17:27:23.998]                             name <- restart$name
[17:27:23.998]                             if (is.null(name)) 
[17:27:23.998]                               next
[17:27:23.998]                             if (!grepl(pattern, name)) 
[17:27:23.998]                               next
[17:27:23.998]                             invokeRestart(restart)
[17:27:23.998]                             muffled <- TRUE
[17:27:23.998]                             break
[17:27:23.998]                           }
[17:27:23.998]                         }
[17:27:23.998]                       }
[17:27:23.998]                       invisible(muffled)
[17:27:23.998]                     }
[17:27:23.998]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.998]                   }
[17:27:23.998]                 }
[17:27:23.998]                 else {
[17:27:23.998]                   if (TRUE) {
[17:27:23.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:23.998]                     {
[17:27:23.998]                       inherits <- base::inherits
[17:27:23.998]                       invokeRestart <- base::invokeRestart
[17:27:23.998]                       is.null <- base::is.null
[17:27:23.998]                       muffled <- FALSE
[17:27:23.998]                       if (inherits(cond, "message")) {
[17:27:23.998]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:23.998]                         if (muffled) 
[17:27:23.998]                           invokeRestart("muffleMessage")
[17:27:23.998]                       }
[17:27:23.998]                       else if (inherits(cond, "warning")) {
[17:27:23.998]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:23.998]                         if (muffled) 
[17:27:23.998]                           invokeRestart("muffleWarning")
[17:27:23.998]                       }
[17:27:23.998]                       else if (inherits(cond, "condition")) {
[17:27:23.998]                         if (!is.null(pattern)) {
[17:27:23.998]                           computeRestarts <- base::computeRestarts
[17:27:23.998]                           grepl <- base::grepl
[17:27:23.998]                           restarts <- computeRestarts(cond)
[17:27:23.998]                           for (restart in restarts) {
[17:27:23.998]                             name <- restart$name
[17:27:23.998]                             if (is.null(name)) 
[17:27:23.998]                               next
[17:27:23.998]                             if (!grepl(pattern, name)) 
[17:27:23.998]                               next
[17:27:23.998]                             invokeRestart(restart)
[17:27:23.998]                             muffled <- TRUE
[17:27:23.998]                             break
[17:27:23.998]                           }
[17:27:23.998]                         }
[17:27:23.998]                       }
[17:27:23.998]                       invisible(muffled)
[17:27:23.998]                     }
[17:27:23.998]                     muffleCondition(cond, pattern = "^muffle")
[17:27:23.998]                   }
[17:27:23.998]                 }
[17:27:23.998]             }
[17:27:23.998]         }))
[17:27:23.998]     }, error = function(ex) {
[17:27:23.998]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:23.998]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:23.998]                 ...future.rng), started = ...future.startTime, 
[17:27:23.998]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:23.998]             version = "1.8"), class = "FutureResult")
[17:27:23.998]     }, finally = {
[17:27:23.998]         if (!identical(...future.workdir, getwd())) 
[17:27:23.998]             setwd(...future.workdir)
[17:27:23.998]         {
[17:27:23.998]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:23.998]                 ...future.oldOptions$nwarnings <- NULL
[17:27:23.998]             }
[17:27:23.998]             base::options(...future.oldOptions)
[17:27:23.998]             if (.Platform$OS.type == "windows") {
[17:27:23.998]                 old_names <- names(...future.oldEnvVars)
[17:27:23.998]                 envs <- base::Sys.getenv()
[17:27:23.998]                 names <- names(envs)
[17:27:23.998]                 common <- intersect(names, old_names)
[17:27:23.998]                 added <- setdiff(names, old_names)
[17:27:23.998]                 removed <- setdiff(old_names, names)
[17:27:23.998]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:23.998]                   envs[common]]
[17:27:23.998]                 NAMES <- toupper(changed)
[17:27:23.998]                 args <- list()
[17:27:23.998]                 for (kk in seq_along(NAMES)) {
[17:27:23.998]                   name <- changed[[kk]]
[17:27:23.998]                   NAME <- NAMES[[kk]]
[17:27:23.998]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.998]                     next
[17:27:23.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.998]                 }
[17:27:23.998]                 NAMES <- toupper(added)
[17:27:23.998]                 for (kk in seq_along(NAMES)) {
[17:27:23.998]                   name <- added[[kk]]
[17:27:23.998]                   NAME <- NAMES[[kk]]
[17:27:23.998]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.998]                     next
[17:27:23.998]                   args[[name]] <- ""
[17:27:23.998]                 }
[17:27:23.998]                 NAMES <- toupper(removed)
[17:27:23.998]                 for (kk in seq_along(NAMES)) {
[17:27:23.998]                   name <- removed[[kk]]
[17:27:23.998]                   NAME <- NAMES[[kk]]
[17:27:23.998]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:23.998]                     next
[17:27:23.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:23.998]                 }
[17:27:23.998]                 if (length(args) > 0) 
[17:27:23.998]                   base::do.call(base::Sys.setenv, args = args)
[17:27:23.998]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:23.998]             }
[17:27:23.998]             else {
[17:27:23.998]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:23.998]             }
[17:27:23.998]             {
[17:27:23.998]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:23.998]                   0L) {
[17:27:23.998]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:23.998]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:23.998]                   base::options(opts)
[17:27:23.998]                 }
[17:27:23.998]                 {
[17:27:23.998]                   {
[17:27:23.998]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:23.998]                     NULL
[17:27:23.998]                   }
[17:27:23.998]                   options(future.plan = NULL)
[17:27:23.998]                   if (is.na(NA_character_)) 
[17:27:23.998]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:23.998]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:23.998]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:23.998]                     .init = FALSE)
[17:27:23.998]                 }
[17:27:23.998]             }
[17:27:23.998]         }
[17:27:23.998]     })
[17:27:23.998]     if (TRUE) {
[17:27:23.998]         base::sink(type = "output", split = FALSE)
[17:27:23.998]         if (TRUE) {
[17:27:23.998]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:23.998]         }
[17:27:23.998]         else {
[17:27:23.998]             ...future.result["stdout"] <- base::list(NULL)
[17:27:23.998]         }
[17:27:23.998]         base::close(...future.stdout)
[17:27:23.998]         ...future.stdout <- NULL
[17:27:23.998]     }
[17:27:23.998]     ...future.result$conditions <- ...future.conditions
[17:27:23.998]     ...future.result$finished <- base::Sys.time()
[17:27:23.998]     ...future.result
[17:27:23.998] }
[17:27:24.006] MultisessionFuture started
[17:27:24.006] - Launch lazy future ... done
[17:27:24.006] run() for 'MultisessionFuture' ... done
[17:27:24.007] result() for ClusterFuture ...
[17:27:24.007] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.008] - Validating connection of MultisessionFuture
[17:27:24.026] - received message: FutureResult
[17:27:24.027] - Received FutureResult
[17:27:24.027] - Erased future from FutureRegistry
[17:27:24.027] result() for ClusterFuture ...
[17:27:24.028] - result already collected: FutureResult
[17:27:24.028] result() for ClusterFuture ... done
[17:27:24.028] signalConditions() ...
[17:27:24.029]  - include = 'immediateCondition'
[17:27:24.029]  - exclude = 
[17:27:24.029]  - resignal = FALSE
[17:27:24.030]  - Number of conditions: 1
[17:27:24.030] signalConditions() ... done
[17:27:24.031] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.031] result() for ClusterFuture ... done
[17:27:24.031] result() for ClusterFuture ...
[17:27:24.032] - result already collected: FutureResult
[17:27:24.032] result() for ClusterFuture ... done
[17:27:24.032] signalConditions() ...
[17:27:24.033]  - include = 'immediateCondition'
[17:27:24.033]  - exclude = 
[17:27:24.033]  - resignal = FALSE
[17:27:24.034]  - Number of conditions: 1
[17:27:24.034] signalConditions() ... done
[17:27:24.035] Future state: 'finished'
[17:27:24.035] result() for ClusterFuture ...
[17:27:24.035] - result already collected: FutureResult
[17:27:24.036] result() for ClusterFuture ... done
[17:27:24.036] signalConditions() ...
[17:27:24.036]  - include = 'condition'
[17:27:24.037]  - exclude = 'immediateCondition'
[17:27:24.037]  - resignal = TRUE
[17:27:24.037]  - Number of conditions: 1
[17:27:24.038]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:24.038] signalConditions() ... done
[17:27:24.039] getGlobalsAndPackages() ...
[17:27:24.039] Searching for globals...
[17:27:24.047] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:27:24.047] Searching for globals ... DONE
[17:27:24.047] Resolving globals: FALSE
[17:27:24.048] The total size of the 1 globals is 35 bytes (35 bytes)
[17:27:24.049] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:27:24.050] - globals: [1] 'ii'
[17:27:24.050] 
[17:27:24.050] getGlobalsAndPackages() ... DONE
[17:27:24.051] run() for 'Future' ...
[17:27:24.051] - state: 'created'
[17:27:24.052] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.072] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.073] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.073]   - Field: 'node'
[17:27:24.073]   - Field: 'label'
[17:27:24.074]   - Field: 'local'
[17:27:24.074]   - Field: 'owner'
[17:27:24.074]   - Field: 'envir'
[17:27:24.074]   - Field: 'workers'
[17:27:24.075]   - Field: 'packages'
[17:27:24.075]   - Field: 'gc'
[17:27:24.075]   - Field: 'conditions'
[17:27:24.076]   - Field: 'persistent'
[17:27:24.076]   - Field: 'expr'
[17:27:24.076]   - Field: 'uuid'
[17:27:24.076]   - Field: 'seed'
[17:27:24.077]   - Field: 'version'
[17:27:24.077]   - Field: 'result'
[17:27:24.077]   - Field: 'asynchronous'
[17:27:24.077]   - Field: 'calls'
[17:27:24.078]   - Field: 'globals'
[17:27:24.078]   - Field: 'stdout'
[17:27:24.078]   - Field: 'earlySignal'
[17:27:24.079]   - Field: 'lazy'
[17:27:24.079]   - Field: 'state'
[17:27:24.079] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.079] - Launch lazy future ...
[17:27:24.080] Packages needed by the future expression (n = 0): <none>
[17:27:24.080] Packages needed by future strategies (n = 0): <none>
[17:27:24.081] {
[17:27:24.081]     {
[17:27:24.081]         {
[17:27:24.081]             ...future.startTime <- base::Sys.time()
[17:27:24.081]             {
[17:27:24.081]                 {
[17:27:24.081]                   {
[17:27:24.081]                     {
[17:27:24.081]                       base::local({
[17:27:24.081]                         has_future <- base::requireNamespace("future", 
[17:27:24.081]                           quietly = TRUE)
[17:27:24.081]                         if (has_future) {
[17:27:24.081]                           ns <- base::getNamespace("future")
[17:27:24.081]                           version <- ns[[".package"]][["version"]]
[17:27:24.081]                           if (is.null(version)) 
[17:27:24.081]                             version <- utils::packageVersion("future")
[17:27:24.081]                         }
[17:27:24.081]                         else {
[17:27:24.081]                           version <- NULL
[17:27:24.081]                         }
[17:27:24.081]                         if (!has_future || version < "1.8.0") {
[17:27:24.081]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.081]                             "", base::R.version$version.string), 
[17:27:24.081]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.081]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.081]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.081]                               "release", "version")], collapse = " "), 
[17:27:24.081]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.081]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.081]                             info)
[17:27:24.081]                           info <- base::paste(info, collapse = "; ")
[17:27:24.081]                           if (!has_future) {
[17:27:24.081]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.081]                               info)
[17:27:24.081]                           }
[17:27:24.081]                           else {
[17:27:24.081]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.081]                               info, version)
[17:27:24.081]                           }
[17:27:24.081]                           base::stop(msg)
[17:27:24.081]                         }
[17:27:24.081]                       })
[17:27:24.081]                     }
[17:27:24.081]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.081]                     base::options(mc.cores = 1L)
[17:27:24.081]                   }
[17:27:24.081]                   ...future.strategy.old <- future::plan("list")
[17:27:24.081]                   options(future.plan = NULL)
[17:27:24.081]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.081]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.081]                 }
[17:27:24.081]                 ...future.workdir <- getwd()
[17:27:24.081]             }
[17:27:24.081]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.081]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.081]         }
[17:27:24.081]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.081]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.081]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.081]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.081]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.081]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.081]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.081]             base::names(...future.oldOptions))
[17:27:24.081]     }
[17:27:24.081]     if (FALSE) {
[17:27:24.081]     }
[17:27:24.081]     else {
[17:27:24.081]         if (TRUE) {
[17:27:24.081]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.081]                 open = "w")
[17:27:24.081]         }
[17:27:24.081]         else {
[17:27:24.081]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.081]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.081]         }
[17:27:24.081]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.081]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.081]             base::sink(type = "output", split = FALSE)
[17:27:24.081]             base::close(...future.stdout)
[17:27:24.081]         }, add = TRUE)
[17:27:24.081]     }
[17:27:24.081]     ...future.frame <- base::sys.nframe()
[17:27:24.081]     ...future.conditions <- base::list()
[17:27:24.081]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.081]     if (FALSE) {
[17:27:24.081]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.081]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.081]     }
[17:27:24.081]     ...future.result <- base::tryCatch({
[17:27:24.081]         base::withCallingHandlers({
[17:27:24.081]             ...future.value <- base::withVisible(base::local({
[17:27:24.081]                 ...future.makeSendCondition <- base::local({
[17:27:24.081]                   sendCondition <- NULL
[17:27:24.081]                   function(frame = 1L) {
[17:27:24.081]                     if (is.function(sendCondition)) 
[17:27:24.081]                       return(sendCondition)
[17:27:24.081]                     ns <- getNamespace("parallel")
[17:27:24.081]                     if (exists("sendData", mode = "function", 
[17:27:24.081]                       envir = ns)) {
[17:27:24.081]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.081]                         envir = ns)
[17:27:24.081]                       envir <- sys.frame(frame)
[17:27:24.081]                       master <- NULL
[17:27:24.081]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.081]                         !identical(envir, emptyenv())) {
[17:27:24.081]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.081]                           inherits = FALSE)) {
[17:27:24.081]                           master <- get("master", mode = "list", 
[17:27:24.081]                             envir = envir, inherits = FALSE)
[17:27:24.081]                           if (inherits(master, c("SOCKnode", 
[17:27:24.081]                             "SOCK0node"))) {
[17:27:24.081]                             sendCondition <<- function(cond) {
[17:27:24.081]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.081]                                 success = TRUE)
[17:27:24.081]                               parallel_sendData(master, data)
[17:27:24.081]                             }
[17:27:24.081]                             return(sendCondition)
[17:27:24.081]                           }
[17:27:24.081]                         }
[17:27:24.081]                         frame <- frame + 1L
[17:27:24.081]                         envir <- sys.frame(frame)
[17:27:24.081]                       }
[17:27:24.081]                     }
[17:27:24.081]                     sendCondition <<- function(cond) NULL
[17:27:24.081]                   }
[17:27:24.081]                 })
[17:27:24.081]                 withCallingHandlers({
[17:27:24.081]                   {
[17:27:24.081]                     if (ii%%2 == 0) 
[17:27:24.081]                       stop("Woops!")
[17:27:24.081]                     ii
[17:27:24.081]                   }
[17:27:24.081]                 }, immediateCondition = function(cond) {
[17:27:24.081]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.081]                   sendCondition(cond)
[17:27:24.081]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.081]                   {
[17:27:24.081]                     inherits <- base::inherits
[17:27:24.081]                     invokeRestart <- base::invokeRestart
[17:27:24.081]                     is.null <- base::is.null
[17:27:24.081]                     muffled <- FALSE
[17:27:24.081]                     if (inherits(cond, "message")) {
[17:27:24.081]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.081]                       if (muffled) 
[17:27:24.081]                         invokeRestart("muffleMessage")
[17:27:24.081]                     }
[17:27:24.081]                     else if (inherits(cond, "warning")) {
[17:27:24.081]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.081]                       if (muffled) 
[17:27:24.081]                         invokeRestart("muffleWarning")
[17:27:24.081]                     }
[17:27:24.081]                     else if (inherits(cond, "condition")) {
[17:27:24.081]                       if (!is.null(pattern)) {
[17:27:24.081]                         computeRestarts <- base::computeRestarts
[17:27:24.081]                         grepl <- base::grepl
[17:27:24.081]                         restarts <- computeRestarts(cond)
[17:27:24.081]                         for (restart in restarts) {
[17:27:24.081]                           name <- restart$name
[17:27:24.081]                           if (is.null(name)) 
[17:27:24.081]                             next
[17:27:24.081]                           if (!grepl(pattern, name)) 
[17:27:24.081]                             next
[17:27:24.081]                           invokeRestart(restart)
[17:27:24.081]                           muffled <- TRUE
[17:27:24.081]                           break
[17:27:24.081]                         }
[17:27:24.081]                       }
[17:27:24.081]                     }
[17:27:24.081]                     invisible(muffled)
[17:27:24.081]                   }
[17:27:24.081]                   muffleCondition(cond)
[17:27:24.081]                 })
[17:27:24.081]             }))
[17:27:24.081]             future::FutureResult(value = ...future.value$value, 
[17:27:24.081]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.081]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.081]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.081]                     ...future.globalenv.names))
[17:27:24.081]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.081]         }, condition = base::local({
[17:27:24.081]             c <- base::c
[17:27:24.081]             inherits <- base::inherits
[17:27:24.081]             invokeRestart <- base::invokeRestart
[17:27:24.081]             length <- base::length
[17:27:24.081]             list <- base::list
[17:27:24.081]             seq.int <- base::seq.int
[17:27:24.081]             signalCondition <- base::signalCondition
[17:27:24.081]             sys.calls <- base::sys.calls
[17:27:24.081]             `[[` <- base::`[[`
[17:27:24.081]             `+` <- base::`+`
[17:27:24.081]             `<<-` <- base::`<<-`
[17:27:24.081]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.081]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.081]                   3L)]
[17:27:24.081]             }
[17:27:24.081]             function(cond) {
[17:27:24.081]                 is_error <- inherits(cond, "error")
[17:27:24.081]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.081]                   NULL)
[17:27:24.081]                 if (is_error) {
[17:27:24.081]                   sessionInformation <- function() {
[17:27:24.081]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.081]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.081]                       search = base::search(), system = base::Sys.info())
[17:27:24.081]                   }
[17:27:24.081]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.081]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.081]                     cond$call), session = sessionInformation(), 
[17:27:24.081]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.081]                   signalCondition(cond)
[17:27:24.081]                 }
[17:27:24.081]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.081]                 "immediateCondition"))) {
[17:27:24.081]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.081]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.081]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.081]                   if (TRUE && !signal) {
[17:27:24.081]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.081]                     {
[17:27:24.081]                       inherits <- base::inherits
[17:27:24.081]                       invokeRestart <- base::invokeRestart
[17:27:24.081]                       is.null <- base::is.null
[17:27:24.081]                       muffled <- FALSE
[17:27:24.081]                       if (inherits(cond, "message")) {
[17:27:24.081]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.081]                         if (muffled) 
[17:27:24.081]                           invokeRestart("muffleMessage")
[17:27:24.081]                       }
[17:27:24.081]                       else if (inherits(cond, "warning")) {
[17:27:24.081]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.081]                         if (muffled) 
[17:27:24.081]                           invokeRestart("muffleWarning")
[17:27:24.081]                       }
[17:27:24.081]                       else if (inherits(cond, "condition")) {
[17:27:24.081]                         if (!is.null(pattern)) {
[17:27:24.081]                           computeRestarts <- base::computeRestarts
[17:27:24.081]                           grepl <- base::grepl
[17:27:24.081]                           restarts <- computeRestarts(cond)
[17:27:24.081]                           for (restart in restarts) {
[17:27:24.081]                             name <- restart$name
[17:27:24.081]                             if (is.null(name)) 
[17:27:24.081]                               next
[17:27:24.081]                             if (!grepl(pattern, name)) 
[17:27:24.081]                               next
[17:27:24.081]                             invokeRestart(restart)
[17:27:24.081]                             muffled <- TRUE
[17:27:24.081]                             break
[17:27:24.081]                           }
[17:27:24.081]                         }
[17:27:24.081]                       }
[17:27:24.081]                       invisible(muffled)
[17:27:24.081]                     }
[17:27:24.081]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.081]                   }
[17:27:24.081]                 }
[17:27:24.081]                 else {
[17:27:24.081]                   if (TRUE) {
[17:27:24.081]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.081]                     {
[17:27:24.081]                       inherits <- base::inherits
[17:27:24.081]                       invokeRestart <- base::invokeRestart
[17:27:24.081]                       is.null <- base::is.null
[17:27:24.081]                       muffled <- FALSE
[17:27:24.081]                       if (inherits(cond, "message")) {
[17:27:24.081]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.081]                         if (muffled) 
[17:27:24.081]                           invokeRestart("muffleMessage")
[17:27:24.081]                       }
[17:27:24.081]                       else if (inherits(cond, "warning")) {
[17:27:24.081]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.081]                         if (muffled) 
[17:27:24.081]                           invokeRestart("muffleWarning")
[17:27:24.081]                       }
[17:27:24.081]                       else if (inherits(cond, "condition")) {
[17:27:24.081]                         if (!is.null(pattern)) {
[17:27:24.081]                           computeRestarts <- base::computeRestarts
[17:27:24.081]                           grepl <- base::grepl
[17:27:24.081]                           restarts <- computeRestarts(cond)
[17:27:24.081]                           for (restart in restarts) {
[17:27:24.081]                             name <- restart$name
[17:27:24.081]                             if (is.null(name)) 
[17:27:24.081]                               next
[17:27:24.081]                             if (!grepl(pattern, name)) 
[17:27:24.081]                               next
[17:27:24.081]                             invokeRestart(restart)
[17:27:24.081]                             muffled <- TRUE
[17:27:24.081]                             break
[17:27:24.081]                           }
[17:27:24.081]                         }
[17:27:24.081]                       }
[17:27:24.081]                       invisible(muffled)
[17:27:24.081]                     }
[17:27:24.081]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.081]                   }
[17:27:24.081]                 }
[17:27:24.081]             }
[17:27:24.081]         }))
[17:27:24.081]     }, error = function(ex) {
[17:27:24.081]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.081]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.081]                 ...future.rng), started = ...future.startTime, 
[17:27:24.081]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.081]             version = "1.8"), class = "FutureResult")
[17:27:24.081]     }, finally = {
[17:27:24.081]         if (!identical(...future.workdir, getwd())) 
[17:27:24.081]             setwd(...future.workdir)
[17:27:24.081]         {
[17:27:24.081]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.081]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.081]             }
[17:27:24.081]             base::options(...future.oldOptions)
[17:27:24.081]             if (.Platform$OS.type == "windows") {
[17:27:24.081]                 old_names <- names(...future.oldEnvVars)
[17:27:24.081]                 envs <- base::Sys.getenv()
[17:27:24.081]                 names <- names(envs)
[17:27:24.081]                 common <- intersect(names, old_names)
[17:27:24.081]                 added <- setdiff(names, old_names)
[17:27:24.081]                 removed <- setdiff(old_names, names)
[17:27:24.081]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.081]                   envs[common]]
[17:27:24.081]                 NAMES <- toupper(changed)
[17:27:24.081]                 args <- list()
[17:27:24.081]                 for (kk in seq_along(NAMES)) {
[17:27:24.081]                   name <- changed[[kk]]
[17:27:24.081]                   NAME <- NAMES[[kk]]
[17:27:24.081]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.081]                     next
[17:27:24.081]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.081]                 }
[17:27:24.081]                 NAMES <- toupper(added)
[17:27:24.081]                 for (kk in seq_along(NAMES)) {
[17:27:24.081]                   name <- added[[kk]]
[17:27:24.081]                   NAME <- NAMES[[kk]]
[17:27:24.081]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.081]                     next
[17:27:24.081]                   args[[name]] <- ""
[17:27:24.081]                 }
[17:27:24.081]                 NAMES <- toupper(removed)
[17:27:24.081]                 for (kk in seq_along(NAMES)) {
[17:27:24.081]                   name <- removed[[kk]]
[17:27:24.081]                   NAME <- NAMES[[kk]]
[17:27:24.081]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.081]                     next
[17:27:24.081]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.081]                 }
[17:27:24.081]                 if (length(args) > 0) 
[17:27:24.081]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.081]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.081]             }
[17:27:24.081]             else {
[17:27:24.081]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.081]             }
[17:27:24.081]             {
[17:27:24.081]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.081]                   0L) {
[17:27:24.081]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.081]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.081]                   base::options(opts)
[17:27:24.081]                 }
[17:27:24.081]                 {
[17:27:24.081]                   {
[17:27:24.081]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.081]                     NULL
[17:27:24.081]                   }
[17:27:24.081]                   options(future.plan = NULL)
[17:27:24.081]                   if (is.na(NA_character_)) 
[17:27:24.081]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.081]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.081]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.081]                     .init = FALSE)
[17:27:24.081]                 }
[17:27:24.081]             }
[17:27:24.081]         }
[17:27:24.081]     })
[17:27:24.081]     if (TRUE) {
[17:27:24.081]         base::sink(type = "output", split = FALSE)
[17:27:24.081]         if (TRUE) {
[17:27:24.081]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.081]         }
[17:27:24.081]         else {
[17:27:24.081]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.081]         }
[17:27:24.081]         base::close(...future.stdout)
[17:27:24.081]         ...future.stdout <- NULL
[17:27:24.081]     }
[17:27:24.081]     ...future.result$conditions <- ...future.conditions
[17:27:24.081]     ...future.result$finished <- base::Sys.time()
[17:27:24.081]     ...future.result
[17:27:24.081] }
[17:27:24.090] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:27:24.090] Exporting 'ii' (35 bytes) to cluster node #1 ...
[17:27:24.091] Exporting 'ii' (35 bytes) to cluster node #1 ... DONE
[17:27:24.092] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:27:24.093] MultisessionFuture started
[17:27:24.093] - Launch lazy future ... done
[17:27:24.093] run() for 'MultisessionFuture' ... done
[17:27:24.094] getGlobalsAndPackages() ...
[17:27:24.094] Searching for globals...
[17:27:24.097] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:27:24.097] Searching for globals ... DONE
[17:27:24.097] Resolving globals: FALSE
[17:27:24.098] The total size of the 1 globals is 35 bytes (35 bytes)
[17:27:24.099] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:27:24.099] - globals: [1] 'ii'
[17:27:24.100] 
[17:27:24.100] getGlobalsAndPackages() ... DONE
[17:27:24.101] run() for 'Future' ...
[17:27:24.101] - state: 'created'
[17:27:24.101] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.120] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.120] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.121]   - Field: 'node'
[17:27:24.121]   - Field: 'label'
[17:27:24.121]   - Field: 'local'
[17:27:24.121]   - Field: 'owner'
[17:27:24.121]   - Field: 'envir'
[17:27:24.122]   - Field: 'workers'
[17:27:24.122]   - Field: 'packages'
[17:27:24.122]   - Field: 'gc'
[17:27:24.122]   - Field: 'conditions'
[17:27:24.122]   - Field: 'persistent'
[17:27:24.123]   - Field: 'expr'
[17:27:24.123]   - Field: 'uuid'
[17:27:24.123]   - Field: 'seed'
[17:27:24.123]   - Field: 'version'
[17:27:24.123]   - Field: 'result'
[17:27:24.124]   - Field: 'asynchronous'
[17:27:24.124]   - Field: 'calls'
[17:27:24.124]   - Field: 'globals'
[17:27:24.124]   - Field: 'stdout'
[17:27:24.124]   - Field: 'earlySignal'
[17:27:24.125]   - Field: 'lazy'
[17:27:24.125]   - Field: 'state'
[17:27:24.125] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.125] - Launch lazy future ...
[17:27:24.126] Packages needed by the future expression (n = 0): <none>
[17:27:24.126] Packages needed by future strategies (n = 0): <none>
[17:27:24.127] {
[17:27:24.127]     {
[17:27:24.127]         {
[17:27:24.127]             ...future.startTime <- base::Sys.time()
[17:27:24.127]             {
[17:27:24.127]                 {
[17:27:24.127]                   {
[17:27:24.127]                     {
[17:27:24.127]                       base::local({
[17:27:24.127]                         has_future <- base::requireNamespace("future", 
[17:27:24.127]                           quietly = TRUE)
[17:27:24.127]                         if (has_future) {
[17:27:24.127]                           ns <- base::getNamespace("future")
[17:27:24.127]                           version <- ns[[".package"]][["version"]]
[17:27:24.127]                           if (is.null(version)) 
[17:27:24.127]                             version <- utils::packageVersion("future")
[17:27:24.127]                         }
[17:27:24.127]                         else {
[17:27:24.127]                           version <- NULL
[17:27:24.127]                         }
[17:27:24.127]                         if (!has_future || version < "1.8.0") {
[17:27:24.127]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.127]                             "", base::R.version$version.string), 
[17:27:24.127]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.127]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.127]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.127]                               "release", "version")], collapse = " "), 
[17:27:24.127]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.127]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.127]                             info)
[17:27:24.127]                           info <- base::paste(info, collapse = "; ")
[17:27:24.127]                           if (!has_future) {
[17:27:24.127]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.127]                               info)
[17:27:24.127]                           }
[17:27:24.127]                           else {
[17:27:24.127]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.127]                               info, version)
[17:27:24.127]                           }
[17:27:24.127]                           base::stop(msg)
[17:27:24.127]                         }
[17:27:24.127]                       })
[17:27:24.127]                     }
[17:27:24.127]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.127]                     base::options(mc.cores = 1L)
[17:27:24.127]                   }
[17:27:24.127]                   ...future.strategy.old <- future::plan("list")
[17:27:24.127]                   options(future.plan = NULL)
[17:27:24.127]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.127]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.127]                 }
[17:27:24.127]                 ...future.workdir <- getwd()
[17:27:24.127]             }
[17:27:24.127]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.127]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.127]         }
[17:27:24.127]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.127]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.127]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.127]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.127]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.127]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.127]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.127]             base::names(...future.oldOptions))
[17:27:24.127]     }
[17:27:24.127]     if (FALSE) {
[17:27:24.127]     }
[17:27:24.127]     else {
[17:27:24.127]         if (TRUE) {
[17:27:24.127]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.127]                 open = "w")
[17:27:24.127]         }
[17:27:24.127]         else {
[17:27:24.127]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.127]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.127]         }
[17:27:24.127]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.127]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.127]             base::sink(type = "output", split = FALSE)
[17:27:24.127]             base::close(...future.stdout)
[17:27:24.127]         }, add = TRUE)
[17:27:24.127]     }
[17:27:24.127]     ...future.frame <- base::sys.nframe()
[17:27:24.127]     ...future.conditions <- base::list()
[17:27:24.127]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.127]     if (FALSE) {
[17:27:24.127]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.127]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.127]     }
[17:27:24.127]     ...future.result <- base::tryCatch({
[17:27:24.127]         base::withCallingHandlers({
[17:27:24.127]             ...future.value <- base::withVisible(base::local({
[17:27:24.127]                 ...future.makeSendCondition <- base::local({
[17:27:24.127]                   sendCondition <- NULL
[17:27:24.127]                   function(frame = 1L) {
[17:27:24.127]                     if (is.function(sendCondition)) 
[17:27:24.127]                       return(sendCondition)
[17:27:24.127]                     ns <- getNamespace("parallel")
[17:27:24.127]                     if (exists("sendData", mode = "function", 
[17:27:24.127]                       envir = ns)) {
[17:27:24.127]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.127]                         envir = ns)
[17:27:24.127]                       envir <- sys.frame(frame)
[17:27:24.127]                       master <- NULL
[17:27:24.127]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.127]                         !identical(envir, emptyenv())) {
[17:27:24.127]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.127]                           inherits = FALSE)) {
[17:27:24.127]                           master <- get("master", mode = "list", 
[17:27:24.127]                             envir = envir, inherits = FALSE)
[17:27:24.127]                           if (inherits(master, c("SOCKnode", 
[17:27:24.127]                             "SOCK0node"))) {
[17:27:24.127]                             sendCondition <<- function(cond) {
[17:27:24.127]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.127]                                 success = TRUE)
[17:27:24.127]                               parallel_sendData(master, data)
[17:27:24.127]                             }
[17:27:24.127]                             return(sendCondition)
[17:27:24.127]                           }
[17:27:24.127]                         }
[17:27:24.127]                         frame <- frame + 1L
[17:27:24.127]                         envir <- sys.frame(frame)
[17:27:24.127]                       }
[17:27:24.127]                     }
[17:27:24.127]                     sendCondition <<- function(cond) NULL
[17:27:24.127]                   }
[17:27:24.127]                 })
[17:27:24.127]                 withCallingHandlers({
[17:27:24.127]                   {
[17:27:24.127]                     if (ii%%2 == 0) 
[17:27:24.127]                       stop("Woops!")
[17:27:24.127]                     ii
[17:27:24.127]                   }
[17:27:24.127]                 }, immediateCondition = function(cond) {
[17:27:24.127]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.127]                   sendCondition(cond)
[17:27:24.127]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.127]                   {
[17:27:24.127]                     inherits <- base::inherits
[17:27:24.127]                     invokeRestart <- base::invokeRestart
[17:27:24.127]                     is.null <- base::is.null
[17:27:24.127]                     muffled <- FALSE
[17:27:24.127]                     if (inherits(cond, "message")) {
[17:27:24.127]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.127]                       if (muffled) 
[17:27:24.127]                         invokeRestart("muffleMessage")
[17:27:24.127]                     }
[17:27:24.127]                     else if (inherits(cond, "warning")) {
[17:27:24.127]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.127]                       if (muffled) 
[17:27:24.127]                         invokeRestart("muffleWarning")
[17:27:24.127]                     }
[17:27:24.127]                     else if (inherits(cond, "condition")) {
[17:27:24.127]                       if (!is.null(pattern)) {
[17:27:24.127]                         computeRestarts <- base::computeRestarts
[17:27:24.127]                         grepl <- base::grepl
[17:27:24.127]                         restarts <- computeRestarts(cond)
[17:27:24.127]                         for (restart in restarts) {
[17:27:24.127]                           name <- restart$name
[17:27:24.127]                           if (is.null(name)) 
[17:27:24.127]                             next
[17:27:24.127]                           if (!grepl(pattern, name)) 
[17:27:24.127]                             next
[17:27:24.127]                           invokeRestart(restart)
[17:27:24.127]                           muffled <- TRUE
[17:27:24.127]                           break
[17:27:24.127]                         }
[17:27:24.127]                       }
[17:27:24.127]                     }
[17:27:24.127]                     invisible(muffled)
[17:27:24.127]                   }
[17:27:24.127]                   muffleCondition(cond)
[17:27:24.127]                 })
[17:27:24.127]             }))
[17:27:24.127]             future::FutureResult(value = ...future.value$value, 
[17:27:24.127]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.127]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.127]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.127]                     ...future.globalenv.names))
[17:27:24.127]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.127]         }, condition = base::local({
[17:27:24.127]             c <- base::c
[17:27:24.127]             inherits <- base::inherits
[17:27:24.127]             invokeRestart <- base::invokeRestart
[17:27:24.127]             length <- base::length
[17:27:24.127]             list <- base::list
[17:27:24.127]             seq.int <- base::seq.int
[17:27:24.127]             signalCondition <- base::signalCondition
[17:27:24.127]             sys.calls <- base::sys.calls
[17:27:24.127]             `[[` <- base::`[[`
[17:27:24.127]             `+` <- base::`+`
[17:27:24.127]             `<<-` <- base::`<<-`
[17:27:24.127]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.127]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.127]                   3L)]
[17:27:24.127]             }
[17:27:24.127]             function(cond) {
[17:27:24.127]                 is_error <- inherits(cond, "error")
[17:27:24.127]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.127]                   NULL)
[17:27:24.127]                 if (is_error) {
[17:27:24.127]                   sessionInformation <- function() {
[17:27:24.127]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.127]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.127]                       search = base::search(), system = base::Sys.info())
[17:27:24.127]                   }
[17:27:24.127]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.127]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.127]                     cond$call), session = sessionInformation(), 
[17:27:24.127]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.127]                   signalCondition(cond)
[17:27:24.127]                 }
[17:27:24.127]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.127]                 "immediateCondition"))) {
[17:27:24.127]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.127]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.127]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.127]                   if (TRUE && !signal) {
[17:27:24.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.127]                     {
[17:27:24.127]                       inherits <- base::inherits
[17:27:24.127]                       invokeRestart <- base::invokeRestart
[17:27:24.127]                       is.null <- base::is.null
[17:27:24.127]                       muffled <- FALSE
[17:27:24.127]                       if (inherits(cond, "message")) {
[17:27:24.127]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.127]                         if (muffled) 
[17:27:24.127]                           invokeRestart("muffleMessage")
[17:27:24.127]                       }
[17:27:24.127]                       else if (inherits(cond, "warning")) {
[17:27:24.127]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.127]                         if (muffled) 
[17:27:24.127]                           invokeRestart("muffleWarning")
[17:27:24.127]                       }
[17:27:24.127]                       else if (inherits(cond, "condition")) {
[17:27:24.127]                         if (!is.null(pattern)) {
[17:27:24.127]                           computeRestarts <- base::computeRestarts
[17:27:24.127]                           grepl <- base::grepl
[17:27:24.127]                           restarts <- computeRestarts(cond)
[17:27:24.127]                           for (restart in restarts) {
[17:27:24.127]                             name <- restart$name
[17:27:24.127]                             if (is.null(name)) 
[17:27:24.127]                               next
[17:27:24.127]                             if (!grepl(pattern, name)) 
[17:27:24.127]                               next
[17:27:24.127]                             invokeRestart(restart)
[17:27:24.127]                             muffled <- TRUE
[17:27:24.127]                             break
[17:27:24.127]                           }
[17:27:24.127]                         }
[17:27:24.127]                       }
[17:27:24.127]                       invisible(muffled)
[17:27:24.127]                     }
[17:27:24.127]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.127]                   }
[17:27:24.127]                 }
[17:27:24.127]                 else {
[17:27:24.127]                   if (TRUE) {
[17:27:24.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.127]                     {
[17:27:24.127]                       inherits <- base::inherits
[17:27:24.127]                       invokeRestart <- base::invokeRestart
[17:27:24.127]                       is.null <- base::is.null
[17:27:24.127]                       muffled <- FALSE
[17:27:24.127]                       if (inherits(cond, "message")) {
[17:27:24.127]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.127]                         if (muffled) 
[17:27:24.127]                           invokeRestart("muffleMessage")
[17:27:24.127]                       }
[17:27:24.127]                       else if (inherits(cond, "warning")) {
[17:27:24.127]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.127]                         if (muffled) 
[17:27:24.127]                           invokeRestart("muffleWarning")
[17:27:24.127]                       }
[17:27:24.127]                       else if (inherits(cond, "condition")) {
[17:27:24.127]                         if (!is.null(pattern)) {
[17:27:24.127]                           computeRestarts <- base::computeRestarts
[17:27:24.127]                           grepl <- base::grepl
[17:27:24.127]                           restarts <- computeRestarts(cond)
[17:27:24.127]                           for (restart in restarts) {
[17:27:24.127]                             name <- restart$name
[17:27:24.127]                             if (is.null(name)) 
[17:27:24.127]                               next
[17:27:24.127]                             if (!grepl(pattern, name)) 
[17:27:24.127]                               next
[17:27:24.127]                             invokeRestart(restart)
[17:27:24.127]                             muffled <- TRUE
[17:27:24.127]                             break
[17:27:24.127]                           }
[17:27:24.127]                         }
[17:27:24.127]                       }
[17:27:24.127]                       invisible(muffled)
[17:27:24.127]                     }
[17:27:24.127]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.127]                   }
[17:27:24.127]                 }
[17:27:24.127]             }
[17:27:24.127]         }))
[17:27:24.127]     }, error = function(ex) {
[17:27:24.127]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.127]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.127]                 ...future.rng), started = ...future.startTime, 
[17:27:24.127]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.127]             version = "1.8"), class = "FutureResult")
[17:27:24.127]     }, finally = {
[17:27:24.127]         if (!identical(...future.workdir, getwd())) 
[17:27:24.127]             setwd(...future.workdir)
[17:27:24.127]         {
[17:27:24.127]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.127]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.127]             }
[17:27:24.127]             base::options(...future.oldOptions)
[17:27:24.127]             if (.Platform$OS.type == "windows") {
[17:27:24.127]                 old_names <- names(...future.oldEnvVars)
[17:27:24.127]                 envs <- base::Sys.getenv()
[17:27:24.127]                 names <- names(envs)
[17:27:24.127]                 common <- intersect(names, old_names)
[17:27:24.127]                 added <- setdiff(names, old_names)
[17:27:24.127]                 removed <- setdiff(old_names, names)
[17:27:24.127]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.127]                   envs[common]]
[17:27:24.127]                 NAMES <- toupper(changed)
[17:27:24.127]                 args <- list()
[17:27:24.127]                 for (kk in seq_along(NAMES)) {
[17:27:24.127]                   name <- changed[[kk]]
[17:27:24.127]                   NAME <- NAMES[[kk]]
[17:27:24.127]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.127]                     next
[17:27:24.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.127]                 }
[17:27:24.127]                 NAMES <- toupper(added)
[17:27:24.127]                 for (kk in seq_along(NAMES)) {
[17:27:24.127]                   name <- added[[kk]]
[17:27:24.127]                   NAME <- NAMES[[kk]]
[17:27:24.127]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.127]                     next
[17:27:24.127]                   args[[name]] <- ""
[17:27:24.127]                 }
[17:27:24.127]                 NAMES <- toupper(removed)
[17:27:24.127]                 for (kk in seq_along(NAMES)) {
[17:27:24.127]                   name <- removed[[kk]]
[17:27:24.127]                   NAME <- NAMES[[kk]]
[17:27:24.127]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.127]                     next
[17:27:24.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.127]                 }
[17:27:24.127]                 if (length(args) > 0) 
[17:27:24.127]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.127]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.127]             }
[17:27:24.127]             else {
[17:27:24.127]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.127]             }
[17:27:24.127]             {
[17:27:24.127]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.127]                   0L) {
[17:27:24.127]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.127]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.127]                   base::options(opts)
[17:27:24.127]                 }
[17:27:24.127]                 {
[17:27:24.127]                   {
[17:27:24.127]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.127]                     NULL
[17:27:24.127]                   }
[17:27:24.127]                   options(future.plan = NULL)
[17:27:24.127]                   if (is.na(NA_character_)) 
[17:27:24.127]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.127]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.127]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.127]                     .init = FALSE)
[17:27:24.127]                 }
[17:27:24.127]             }
[17:27:24.127]         }
[17:27:24.127]     })
[17:27:24.127]     if (TRUE) {
[17:27:24.127]         base::sink(type = "output", split = FALSE)
[17:27:24.127]         if (TRUE) {
[17:27:24.127]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.127]         }
[17:27:24.127]         else {
[17:27:24.127]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.127]         }
[17:27:24.127]         base::close(...future.stdout)
[17:27:24.127]         ...future.stdout <- NULL
[17:27:24.127]     }
[17:27:24.127]     ...future.result$conditions <- ...future.conditions
[17:27:24.127]     ...future.result$finished <- base::Sys.time()
[17:27:24.127]     ...future.result
[17:27:24.127] }
[17:27:24.263] Exporting 1 global objects (340 bytes) to cluster node #2 ...
[17:27:24.264] Exporting 'ii' (35 bytes) to cluster node #2 ...
[17:27:24.265] Exporting 'ii' (35 bytes) to cluster node #2 ... DONE
[17:27:24.265] Exporting 1 global objects (340 bytes) to cluster node #2 ... DONE
[17:27:24.267] MultisessionFuture started
[17:27:24.268] - Launch lazy future ... done
[17:27:24.268] run() for 'MultisessionFuture' ... done
[17:27:24.269] getGlobalsAndPackages() ...
[17:27:24.269] Searching for globals...
[17:27:24.273] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:27:24.273] Searching for globals ... DONE
[17:27:24.273] Resolving globals: FALSE
[17:27:24.274] The total size of the 1 globals is 35 bytes (35 bytes)
[17:27:24.275] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:27:24.276] - globals: [1] 'ii'
[17:27:24.276] 
[17:27:24.276] getGlobalsAndPackages() ... DONE
[17:27:24.277] run() for 'Future' ...
[17:27:24.277] - state: 'created'
[17:27:24.278] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.300] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.300] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.301]   - Field: 'node'
[17:27:24.301]   - Field: 'label'
[17:27:24.302]   - Field: 'local'
[17:27:24.302]   - Field: 'owner'
[17:27:24.302]   - Field: 'envir'
[17:27:24.302]   - Field: 'workers'
[17:27:24.303]   - Field: 'packages'
[17:27:24.303]   - Field: 'gc'
[17:27:24.303]   - Field: 'conditions'
[17:27:24.304]   - Field: 'persistent'
[17:27:24.304]   - Field: 'expr'
[17:27:24.304]   - Field: 'uuid'
[17:27:24.305]   - Field: 'seed'
[17:27:24.305]   - Field: 'version'
[17:27:24.305]   - Field: 'result'
[17:27:24.305]   - Field: 'asynchronous'
[17:27:24.306]   - Field: 'calls'
[17:27:24.306]   - Field: 'globals'
[17:27:24.306]   - Field: 'stdout'
[17:27:24.307]   - Field: 'earlySignal'
[17:27:24.307]   - Field: 'lazy'
[17:27:24.307]   - Field: 'state'
[17:27:24.308] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.308] - Launch lazy future ...
[17:27:24.309] Packages needed by the future expression (n = 0): <none>
[17:27:24.309] Packages needed by future strategies (n = 0): <none>
[17:27:24.310] {
[17:27:24.310]     {
[17:27:24.310]         {
[17:27:24.310]             ...future.startTime <- base::Sys.time()
[17:27:24.310]             {
[17:27:24.310]                 {
[17:27:24.310]                   {
[17:27:24.310]                     {
[17:27:24.310]                       base::local({
[17:27:24.310]                         has_future <- base::requireNamespace("future", 
[17:27:24.310]                           quietly = TRUE)
[17:27:24.310]                         if (has_future) {
[17:27:24.310]                           ns <- base::getNamespace("future")
[17:27:24.310]                           version <- ns[[".package"]][["version"]]
[17:27:24.310]                           if (is.null(version)) 
[17:27:24.310]                             version <- utils::packageVersion("future")
[17:27:24.310]                         }
[17:27:24.310]                         else {
[17:27:24.310]                           version <- NULL
[17:27:24.310]                         }
[17:27:24.310]                         if (!has_future || version < "1.8.0") {
[17:27:24.310]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.310]                             "", base::R.version$version.string), 
[17:27:24.310]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.310]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.310]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.310]                               "release", "version")], collapse = " "), 
[17:27:24.310]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.310]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.310]                             info)
[17:27:24.310]                           info <- base::paste(info, collapse = "; ")
[17:27:24.310]                           if (!has_future) {
[17:27:24.310]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.310]                               info)
[17:27:24.310]                           }
[17:27:24.310]                           else {
[17:27:24.310]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.310]                               info, version)
[17:27:24.310]                           }
[17:27:24.310]                           base::stop(msg)
[17:27:24.310]                         }
[17:27:24.310]                       })
[17:27:24.310]                     }
[17:27:24.310]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.310]                     base::options(mc.cores = 1L)
[17:27:24.310]                   }
[17:27:24.310]                   ...future.strategy.old <- future::plan("list")
[17:27:24.310]                   options(future.plan = NULL)
[17:27:24.310]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.310]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.310]                 }
[17:27:24.310]                 ...future.workdir <- getwd()
[17:27:24.310]             }
[17:27:24.310]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.310]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.310]         }
[17:27:24.310]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.310]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.310]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.310]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.310]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.310]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.310]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.310]             base::names(...future.oldOptions))
[17:27:24.310]     }
[17:27:24.310]     if (FALSE) {
[17:27:24.310]     }
[17:27:24.310]     else {
[17:27:24.310]         if (TRUE) {
[17:27:24.310]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.310]                 open = "w")
[17:27:24.310]         }
[17:27:24.310]         else {
[17:27:24.310]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.310]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.310]         }
[17:27:24.310]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.310]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.310]             base::sink(type = "output", split = FALSE)
[17:27:24.310]             base::close(...future.stdout)
[17:27:24.310]         }, add = TRUE)
[17:27:24.310]     }
[17:27:24.310]     ...future.frame <- base::sys.nframe()
[17:27:24.310]     ...future.conditions <- base::list()
[17:27:24.310]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.310]     if (FALSE) {
[17:27:24.310]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.310]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.310]     }
[17:27:24.310]     ...future.result <- base::tryCatch({
[17:27:24.310]         base::withCallingHandlers({
[17:27:24.310]             ...future.value <- base::withVisible(base::local({
[17:27:24.310]                 ...future.makeSendCondition <- base::local({
[17:27:24.310]                   sendCondition <- NULL
[17:27:24.310]                   function(frame = 1L) {
[17:27:24.310]                     if (is.function(sendCondition)) 
[17:27:24.310]                       return(sendCondition)
[17:27:24.310]                     ns <- getNamespace("parallel")
[17:27:24.310]                     if (exists("sendData", mode = "function", 
[17:27:24.310]                       envir = ns)) {
[17:27:24.310]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.310]                         envir = ns)
[17:27:24.310]                       envir <- sys.frame(frame)
[17:27:24.310]                       master <- NULL
[17:27:24.310]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.310]                         !identical(envir, emptyenv())) {
[17:27:24.310]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.310]                           inherits = FALSE)) {
[17:27:24.310]                           master <- get("master", mode = "list", 
[17:27:24.310]                             envir = envir, inherits = FALSE)
[17:27:24.310]                           if (inherits(master, c("SOCKnode", 
[17:27:24.310]                             "SOCK0node"))) {
[17:27:24.310]                             sendCondition <<- function(cond) {
[17:27:24.310]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.310]                                 success = TRUE)
[17:27:24.310]                               parallel_sendData(master, data)
[17:27:24.310]                             }
[17:27:24.310]                             return(sendCondition)
[17:27:24.310]                           }
[17:27:24.310]                         }
[17:27:24.310]                         frame <- frame + 1L
[17:27:24.310]                         envir <- sys.frame(frame)
[17:27:24.310]                       }
[17:27:24.310]                     }
[17:27:24.310]                     sendCondition <<- function(cond) NULL
[17:27:24.310]                   }
[17:27:24.310]                 })
[17:27:24.310]                 withCallingHandlers({
[17:27:24.310]                   {
[17:27:24.310]                     if (ii%%2 == 0) 
[17:27:24.310]                       stop("Woops!")
[17:27:24.310]                     ii
[17:27:24.310]                   }
[17:27:24.310]                 }, immediateCondition = function(cond) {
[17:27:24.310]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.310]                   sendCondition(cond)
[17:27:24.310]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.310]                   {
[17:27:24.310]                     inherits <- base::inherits
[17:27:24.310]                     invokeRestart <- base::invokeRestart
[17:27:24.310]                     is.null <- base::is.null
[17:27:24.310]                     muffled <- FALSE
[17:27:24.310]                     if (inherits(cond, "message")) {
[17:27:24.310]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.310]                       if (muffled) 
[17:27:24.310]                         invokeRestart("muffleMessage")
[17:27:24.310]                     }
[17:27:24.310]                     else if (inherits(cond, "warning")) {
[17:27:24.310]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.310]                       if (muffled) 
[17:27:24.310]                         invokeRestart("muffleWarning")
[17:27:24.310]                     }
[17:27:24.310]                     else if (inherits(cond, "condition")) {
[17:27:24.310]                       if (!is.null(pattern)) {
[17:27:24.310]                         computeRestarts <- base::computeRestarts
[17:27:24.310]                         grepl <- base::grepl
[17:27:24.310]                         restarts <- computeRestarts(cond)
[17:27:24.310]                         for (restart in restarts) {
[17:27:24.310]                           name <- restart$name
[17:27:24.310]                           if (is.null(name)) 
[17:27:24.310]                             next
[17:27:24.310]                           if (!grepl(pattern, name)) 
[17:27:24.310]                             next
[17:27:24.310]                           invokeRestart(restart)
[17:27:24.310]                           muffled <- TRUE
[17:27:24.310]                           break
[17:27:24.310]                         }
[17:27:24.310]                       }
[17:27:24.310]                     }
[17:27:24.310]                     invisible(muffled)
[17:27:24.310]                   }
[17:27:24.310]                   muffleCondition(cond)
[17:27:24.310]                 })
[17:27:24.310]             }))
[17:27:24.310]             future::FutureResult(value = ...future.value$value, 
[17:27:24.310]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.310]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.310]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.310]                     ...future.globalenv.names))
[17:27:24.310]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.310]         }, condition = base::local({
[17:27:24.310]             c <- base::c
[17:27:24.310]             inherits <- base::inherits
[17:27:24.310]             invokeRestart <- base::invokeRestart
[17:27:24.310]             length <- base::length
[17:27:24.310]             list <- base::list
[17:27:24.310]             seq.int <- base::seq.int
[17:27:24.310]             signalCondition <- base::signalCondition
[17:27:24.310]             sys.calls <- base::sys.calls
[17:27:24.310]             `[[` <- base::`[[`
[17:27:24.310]             `+` <- base::`+`
[17:27:24.310]             `<<-` <- base::`<<-`
[17:27:24.310]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.310]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.310]                   3L)]
[17:27:24.310]             }
[17:27:24.310]             function(cond) {
[17:27:24.310]                 is_error <- inherits(cond, "error")
[17:27:24.310]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.310]                   NULL)
[17:27:24.310]                 if (is_error) {
[17:27:24.310]                   sessionInformation <- function() {
[17:27:24.310]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.310]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.310]                       search = base::search(), system = base::Sys.info())
[17:27:24.310]                   }
[17:27:24.310]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.310]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.310]                     cond$call), session = sessionInformation(), 
[17:27:24.310]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.310]                   signalCondition(cond)
[17:27:24.310]                 }
[17:27:24.310]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.310]                 "immediateCondition"))) {
[17:27:24.310]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.310]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.310]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.310]                   if (TRUE && !signal) {
[17:27:24.310]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.310]                     {
[17:27:24.310]                       inherits <- base::inherits
[17:27:24.310]                       invokeRestart <- base::invokeRestart
[17:27:24.310]                       is.null <- base::is.null
[17:27:24.310]                       muffled <- FALSE
[17:27:24.310]                       if (inherits(cond, "message")) {
[17:27:24.310]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.310]                         if (muffled) 
[17:27:24.310]                           invokeRestart("muffleMessage")
[17:27:24.310]                       }
[17:27:24.310]                       else if (inherits(cond, "warning")) {
[17:27:24.310]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.310]                         if (muffled) 
[17:27:24.310]                           invokeRestart("muffleWarning")
[17:27:24.310]                       }
[17:27:24.310]                       else if (inherits(cond, "condition")) {
[17:27:24.310]                         if (!is.null(pattern)) {
[17:27:24.310]                           computeRestarts <- base::computeRestarts
[17:27:24.310]                           grepl <- base::grepl
[17:27:24.310]                           restarts <- computeRestarts(cond)
[17:27:24.310]                           for (restart in restarts) {
[17:27:24.310]                             name <- restart$name
[17:27:24.310]                             if (is.null(name)) 
[17:27:24.310]                               next
[17:27:24.310]                             if (!grepl(pattern, name)) 
[17:27:24.310]                               next
[17:27:24.310]                             invokeRestart(restart)
[17:27:24.310]                             muffled <- TRUE
[17:27:24.310]                             break
[17:27:24.310]                           }
[17:27:24.310]                         }
[17:27:24.310]                       }
[17:27:24.310]                       invisible(muffled)
[17:27:24.310]                     }
[17:27:24.310]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.310]                   }
[17:27:24.310]                 }
[17:27:24.310]                 else {
[17:27:24.310]                   if (TRUE) {
[17:27:24.310]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.310]                     {
[17:27:24.310]                       inherits <- base::inherits
[17:27:24.310]                       invokeRestart <- base::invokeRestart
[17:27:24.310]                       is.null <- base::is.null
[17:27:24.310]                       muffled <- FALSE
[17:27:24.310]                       if (inherits(cond, "message")) {
[17:27:24.310]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.310]                         if (muffled) 
[17:27:24.310]                           invokeRestart("muffleMessage")
[17:27:24.310]                       }
[17:27:24.310]                       else if (inherits(cond, "warning")) {
[17:27:24.310]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.310]                         if (muffled) 
[17:27:24.310]                           invokeRestart("muffleWarning")
[17:27:24.310]                       }
[17:27:24.310]                       else if (inherits(cond, "condition")) {
[17:27:24.310]                         if (!is.null(pattern)) {
[17:27:24.310]                           computeRestarts <- base::computeRestarts
[17:27:24.310]                           grepl <- base::grepl
[17:27:24.310]                           restarts <- computeRestarts(cond)
[17:27:24.310]                           for (restart in restarts) {
[17:27:24.310]                             name <- restart$name
[17:27:24.310]                             if (is.null(name)) 
[17:27:24.310]                               next
[17:27:24.310]                             if (!grepl(pattern, name)) 
[17:27:24.310]                               next
[17:27:24.310]                             invokeRestart(restart)
[17:27:24.310]                             muffled <- TRUE
[17:27:24.310]                             break
[17:27:24.310]                           }
[17:27:24.310]                         }
[17:27:24.310]                       }
[17:27:24.310]                       invisible(muffled)
[17:27:24.310]                     }
[17:27:24.310]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.310]                   }
[17:27:24.310]                 }
[17:27:24.310]             }
[17:27:24.310]         }))
[17:27:24.310]     }, error = function(ex) {
[17:27:24.310]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.310]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.310]                 ...future.rng), started = ...future.startTime, 
[17:27:24.310]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.310]             version = "1.8"), class = "FutureResult")
[17:27:24.310]     }, finally = {
[17:27:24.310]         if (!identical(...future.workdir, getwd())) 
[17:27:24.310]             setwd(...future.workdir)
[17:27:24.310]         {
[17:27:24.310]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.310]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.310]             }
[17:27:24.310]             base::options(...future.oldOptions)
[17:27:24.310]             if (.Platform$OS.type == "windows") {
[17:27:24.310]                 old_names <- names(...future.oldEnvVars)
[17:27:24.310]                 envs <- base::Sys.getenv()
[17:27:24.310]                 names <- names(envs)
[17:27:24.310]                 common <- intersect(names, old_names)
[17:27:24.310]                 added <- setdiff(names, old_names)
[17:27:24.310]                 removed <- setdiff(old_names, names)
[17:27:24.310]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.310]                   envs[common]]
[17:27:24.310]                 NAMES <- toupper(changed)
[17:27:24.310]                 args <- list()
[17:27:24.310]                 for (kk in seq_along(NAMES)) {
[17:27:24.310]                   name <- changed[[kk]]
[17:27:24.310]                   NAME <- NAMES[[kk]]
[17:27:24.310]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.310]                     next
[17:27:24.310]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.310]                 }
[17:27:24.310]                 NAMES <- toupper(added)
[17:27:24.310]                 for (kk in seq_along(NAMES)) {
[17:27:24.310]                   name <- added[[kk]]
[17:27:24.310]                   NAME <- NAMES[[kk]]
[17:27:24.310]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.310]                     next
[17:27:24.310]                   args[[name]] <- ""
[17:27:24.310]                 }
[17:27:24.310]                 NAMES <- toupper(removed)
[17:27:24.310]                 for (kk in seq_along(NAMES)) {
[17:27:24.310]                   name <- removed[[kk]]
[17:27:24.310]                   NAME <- NAMES[[kk]]
[17:27:24.310]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.310]                     next
[17:27:24.310]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.310]                 }
[17:27:24.310]                 if (length(args) > 0) 
[17:27:24.310]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.310]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.310]             }
[17:27:24.310]             else {
[17:27:24.310]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.310]             }
[17:27:24.310]             {
[17:27:24.310]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.310]                   0L) {
[17:27:24.310]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.310]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.310]                   base::options(opts)
[17:27:24.310]                 }
[17:27:24.310]                 {
[17:27:24.310]                   {
[17:27:24.310]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.310]                     NULL
[17:27:24.310]                   }
[17:27:24.310]                   options(future.plan = NULL)
[17:27:24.310]                   if (is.na(NA_character_)) 
[17:27:24.310]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.310]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.310]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.310]                     .init = FALSE)
[17:27:24.310]                 }
[17:27:24.310]             }
[17:27:24.310]         }
[17:27:24.310]     })
[17:27:24.310]     if (TRUE) {
[17:27:24.310]         base::sink(type = "output", split = FALSE)
[17:27:24.310]         if (TRUE) {
[17:27:24.310]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.310]         }
[17:27:24.310]         else {
[17:27:24.310]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.310]         }
[17:27:24.310]         base::close(...future.stdout)
[17:27:24.310]         ...future.stdout <- NULL
[17:27:24.310]     }
[17:27:24.310]     ...future.result$conditions <- ...future.conditions
[17:27:24.310]     ...future.result$finished <- base::Sys.time()
[17:27:24.310]     ...future.result
[17:27:24.310] }
[17:27:24.318] Poll #1 (0): usedNodes() = 2, workers = 2
[17:27:24.330] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.331] - Validating connection of MultisessionFuture
[17:27:24.331] - received message: FutureResult
[17:27:24.332] - Received FutureResult
[17:27:24.332] - Erased future from FutureRegistry
[17:27:24.332] result() for ClusterFuture ...
[17:27:24.333] - result already collected: FutureResult
[17:27:24.333] result() for ClusterFuture ... done
[17:27:24.333] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.334] result() for ClusterFuture ...
[17:27:24.334] - result already collected: FutureResult
[17:27:24.334] result() for ClusterFuture ... done
[17:27:24.335] result() for ClusterFuture ...
[17:27:24.335] - result already collected: FutureResult
[17:27:24.335] result() for ClusterFuture ... done
[17:27:24.337] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:27:24.337] Exporting 'ii' (35 bytes) to cluster node #1 ...
[17:27:24.338] Exporting 'ii' (35 bytes) to cluster node #1 ... DONE
[17:27:24.338] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:27:24.339] MultisessionFuture started
[17:27:24.339] - Launch lazy future ... done
[17:27:24.340] run() for 'MultisessionFuture' ... done
[17:27:24.340] result() for ClusterFuture ...
[17:27:24.341] - result already collected: FutureResult
[17:27:24.341] result() for ClusterFuture ... done
[17:27:24.341] result() for ClusterFuture ...
[17:27:24.341] - result already collected: FutureResult
[17:27:24.342] result() for ClusterFuture ... done
[17:27:24.342] result() for ClusterFuture ...
[17:27:24.342] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.343] - Validating connection of MultisessionFuture
[17:27:24.365] - received message: FutureResult
[17:27:24.365] - Received FutureResult
[17:27:24.366] - Erased future from FutureRegistry
[17:27:24.366] result() for ClusterFuture ...
[17:27:24.367] - result already collected: FutureResult
[17:27:24.367] result() for ClusterFuture ... done
[17:27:24.367] signalConditions() ...
[17:27:24.367]  - include = 'immediateCondition'
[17:27:24.368]  - exclude = 
[17:27:24.368]  - resignal = FALSE
[17:27:24.368]  - Number of conditions: 1
[17:27:24.369] signalConditions() ... done
[17:27:24.369] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.369] result() for ClusterFuture ... done
[17:27:24.370] result() for ClusterFuture ...
[17:27:24.370] - result already collected: FutureResult
[17:27:24.370] result() for ClusterFuture ... done
[17:27:24.371] signalConditions() ...
[17:27:24.371]  - include = 'immediateCondition'
[17:27:24.371]  - exclude = 
[17:27:24.371]  - resignal = FALSE
[17:27:24.372]  - Number of conditions: 1
[17:27:24.372] signalConditions() ... done
[17:27:24.373] Future state: 'finished'
[17:27:24.373] result() for ClusterFuture ...
[17:27:24.373] - result already collected: FutureResult
[17:27:24.373] result() for ClusterFuture ... done
[17:27:24.374] signalConditions() ...
[17:27:24.374]  - include = 'condition'
[17:27:24.374]  - exclude = 'immediateCondition'
[17:27:24.375]  - resignal = TRUE
[17:27:24.375]  - Number of conditions: 1
[17:27:24.375]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:24.376] signalConditions() ... done
[17:27:24.377] result() for ClusterFuture ...
[17:27:24.377] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.377] - Validating connection of MultisessionFuture
[17:27:24.378] - received message: FutureResult
[17:27:24.378] - Received FutureResult
[17:27:24.378] - Erased future from FutureRegistry
[17:27:24.379] result() for ClusterFuture ...
[17:27:24.379] - result already collected: FutureResult
[17:27:24.379] result() for ClusterFuture ... done
[17:27:24.380] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.380] result() for ClusterFuture ... done
[17:27:24.380] result() for ClusterFuture ...
[17:27:24.381] - result already collected: FutureResult
[17:27:24.381] result() for ClusterFuture ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:27:24.382] result() for ClusterFuture ...
[17:27:24.382] - result already collected: FutureResult
[17:27:24.382] result() for ClusterFuture ... done
[17:27:24.383] result() for ClusterFuture ...
[17:27:24.383] - result already collected: FutureResult
[17:27:24.383] result() for ClusterFuture ... done
[17:27:24.384] signalConditions() ...
[17:27:24.384]  - include = 'immediateCondition'
[17:27:24.384]  - exclude = 
[17:27:24.384]  - resignal = FALSE
[17:27:24.385]  - Number of conditions: 1
[17:27:24.385] signalConditions() ... done
[17:27:24.385] Future state: 'finished'
[17:27:24.386] result() for ClusterFuture ...
[17:27:24.386] - result already collected: FutureResult
[17:27:24.386] result() for ClusterFuture ... done
[17:27:24.387] signalConditions() ...
[17:27:24.387]  - include = 'condition'
[17:27:24.387]  - exclude = 'immediateCondition'
[17:27:24.388]  - resignal = TRUE
[17:27:24.388]  - Number of conditions: 1
[17:27:24.388]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:24.389] signalConditions() ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:27:24.390] result() for ClusterFuture ...
[17:27:24.390] - result already collected: FutureResult
[17:27:24.390] result() for ClusterFuture ... done
[17:27:24.391] result() for ClusterFuture ...
[17:27:24.391] - result already collected: FutureResult
[17:27:24.391] result() for ClusterFuture ... done
[17:27:24.392] signalConditions() ...
[17:27:24.392]  - include = 'immediateCondition'
[17:27:24.392]  - exclude = 
[17:27:24.393]  - resignal = FALSE
[17:27:24.393]  - Number of conditions: 1
[17:27:24.393] signalConditions() ... done
[17:27:24.394] Future state: 'finished'
[17:27:24.394] result() for ClusterFuture ...
[17:27:24.394] - result already collected: FutureResult
[17:27:24.394] result() for ClusterFuture ... done
[17:27:24.395] signalConditions() ...
[17:27:24.395]  - include = 'condition'
[17:27:24.395]  - exclude = 'immediateCondition'
[17:27:24.396]  - resignal = TRUE
[17:27:24.396]  - Number of conditions: 1
[17:27:24.396]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:24.397] signalConditions() ... done
** Future evaluation with a poor-man's "progress bar"
[17:27:24.398] getGlobalsAndPackages() ...
[17:27:24.398] Searching for globals...
[17:27:24.402] - globals found: [4] '{', 'cat', 'for', ':'
[17:27:24.403] Searching for globals ... DONE
[17:27:24.403] Resolving globals: FALSE
[17:27:24.404] 
[17:27:24.404] 
[17:27:24.404] getGlobalsAndPackages() ... DONE
[17:27:24.405] run() for 'Future' ...
[17:27:24.405] - state: 'created'
[17:27:24.406] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.426] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.426] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.427]   - Field: 'node'
[17:27:24.427]   - Field: 'label'
[17:27:24.427]   - Field: 'local'
[17:27:24.428]   - Field: 'owner'
[17:27:24.428]   - Field: 'envir'
[17:27:24.428]   - Field: 'workers'
[17:27:24.428]   - Field: 'packages'
[17:27:24.429]   - Field: 'gc'
[17:27:24.429]   - Field: 'conditions'
[17:27:24.429]   - Field: 'persistent'
[17:27:24.429]   - Field: 'expr'
[17:27:24.430]   - Field: 'uuid'
[17:27:24.430]   - Field: 'seed'
[17:27:24.430]   - Field: 'version'
[17:27:24.431]   - Field: 'result'
[17:27:24.431]   - Field: 'asynchronous'
[17:27:24.431]   - Field: 'calls'
[17:27:24.431]   - Field: 'globals'
[17:27:24.432]   - Field: 'stdout'
[17:27:24.432]   - Field: 'earlySignal'
[17:27:24.432]   - Field: 'lazy'
[17:27:24.432]   - Field: 'state'
[17:27:24.433] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.433] - Launch lazy future ...
[17:27:24.434] Packages needed by the future expression (n = 0): <none>
[17:27:24.434] Packages needed by future strategies (n = 0): <none>
[17:27:24.435] {
[17:27:24.435]     {
[17:27:24.435]         {
[17:27:24.435]             ...future.startTime <- base::Sys.time()
[17:27:24.435]             {
[17:27:24.435]                 {
[17:27:24.435]                   {
[17:27:24.435]                     {
[17:27:24.435]                       base::local({
[17:27:24.435]                         has_future <- base::requireNamespace("future", 
[17:27:24.435]                           quietly = TRUE)
[17:27:24.435]                         if (has_future) {
[17:27:24.435]                           ns <- base::getNamespace("future")
[17:27:24.435]                           version <- ns[[".package"]][["version"]]
[17:27:24.435]                           if (is.null(version)) 
[17:27:24.435]                             version <- utils::packageVersion("future")
[17:27:24.435]                         }
[17:27:24.435]                         else {
[17:27:24.435]                           version <- NULL
[17:27:24.435]                         }
[17:27:24.435]                         if (!has_future || version < "1.8.0") {
[17:27:24.435]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.435]                             "", base::R.version$version.string), 
[17:27:24.435]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.435]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.435]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.435]                               "release", "version")], collapse = " "), 
[17:27:24.435]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.435]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.435]                             info)
[17:27:24.435]                           info <- base::paste(info, collapse = "; ")
[17:27:24.435]                           if (!has_future) {
[17:27:24.435]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.435]                               info)
[17:27:24.435]                           }
[17:27:24.435]                           else {
[17:27:24.435]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.435]                               info, version)
[17:27:24.435]                           }
[17:27:24.435]                           base::stop(msg)
[17:27:24.435]                         }
[17:27:24.435]                       })
[17:27:24.435]                     }
[17:27:24.435]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.435]                     base::options(mc.cores = 1L)
[17:27:24.435]                   }
[17:27:24.435]                   ...future.strategy.old <- future::plan("list")
[17:27:24.435]                   options(future.plan = NULL)
[17:27:24.435]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.435]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.435]                 }
[17:27:24.435]                 ...future.workdir <- getwd()
[17:27:24.435]             }
[17:27:24.435]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.435]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.435]         }
[17:27:24.435]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.435]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.435]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.435]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.435]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.435]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.435]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.435]             base::names(...future.oldOptions))
[17:27:24.435]     }
[17:27:24.435]     if (FALSE) {
[17:27:24.435]     }
[17:27:24.435]     else {
[17:27:24.435]         if (TRUE) {
[17:27:24.435]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.435]                 open = "w")
[17:27:24.435]         }
[17:27:24.435]         else {
[17:27:24.435]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.435]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.435]         }
[17:27:24.435]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.435]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.435]             base::sink(type = "output", split = FALSE)
[17:27:24.435]             base::close(...future.stdout)
[17:27:24.435]         }, add = TRUE)
[17:27:24.435]     }
[17:27:24.435]     ...future.frame <- base::sys.nframe()
[17:27:24.435]     ...future.conditions <- base::list()
[17:27:24.435]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.435]     if (FALSE) {
[17:27:24.435]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.435]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.435]     }
[17:27:24.435]     ...future.result <- base::tryCatch({
[17:27:24.435]         base::withCallingHandlers({
[17:27:24.435]             ...future.value <- base::withVisible(base::local({
[17:27:24.435]                 ...future.makeSendCondition <- base::local({
[17:27:24.435]                   sendCondition <- NULL
[17:27:24.435]                   function(frame = 1L) {
[17:27:24.435]                     if (is.function(sendCondition)) 
[17:27:24.435]                       return(sendCondition)
[17:27:24.435]                     ns <- getNamespace("parallel")
[17:27:24.435]                     if (exists("sendData", mode = "function", 
[17:27:24.435]                       envir = ns)) {
[17:27:24.435]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.435]                         envir = ns)
[17:27:24.435]                       envir <- sys.frame(frame)
[17:27:24.435]                       master <- NULL
[17:27:24.435]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.435]                         !identical(envir, emptyenv())) {
[17:27:24.435]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.435]                           inherits = FALSE)) {
[17:27:24.435]                           master <- get("master", mode = "list", 
[17:27:24.435]                             envir = envir, inherits = FALSE)
[17:27:24.435]                           if (inherits(master, c("SOCKnode", 
[17:27:24.435]                             "SOCK0node"))) {
[17:27:24.435]                             sendCondition <<- function(cond) {
[17:27:24.435]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.435]                                 success = TRUE)
[17:27:24.435]                               parallel_sendData(master, data)
[17:27:24.435]                             }
[17:27:24.435]                             return(sendCondition)
[17:27:24.435]                           }
[17:27:24.435]                         }
[17:27:24.435]                         frame <- frame + 1L
[17:27:24.435]                         envir <- sys.frame(frame)
[17:27:24.435]                       }
[17:27:24.435]                     }
[17:27:24.435]                     sendCondition <<- function(cond) NULL
[17:27:24.435]                   }
[17:27:24.435]                 })
[17:27:24.435]                 withCallingHandlers({
[17:27:24.435]                   {
[17:27:24.435]                     cat("Processing: ")
[17:27:24.435]                     for (ii in 1:10) {
[17:27:24.435]                       cat(".")
[17:27:24.435]                     }
[17:27:24.435]                     cat(" [100%]\n")
[17:27:24.435]                     4
[17:27:24.435]                   }
[17:27:24.435]                 }, immediateCondition = function(cond) {
[17:27:24.435]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.435]                   sendCondition(cond)
[17:27:24.435]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.435]                   {
[17:27:24.435]                     inherits <- base::inherits
[17:27:24.435]                     invokeRestart <- base::invokeRestart
[17:27:24.435]                     is.null <- base::is.null
[17:27:24.435]                     muffled <- FALSE
[17:27:24.435]                     if (inherits(cond, "message")) {
[17:27:24.435]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.435]                       if (muffled) 
[17:27:24.435]                         invokeRestart("muffleMessage")
[17:27:24.435]                     }
[17:27:24.435]                     else if (inherits(cond, "warning")) {
[17:27:24.435]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.435]                       if (muffled) 
[17:27:24.435]                         invokeRestart("muffleWarning")
[17:27:24.435]                     }
[17:27:24.435]                     else if (inherits(cond, "condition")) {
[17:27:24.435]                       if (!is.null(pattern)) {
[17:27:24.435]                         computeRestarts <- base::computeRestarts
[17:27:24.435]                         grepl <- base::grepl
[17:27:24.435]                         restarts <- computeRestarts(cond)
[17:27:24.435]                         for (restart in restarts) {
[17:27:24.435]                           name <- restart$name
[17:27:24.435]                           if (is.null(name)) 
[17:27:24.435]                             next
[17:27:24.435]                           if (!grepl(pattern, name)) 
[17:27:24.435]                             next
[17:27:24.435]                           invokeRestart(restart)
[17:27:24.435]                           muffled <- TRUE
[17:27:24.435]                           break
[17:27:24.435]                         }
[17:27:24.435]                       }
[17:27:24.435]                     }
[17:27:24.435]                     invisible(muffled)
[17:27:24.435]                   }
[17:27:24.435]                   muffleCondition(cond)
[17:27:24.435]                 })
[17:27:24.435]             }))
[17:27:24.435]             future::FutureResult(value = ...future.value$value, 
[17:27:24.435]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.435]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.435]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.435]                     ...future.globalenv.names))
[17:27:24.435]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.435]         }, condition = base::local({
[17:27:24.435]             c <- base::c
[17:27:24.435]             inherits <- base::inherits
[17:27:24.435]             invokeRestart <- base::invokeRestart
[17:27:24.435]             length <- base::length
[17:27:24.435]             list <- base::list
[17:27:24.435]             seq.int <- base::seq.int
[17:27:24.435]             signalCondition <- base::signalCondition
[17:27:24.435]             sys.calls <- base::sys.calls
[17:27:24.435]             `[[` <- base::`[[`
[17:27:24.435]             `+` <- base::`+`
[17:27:24.435]             `<<-` <- base::`<<-`
[17:27:24.435]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.435]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.435]                   3L)]
[17:27:24.435]             }
[17:27:24.435]             function(cond) {
[17:27:24.435]                 is_error <- inherits(cond, "error")
[17:27:24.435]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.435]                   NULL)
[17:27:24.435]                 if (is_error) {
[17:27:24.435]                   sessionInformation <- function() {
[17:27:24.435]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.435]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.435]                       search = base::search(), system = base::Sys.info())
[17:27:24.435]                   }
[17:27:24.435]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.435]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.435]                     cond$call), session = sessionInformation(), 
[17:27:24.435]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.435]                   signalCondition(cond)
[17:27:24.435]                 }
[17:27:24.435]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.435]                 "immediateCondition"))) {
[17:27:24.435]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.435]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.435]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.435]                   if (TRUE && !signal) {
[17:27:24.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.435]                     {
[17:27:24.435]                       inherits <- base::inherits
[17:27:24.435]                       invokeRestart <- base::invokeRestart
[17:27:24.435]                       is.null <- base::is.null
[17:27:24.435]                       muffled <- FALSE
[17:27:24.435]                       if (inherits(cond, "message")) {
[17:27:24.435]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.435]                         if (muffled) 
[17:27:24.435]                           invokeRestart("muffleMessage")
[17:27:24.435]                       }
[17:27:24.435]                       else if (inherits(cond, "warning")) {
[17:27:24.435]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.435]                         if (muffled) 
[17:27:24.435]                           invokeRestart("muffleWarning")
[17:27:24.435]                       }
[17:27:24.435]                       else if (inherits(cond, "condition")) {
[17:27:24.435]                         if (!is.null(pattern)) {
[17:27:24.435]                           computeRestarts <- base::computeRestarts
[17:27:24.435]                           grepl <- base::grepl
[17:27:24.435]                           restarts <- computeRestarts(cond)
[17:27:24.435]                           for (restart in restarts) {
[17:27:24.435]                             name <- restart$name
[17:27:24.435]                             if (is.null(name)) 
[17:27:24.435]                               next
[17:27:24.435]                             if (!grepl(pattern, name)) 
[17:27:24.435]                               next
[17:27:24.435]                             invokeRestart(restart)
[17:27:24.435]                             muffled <- TRUE
[17:27:24.435]                             break
[17:27:24.435]                           }
[17:27:24.435]                         }
[17:27:24.435]                       }
[17:27:24.435]                       invisible(muffled)
[17:27:24.435]                     }
[17:27:24.435]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.435]                   }
[17:27:24.435]                 }
[17:27:24.435]                 else {
[17:27:24.435]                   if (TRUE) {
[17:27:24.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.435]                     {
[17:27:24.435]                       inherits <- base::inherits
[17:27:24.435]                       invokeRestart <- base::invokeRestart
[17:27:24.435]                       is.null <- base::is.null
[17:27:24.435]                       muffled <- FALSE
[17:27:24.435]                       if (inherits(cond, "message")) {
[17:27:24.435]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.435]                         if (muffled) 
[17:27:24.435]                           invokeRestart("muffleMessage")
[17:27:24.435]                       }
[17:27:24.435]                       else if (inherits(cond, "warning")) {
[17:27:24.435]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.435]                         if (muffled) 
[17:27:24.435]                           invokeRestart("muffleWarning")
[17:27:24.435]                       }
[17:27:24.435]                       else if (inherits(cond, "condition")) {
[17:27:24.435]                         if (!is.null(pattern)) {
[17:27:24.435]                           computeRestarts <- base::computeRestarts
[17:27:24.435]                           grepl <- base::grepl
[17:27:24.435]                           restarts <- computeRestarts(cond)
[17:27:24.435]                           for (restart in restarts) {
[17:27:24.435]                             name <- restart$name
[17:27:24.435]                             if (is.null(name)) 
[17:27:24.435]                               next
[17:27:24.435]                             if (!grepl(pattern, name)) 
[17:27:24.435]                               next
[17:27:24.435]                             invokeRestart(restart)
[17:27:24.435]                             muffled <- TRUE
[17:27:24.435]                             break
[17:27:24.435]                           }
[17:27:24.435]                         }
[17:27:24.435]                       }
[17:27:24.435]                       invisible(muffled)
[17:27:24.435]                     }
[17:27:24.435]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.435]                   }
[17:27:24.435]                 }
[17:27:24.435]             }
[17:27:24.435]         }))
[17:27:24.435]     }, error = function(ex) {
[17:27:24.435]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.435]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.435]                 ...future.rng), started = ...future.startTime, 
[17:27:24.435]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.435]             version = "1.8"), class = "FutureResult")
[17:27:24.435]     }, finally = {
[17:27:24.435]         if (!identical(...future.workdir, getwd())) 
[17:27:24.435]             setwd(...future.workdir)
[17:27:24.435]         {
[17:27:24.435]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.435]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.435]             }
[17:27:24.435]             base::options(...future.oldOptions)
[17:27:24.435]             if (.Platform$OS.type == "windows") {
[17:27:24.435]                 old_names <- names(...future.oldEnvVars)
[17:27:24.435]                 envs <- base::Sys.getenv()
[17:27:24.435]                 names <- names(envs)
[17:27:24.435]                 common <- intersect(names, old_names)
[17:27:24.435]                 added <- setdiff(names, old_names)
[17:27:24.435]                 removed <- setdiff(old_names, names)
[17:27:24.435]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.435]                   envs[common]]
[17:27:24.435]                 NAMES <- toupper(changed)
[17:27:24.435]                 args <- list()
[17:27:24.435]                 for (kk in seq_along(NAMES)) {
[17:27:24.435]                   name <- changed[[kk]]
[17:27:24.435]                   NAME <- NAMES[[kk]]
[17:27:24.435]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.435]                     next
[17:27:24.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.435]                 }
[17:27:24.435]                 NAMES <- toupper(added)
[17:27:24.435]                 for (kk in seq_along(NAMES)) {
[17:27:24.435]                   name <- added[[kk]]
[17:27:24.435]                   NAME <- NAMES[[kk]]
[17:27:24.435]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.435]                     next
[17:27:24.435]                   args[[name]] <- ""
[17:27:24.435]                 }
[17:27:24.435]                 NAMES <- toupper(removed)
[17:27:24.435]                 for (kk in seq_along(NAMES)) {
[17:27:24.435]                   name <- removed[[kk]]
[17:27:24.435]                   NAME <- NAMES[[kk]]
[17:27:24.435]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.435]                     next
[17:27:24.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.435]                 }
[17:27:24.435]                 if (length(args) > 0) 
[17:27:24.435]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.435]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.435]             }
[17:27:24.435]             else {
[17:27:24.435]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.435]             }
[17:27:24.435]             {
[17:27:24.435]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.435]                   0L) {
[17:27:24.435]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.435]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.435]                   base::options(opts)
[17:27:24.435]                 }
[17:27:24.435]                 {
[17:27:24.435]                   {
[17:27:24.435]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.435]                     NULL
[17:27:24.435]                   }
[17:27:24.435]                   options(future.plan = NULL)
[17:27:24.435]                   if (is.na(NA_character_)) 
[17:27:24.435]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.435]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.435]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.435]                     .init = FALSE)
[17:27:24.435]                 }
[17:27:24.435]             }
[17:27:24.435]         }
[17:27:24.435]     })
[17:27:24.435]     if (TRUE) {
[17:27:24.435]         base::sink(type = "output", split = FALSE)
[17:27:24.435]         if (TRUE) {
[17:27:24.435]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.435]         }
[17:27:24.435]         else {
[17:27:24.435]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.435]         }
[17:27:24.435]         base::close(...future.stdout)
[17:27:24.435]         ...future.stdout <- NULL
[17:27:24.435]     }
[17:27:24.435]     ...future.result$conditions <- ...future.conditions
[17:27:24.435]     ...future.result$finished <- base::Sys.time()
[17:27:24.435]     ...future.result
[17:27:24.435] }
[17:27:24.444] MultisessionFuture started
[17:27:24.444] - Launch lazy future ... done
[17:27:24.444] run() for 'MultisessionFuture' ... done
** Collecting results
v1 = 1
v2 = 2
Warning in sprintf(...) : restarting interrupted promise evaluation
[17:27:24.445] result() for ClusterFuture ...
[17:27:24.445] - result already collected: FutureResult
[17:27:24.446] result() for ClusterFuture ... done
[17:27:24.446] result() for ClusterFuture ...
[17:27:24.446] - result already collected: FutureResult
[17:27:24.446] result() for ClusterFuture ... done
[17:27:24.447] signalConditions() ...
[17:27:24.447]  - include = 'immediateCondition'
[17:27:24.447]  - exclude = 
[17:27:24.447]  - resignal = FALSE
[17:27:24.448]  - Number of conditions: 1
[17:27:24.448] signalConditions() ... done
[17:27:24.448] Future state: 'finished'
[17:27:24.448] result() for ClusterFuture ...
[17:27:24.449] - result already collected: FutureResult
[17:27:24.449] result() for ClusterFuture ... done
[17:27:24.449] signalConditions() ...
[17:27:24.449]  - include = 'condition'
[17:27:24.450]  - exclude = 'immediateCondition'
[17:27:24.450]  - resignal = TRUE
[17:27:24.450]  - Number of conditions: 1
[17:27:24.450]  - Condition #1: 'simpleError', 'error', 'condition'
[17:27:24.451] signalConditions() ... done
v3: <simpleError> (as expect)
[17:27:24.451] result() for ClusterFuture ...
[17:27:24.451] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.452] - Validating connection of MultisessionFuture
[17:27:24.466] - received message: FutureResult
[17:27:24.466] - Received FutureResult
[17:27:24.467] - Erased future from FutureRegistry
[17:27:24.467] result() for ClusterFuture ...
[17:27:24.467] - result already collected: FutureResult
[17:27:24.468] result() for ClusterFuture ... done
[17:27:24.468] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.468] result() for ClusterFuture ... done
[17:27:24.468] result() for ClusterFuture ...
[17:27:24.468] - result already collected: FutureResult
[17:27:24.469] result() for ClusterFuture ... done
Processing: .......... [100%]
v4 = 4
** Left-to-right and right-to-left future assignments
[17:27:24.470] getGlobalsAndPackages() ...
[17:27:24.470] Searching for globals...
[17:27:24.471] 
[17:27:24.471] Searching for globals ... DONE
[17:27:24.471] - globals: [0] <none>
[17:27:24.471] getGlobalsAndPackages() ... DONE
[17:27:24.472] run() for 'Future' ...
[17:27:24.472] - state: 'created'
[17:27:24.473] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.491] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.491] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.492]   - Field: 'node'
[17:27:24.492]   - Field: 'label'
[17:27:24.492]   - Field: 'local'
[17:27:24.493]   - Field: 'owner'
[17:27:24.493]   - Field: 'envir'
[17:27:24.493]   - Field: 'workers'
[17:27:24.493]   - Field: 'packages'
[17:27:24.494]   - Field: 'gc'
[17:27:24.494]   - Field: 'conditions'
[17:27:24.494]   - Field: 'persistent'
[17:27:24.494]   - Field: 'expr'
[17:27:24.495]   - Field: 'uuid'
[17:27:24.495]   - Field: 'seed'
[17:27:24.495]   - Field: 'version'
[17:27:24.495]   - Field: 'result'
[17:27:24.496]   - Field: 'asynchronous'
[17:27:24.496]   - Field: 'calls'
[17:27:24.496]   - Field: 'globals'
[17:27:24.496]   - Field: 'stdout'
[17:27:24.497]   - Field: 'earlySignal'
[17:27:24.497]   - Field: 'lazy'
[17:27:24.497]   - Field: 'state'
[17:27:24.497] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.498] - Launch lazy future ...
[17:27:24.498] Packages needed by the future expression (n = 0): <none>
[17:27:24.499] Packages needed by future strategies (n = 0): <none>
[17:27:24.499] {
[17:27:24.499]     {
[17:27:24.499]         {
[17:27:24.499]             ...future.startTime <- base::Sys.time()
[17:27:24.499]             {
[17:27:24.499]                 {
[17:27:24.499]                   {
[17:27:24.499]                     {
[17:27:24.499]                       base::local({
[17:27:24.499]                         has_future <- base::requireNamespace("future", 
[17:27:24.499]                           quietly = TRUE)
[17:27:24.499]                         if (has_future) {
[17:27:24.499]                           ns <- base::getNamespace("future")
[17:27:24.499]                           version <- ns[[".package"]][["version"]]
[17:27:24.499]                           if (is.null(version)) 
[17:27:24.499]                             version <- utils::packageVersion("future")
[17:27:24.499]                         }
[17:27:24.499]                         else {
[17:27:24.499]                           version <- NULL
[17:27:24.499]                         }
[17:27:24.499]                         if (!has_future || version < "1.8.0") {
[17:27:24.499]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.499]                             "", base::R.version$version.string), 
[17:27:24.499]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.499]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.499]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.499]                               "release", "version")], collapse = " "), 
[17:27:24.499]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.499]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.499]                             info)
[17:27:24.499]                           info <- base::paste(info, collapse = "; ")
[17:27:24.499]                           if (!has_future) {
[17:27:24.499]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.499]                               info)
[17:27:24.499]                           }
[17:27:24.499]                           else {
[17:27:24.499]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.499]                               info, version)
[17:27:24.499]                           }
[17:27:24.499]                           base::stop(msg)
[17:27:24.499]                         }
[17:27:24.499]                       })
[17:27:24.499]                     }
[17:27:24.499]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.499]                     base::options(mc.cores = 1L)
[17:27:24.499]                   }
[17:27:24.499]                   ...future.strategy.old <- future::plan("list")
[17:27:24.499]                   options(future.plan = NULL)
[17:27:24.499]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.499]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.499]                 }
[17:27:24.499]                 ...future.workdir <- getwd()
[17:27:24.499]             }
[17:27:24.499]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.499]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.499]         }
[17:27:24.499]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.499]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.499]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.499]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.499]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.499]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.499]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.499]             base::names(...future.oldOptions))
[17:27:24.499]     }
[17:27:24.499]     if (FALSE) {
[17:27:24.499]     }
[17:27:24.499]     else {
[17:27:24.499]         if (TRUE) {
[17:27:24.499]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.499]                 open = "w")
[17:27:24.499]         }
[17:27:24.499]         else {
[17:27:24.499]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.499]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.499]         }
[17:27:24.499]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.499]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.499]             base::sink(type = "output", split = FALSE)
[17:27:24.499]             base::close(...future.stdout)
[17:27:24.499]         }, add = TRUE)
[17:27:24.499]     }
[17:27:24.499]     ...future.frame <- base::sys.nframe()
[17:27:24.499]     ...future.conditions <- base::list()
[17:27:24.499]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.499]     if (FALSE) {
[17:27:24.499]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.499]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.499]     }
[17:27:24.499]     ...future.result <- base::tryCatch({
[17:27:24.499]         base::withCallingHandlers({
[17:27:24.499]             ...future.value <- base::withVisible(base::local({
[17:27:24.499]                 ...future.makeSendCondition <- base::local({
[17:27:24.499]                   sendCondition <- NULL
[17:27:24.499]                   function(frame = 1L) {
[17:27:24.499]                     if (is.function(sendCondition)) 
[17:27:24.499]                       return(sendCondition)
[17:27:24.499]                     ns <- getNamespace("parallel")
[17:27:24.499]                     if (exists("sendData", mode = "function", 
[17:27:24.499]                       envir = ns)) {
[17:27:24.499]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.499]                         envir = ns)
[17:27:24.499]                       envir <- sys.frame(frame)
[17:27:24.499]                       master <- NULL
[17:27:24.499]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.499]                         !identical(envir, emptyenv())) {
[17:27:24.499]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.499]                           inherits = FALSE)) {
[17:27:24.499]                           master <- get("master", mode = "list", 
[17:27:24.499]                             envir = envir, inherits = FALSE)
[17:27:24.499]                           if (inherits(master, c("SOCKnode", 
[17:27:24.499]                             "SOCK0node"))) {
[17:27:24.499]                             sendCondition <<- function(cond) {
[17:27:24.499]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.499]                                 success = TRUE)
[17:27:24.499]                               parallel_sendData(master, data)
[17:27:24.499]                             }
[17:27:24.499]                             return(sendCondition)
[17:27:24.499]                           }
[17:27:24.499]                         }
[17:27:24.499]                         frame <- frame + 1L
[17:27:24.499]                         envir <- sys.frame(frame)
[17:27:24.499]                       }
[17:27:24.499]                     }
[17:27:24.499]                     sendCondition <<- function(cond) NULL
[17:27:24.499]                   }
[17:27:24.499]                 })
[17:27:24.499]                 withCallingHandlers({
[17:27:24.499]                   1
[17:27:24.499]                 }, immediateCondition = function(cond) {
[17:27:24.499]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.499]                   sendCondition(cond)
[17:27:24.499]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.499]                   {
[17:27:24.499]                     inherits <- base::inherits
[17:27:24.499]                     invokeRestart <- base::invokeRestart
[17:27:24.499]                     is.null <- base::is.null
[17:27:24.499]                     muffled <- FALSE
[17:27:24.499]                     if (inherits(cond, "message")) {
[17:27:24.499]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.499]                       if (muffled) 
[17:27:24.499]                         invokeRestart("muffleMessage")
[17:27:24.499]                     }
[17:27:24.499]                     else if (inherits(cond, "warning")) {
[17:27:24.499]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.499]                       if (muffled) 
[17:27:24.499]                         invokeRestart("muffleWarning")
[17:27:24.499]                     }
[17:27:24.499]                     else if (inherits(cond, "condition")) {
[17:27:24.499]                       if (!is.null(pattern)) {
[17:27:24.499]                         computeRestarts <- base::computeRestarts
[17:27:24.499]                         grepl <- base::grepl
[17:27:24.499]                         restarts <- computeRestarts(cond)
[17:27:24.499]                         for (restart in restarts) {
[17:27:24.499]                           name <- restart$name
[17:27:24.499]                           if (is.null(name)) 
[17:27:24.499]                             next
[17:27:24.499]                           if (!grepl(pattern, name)) 
[17:27:24.499]                             next
[17:27:24.499]                           invokeRestart(restart)
[17:27:24.499]                           muffled <- TRUE
[17:27:24.499]                           break
[17:27:24.499]                         }
[17:27:24.499]                       }
[17:27:24.499]                     }
[17:27:24.499]                     invisible(muffled)
[17:27:24.499]                   }
[17:27:24.499]                   muffleCondition(cond)
[17:27:24.499]                 })
[17:27:24.499]             }))
[17:27:24.499]             future::FutureResult(value = ...future.value$value, 
[17:27:24.499]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.499]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.499]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.499]                     ...future.globalenv.names))
[17:27:24.499]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.499]         }, condition = base::local({
[17:27:24.499]             c <- base::c
[17:27:24.499]             inherits <- base::inherits
[17:27:24.499]             invokeRestart <- base::invokeRestart
[17:27:24.499]             length <- base::length
[17:27:24.499]             list <- base::list
[17:27:24.499]             seq.int <- base::seq.int
[17:27:24.499]             signalCondition <- base::signalCondition
[17:27:24.499]             sys.calls <- base::sys.calls
[17:27:24.499]             `[[` <- base::`[[`
[17:27:24.499]             `+` <- base::`+`
[17:27:24.499]             `<<-` <- base::`<<-`
[17:27:24.499]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.499]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.499]                   3L)]
[17:27:24.499]             }
[17:27:24.499]             function(cond) {
[17:27:24.499]                 is_error <- inherits(cond, "error")
[17:27:24.499]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.499]                   NULL)
[17:27:24.499]                 if (is_error) {
[17:27:24.499]                   sessionInformation <- function() {
[17:27:24.499]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.499]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.499]                       search = base::search(), system = base::Sys.info())
[17:27:24.499]                   }
[17:27:24.499]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.499]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.499]                     cond$call), session = sessionInformation(), 
[17:27:24.499]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.499]                   signalCondition(cond)
[17:27:24.499]                 }
[17:27:24.499]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.499]                 "immediateCondition"))) {
[17:27:24.499]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.499]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.499]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.499]                   if (TRUE && !signal) {
[17:27:24.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.499]                     {
[17:27:24.499]                       inherits <- base::inherits
[17:27:24.499]                       invokeRestart <- base::invokeRestart
[17:27:24.499]                       is.null <- base::is.null
[17:27:24.499]                       muffled <- FALSE
[17:27:24.499]                       if (inherits(cond, "message")) {
[17:27:24.499]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.499]                         if (muffled) 
[17:27:24.499]                           invokeRestart("muffleMessage")
[17:27:24.499]                       }
[17:27:24.499]                       else if (inherits(cond, "warning")) {
[17:27:24.499]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.499]                         if (muffled) 
[17:27:24.499]                           invokeRestart("muffleWarning")
[17:27:24.499]                       }
[17:27:24.499]                       else if (inherits(cond, "condition")) {
[17:27:24.499]                         if (!is.null(pattern)) {
[17:27:24.499]                           computeRestarts <- base::computeRestarts
[17:27:24.499]                           grepl <- base::grepl
[17:27:24.499]                           restarts <- computeRestarts(cond)
[17:27:24.499]                           for (restart in restarts) {
[17:27:24.499]                             name <- restart$name
[17:27:24.499]                             if (is.null(name)) 
[17:27:24.499]                               next
[17:27:24.499]                             if (!grepl(pattern, name)) 
[17:27:24.499]                               next
[17:27:24.499]                             invokeRestart(restart)
[17:27:24.499]                             muffled <- TRUE
[17:27:24.499]                             break
[17:27:24.499]                           }
[17:27:24.499]                         }
[17:27:24.499]                       }
[17:27:24.499]                       invisible(muffled)
[17:27:24.499]                     }
[17:27:24.499]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.499]                   }
[17:27:24.499]                 }
[17:27:24.499]                 else {
[17:27:24.499]                   if (TRUE) {
[17:27:24.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.499]                     {
[17:27:24.499]                       inherits <- base::inherits
[17:27:24.499]                       invokeRestart <- base::invokeRestart
[17:27:24.499]                       is.null <- base::is.null
[17:27:24.499]                       muffled <- FALSE
[17:27:24.499]                       if (inherits(cond, "message")) {
[17:27:24.499]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.499]                         if (muffled) 
[17:27:24.499]                           invokeRestart("muffleMessage")
[17:27:24.499]                       }
[17:27:24.499]                       else if (inherits(cond, "warning")) {
[17:27:24.499]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.499]                         if (muffled) 
[17:27:24.499]                           invokeRestart("muffleWarning")
[17:27:24.499]                       }
[17:27:24.499]                       else if (inherits(cond, "condition")) {
[17:27:24.499]                         if (!is.null(pattern)) {
[17:27:24.499]                           computeRestarts <- base::computeRestarts
[17:27:24.499]                           grepl <- base::grepl
[17:27:24.499]                           restarts <- computeRestarts(cond)
[17:27:24.499]                           for (restart in restarts) {
[17:27:24.499]                             name <- restart$name
[17:27:24.499]                             if (is.null(name)) 
[17:27:24.499]                               next
[17:27:24.499]                             if (!grepl(pattern, name)) 
[17:27:24.499]                               next
[17:27:24.499]                             invokeRestart(restart)
[17:27:24.499]                             muffled <- TRUE
[17:27:24.499]                             break
[17:27:24.499]                           }
[17:27:24.499]                         }
[17:27:24.499]                       }
[17:27:24.499]                       invisible(muffled)
[17:27:24.499]                     }
[17:27:24.499]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.499]                   }
[17:27:24.499]                 }
[17:27:24.499]             }
[17:27:24.499]         }))
[17:27:24.499]     }, error = function(ex) {
[17:27:24.499]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.499]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.499]                 ...future.rng), started = ...future.startTime, 
[17:27:24.499]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.499]             version = "1.8"), class = "FutureResult")
[17:27:24.499]     }, finally = {
[17:27:24.499]         if (!identical(...future.workdir, getwd())) 
[17:27:24.499]             setwd(...future.workdir)
[17:27:24.499]         {
[17:27:24.499]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.499]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.499]             }
[17:27:24.499]             base::options(...future.oldOptions)
[17:27:24.499]             if (.Platform$OS.type == "windows") {
[17:27:24.499]                 old_names <- names(...future.oldEnvVars)
[17:27:24.499]                 envs <- base::Sys.getenv()
[17:27:24.499]                 names <- names(envs)
[17:27:24.499]                 common <- intersect(names, old_names)
[17:27:24.499]                 added <- setdiff(names, old_names)
[17:27:24.499]                 removed <- setdiff(old_names, names)
[17:27:24.499]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.499]                   envs[common]]
[17:27:24.499]                 NAMES <- toupper(changed)
[17:27:24.499]                 args <- list()
[17:27:24.499]                 for (kk in seq_along(NAMES)) {
[17:27:24.499]                   name <- changed[[kk]]
[17:27:24.499]                   NAME <- NAMES[[kk]]
[17:27:24.499]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.499]                     next
[17:27:24.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.499]                 }
[17:27:24.499]                 NAMES <- toupper(added)
[17:27:24.499]                 for (kk in seq_along(NAMES)) {
[17:27:24.499]                   name <- added[[kk]]
[17:27:24.499]                   NAME <- NAMES[[kk]]
[17:27:24.499]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.499]                     next
[17:27:24.499]                   args[[name]] <- ""
[17:27:24.499]                 }
[17:27:24.499]                 NAMES <- toupper(removed)
[17:27:24.499]                 for (kk in seq_along(NAMES)) {
[17:27:24.499]                   name <- removed[[kk]]
[17:27:24.499]                   NAME <- NAMES[[kk]]
[17:27:24.499]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.499]                     next
[17:27:24.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.499]                 }
[17:27:24.499]                 if (length(args) > 0) 
[17:27:24.499]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.499]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.499]             }
[17:27:24.499]             else {
[17:27:24.499]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.499]             }
[17:27:24.499]             {
[17:27:24.499]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.499]                   0L) {
[17:27:24.499]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.499]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.499]                   base::options(opts)
[17:27:24.499]                 }
[17:27:24.499]                 {
[17:27:24.499]                   {
[17:27:24.499]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.499]                     NULL
[17:27:24.499]                   }
[17:27:24.499]                   options(future.plan = NULL)
[17:27:24.499]                   if (is.na(NA_character_)) 
[17:27:24.499]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.499]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.499]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.499]                     .init = FALSE)
[17:27:24.499]                 }
[17:27:24.499]             }
[17:27:24.499]         }
[17:27:24.499]     })
[17:27:24.499]     if (TRUE) {
[17:27:24.499]         base::sink(type = "output", split = FALSE)
[17:27:24.499]         if (TRUE) {
[17:27:24.499]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.499]         }
[17:27:24.499]         else {
[17:27:24.499]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.499]         }
[17:27:24.499]         base::close(...future.stdout)
[17:27:24.499]         ...future.stdout <- NULL
[17:27:24.499]     }
[17:27:24.499]     ...future.result$conditions <- ...future.conditions
[17:27:24.499]     ...future.result$finished <- base::Sys.time()
[17:27:24.499]     ...future.result
[17:27:24.499] }
[17:27:24.508] MultisessionFuture started
[17:27:24.508] - Launch lazy future ... done
[17:27:24.508] run() for 'MultisessionFuture' ... done
[17:27:24.509] result() for ClusterFuture ...
[17:27:24.509] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.509] - Validating connection of MultisessionFuture
[17:27:24.528] - received message: FutureResult
[17:27:24.529] - Received FutureResult
[17:27:24.529] - Erased future from FutureRegistry
[17:27:24.529] result() for ClusterFuture ...
[17:27:24.530] - result already collected: FutureResult
[17:27:24.530] result() for ClusterFuture ... done
[17:27:24.530] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.530] result() for ClusterFuture ... done
[17:27:24.530] result() for ClusterFuture ...
[17:27:24.530] - result already collected: FutureResult
[17:27:24.531] result() for ClusterFuture ... done
c = 1
[17:27:24.531] getGlobalsAndPackages() ...
[17:27:24.531] Searching for globals...
[17:27:24.532] 
[17:27:24.532] Searching for globals ... DONE
[17:27:24.532] - globals: [0] <none>
[17:27:24.533] getGlobalsAndPackages() ... DONE
[17:27:24.533] run() for 'Future' ...
[17:27:24.533] - state: 'created'
[17:27:24.534] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.553] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.554] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.554]   - Field: 'node'
[17:27:24.554]   - Field: 'label'
[17:27:24.554]   - Field: 'local'
[17:27:24.555]   - Field: 'owner'
[17:27:24.555]   - Field: 'envir'
[17:27:24.555]   - Field: 'workers'
[17:27:24.555]   - Field: 'packages'
[17:27:24.555]   - Field: 'gc'
[17:27:24.556]   - Field: 'conditions'
[17:27:24.556]   - Field: 'persistent'
[17:27:24.556]   - Field: 'expr'
[17:27:24.556]   - Field: 'uuid'
[17:27:24.557]   - Field: 'seed'
[17:27:24.557]   - Field: 'version'
[17:27:24.557]   - Field: 'result'
[17:27:24.557]   - Field: 'asynchronous'
[17:27:24.557]   - Field: 'calls'
[17:27:24.557]   - Field: 'globals'
[17:27:24.558]   - Field: 'stdout'
[17:27:24.558]   - Field: 'earlySignal'
[17:27:24.558]   - Field: 'lazy'
[17:27:24.558]   - Field: 'state'
[17:27:24.559] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.559] - Launch lazy future ...
[17:27:24.560] Packages needed by the future expression (n = 0): <none>
[17:27:24.560] Packages needed by future strategies (n = 0): <none>
[17:27:24.561] {
[17:27:24.561]     {
[17:27:24.561]         {
[17:27:24.561]             ...future.startTime <- base::Sys.time()
[17:27:24.561]             {
[17:27:24.561]                 {
[17:27:24.561]                   {
[17:27:24.561]                     {
[17:27:24.561]                       base::local({
[17:27:24.561]                         has_future <- base::requireNamespace("future", 
[17:27:24.561]                           quietly = TRUE)
[17:27:24.561]                         if (has_future) {
[17:27:24.561]                           ns <- base::getNamespace("future")
[17:27:24.561]                           version <- ns[[".package"]][["version"]]
[17:27:24.561]                           if (is.null(version)) 
[17:27:24.561]                             version <- utils::packageVersion("future")
[17:27:24.561]                         }
[17:27:24.561]                         else {
[17:27:24.561]                           version <- NULL
[17:27:24.561]                         }
[17:27:24.561]                         if (!has_future || version < "1.8.0") {
[17:27:24.561]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.561]                             "", base::R.version$version.string), 
[17:27:24.561]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.561]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.561]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.561]                               "release", "version")], collapse = " "), 
[17:27:24.561]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.561]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.561]                             info)
[17:27:24.561]                           info <- base::paste(info, collapse = "; ")
[17:27:24.561]                           if (!has_future) {
[17:27:24.561]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.561]                               info)
[17:27:24.561]                           }
[17:27:24.561]                           else {
[17:27:24.561]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.561]                               info, version)
[17:27:24.561]                           }
[17:27:24.561]                           base::stop(msg)
[17:27:24.561]                         }
[17:27:24.561]                       })
[17:27:24.561]                     }
[17:27:24.561]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.561]                     base::options(mc.cores = 1L)
[17:27:24.561]                   }
[17:27:24.561]                   ...future.strategy.old <- future::plan("list")
[17:27:24.561]                   options(future.plan = NULL)
[17:27:24.561]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.561]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.561]                 }
[17:27:24.561]                 ...future.workdir <- getwd()
[17:27:24.561]             }
[17:27:24.561]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.561]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.561]         }
[17:27:24.561]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.561]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.561]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.561]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.561]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.561]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.561]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.561]             base::names(...future.oldOptions))
[17:27:24.561]     }
[17:27:24.561]     if (FALSE) {
[17:27:24.561]     }
[17:27:24.561]     else {
[17:27:24.561]         if (TRUE) {
[17:27:24.561]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.561]                 open = "w")
[17:27:24.561]         }
[17:27:24.561]         else {
[17:27:24.561]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.561]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.561]         }
[17:27:24.561]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.561]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.561]             base::sink(type = "output", split = FALSE)
[17:27:24.561]             base::close(...future.stdout)
[17:27:24.561]         }, add = TRUE)
[17:27:24.561]     }
[17:27:24.561]     ...future.frame <- base::sys.nframe()
[17:27:24.561]     ...future.conditions <- base::list()
[17:27:24.561]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.561]     if (FALSE) {
[17:27:24.561]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.561]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.561]     }
[17:27:24.561]     ...future.result <- base::tryCatch({
[17:27:24.561]         base::withCallingHandlers({
[17:27:24.561]             ...future.value <- base::withVisible(base::local({
[17:27:24.561]                 ...future.makeSendCondition <- base::local({
[17:27:24.561]                   sendCondition <- NULL
[17:27:24.561]                   function(frame = 1L) {
[17:27:24.561]                     if (is.function(sendCondition)) 
[17:27:24.561]                       return(sendCondition)
[17:27:24.561]                     ns <- getNamespace("parallel")
[17:27:24.561]                     if (exists("sendData", mode = "function", 
[17:27:24.561]                       envir = ns)) {
[17:27:24.561]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.561]                         envir = ns)
[17:27:24.561]                       envir <- sys.frame(frame)
[17:27:24.561]                       master <- NULL
[17:27:24.561]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.561]                         !identical(envir, emptyenv())) {
[17:27:24.561]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.561]                           inherits = FALSE)) {
[17:27:24.561]                           master <- get("master", mode = "list", 
[17:27:24.561]                             envir = envir, inherits = FALSE)
[17:27:24.561]                           if (inherits(master, c("SOCKnode", 
[17:27:24.561]                             "SOCK0node"))) {
[17:27:24.561]                             sendCondition <<- function(cond) {
[17:27:24.561]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.561]                                 success = TRUE)
[17:27:24.561]                               parallel_sendData(master, data)
[17:27:24.561]                             }
[17:27:24.561]                             return(sendCondition)
[17:27:24.561]                           }
[17:27:24.561]                         }
[17:27:24.561]                         frame <- frame + 1L
[17:27:24.561]                         envir <- sys.frame(frame)
[17:27:24.561]                       }
[17:27:24.561]                     }
[17:27:24.561]                     sendCondition <<- function(cond) NULL
[17:27:24.561]                   }
[17:27:24.561]                 })
[17:27:24.561]                 withCallingHandlers({
[17:27:24.561]                   1
[17:27:24.561]                 }, immediateCondition = function(cond) {
[17:27:24.561]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.561]                   sendCondition(cond)
[17:27:24.561]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.561]                   {
[17:27:24.561]                     inherits <- base::inherits
[17:27:24.561]                     invokeRestart <- base::invokeRestart
[17:27:24.561]                     is.null <- base::is.null
[17:27:24.561]                     muffled <- FALSE
[17:27:24.561]                     if (inherits(cond, "message")) {
[17:27:24.561]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.561]                       if (muffled) 
[17:27:24.561]                         invokeRestart("muffleMessage")
[17:27:24.561]                     }
[17:27:24.561]                     else if (inherits(cond, "warning")) {
[17:27:24.561]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.561]                       if (muffled) 
[17:27:24.561]                         invokeRestart("muffleWarning")
[17:27:24.561]                     }
[17:27:24.561]                     else if (inherits(cond, "condition")) {
[17:27:24.561]                       if (!is.null(pattern)) {
[17:27:24.561]                         computeRestarts <- base::computeRestarts
[17:27:24.561]                         grepl <- base::grepl
[17:27:24.561]                         restarts <- computeRestarts(cond)
[17:27:24.561]                         for (restart in restarts) {
[17:27:24.561]                           name <- restart$name
[17:27:24.561]                           if (is.null(name)) 
[17:27:24.561]                             next
[17:27:24.561]                           if (!grepl(pattern, name)) 
[17:27:24.561]                             next
[17:27:24.561]                           invokeRestart(restart)
[17:27:24.561]                           muffled <- TRUE
[17:27:24.561]                           break
[17:27:24.561]                         }
[17:27:24.561]                       }
[17:27:24.561]                     }
[17:27:24.561]                     invisible(muffled)
[17:27:24.561]                   }
[17:27:24.561]                   muffleCondition(cond)
[17:27:24.561]                 })
[17:27:24.561]             }))
[17:27:24.561]             future::FutureResult(value = ...future.value$value, 
[17:27:24.561]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.561]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.561]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.561]                     ...future.globalenv.names))
[17:27:24.561]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.561]         }, condition = base::local({
[17:27:24.561]             c <- base::c
[17:27:24.561]             inherits <- base::inherits
[17:27:24.561]             invokeRestart <- base::invokeRestart
[17:27:24.561]             length <- base::length
[17:27:24.561]             list <- base::list
[17:27:24.561]             seq.int <- base::seq.int
[17:27:24.561]             signalCondition <- base::signalCondition
[17:27:24.561]             sys.calls <- base::sys.calls
[17:27:24.561]             `[[` <- base::`[[`
[17:27:24.561]             `+` <- base::`+`
[17:27:24.561]             `<<-` <- base::`<<-`
[17:27:24.561]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.561]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.561]                   3L)]
[17:27:24.561]             }
[17:27:24.561]             function(cond) {
[17:27:24.561]                 is_error <- inherits(cond, "error")
[17:27:24.561]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.561]                   NULL)
[17:27:24.561]                 if (is_error) {
[17:27:24.561]                   sessionInformation <- function() {
[17:27:24.561]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.561]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.561]                       search = base::search(), system = base::Sys.info())
[17:27:24.561]                   }
[17:27:24.561]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.561]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.561]                     cond$call), session = sessionInformation(), 
[17:27:24.561]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.561]                   signalCondition(cond)
[17:27:24.561]                 }
[17:27:24.561]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.561]                 "immediateCondition"))) {
[17:27:24.561]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.561]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.561]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.561]                   if (TRUE && !signal) {
[17:27:24.561]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.561]                     {
[17:27:24.561]                       inherits <- base::inherits
[17:27:24.561]                       invokeRestart <- base::invokeRestart
[17:27:24.561]                       is.null <- base::is.null
[17:27:24.561]                       muffled <- FALSE
[17:27:24.561]                       if (inherits(cond, "message")) {
[17:27:24.561]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.561]                         if (muffled) 
[17:27:24.561]                           invokeRestart("muffleMessage")
[17:27:24.561]                       }
[17:27:24.561]                       else if (inherits(cond, "warning")) {
[17:27:24.561]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.561]                         if (muffled) 
[17:27:24.561]                           invokeRestart("muffleWarning")
[17:27:24.561]                       }
[17:27:24.561]                       else if (inherits(cond, "condition")) {
[17:27:24.561]                         if (!is.null(pattern)) {
[17:27:24.561]                           computeRestarts <- base::computeRestarts
[17:27:24.561]                           grepl <- base::grepl
[17:27:24.561]                           restarts <- computeRestarts(cond)
[17:27:24.561]                           for (restart in restarts) {
[17:27:24.561]                             name <- restart$name
[17:27:24.561]                             if (is.null(name)) 
[17:27:24.561]                               next
[17:27:24.561]                             if (!grepl(pattern, name)) 
[17:27:24.561]                               next
[17:27:24.561]                             invokeRestart(restart)
[17:27:24.561]                             muffled <- TRUE
[17:27:24.561]                             break
[17:27:24.561]                           }
[17:27:24.561]                         }
[17:27:24.561]                       }
[17:27:24.561]                       invisible(muffled)
[17:27:24.561]                     }
[17:27:24.561]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.561]                   }
[17:27:24.561]                 }
[17:27:24.561]                 else {
[17:27:24.561]                   if (TRUE) {
[17:27:24.561]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.561]                     {
[17:27:24.561]                       inherits <- base::inherits
[17:27:24.561]                       invokeRestart <- base::invokeRestart
[17:27:24.561]                       is.null <- base::is.null
[17:27:24.561]                       muffled <- FALSE
[17:27:24.561]                       if (inherits(cond, "message")) {
[17:27:24.561]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.561]                         if (muffled) 
[17:27:24.561]                           invokeRestart("muffleMessage")
[17:27:24.561]                       }
[17:27:24.561]                       else if (inherits(cond, "warning")) {
[17:27:24.561]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.561]                         if (muffled) 
[17:27:24.561]                           invokeRestart("muffleWarning")
[17:27:24.561]                       }
[17:27:24.561]                       else if (inherits(cond, "condition")) {
[17:27:24.561]                         if (!is.null(pattern)) {
[17:27:24.561]                           computeRestarts <- base::computeRestarts
[17:27:24.561]                           grepl <- base::grepl
[17:27:24.561]                           restarts <- computeRestarts(cond)
[17:27:24.561]                           for (restart in restarts) {
[17:27:24.561]                             name <- restart$name
[17:27:24.561]                             if (is.null(name)) 
[17:27:24.561]                               next
[17:27:24.561]                             if (!grepl(pattern, name)) 
[17:27:24.561]                               next
[17:27:24.561]                             invokeRestart(restart)
[17:27:24.561]                             muffled <- TRUE
[17:27:24.561]                             break
[17:27:24.561]                           }
[17:27:24.561]                         }
[17:27:24.561]                       }
[17:27:24.561]                       invisible(muffled)
[17:27:24.561]                     }
[17:27:24.561]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.561]                   }
[17:27:24.561]                 }
[17:27:24.561]             }
[17:27:24.561]         }))
[17:27:24.561]     }, error = function(ex) {
[17:27:24.561]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.561]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.561]                 ...future.rng), started = ...future.startTime, 
[17:27:24.561]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.561]             version = "1.8"), class = "FutureResult")
[17:27:24.561]     }, finally = {
[17:27:24.561]         if (!identical(...future.workdir, getwd())) 
[17:27:24.561]             setwd(...future.workdir)
[17:27:24.561]         {
[17:27:24.561]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.561]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.561]             }
[17:27:24.561]             base::options(...future.oldOptions)
[17:27:24.561]             if (.Platform$OS.type == "windows") {
[17:27:24.561]                 old_names <- names(...future.oldEnvVars)
[17:27:24.561]                 envs <- base::Sys.getenv()
[17:27:24.561]                 names <- names(envs)
[17:27:24.561]                 common <- intersect(names, old_names)
[17:27:24.561]                 added <- setdiff(names, old_names)
[17:27:24.561]                 removed <- setdiff(old_names, names)
[17:27:24.561]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.561]                   envs[common]]
[17:27:24.561]                 NAMES <- toupper(changed)
[17:27:24.561]                 args <- list()
[17:27:24.561]                 for (kk in seq_along(NAMES)) {
[17:27:24.561]                   name <- changed[[kk]]
[17:27:24.561]                   NAME <- NAMES[[kk]]
[17:27:24.561]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.561]                     next
[17:27:24.561]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.561]                 }
[17:27:24.561]                 NAMES <- toupper(added)
[17:27:24.561]                 for (kk in seq_along(NAMES)) {
[17:27:24.561]                   name <- added[[kk]]
[17:27:24.561]                   NAME <- NAMES[[kk]]
[17:27:24.561]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.561]                     next
[17:27:24.561]                   args[[name]] <- ""
[17:27:24.561]                 }
[17:27:24.561]                 NAMES <- toupper(removed)
[17:27:24.561]                 for (kk in seq_along(NAMES)) {
[17:27:24.561]                   name <- removed[[kk]]
[17:27:24.561]                   NAME <- NAMES[[kk]]
[17:27:24.561]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.561]                     next
[17:27:24.561]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.561]                 }
[17:27:24.561]                 if (length(args) > 0) 
[17:27:24.561]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.561]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.561]             }
[17:27:24.561]             else {
[17:27:24.561]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.561]             }
[17:27:24.561]             {
[17:27:24.561]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.561]                   0L) {
[17:27:24.561]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.561]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.561]                   base::options(opts)
[17:27:24.561]                 }
[17:27:24.561]                 {
[17:27:24.561]                   {
[17:27:24.561]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.561]                     NULL
[17:27:24.561]                   }
[17:27:24.561]                   options(future.plan = NULL)
[17:27:24.561]                   if (is.na(NA_character_)) 
[17:27:24.561]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.561]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.561]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.561]                     .init = FALSE)
[17:27:24.561]                 }
[17:27:24.561]             }
[17:27:24.561]         }
[17:27:24.561]     })
[17:27:24.561]     if (TRUE) {
[17:27:24.561]         base::sink(type = "output", split = FALSE)
[17:27:24.561]         if (TRUE) {
[17:27:24.561]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.561]         }
[17:27:24.561]         else {
[17:27:24.561]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.561]         }
[17:27:24.561]         base::close(...future.stdout)
[17:27:24.561]         ...future.stdout <- NULL
[17:27:24.561]     }
[17:27:24.561]     ...future.result$conditions <- ...future.conditions
[17:27:24.561]     ...future.result$finished <- base::Sys.time()
[17:27:24.561]     ...future.result
[17:27:24.561] }
[17:27:24.571] MultisessionFuture started
[17:27:24.571] - Launch lazy future ... done
[17:27:24.571] run() for 'MultisessionFuture' ... done
[17:27:24.572] result() for ClusterFuture ...
[17:27:24.572] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.572] - Validating connection of MultisessionFuture
[17:27:24.603] - received message: FutureResult
[17:27:24.604] - Received FutureResult
[17:27:24.604] - Erased future from FutureRegistry
[17:27:24.605] result() for ClusterFuture ...
[17:27:24.605] - result already collected: FutureResult
[17:27:24.605] result() for ClusterFuture ... done
[17:27:24.606] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.606] result() for ClusterFuture ... done
[17:27:24.606] result() for ClusterFuture ...
[17:27:24.607] - result already collected: FutureResult
[17:27:24.607] result() for ClusterFuture ... done
d = 1
** Nested future assignments
[17:27:24.608] getGlobalsAndPackages() ...
[17:27:24.608] Searching for globals...
[17:27:24.618] - globals found: [5] '{', '<-', '%<-%', '%->%', '+'
[17:27:24.619] Searching for globals ... DONE
[17:27:24.619] Resolving globals: FALSE
[17:27:24.620] 
[17:27:24.620] - packages: [1] 'future'
[17:27:24.621] getGlobalsAndPackages() ... DONE
[17:27:24.621] run() for 'Future' ...
[17:27:24.622] - state: 'created'
[17:27:24.622] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.647] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.648] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.648]   - Field: 'node'
[17:27:24.649]   - Field: 'label'
[17:27:24.649]   - Field: 'local'
[17:27:24.649]   - Field: 'owner'
[17:27:24.650]   - Field: 'envir'
[17:27:24.650]   - Field: 'workers'
[17:27:24.651]   - Field: 'packages'
[17:27:24.651]   - Field: 'gc'
[17:27:24.651]   - Field: 'conditions'
[17:27:24.652]   - Field: 'persistent'
[17:27:24.652]   - Field: 'expr'
[17:27:24.652]   - Field: 'uuid'
[17:27:24.653]   - Field: 'seed'
[17:27:24.653]   - Field: 'version'
[17:27:24.654]   - Field: 'result'
[17:27:24.654]   - Field: 'asynchronous'
[17:27:24.654]   - Field: 'calls'
[17:27:24.655]   - Field: 'globals'
[17:27:24.655]   - Field: 'stdout'
[17:27:24.655]   - Field: 'earlySignal'
[17:27:24.656]   - Field: 'lazy'
[17:27:24.656]   - Field: 'state'
[17:27:24.656] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.657] - Launch lazy future ...
[17:27:24.657] Packages needed by the future expression (n = 1): 'future'
[17:27:24.658] Packages needed by future strategies (n = 0): <none>
[17:27:24.659] {
[17:27:24.659]     {
[17:27:24.659]         {
[17:27:24.659]             ...future.startTime <- base::Sys.time()
[17:27:24.659]             {
[17:27:24.659]                 {
[17:27:24.659]                   {
[17:27:24.659]                     {
[17:27:24.659]                       {
[17:27:24.659]                         base::local({
[17:27:24.659]                           has_future <- base::requireNamespace("future", 
[17:27:24.659]                             quietly = TRUE)
[17:27:24.659]                           if (has_future) {
[17:27:24.659]                             ns <- base::getNamespace("future")
[17:27:24.659]                             version <- ns[[".package"]][["version"]]
[17:27:24.659]                             if (is.null(version)) 
[17:27:24.659]                               version <- utils::packageVersion("future")
[17:27:24.659]                           }
[17:27:24.659]                           else {
[17:27:24.659]                             version <- NULL
[17:27:24.659]                           }
[17:27:24.659]                           if (!has_future || version < "1.8.0") {
[17:27:24.659]                             info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.659]                               "", base::R.version$version.string), 
[17:27:24.659]                               platform = base::sprintf("%s (%s-bit)", 
[17:27:24.659]                                 base::R.version$platform, 8 * 
[17:27:24.659]                                   base::.Machine$sizeof.pointer), 
[17:27:24.659]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.659]                                 "release", "version")], collapse = " "), 
[17:27:24.659]                               hostname = base::Sys.info()[["nodename"]])
[17:27:24.659]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.659]                               info)
[17:27:24.659]                             info <- base::paste(info, collapse = "; ")
[17:27:24.659]                             if (!has_future) {
[17:27:24.659]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.659]                                 info)
[17:27:24.659]                             }
[17:27:24.659]                             else {
[17:27:24.659]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.659]                                 info, version)
[17:27:24.659]                             }
[17:27:24.659]                             base::stop(msg)
[17:27:24.659]                           }
[17:27:24.659]                         })
[17:27:24.659]                       }
[17:27:24.659]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.659]                       base::options(mc.cores = 1L)
[17:27:24.659]                     }
[17:27:24.659]                     base::local({
[17:27:24.659]                       for (pkg in "future") {
[17:27:24.659]                         base::loadNamespace(pkg)
[17:27:24.659]                         base::library(pkg, character.only = TRUE)
[17:27:24.659]                       }
[17:27:24.659]                     })
[17:27:24.659]                   }
[17:27:24.659]                   ...future.strategy.old <- future::plan("list")
[17:27:24.659]                   options(future.plan = NULL)
[17:27:24.659]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.659]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.659]                 }
[17:27:24.659]                 ...future.workdir <- getwd()
[17:27:24.659]             }
[17:27:24.659]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.659]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.659]         }
[17:27:24.659]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.659]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.659]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.659]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.659]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.659]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.659]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.659]             base::names(...future.oldOptions))
[17:27:24.659]     }
[17:27:24.659]     if (FALSE) {
[17:27:24.659]     }
[17:27:24.659]     else {
[17:27:24.659]         if (TRUE) {
[17:27:24.659]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.659]                 open = "w")
[17:27:24.659]         }
[17:27:24.659]         else {
[17:27:24.659]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.659]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.659]         }
[17:27:24.659]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.659]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.659]             base::sink(type = "output", split = FALSE)
[17:27:24.659]             base::close(...future.stdout)
[17:27:24.659]         }, add = TRUE)
[17:27:24.659]     }
[17:27:24.659]     ...future.frame <- base::sys.nframe()
[17:27:24.659]     ...future.conditions <- base::list()
[17:27:24.659]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.659]     if (FALSE) {
[17:27:24.659]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.659]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.659]     }
[17:27:24.659]     ...future.result <- base::tryCatch({
[17:27:24.659]         base::withCallingHandlers({
[17:27:24.659]             ...future.value <- base::withVisible(base::local({
[17:27:24.659]                 ...future.makeSendCondition <- base::local({
[17:27:24.659]                   sendCondition <- NULL
[17:27:24.659]                   function(frame = 1L) {
[17:27:24.659]                     if (is.function(sendCondition)) 
[17:27:24.659]                       return(sendCondition)
[17:27:24.659]                     ns <- getNamespace("parallel")
[17:27:24.659]                     if (exists("sendData", mode = "function", 
[17:27:24.659]                       envir = ns)) {
[17:27:24.659]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.659]                         envir = ns)
[17:27:24.659]                       envir <- sys.frame(frame)
[17:27:24.659]                       master <- NULL
[17:27:24.659]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.659]                         !identical(envir, emptyenv())) {
[17:27:24.659]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.659]                           inherits = FALSE)) {
[17:27:24.659]                           master <- get("master", mode = "list", 
[17:27:24.659]                             envir = envir, inherits = FALSE)
[17:27:24.659]                           if (inherits(master, c("SOCKnode", 
[17:27:24.659]                             "SOCK0node"))) {
[17:27:24.659]                             sendCondition <<- function(cond) {
[17:27:24.659]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.659]                                 success = TRUE)
[17:27:24.659]                               parallel_sendData(master, data)
[17:27:24.659]                             }
[17:27:24.659]                             return(sendCondition)
[17:27:24.659]                           }
[17:27:24.659]                         }
[17:27:24.659]                         frame <- frame + 1L
[17:27:24.659]                         envir <- sys.frame(frame)
[17:27:24.659]                       }
[17:27:24.659]                     }
[17:27:24.659]                     sendCondition <<- function(cond) NULL
[17:27:24.659]                   }
[17:27:24.659]                 })
[17:27:24.659]                 withCallingHandlers({
[17:27:24.659]                   {
[17:27:24.659]                     b <- 1
[17:27:24.659]                     c %<-% 2
[17:27:24.659]                     d <- 3
[17:27:24.659]                     4 %->% e
[17:27:24.659]                     b + c + d + e
[17:27:24.659]                   }
[17:27:24.659]                 }, immediateCondition = function(cond) {
[17:27:24.659]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.659]                   sendCondition(cond)
[17:27:24.659]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.659]                   {
[17:27:24.659]                     inherits <- base::inherits
[17:27:24.659]                     invokeRestart <- base::invokeRestart
[17:27:24.659]                     is.null <- base::is.null
[17:27:24.659]                     muffled <- FALSE
[17:27:24.659]                     if (inherits(cond, "message")) {
[17:27:24.659]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.659]                       if (muffled) 
[17:27:24.659]                         invokeRestart("muffleMessage")
[17:27:24.659]                     }
[17:27:24.659]                     else if (inherits(cond, "warning")) {
[17:27:24.659]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.659]                       if (muffled) 
[17:27:24.659]                         invokeRestart("muffleWarning")
[17:27:24.659]                     }
[17:27:24.659]                     else if (inherits(cond, "condition")) {
[17:27:24.659]                       if (!is.null(pattern)) {
[17:27:24.659]                         computeRestarts <- base::computeRestarts
[17:27:24.659]                         grepl <- base::grepl
[17:27:24.659]                         restarts <- computeRestarts(cond)
[17:27:24.659]                         for (restart in restarts) {
[17:27:24.659]                           name <- restart$name
[17:27:24.659]                           if (is.null(name)) 
[17:27:24.659]                             next
[17:27:24.659]                           if (!grepl(pattern, name)) 
[17:27:24.659]                             next
[17:27:24.659]                           invokeRestart(restart)
[17:27:24.659]                           muffled <- TRUE
[17:27:24.659]                           break
[17:27:24.659]                         }
[17:27:24.659]                       }
[17:27:24.659]                     }
[17:27:24.659]                     invisible(muffled)
[17:27:24.659]                   }
[17:27:24.659]                   muffleCondition(cond)
[17:27:24.659]                 })
[17:27:24.659]             }))
[17:27:24.659]             future::FutureResult(value = ...future.value$value, 
[17:27:24.659]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.659]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.659]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.659]                     ...future.globalenv.names))
[17:27:24.659]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.659]         }, condition = base::local({
[17:27:24.659]             c <- base::c
[17:27:24.659]             inherits <- base::inherits
[17:27:24.659]             invokeRestart <- base::invokeRestart
[17:27:24.659]             length <- base::length
[17:27:24.659]             list <- base::list
[17:27:24.659]             seq.int <- base::seq.int
[17:27:24.659]             signalCondition <- base::signalCondition
[17:27:24.659]             sys.calls <- base::sys.calls
[17:27:24.659]             `[[` <- base::`[[`
[17:27:24.659]             `+` <- base::`+`
[17:27:24.659]             `<<-` <- base::`<<-`
[17:27:24.659]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.659]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.659]                   3L)]
[17:27:24.659]             }
[17:27:24.659]             function(cond) {
[17:27:24.659]                 is_error <- inherits(cond, "error")
[17:27:24.659]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.659]                   NULL)
[17:27:24.659]                 if (is_error) {
[17:27:24.659]                   sessionInformation <- function() {
[17:27:24.659]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.659]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.659]                       search = base::search(), system = base::Sys.info())
[17:27:24.659]                   }
[17:27:24.659]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.659]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.659]                     cond$call), session = sessionInformation(), 
[17:27:24.659]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.659]                   signalCondition(cond)
[17:27:24.659]                 }
[17:27:24.659]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.659]                 "immediateCondition"))) {
[17:27:24.659]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.659]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.659]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.659]                   if (TRUE && !signal) {
[17:27:24.659]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.659]                     {
[17:27:24.659]                       inherits <- base::inherits
[17:27:24.659]                       invokeRestart <- base::invokeRestart
[17:27:24.659]                       is.null <- base::is.null
[17:27:24.659]                       muffled <- FALSE
[17:27:24.659]                       if (inherits(cond, "message")) {
[17:27:24.659]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.659]                         if (muffled) 
[17:27:24.659]                           invokeRestart("muffleMessage")
[17:27:24.659]                       }
[17:27:24.659]                       else if (inherits(cond, "warning")) {
[17:27:24.659]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.659]                         if (muffled) 
[17:27:24.659]                           invokeRestart("muffleWarning")
[17:27:24.659]                       }
[17:27:24.659]                       else if (inherits(cond, "condition")) {
[17:27:24.659]                         if (!is.null(pattern)) {
[17:27:24.659]                           computeRestarts <- base::computeRestarts
[17:27:24.659]                           grepl <- base::grepl
[17:27:24.659]                           restarts <- computeRestarts(cond)
[17:27:24.659]                           for (restart in restarts) {
[17:27:24.659]                             name <- restart$name
[17:27:24.659]                             if (is.null(name)) 
[17:27:24.659]                               next
[17:27:24.659]                             if (!grepl(pattern, name)) 
[17:27:24.659]                               next
[17:27:24.659]                             invokeRestart(restart)
[17:27:24.659]                             muffled <- TRUE
[17:27:24.659]                             break
[17:27:24.659]                           }
[17:27:24.659]                         }
[17:27:24.659]                       }
[17:27:24.659]                       invisible(muffled)
[17:27:24.659]                     }
[17:27:24.659]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.659]                   }
[17:27:24.659]                 }
[17:27:24.659]                 else {
[17:27:24.659]                   if (TRUE) {
[17:27:24.659]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.659]                     {
[17:27:24.659]                       inherits <- base::inherits
[17:27:24.659]                       invokeRestart <- base::invokeRestart
[17:27:24.659]                       is.null <- base::is.null
[17:27:24.659]                       muffled <- FALSE
[17:27:24.659]                       if (inherits(cond, "message")) {
[17:27:24.659]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.659]                         if (muffled) 
[17:27:24.659]                           invokeRestart("muffleMessage")
[17:27:24.659]                       }
[17:27:24.659]                       else if (inherits(cond, "warning")) {
[17:27:24.659]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.659]                         if (muffled) 
[17:27:24.659]                           invokeRestart("muffleWarning")
[17:27:24.659]                       }
[17:27:24.659]                       else if (inherits(cond, "condition")) {
[17:27:24.659]                         if (!is.null(pattern)) {
[17:27:24.659]                           computeRestarts <- base::computeRestarts
[17:27:24.659]                           grepl <- base::grepl
[17:27:24.659]                           restarts <- computeRestarts(cond)
[17:27:24.659]                           for (restart in restarts) {
[17:27:24.659]                             name <- restart$name
[17:27:24.659]                             if (is.null(name)) 
[17:27:24.659]                               next
[17:27:24.659]                             if (!grepl(pattern, name)) 
[17:27:24.659]                               next
[17:27:24.659]                             invokeRestart(restart)
[17:27:24.659]                             muffled <- TRUE
[17:27:24.659]                             break
[17:27:24.659]                           }
[17:27:24.659]                         }
[17:27:24.659]                       }
[17:27:24.659]                       invisible(muffled)
[17:27:24.659]                     }
[17:27:24.659]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.659]                   }
[17:27:24.659]                 }
[17:27:24.659]             }
[17:27:24.659]         }))
[17:27:24.659]     }, error = function(ex) {
[17:27:24.659]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.659]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.659]                 ...future.rng), started = ...future.startTime, 
[17:27:24.659]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.659]             version = "1.8"), class = "FutureResult")
[17:27:24.659]     }, finally = {
[17:27:24.659]         if (!identical(...future.workdir, getwd())) 
[17:27:24.659]             setwd(...future.workdir)
[17:27:24.659]         {
[17:27:24.659]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.659]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.659]             }
[17:27:24.659]             base::options(...future.oldOptions)
[17:27:24.659]             if (.Platform$OS.type == "windows") {
[17:27:24.659]                 old_names <- names(...future.oldEnvVars)
[17:27:24.659]                 envs <- base::Sys.getenv()
[17:27:24.659]                 names <- names(envs)
[17:27:24.659]                 common <- intersect(names, old_names)
[17:27:24.659]                 added <- setdiff(names, old_names)
[17:27:24.659]                 removed <- setdiff(old_names, names)
[17:27:24.659]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.659]                   envs[common]]
[17:27:24.659]                 NAMES <- toupper(changed)
[17:27:24.659]                 args <- list()
[17:27:24.659]                 for (kk in seq_along(NAMES)) {
[17:27:24.659]                   name <- changed[[kk]]
[17:27:24.659]                   NAME <- NAMES[[kk]]
[17:27:24.659]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.659]                     next
[17:27:24.659]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.659]                 }
[17:27:24.659]                 NAMES <- toupper(added)
[17:27:24.659]                 for (kk in seq_along(NAMES)) {
[17:27:24.659]                   name <- added[[kk]]
[17:27:24.659]                   NAME <- NAMES[[kk]]
[17:27:24.659]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.659]                     next
[17:27:24.659]                   args[[name]] <- ""
[17:27:24.659]                 }
[17:27:24.659]                 NAMES <- toupper(removed)
[17:27:24.659]                 for (kk in seq_along(NAMES)) {
[17:27:24.659]                   name <- removed[[kk]]
[17:27:24.659]                   NAME <- NAMES[[kk]]
[17:27:24.659]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.659]                     next
[17:27:24.659]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.659]                 }
[17:27:24.659]                 if (length(args) > 0) 
[17:27:24.659]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.659]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.659]             }
[17:27:24.659]             else {
[17:27:24.659]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.659]             }
[17:27:24.659]             {
[17:27:24.659]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.659]                   0L) {
[17:27:24.659]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.659]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.659]                   base::options(opts)
[17:27:24.659]                 }
[17:27:24.659]                 {
[17:27:24.659]                   {
[17:27:24.659]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.659]                     NULL
[17:27:24.659]                   }
[17:27:24.659]                   options(future.plan = NULL)
[17:27:24.659]                   if (is.na(NA_character_)) 
[17:27:24.659]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.659]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.659]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.659]                     .init = FALSE)
[17:27:24.659]                 }
[17:27:24.659]             }
[17:27:24.659]         }
[17:27:24.659]     })
[17:27:24.659]     if (TRUE) {
[17:27:24.659]         base::sink(type = "output", split = FALSE)
[17:27:24.659]         if (TRUE) {
[17:27:24.659]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.659]         }
[17:27:24.659]         else {
[17:27:24.659]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.659]         }
[17:27:24.659]         base::close(...future.stdout)
[17:27:24.659]         ...future.stdout <- NULL
[17:27:24.659]     }
[17:27:24.659]     ...future.result$conditions <- ...future.conditions
[17:27:24.659]     ...future.result$finished <- base::Sys.time()
[17:27:24.659]     ...future.result
[17:27:24.659] }
[17:27:24.671] MultisessionFuture started
[17:27:24.671] - Launch lazy future ... done
[17:27:24.672] run() for 'MultisessionFuture' ... done
[17:27:24.672] result() for ClusterFuture ...
[17:27:24.673] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.673] - Validating connection of MultisessionFuture
[17:27:24.726] - received message: FutureResult
[17:27:24.727] - Received FutureResult
[17:27:24.727] - Erased future from FutureRegistry
[17:27:24.727] result() for ClusterFuture ...
[17:27:24.728] - result already collected: FutureResult
[17:27:24.728] result() for ClusterFuture ... done
[17:27:24.728] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.729] result() for ClusterFuture ... done
[17:27:24.729] result() for ClusterFuture ...
[17:27:24.729] - result already collected: FutureResult
[17:27:24.730] result() for ClusterFuture ... done
a = 10
[17:27:24.730] getGlobalsAndPackages() ...
[17:27:24.731] Searching for globals...
[17:27:24.733] - globals found: [3] '{', '+', 'a'
[17:27:24.733] Searching for globals ... DONE
[17:27:24.734] Resolving globals: FALSE
[17:27:24.735] The total size of the 1 globals is 39 bytes (39 bytes)
[17:27:24.736] The total size of the 1 globals exported for future expression ('{; a + 1; }') is 39 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (39 bytes of class 'numeric')
[17:27:24.736] - globals: [1] 'a'
[17:27:24.736] 
[17:27:24.737] getGlobalsAndPackages() ... DONE
[17:27:24.737] run() for 'Future' ...
[17:27:24.738] - state: 'created'
[17:27:24.738] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:27:24.759] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:27:24.760] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:27:24.760]   - Field: 'node'
[17:27:24.760]   - Field: 'label'
[17:27:24.760]   - Field: 'local'
[17:27:24.760]   - Field: 'owner'
[17:27:24.761]   - Field: 'envir'
[17:27:24.761]   - Field: 'workers'
[17:27:24.761]   - Field: 'packages'
[17:27:24.761]   - Field: 'gc'
[17:27:24.761]   - Field: 'conditions'
[17:27:24.762]   - Field: 'persistent'
[17:27:24.762]   - Field: 'expr'
[17:27:24.762]   - Field: 'uuid'
[17:27:24.762]   - Field: 'seed'
[17:27:24.762]   - Field: 'version'
[17:27:24.763]   - Field: 'result'
[17:27:24.763]   - Field: 'asynchronous'
[17:27:24.763]   - Field: 'calls'
[17:27:24.763]   - Field: 'globals'
[17:27:24.763]   - Field: 'stdout'
[17:27:24.764]   - Field: 'earlySignal'
[17:27:24.764]   - Field: 'lazy'
[17:27:24.764]   - Field: 'state'
[17:27:24.764] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:27:24.764] - Launch lazy future ...
[17:27:24.765] Packages needed by the future expression (n = 0): <none>
[17:27:24.765] Packages needed by future strategies (n = 0): <none>
[17:27:24.766] {
[17:27:24.766]     {
[17:27:24.766]         {
[17:27:24.766]             ...future.startTime <- base::Sys.time()
[17:27:24.766]             {
[17:27:24.766]                 {
[17:27:24.766]                   {
[17:27:24.766]                     {
[17:27:24.766]                       base::local({
[17:27:24.766]                         has_future <- base::requireNamespace("future", 
[17:27:24.766]                           quietly = TRUE)
[17:27:24.766]                         if (has_future) {
[17:27:24.766]                           ns <- base::getNamespace("future")
[17:27:24.766]                           version <- ns[[".package"]][["version"]]
[17:27:24.766]                           if (is.null(version)) 
[17:27:24.766]                             version <- utils::packageVersion("future")
[17:27:24.766]                         }
[17:27:24.766]                         else {
[17:27:24.766]                           version <- NULL
[17:27:24.766]                         }
[17:27:24.766]                         if (!has_future || version < "1.8.0") {
[17:27:24.766]                           info <- base::c(r_version = base::gsub("R version ", 
[17:27:24.766]                             "", base::R.version$version.string), 
[17:27:24.766]                             platform = base::sprintf("%s (%s-bit)", 
[17:27:24.766]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:27:24.766]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:27:24.766]                               "release", "version")], collapse = " "), 
[17:27:24.766]                             hostname = base::Sys.info()[["nodename"]])
[17:27:24.766]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:27:24.766]                             info)
[17:27:24.766]                           info <- base::paste(info, collapse = "; ")
[17:27:24.766]                           if (!has_future) {
[17:27:24.766]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:27:24.766]                               info)
[17:27:24.766]                           }
[17:27:24.766]                           else {
[17:27:24.766]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:27:24.766]                               info, version)
[17:27:24.766]                           }
[17:27:24.766]                           base::stop(msg)
[17:27:24.766]                         }
[17:27:24.766]                       })
[17:27:24.766]                     }
[17:27:24.766]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:27:24.766]                     base::options(mc.cores = 1L)
[17:27:24.766]                   }
[17:27:24.766]                   ...future.strategy.old <- future::plan("list")
[17:27:24.766]                   options(future.plan = NULL)
[17:27:24.766]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.766]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:27:24.766]                 }
[17:27:24.766]                 ...future.workdir <- getwd()
[17:27:24.766]             }
[17:27:24.766]             ...future.oldOptions <- base::as.list(base::.Options)
[17:27:24.766]             ...future.oldEnvVars <- base::Sys.getenv()
[17:27:24.766]         }
[17:27:24.766]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:27:24.766]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:27:24.766]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:27:24.766]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:27:24.766]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:27:24.766]             future.stdout.windows.reencode = NULL, width = 80L)
[17:27:24.766]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:27:24.766]             base::names(...future.oldOptions))
[17:27:24.766]     }
[17:27:24.766]     if (FALSE) {
[17:27:24.766]     }
[17:27:24.766]     else {
[17:27:24.766]         if (TRUE) {
[17:27:24.766]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:27:24.766]                 open = "w")
[17:27:24.766]         }
[17:27:24.766]         else {
[17:27:24.766]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:27:24.766]                 windows = "NUL", "/dev/null"), open = "w")
[17:27:24.766]         }
[17:27:24.766]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:27:24.766]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:27:24.766]             base::sink(type = "output", split = FALSE)
[17:27:24.766]             base::close(...future.stdout)
[17:27:24.766]         }, add = TRUE)
[17:27:24.766]     }
[17:27:24.766]     ...future.frame <- base::sys.nframe()
[17:27:24.766]     ...future.conditions <- base::list()
[17:27:24.766]     ...future.rng <- base::globalenv()$.Random.seed
[17:27:24.766]     if (FALSE) {
[17:27:24.766]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:27:24.766]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:27:24.766]     }
[17:27:24.766]     ...future.result <- base::tryCatch({
[17:27:24.766]         base::withCallingHandlers({
[17:27:24.766]             ...future.value <- base::withVisible(base::local({
[17:27:24.766]                 ...future.makeSendCondition <- base::local({
[17:27:24.766]                   sendCondition <- NULL
[17:27:24.766]                   function(frame = 1L) {
[17:27:24.766]                     if (is.function(sendCondition)) 
[17:27:24.766]                       return(sendCondition)
[17:27:24.766]                     ns <- getNamespace("parallel")
[17:27:24.766]                     if (exists("sendData", mode = "function", 
[17:27:24.766]                       envir = ns)) {
[17:27:24.766]                       parallel_sendData <- get("sendData", mode = "function", 
[17:27:24.766]                         envir = ns)
[17:27:24.766]                       envir <- sys.frame(frame)
[17:27:24.766]                       master <- NULL
[17:27:24.766]                       while (!identical(envir, .GlobalEnv) && 
[17:27:24.766]                         !identical(envir, emptyenv())) {
[17:27:24.766]                         if (exists("master", mode = "list", envir = envir, 
[17:27:24.766]                           inherits = FALSE)) {
[17:27:24.766]                           master <- get("master", mode = "list", 
[17:27:24.766]                             envir = envir, inherits = FALSE)
[17:27:24.766]                           if (inherits(master, c("SOCKnode", 
[17:27:24.766]                             "SOCK0node"))) {
[17:27:24.766]                             sendCondition <<- function(cond) {
[17:27:24.766]                               data <- list(type = "VALUE", value = cond, 
[17:27:24.766]                                 success = TRUE)
[17:27:24.766]                               parallel_sendData(master, data)
[17:27:24.766]                             }
[17:27:24.766]                             return(sendCondition)
[17:27:24.766]                           }
[17:27:24.766]                         }
[17:27:24.766]                         frame <- frame + 1L
[17:27:24.766]                         envir <- sys.frame(frame)
[17:27:24.766]                       }
[17:27:24.766]                     }
[17:27:24.766]                     sendCondition <<- function(cond) NULL
[17:27:24.766]                   }
[17:27:24.766]                 })
[17:27:24.766]                 withCallingHandlers({
[17:27:24.766]                   {
[17:27:24.766]                     a + 1
[17:27:24.766]                   }
[17:27:24.766]                 }, immediateCondition = function(cond) {
[17:27:24.766]                   sendCondition <- ...future.makeSendCondition()
[17:27:24.766]                   sendCondition(cond)
[17:27:24.766]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.766]                   {
[17:27:24.766]                     inherits <- base::inherits
[17:27:24.766]                     invokeRestart <- base::invokeRestart
[17:27:24.766]                     is.null <- base::is.null
[17:27:24.766]                     muffled <- FALSE
[17:27:24.766]                     if (inherits(cond, "message")) {
[17:27:24.766]                       muffled <- grepl(pattern, "muffleMessage")
[17:27:24.766]                       if (muffled) 
[17:27:24.766]                         invokeRestart("muffleMessage")
[17:27:24.766]                     }
[17:27:24.766]                     else if (inherits(cond, "warning")) {
[17:27:24.766]                       muffled <- grepl(pattern, "muffleWarning")
[17:27:24.766]                       if (muffled) 
[17:27:24.766]                         invokeRestart("muffleWarning")
[17:27:24.766]                     }
[17:27:24.766]                     else if (inherits(cond, "condition")) {
[17:27:24.766]                       if (!is.null(pattern)) {
[17:27:24.766]                         computeRestarts <- base::computeRestarts
[17:27:24.766]                         grepl <- base::grepl
[17:27:24.766]                         restarts <- computeRestarts(cond)
[17:27:24.766]                         for (restart in restarts) {
[17:27:24.766]                           name <- restart$name
[17:27:24.766]                           if (is.null(name)) 
[17:27:24.766]                             next
[17:27:24.766]                           if (!grepl(pattern, name)) 
[17:27:24.766]                             next
[17:27:24.766]                           invokeRestart(restart)
[17:27:24.766]                           muffled <- TRUE
[17:27:24.766]                           break
[17:27:24.766]                         }
[17:27:24.766]                       }
[17:27:24.766]                     }
[17:27:24.766]                     invisible(muffled)
[17:27:24.766]                   }
[17:27:24.766]                   muffleCondition(cond)
[17:27:24.766]                 })
[17:27:24.766]             }))
[17:27:24.766]             future::FutureResult(value = ...future.value$value, 
[17:27:24.766]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.766]                   ...future.rng), globalenv = if (FALSE) 
[17:27:24.766]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:27:24.766]                     ...future.globalenv.names))
[17:27:24.766]                 else NULL, started = ...future.startTime, version = "1.8")
[17:27:24.766]         }, condition = base::local({
[17:27:24.766]             c <- base::c
[17:27:24.766]             inherits <- base::inherits
[17:27:24.766]             invokeRestart <- base::invokeRestart
[17:27:24.766]             length <- base::length
[17:27:24.766]             list <- base::list
[17:27:24.766]             seq.int <- base::seq.int
[17:27:24.766]             signalCondition <- base::signalCondition
[17:27:24.766]             sys.calls <- base::sys.calls
[17:27:24.766]             `[[` <- base::`[[`
[17:27:24.766]             `+` <- base::`+`
[17:27:24.766]             `<<-` <- base::`<<-`
[17:27:24.766]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:27:24.766]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:27:24.766]                   3L)]
[17:27:24.766]             }
[17:27:24.766]             function(cond) {
[17:27:24.766]                 is_error <- inherits(cond, "error")
[17:27:24.766]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:27:24.766]                   NULL)
[17:27:24.766]                 if (is_error) {
[17:27:24.766]                   sessionInformation <- function() {
[17:27:24.766]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:27:24.766]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:27:24.766]                       search = base::search(), system = base::Sys.info())
[17:27:24.766]                   }
[17:27:24.766]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.766]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:27:24.766]                     cond$call), session = sessionInformation(), 
[17:27:24.766]                     timestamp = base::Sys.time(), signaled = 0L)
[17:27:24.766]                   signalCondition(cond)
[17:27:24.766]                 }
[17:27:24.766]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:27:24.766]                 "immediateCondition"))) {
[17:27:24.766]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:27:24.766]                   ...future.conditions[[length(...future.conditions) + 
[17:27:24.766]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:27:24.766]                   if (TRUE && !signal) {
[17:27:24.766]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.766]                     {
[17:27:24.766]                       inherits <- base::inherits
[17:27:24.766]                       invokeRestart <- base::invokeRestart
[17:27:24.766]                       is.null <- base::is.null
[17:27:24.766]                       muffled <- FALSE
[17:27:24.766]                       if (inherits(cond, "message")) {
[17:27:24.766]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.766]                         if (muffled) 
[17:27:24.766]                           invokeRestart("muffleMessage")
[17:27:24.766]                       }
[17:27:24.766]                       else if (inherits(cond, "warning")) {
[17:27:24.766]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.766]                         if (muffled) 
[17:27:24.766]                           invokeRestart("muffleWarning")
[17:27:24.766]                       }
[17:27:24.766]                       else if (inherits(cond, "condition")) {
[17:27:24.766]                         if (!is.null(pattern)) {
[17:27:24.766]                           computeRestarts <- base::computeRestarts
[17:27:24.766]                           grepl <- base::grepl
[17:27:24.766]                           restarts <- computeRestarts(cond)
[17:27:24.766]                           for (restart in restarts) {
[17:27:24.766]                             name <- restart$name
[17:27:24.766]                             if (is.null(name)) 
[17:27:24.766]                               next
[17:27:24.766]                             if (!grepl(pattern, name)) 
[17:27:24.766]                               next
[17:27:24.766]                             invokeRestart(restart)
[17:27:24.766]                             muffled <- TRUE
[17:27:24.766]                             break
[17:27:24.766]                           }
[17:27:24.766]                         }
[17:27:24.766]                       }
[17:27:24.766]                       invisible(muffled)
[17:27:24.766]                     }
[17:27:24.766]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.766]                   }
[17:27:24.766]                 }
[17:27:24.766]                 else {
[17:27:24.766]                   if (TRUE) {
[17:27:24.766]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:27:24.766]                     {
[17:27:24.766]                       inherits <- base::inherits
[17:27:24.766]                       invokeRestart <- base::invokeRestart
[17:27:24.766]                       is.null <- base::is.null
[17:27:24.766]                       muffled <- FALSE
[17:27:24.766]                       if (inherits(cond, "message")) {
[17:27:24.766]                         muffled <- grepl(pattern, "muffleMessage")
[17:27:24.766]                         if (muffled) 
[17:27:24.766]                           invokeRestart("muffleMessage")
[17:27:24.766]                       }
[17:27:24.766]                       else if (inherits(cond, "warning")) {
[17:27:24.766]                         muffled <- grepl(pattern, "muffleWarning")
[17:27:24.766]                         if (muffled) 
[17:27:24.766]                           invokeRestart("muffleWarning")
[17:27:24.766]                       }
[17:27:24.766]                       else if (inherits(cond, "condition")) {
[17:27:24.766]                         if (!is.null(pattern)) {
[17:27:24.766]                           computeRestarts <- base::computeRestarts
[17:27:24.766]                           grepl <- base::grepl
[17:27:24.766]                           restarts <- computeRestarts(cond)
[17:27:24.766]                           for (restart in restarts) {
[17:27:24.766]                             name <- restart$name
[17:27:24.766]                             if (is.null(name)) 
[17:27:24.766]                               next
[17:27:24.766]                             if (!grepl(pattern, name)) 
[17:27:24.766]                               next
[17:27:24.766]                             invokeRestart(restart)
[17:27:24.766]                             muffled <- TRUE
[17:27:24.766]                             break
[17:27:24.766]                           }
[17:27:24.766]                         }
[17:27:24.766]                       }
[17:27:24.766]                       invisible(muffled)
[17:27:24.766]                     }
[17:27:24.766]                     muffleCondition(cond, pattern = "^muffle")
[17:27:24.766]                   }
[17:27:24.766]                 }
[17:27:24.766]             }
[17:27:24.766]         }))
[17:27:24.766]     }, error = function(ex) {
[17:27:24.766]         base::structure(base::list(value = NULL, visible = NULL, 
[17:27:24.766]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:27:24.766]                 ...future.rng), started = ...future.startTime, 
[17:27:24.766]             finished = Sys.time(), session_uuid = NA_character_, 
[17:27:24.766]             version = "1.8"), class = "FutureResult")
[17:27:24.766]     }, finally = {
[17:27:24.766]         if (!identical(...future.workdir, getwd())) 
[17:27:24.766]             setwd(...future.workdir)
[17:27:24.766]         {
[17:27:24.766]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:27:24.766]                 ...future.oldOptions$nwarnings <- NULL
[17:27:24.766]             }
[17:27:24.766]             base::options(...future.oldOptions)
[17:27:24.766]             if (.Platform$OS.type == "windows") {
[17:27:24.766]                 old_names <- names(...future.oldEnvVars)
[17:27:24.766]                 envs <- base::Sys.getenv()
[17:27:24.766]                 names <- names(envs)
[17:27:24.766]                 common <- intersect(names, old_names)
[17:27:24.766]                 added <- setdiff(names, old_names)
[17:27:24.766]                 removed <- setdiff(old_names, names)
[17:27:24.766]                 changed <- common[...future.oldEnvVars[common] != 
[17:27:24.766]                   envs[common]]
[17:27:24.766]                 NAMES <- toupper(changed)
[17:27:24.766]                 args <- list()
[17:27:24.766]                 for (kk in seq_along(NAMES)) {
[17:27:24.766]                   name <- changed[[kk]]
[17:27:24.766]                   NAME <- NAMES[[kk]]
[17:27:24.766]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.766]                     next
[17:27:24.766]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.766]                 }
[17:27:24.766]                 NAMES <- toupper(added)
[17:27:24.766]                 for (kk in seq_along(NAMES)) {
[17:27:24.766]                   name <- added[[kk]]
[17:27:24.766]                   NAME <- NAMES[[kk]]
[17:27:24.766]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.766]                     next
[17:27:24.766]                   args[[name]] <- ""
[17:27:24.766]                 }
[17:27:24.766]                 NAMES <- toupper(removed)
[17:27:24.766]                 for (kk in seq_along(NAMES)) {
[17:27:24.766]                   name <- removed[[kk]]
[17:27:24.766]                   NAME <- NAMES[[kk]]
[17:27:24.766]                   if (name != NAME && is.element(NAME, old_names)) 
[17:27:24.766]                     next
[17:27:24.766]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:27:24.766]                 }
[17:27:24.766]                 if (length(args) > 0) 
[17:27:24.766]                   base::do.call(base::Sys.setenv, args = args)
[17:27:24.766]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:27:24.766]             }
[17:27:24.766]             else {
[17:27:24.766]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:27:24.766]             }
[17:27:24.766]             {
[17:27:24.766]                 if (base::length(...future.futureOptionsAdded) > 
[17:27:24.766]                   0L) {
[17:27:24.766]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:27:24.766]                   base::names(opts) <- ...future.futureOptionsAdded
[17:27:24.766]                   base::options(opts)
[17:27:24.766]                 }
[17:27:24.766]                 {
[17:27:24.766]                   {
[17:27:24.766]                     base::options(mc.cores = ...future.mc.cores.old)
[17:27:24.766]                     NULL
[17:27:24.766]                   }
[17:27:24.766]                   options(future.plan = NULL)
[17:27:24.766]                   if (is.na(NA_character_)) 
[17:27:24.766]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:27:24.766]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:27:24.766]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:27:24.766]                     .init = FALSE)
[17:27:24.766]                 }
[17:27:24.766]             }
[17:27:24.766]         }
[17:27:24.766]     })
[17:27:24.766]     if (TRUE) {
[17:27:24.766]         base::sink(type = "output", split = FALSE)
[17:27:24.766]         if (TRUE) {
[17:27:24.766]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:27:24.766]         }
[17:27:24.766]         else {
[17:27:24.766]             ...future.result["stdout"] <- base::list(NULL)
[17:27:24.766]         }
[17:27:24.766]         base::close(...future.stdout)
[17:27:24.766]         ...future.stdout <- NULL
[17:27:24.766]     }
[17:27:24.766]     ...future.result$conditions <- ...future.conditions
[17:27:24.766]     ...future.result$finished <- base::Sys.time()
[17:27:24.766]     ...future.result
[17:27:24.766] }
[17:27:24.773] Exporting 1 global objects (342 bytes) to cluster node #1 ...
[17:27:24.773] Exporting 'a' (39 bytes) to cluster node #1 ...
[17:27:24.774] Exporting 'a' (39 bytes) to cluster node #1 ... DONE
[17:27:24.775] Exporting 1 global objects (342 bytes) to cluster node #1 ... DONE
[17:27:24.777] MultisessionFuture started
[17:27:24.777] - Launch lazy future ... done
[17:27:24.777] run() for 'MultisessionFuture' ... done
[17:27:24.778] result() for ClusterFuture ...
[17:27:24.778] receiveMessageFromWorker() for ClusterFuture ...
[17:27:24.779] - Validating connection of MultisessionFuture
[17:27:24.806] - received message: FutureResult
[17:27:24.807] - Received FutureResult
[17:27:24.807] - Erased future from FutureRegistry
[17:27:24.808] result() for ClusterFuture ...
[17:27:24.808] - result already collected: FutureResult
[17:27:24.808] result() for ClusterFuture ... done
[17:27:24.809] receiveMessageFromWorker() for ClusterFuture ... done
[17:27:24.809] result() for ClusterFuture ... done
[17:27:24.810] result() for ClusterFuture ...
[17:27:24.810] - result already collected: FutureResult
[17:27:24.810] result() for ClusterFuture ... done
b = 11
*** %<-% with 'multisession' futures ... DONE
Testing with 2 cores ... DONE
> 
> message("*** %<-% ... DONE")
*** %<-% ... DONE
> 
> source("incl/end.R")
[17:27:24.813] plan(): Setting new future strategy stack:
[17:27:24.813] List of future strategies:
[17:27:24.813] 1. FutureStrategy:
[17:27:24.813]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:27:24.813]    - tweaked: FALSE
[17:27:24.813]    - call: future::plan(oplan)
[17:27:24.823] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.96    0.18    3.53